#479011826

Committed 30 Dec 2025 07:45AM UTC coverage: 24.363% (-0.04%) from 24.402%

Build # #479011826

Build Type

push

github

Committed by

rubensworks

Commit Message

Fix buffer insertion failing if there are no empty slots

Run Details

0 of 6 new or added lines in 1 file covered. (0.0%)

755 of 3099 relevant lines covered (24.36%)

0.24 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/main/java/org/cyclops/integratedcrafting/core/PendingCraftingJobResultIndexObserver.java

package org.cyclops.integratedcrafting.core;

import com.google.common.collect.Maps;
import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
import it.unimi.dsi.fastutil.ints.IntIterator;
import it.unimi.dsi.fastutil.objects.ObjectIterator;
import org.apache.commons.compress.utils.Lists;
import org.cyclops.commoncapabilities.api.ingredient.*;
import org.cyclops.commoncapabilities.api.ingredient.storage.IIngredientComponentStorage;
import org.cyclops.cyclopscore.ingredient.collection.IIngredientCollection;
import org.cyclops.cyclopscore.ingredient.collection.IngredientCollectionPrototypeMap;
import org.cyclops.cyclopscore.ingredient.collection.IngredientList;
import org.cyclops.cyclopscore.ingredient.storage.IngredientComponentStorageCollectionWrapper;
import org.cyclops.cyclopscore.ingredient.storage.IngredientComponentStorageSlottedCollectionWrapper;
import org.cyclops.integratedcrafting.IntegratedCrafting;
import org.cyclops.integratedcrafting.api.crafting.CraftingJob;
import org.cyclops.integratedcrafting.api.network.ICraftingNetwork;
import org.cyclops.integrateddynamics.api.ingredient.IIngredientComponentStorageObservable;
import org.cyclops.integrateddynamics.api.network.INetwork;
import org.cyclops.integrateddynamics.api.network.INetworkIngredientsChannel;
import org.cyclops.integrateddynamics.api.network.IPositionedAddonsNetwork;
import org.cyclops.integrateddynamics.api.network.IPositionedAddonsNetworkIngredients;

import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;

/**
 * An ingredient index observer that tracks crafting job outputs for a certain ingredient component type.
 *
 * It will observe changes and (partially) resolve awaiting crafting job outputs when applicable.
 *
 * @author rubensworks
 */
public class PendingCraftingJobResultIndexObserver<T, M>
        implements IIngredientComponentStorageObservable.IIndexChangeObserver<T, M> {

    private final IngredientComponent<T, M> ingredientComponent;
    private final CraftingJobHandler handler;
    private final ICraftingNetwork craftingNetwork;
    private final IPositionedAddonsNetworkIngredients<T, M> ingredientsNetwork;
    private final INetwork network;

    public PendingCraftingJobResultIndexObserver(IngredientComponent<T, M> ingredientComponent, CraftingJobHandler handler, ICraftingNetwork craftingNetwork, IPositionedAddonsNetworkIngredients<T, M> ingredientsNetwork, INetwork network) {
        this.ingredientComponent = ingredientComponent;
        this.handler = handler;
        this.craftingNetwork = craftingNetwork;
        this.ingredientsNetwork = ingredientsNetwork;
        this.network = network;
    }

    @Override
    public void onChange(IIngredientComponentStorageObservable.StorageChangeEvent<T, M> event) {
        if (event.getChangeType() == IIngredientComponentStorageObservable.Change.ADDITION
                // If we're still initializing the network, skip addition events.
                // Otherwise, we could incorrectly mark running crafting jobs as finished.
                && !event.isInitialChange()) {
            IIngredientCollection<T, M> addedIngredients = event.getInstances();
            IIngredientComponentStorage<T, M> ingredientsHayStack = null; // A mutable copy of addedIngredients (lazily created)
            IIngredientMatcher<T, M> matcher = ingredientComponent.getMatcher();

            Int2ObjectMap<List<Map<IngredientComponent<?, ?>, List<IPrototypedIngredient<?, ?>>>>> processingJobs = handler.getProcessingCraftingJobsPendingIngredients();
            ObjectIterator<Int2ObjectMap.Entry<List<Map<IngredientComponent<?, ?>, List<IPrototypedIngredient<?, ?>>>>>> jobsEntryIt = processingJobs.int2ObjectEntrySet().iterator();
            while (jobsEntryIt.hasNext()) {
                Int2ObjectMap.Entry<List<Map<IngredientComponent<?, ?>, List<IPrototypedIngredient<?, ?>>>>> jobsEntry = jobsEntryIt.next();
                int craftingJobId = jobsEntry.getIntKey();
                // Only check jobs that have a matching channel with the event
                CraftingJob craftingJob = handler.getAllCraftingJobs().get(jobsEntry.getIntKey());
                if (craftingJob != null
                        && (craftingJob.getChannel() == IPositionedAddonsNetwork.WILDCARD_CHANNEL || craftingJob.getChannel() == event.getChannel())) {
                    Iterator<Map<IngredientComponent<?, ?>, List<IPrototypedIngredient<?, ?>>>> jobEntryIt = jobsEntry.getValue().iterator();
                    while (jobEntryIt.hasNext()) {
                        Map<IngredientComponent<?, ?>, List<IPrototypedIngredient<?, ?>>> jobEntry = jobEntryIt.next();
                        List<IPrototypedIngredient<?, ?>> pendingIngredientsUnsafe = jobEntry.get(ingredientComponent);
                        if (pendingIngredientsUnsafe != null) {
                            // Remove pending ingredients that were added in the event
                            List<IPrototypedIngredient<T, M>> pendingIngredients = (List<IPrototypedIngredient<T, M>>) (Object) pendingIngredientsUnsafe;

                            // Iterate over all pending ingredients for this ingredient component
                            ListIterator<IPrototypedIngredient<T, M>> it = pendingIngredients.listIterator();
                            while (it.hasNext()) {
                                IPrototypedIngredient<T, M> prototypedIngredient = it.next();
                                final long initialQuantity = matcher.getQuantity(prototypedIngredient.getPrototype());
                                long remainingQuantity = initialQuantity;

                                // Lazily create ingredientsHayStack only when needed,
                                // because we need to copy all ingredients from addedIngredients,
                                // which can get expensive
                                // We need to make a copy because multiple crafting jobs can have the same pending instances,
                                // so each instance may only be consumed by a single crafting job.
                                if (ingredientsHayStack == null) {
                                    if (addedIngredients.contains(prototypedIngredient.getPrototype(),
                                            prototypedIngredient.getCondition())) {
                                        IngredientCollectionPrototypeMap<T, M> prototypeMap = new IngredientCollectionPrototypeMap<>(ingredientComponent);
                                        ingredientsHayStack = new IngredientComponentStorageCollectionWrapper<>(prototypeMap);
                                        prototypeMap.addAll(addedIngredients);
                                    } else {
                                        continue;
                                    }
                                }

                                // Iteratively extract the pending ingredient from the hay stack.
                                T extracted;
                                do {
                                    extracted = ingredientsHayStack.extract(prototypedIngredient.getPrototype(),
                                            prototypedIngredient.getCondition(), false);

                                    if (matcher.isEmpty(extracted)) {
                                        // Quickly break when no matches are available anymore
                                        break;
                                    } else {
                                        // Move this ingredient from storage to the first dependent crafting job.
                                        IntIterator dependentJobs = craftingJob.getDependentCraftingJobs().intIterator();
                                        while (dependentJobs.hasNext()) {
                                            CraftingJob dependentJob = craftingNetwork.getCraftingJob(craftingJob.getChannel(), dependentJobs.nextInt());
                                            if (dependentJob != null) {
                                                INetworkIngredientsChannel<T, M> storage = this.ingredientsNetwork.getChannelInternal(craftingJob.getChannel());
                                                T extractedFromStorage = storage.extract(extracted, matcher.getExactMatchCondition(), false);
                                                if (!matcher.matchesExactly(extracted, extractedFromStorage)) {
                                                    IntegratedCrafting.clog("Unable to extract ingredient from storage for pending crafting job: " + extracted);
                                                    storage.insert(extractedFromStorage, false);
                                                } else {
                                                    IMixedIngredients buffer = dependentJob.getIngredientsStorageBuffer();
                                                    if (!buffer.getComponents().contains(ingredientComponent)) {
                                                        Map<IngredientComponent<?, ?>, List<?>> mixedIngredientsRaw = Maps.newIdentityHashMap();
                                                        for (IngredientComponent<?, ?> component : buffer.getComponents()) {
                                                            mixedIngredientsRaw.put(component, buffer.getInstances(component));
                                                        }
                                                        List<T> list = Lists.newArrayList();
                                                        mixedIngredientsRaw.put(ingredientComponent, list);
                                                        list.add(extractedFromStorage);
                                                        buffer = new MixedIngredients(mixedIngredientsRaw);
                                                        dependentJob.setIngredientsStorageBuffer(buffer);
                                                    } else {
                                                        List<T> instances = buffer.getInstances(ingredientComponent);
                                                        if (!instances.stream().anyMatch(matcher::isEmpty)) {
                                                            // Make sure we have at least one empty slot available, to guarantee insertion can succeed.
                                                            instances.add(matcher.getEmptyInstance());
                                                        }
                                                        T remaining = new IngredientComponentStorageSlottedCollectionWrapper<>(new IngredientList<>(ingredientComponent, instances), Integer.MAX_VALUE, Integer.MAX_VALUE).insert(extractedFromStorage, false);
                                                        if (!matcher.isEmpty(remaining)) {
                                                            throw new IllegalStateException(String.format("Unable to insert %s into the crafting job buffer, remaining: ", extractedFromStorage, remaining));
                                                        }
                                                    }
                                                }
                                                break;
                                            }
                                        }
                                    }

                                    remainingQuantity -= matcher.getQuantity(extracted);
                                } while (!matcher.isEmpty(extracted) && remainingQuantity > 0);

                                // Update the list if the prototype has changed.
                                if (remainingQuantity <= 0) {
                                    it.remove();
                                } else if (initialQuantity != remainingQuantity) {
                                    it.set(new PrototypedIngredient<>(ingredientComponent,
                                            matcher.withQuantity(prototypedIngredient.getPrototype(), remainingQuantity),
                                            prototypedIngredient.getCondition()));
                                }
                            }

                            // If no prototypes for this component type for this crafting job for this job entry are pending.
                            if (pendingIngredients.isEmpty()) {
                                // Remove observer (in next tick) when all pending ingredients are resolved
                                handler.getObserversPendingDeletion().add(ingredientComponent);

                                // Remove crafting job if needed.
                                // No ingredients of this ingredient component type are pending
                                jobEntry.remove(ingredientComponent);
                                if (jobEntry.isEmpty()) {
                                    // No ingredients are pending for this non-blocking-mode-entry are pending
                                    handler.onCraftingJobEntryFinished(this.craftingNetwork, craftingJobId);
                                    jobEntryIt.remove();
                                }
                                if (jobsEntry.getValue().isEmpty()) {
                                    // No more entries for this crafting job are pending
                                    handler.onCraftingJobFinished(handler.getAllCraftingJobs().get(craftingJobId));
                                    handler.getProcessingCraftingJobsRaw().remove(craftingJobId);
                                    jobsEntryIt.remove();
                                }
                            }
                        }
                    }
                }
            }
        }
    }


}

1	package org.cyclops.integratedcrafting.core;
2
3	import com.google.common.collect.Maps;
4	import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
5	import it.unimi.dsi.fastutil.ints.IntIterator;
6	import it.unimi.dsi.fastutil.objects.ObjectIterator;
7	import org.apache.commons.compress.utils.Lists;
8	import org.cyclops.commoncapabilities.api.ingredient.*;
9	import org.cyclops.commoncapabilities.api.ingredient.storage.IIngredientComponentStorage;
10	import org.cyclops.cyclopscore.ingredient.collection.IIngredientCollection;
11	import org.cyclops.cyclopscore.ingredient.collection.IngredientCollectionPrototypeMap;
12	import org.cyclops.cyclopscore.ingredient.collection.IngredientList;
13	import org.cyclops.cyclopscore.ingredient.storage.IngredientComponentStorageCollectionWrapper;
14	import org.cyclops.cyclopscore.ingredient.storage.IngredientComponentStorageSlottedCollectionWrapper;
15	import org.cyclops.integratedcrafting.IntegratedCrafting;
16	import org.cyclops.integratedcrafting.api.crafting.CraftingJob;
17	import org.cyclops.integratedcrafting.api.network.ICraftingNetwork;
18	import org.cyclops.integrateddynamics.api.ingredient.IIngredientComponentStorageObservable;
19	import org.cyclops.integrateddynamics.api.network.INetwork;
20	import org.cyclops.integrateddynamics.api.network.INetworkIngredientsChannel;
21	import org.cyclops.integrateddynamics.api.network.IPositionedAddonsNetwork;
22	import org.cyclops.integrateddynamics.api.network.IPositionedAddonsNetworkIngredients;
23
24	import java.util.Iterator;
25	import java.util.List;
26	import java.util.ListIterator;
27	import java.util.Map;
28
29	/**
30	* An ingredient index observer that tracks crafting job outputs for a certain ingredient component type.
31	*
32	* It will observe changes and (partially) resolve awaiting crafting job outputs when applicable.
33	*
34	* @author rubensworks
35	*/
36	public class PendingCraftingJobResultIndexObserver<T, M>
37	implements IIngredientComponentStorageObservable.IIndexChangeObserver<T, M> {
38
39	private final IngredientComponent<T, M> ingredientComponent;
40	private final CraftingJobHandler handler;
41	private final ICraftingNetwork craftingNetwork;
42	private final IPositionedAddonsNetworkIngredients<T, M> ingredientsNetwork;
43	private final INetwork network;
44
45	public PendingCraftingJobResultIndexObserver(IngredientComponent<T, M> ingredientComponent, CraftingJobHandler handler, ICraftingNetwork craftingNetwork, IPositionedAddonsNetworkIngredients<T, M> ingredientsNetwork, INetwork network) {	×
46	this.ingredientComponent = ingredientComponent;	×
47	this.handler = handler;	×
48	this.craftingNetwork = craftingNetwork;	×
49	this.ingredientsNetwork = ingredientsNetwork;	×
50	this.network = network;	×
51	}	×
52
53	@Override
54	public void onChange(IIngredientComponentStorageObservable.StorageChangeEvent<T, M> event) {
55	if (event.getChangeType() == IIngredientComponentStorageObservable.Change.ADDITION	×
56	// If we're still initializing the network, skip addition events.
57	// Otherwise, we could incorrectly mark running crafting jobs as finished.
58	&& !event.isInitialChange()) {	×
59	IIngredientCollection<T, M> addedIngredients = event.getInstances();	×
60	IIngredientComponentStorage<T, M> ingredientsHayStack = null; // A mutable copy of addedIngredients (lazily created)	×
61	IIngredientMatcher<T, M> matcher = ingredientComponent.getMatcher();	×
62
63	Int2ObjectMap<List<Map<IngredientComponent<?, ?>, List<IPrototypedIngredient<?, ?>>>>> processingJobs = handler.getProcessingCraftingJobsPendingIngredients();	×
64	ObjectIterator<Int2ObjectMap.Entry<List<Map<IngredientComponent<?, ?>, List<IPrototypedIngredient<?, ?>>>>>> jobsEntryIt = processingJobs.int2ObjectEntrySet().iterator();	×
65	while (jobsEntryIt.hasNext()) {	×
66	Int2ObjectMap.Entry<List<Map<IngredientComponent<?, ?>, List<IPrototypedIngredient<?, ?>>>>> jobsEntry = jobsEntryIt.next();	×
67	int craftingJobId = jobsEntry.getIntKey();	×
68	// Only check jobs that have a matching channel with the event
69	CraftingJob craftingJob = handler.getAllCraftingJobs().get(jobsEntry.getIntKey());	×
70	if (craftingJob != null	×
71	&& (craftingJob.getChannel() == IPositionedAddonsNetwork.WILDCARD_CHANNEL \|\| craftingJob.getChannel() == event.getChannel())) {	×
72	Iterator<Map<IngredientComponent<?, ?>, List<IPrototypedIngredient<?, ?>>>> jobEntryIt = jobsEntry.getValue().iterator();	×
73	while (jobEntryIt.hasNext()) {	×
74	Map<IngredientComponent<?, ?>, List<IPrototypedIngredient<?, ?>>> jobEntry = jobEntryIt.next();	×
75	List<IPrototypedIngredient<?, ?>> pendingIngredientsUnsafe = jobEntry.get(ingredientComponent);	×
76	if (pendingIngredientsUnsafe != null) {	×
77	// Remove pending ingredients that were added in the event
78	List<IPrototypedIngredient<T, M>> pendingIngredients = (List<IPrototypedIngredient<T, M>>) (Object) pendingIngredientsUnsafe;	×
79
80	// Iterate over all pending ingredients for this ingredient component
81	ListIterator<IPrototypedIngredient<T, M>> it = pendingIngredients.listIterator();	×
82	while (it.hasNext()) {	×
83	IPrototypedIngredient<T, M> prototypedIngredient = it.next();	×
84	final long initialQuantity = matcher.getQuantity(prototypedIngredient.getPrototype());	×
85	long remainingQuantity = initialQuantity;	×
86
87	// Lazily create ingredientsHayStack only when needed,
88	// because we need to copy all ingredients from addedIngredients,
89	// which can get expensive
90	// We need to make a copy because multiple crafting jobs can have the same pending instances,
91	// so each instance may only be consumed by a single crafting job.
92	if (ingredientsHayStack == null) {	×
93	if (addedIngredients.contains(prototypedIngredient.getPrototype(),	×
94	prototypedIngredient.getCondition())) {	×
95	IngredientCollectionPrototypeMap<T, M> prototypeMap = new IngredientCollectionPrototypeMap<>(ingredientComponent);	×
96	ingredientsHayStack = new IngredientComponentStorageCollectionWrapper<>(prototypeMap);	×
97	prototypeMap.addAll(addedIngredients);	×
98	} else {
99	continue;
100	}
101	}
102
103	// Iteratively extract the pending ingredient from the hay stack.
104	T extracted;
105	do {
106	extracted = ingredientsHayStack.extract(prototypedIngredient.getPrototype(),	×
107	prototypedIngredient.getCondition(), false);	×
108
109	if (matcher.isEmpty(extracted)) {	×
110	// Quickly break when no matches are available anymore
111	break;	×
112	} else {
113	// Move this ingredient from storage to the first dependent crafting job.
114	IntIterator dependentJobs = craftingJob.getDependentCraftingJobs().intIterator();	×
115	while (dependentJobs.hasNext()) {	×
116	CraftingJob dependentJob = craftingNetwork.getCraftingJob(craftingJob.getChannel(), dependentJobs.nextInt());	×
117	if (dependentJob != null) {	×
118	INetworkIngredientsChannel<T, M> storage = this.ingredientsNetwork.getChannelInternal(craftingJob.getChannel());	×
119	T extractedFromStorage = storage.extract(extracted, matcher.getExactMatchCondition(), false);	×
120	if (!matcher.matchesExactly(extracted, extractedFromStorage)) {	×
121	IntegratedCrafting.clog("Unable to extract ingredient from storage for pending crafting job: " + extracted);	×
122	storage.insert(extractedFromStorage, false);	×
123	} else {
124	IMixedIngredients buffer = dependentJob.getIngredientsStorageBuffer();	×
125	if (!buffer.getComponents().contains(ingredientComponent)) {	×
126	Map<IngredientComponent<?, ?>, List<?>> mixedIngredientsRaw = Maps.newIdentityHashMap();	×
127	for (IngredientComponent<?, ?> component : buffer.getComponents()) {	×
128	mixedIngredientsRaw.put(component, buffer.getInstances(component));	×
129	}	×
130	List<T> list = Lists.newArrayList();	×
131	mixedIngredientsRaw.put(ingredientComponent, list);	×
132	list.add(extractedFromStorage);	×
133	buffer = new MixedIngredients(mixedIngredientsRaw);	×
134	dependentJob.setIngredientsStorageBuffer(buffer);	×
135	} else {	×
NEW 136	List<T> instances = buffer.getInstances(ingredientComponent);	×
NEW 137	if (!instances.stream().anyMatch(matcher::isEmpty)) {	×
138	// Make sure we have at least one empty slot available, to guarantee insertion can succeed.
NEW 139	instances.add(matcher.getEmptyInstance());	×
140	}
NEW 141	T remaining = new IngredientComponentStorageSlottedCollectionWrapper<>(new IngredientList<>(ingredientComponent, instances), Integer.MAX_VALUE, Integer.MAX_VALUE).insert(extractedFromStorage, false);	×
NEW 142	if (!matcher.isEmpty(remaining)) {	×
NEW 143	throw new IllegalStateException(String.format("Unable to insert %s into the crafting job buffer, remaining: ", extractedFromStorage, remaining));	×
144	}
145	}
146	}
147	break;	×
148	}
149	}	×
150	}
151
152	remainingQuantity -= matcher.getQuantity(extracted);	×
153	} while (!matcher.isEmpty(extracted) && remainingQuantity > 0);	×
154
155	// Update the list if the prototype has changed.
156	if (remainingQuantity <= 0) {	×
157	it.remove();	×
158	} else if (initialQuantity != remainingQuantity) {	×
159	it.set(new PrototypedIngredient<>(ingredientComponent,	×
160	matcher.withQuantity(prototypedIngredient.getPrototype(), remainingQuantity),	×
161	prototypedIngredient.getCondition()));	×
162	}
163	}	×
164
165	// If no prototypes for this component type for this crafting job for this job entry are pending.
166	if (pendingIngredients.isEmpty()) {	×
167	// Remove observer (in next tick) when all pending ingredients are resolved
168	handler.getObserversPendingDeletion().add(ingredientComponent);	×
169
170	// Remove crafting job if needed.
171	// No ingredients of this ingredient component type are pending
172	jobEntry.remove(ingredientComponent);	×
173	if (jobEntry.isEmpty()) {	×
174	// No ingredients are pending for this non-blocking-mode-entry are pending
175	handler.onCraftingJobEntryFinished(this.craftingNetwork, craftingJobId);	×
176	jobEntryIt.remove();	×
177	}
178	if (jobsEntry.getValue().isEmpty()) {	×
179	// No more entries for this crafting job are pending
180	handler.onCraftingJobFinished(handler.getAllCraftingJobs().get(craftingJobId));	×
181	handler.getProcessingCraftingJobsRaw().remove(craftingJobId);	×
182	jobsEntryIt.remove();	×
183	}
184	}
185	}
186	}	×
187	}
188	}	×
189	}
190	}	×
191
192
193	}

CyclopsMC / IntegratedCrafting / #479011826

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous