#479011834

Committed 31 Dec 2025 02:03PM UTC coverage: 23.802% (-1.1%) from 24.876%

Build # #479011834

Build Type

push

github

Committed by

rubensworks

Commit Message

Fix incorrect commoncapabilities version

Run Details

755 of 3172 relevant lines covered (23.8%)

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/network/CraftingNetwork.java

package org.cyclops.integratedcrafting.core.network;

import com.google.common.collect.Iterators;
import com.google.common.collect.Multimap;
import com.google.common.collect.MultimapBuilder;
import com.google.common.collect.Sets;
import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
import it.unimi.dsi.fastutil.ints.IntListIterator;
import net.minecraft.world.level.Level;
import net.minecraftforge.server.ServerLifecycleHooks;
import org.cyclops.commoncapabilities.api.capability.recipehandler.IRecipeDefinition;
import org.cyclops.commoncapabilities.api.ingredient.IngredientComponent;
import org.cyclops.commoncapabilities.api.ingredient.storage.IIngredientComponentStorage;
import org.cyclops.cyclopscore.datastructure.MultitransformIterator;
import org.cyclops.integratedcrafting.api.crafting.CraftingJob;
import org.cyclops.integratedcrafting.api.crafting.CraftingJobDependencyGraph;
import org.cyclops.integratedcrafting.api.crafting.ICraftingInterface;
import org.cyclops.integratedcrafting.api.crafting.UnavailableCraftingInterfacesException;
import org.cyclops.integratedcrafting.api.network.ICraftingNetwork;
import org.cyclops.integratedcrafting.api.recipe.ICraftingJobIndexModifiable;
import org.cyclops.integratedcrafting.api.recipe.IRecipeIndexModifiable;
import org.cyclops.integratedcrafting.core.CraftingHelpers;
import org.cyclops.integratedcrafting.core.CraftingJobIndexDefault;
import org.cyclops.integratedcrafting.core.RecipeIndexDefault;
import org.cyclops.integrateddynamics.api.network.IPositionedAddonsNetwork;

import javax.annotation.Nullable;
import java.util.Collection;
import java.util.Iterator;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * A crafting handler network with multiple channels.
 * @author rubensworks
 */
public class CraftingNetwork implements ICraftingNetwork {

    private final Set<ICraftingInterface> allCraftingInterfaces = Sets.newHashSet();
    private final Int2ObjectMap<Set<ICraftingInterface>> craftingInterfaces = new Int2ObjectOpenHashMap<>();

    private final Multimap<IRecipeDefinition, ICraftingInterface> allRecipeCraftingInterfaces = newRecipeCraftingInterfacesMap();
    private final Int2ObjectMap<Multimap<IRecipeDefinition, ICraftingInterface>> recipeCraftingInterfaces = new Int2ObjectOpenHashMap<>();

    private final IRecipeIndexModifiable allRecipesIndex = new RecipeIndexDefault();
    private final Int2ObjectMap<IRecipeIndexModifiable> recipeIndexes = new Int2ObjectOpenHashMap<>();

    private final ICraftingJobIndexModifiable allIndexedCraftingJobs = new CraftingJobIndexDefault();
    private final Int2ObjectMap<ICraftingJobIndexModifiable> indexedCraftingJobs = new Int2ObjectOpenHashMap<>();

    private final Int2ObjectMap<ICraftingInterface> allCraftingJobsToInterface = new Int2ObjectOpenHashMap<>();
    private final Int2ObjectMap<Int2ObjectMap<ICraftingInterface>> channeledCraftingJobsToInterface = new Int2ObjectOpenHashMap<>();

    private final CraftingJobDependencyGraph craftingJobDependencyGraph = new CraftingJobDependencyGraph();

    protected static Multimap<IRecipeDefinition, ICraftingInterface> newRecipeCraftingInterfacesMap() {
        return MultimapBuilder.hashKeys().treeSetValues(ICraftingInterface.createComparator()).build();
    }

    @Override
    public int[] getChannels() {
        return craftingInterfaces.keySet().toIntArray();
    }

    @Override
    public Set<ICraftingInterface> getCraftingInterfaces(int channel) {
        if (channel == IPositionedAddonsNetwork.WILDCARD_CHANNEL) {
            return allCraftingInterfaces;
        }
        Set<ICraftingInterface> craftingInterfaces = this.craftingInterfaces.get(channel);
        if (craftingInterfaces == null) {
            craftingInterfaces = Sets.newTreeSet(ICraftingInterface.createComparator());
            this.craftingInterfaces.put(channel, craftingInterfaces);
        }
        return craftingInterfaces;
    }

    @Override
    public Multimap<IRecipeDefinition, ICraftingInterface> getRecipeCraftingInterfaces(int channel) {
        if (channel == IPositionedAddonsNetwork.WILDCARD_CHANNEL) {
            return allRecipeCraftingInterfaces;
        }
        Multimap<IRecipeDefinition, ICraftingInterface> recipeCraftingInterfaces = this.recipeCraftingInterfaces.get(channel);
        if (recipeCraftingInterfaces == null) {
            recipeCraftingInterfaces = newRecipeCraftingInterfacesMap();
            this.recipeCraftingInterfaces.put(channel, recipeCraftingInterfaces);
        }
        return recipeCraftingInterfaces;
    }

    @Override
    public IRecipeIndexModifiable getRecipeIndex(int channel) {
        if (channel == IPositionedAddonsNetwork.WILDCARD_CHANNEL) {
            return allRecipesIndex;
        }
        IRecipeIndexModifiable recipeIndex = this.recipeIndexes.get(channel);
        if (recipeIndex == null) {
            recipeIndex = new RecipeIndexDefault();
            this.recipeIndexes.put(channel, recipeIndex);
        }
        return recipeIndex;
    }

    @Override
    public boolean addCraftingInterface(int channel, ICraftingInterface craftingInterface) {
        // Only process deeper indexes if the interface was not yet present
        if (getCraftingInterfaces(channel).add(craftingInterface)) {
            allCraftingInterfaces.add(craftingInterface);
            IRecipeIndexModifiable recipeIndex = getRecipeIndex(channel);
            Multimap<IRecipeDefinition, ICraftingInterface> recipeCraftingInterfaces = getRecipeCraftingInterfaces(channel);
            for (IRecipeDefinition recipe : craftingInterface.getRecipes()) {
                // Save the recipes in the index
                recipeIndex.addRecipe(recipe);
                allRecipesIndex.addRecipe(recipe);
                // Save a mapping from each of the recipes to this crafting interface
                recipeCraftingInterfaces.put(recipe, craftingInterface);
                allRecipeCraftingInterfaces.put(recipe, craftingInterface);
            }

            // Loop over the crafting jobs owned by the interface
            Iterator<CraftingJob> craftingJobsIt = craftingInterface.getCraftingJobs();
            while (craftingJobsIt.hasNext()) {
                CraftingJob craftingJob = craftingJobsIt.next();

                // Store mapping between interface and job in the network
                addCraftingJob(craftingJob.getChannel(), craftingJob, craftingInterface);

                // Add the crafting job dependencies
                craftingJobDependencyGraph.addCraftingJobId(craftingJob);
                IntListIterator dependencyIt = craftingJob.getDependencyCraftingJobs().iterator();
                while (dependencyIt.hasNext()) {
                    craftingJobDependencyGraph.addDependency(craftingJob, dependencyIt.nextInt());
                }
            }

            return true;
        }
        return false;
    }

    @Override
    public boolean removeCraftingInterface(int channel, ICraftingInterface craftingInterface) {
        // Only process deeper indexes if the interface was present
        if (getCraftingInterfaces(channel).remove(craftingInterface)) {
            allCraftingInterfaces.remove(craftingInterface);
            IRecipeIndexModifiable recipeIndex = getRecipeIndex(channel);
            Multimap<IRecipeDefinition, ICraftingInterface> recipeCraftingInterfaces = getRecipeCraftingInterfaces(channel);
            for (IRecipeDefinition recipe : craftingInterface.getRecipes()) {
                // Remove the mappings from each of the recipes to this crafting interface
                recipeCraftingInterfaces.remove(recipe, craftingInterface);
                allRecipeCraftingInterfaces.remove(recipe, craftingInterface);

                // If the mapping from this recipe to crafting interfaces is empty, remove the recipe from the index
                if (!recipeCraftingInterfaces.containsKey(recipe)) {
                    recipeIndex.removeRecipe(recipe);
                }
                if (!allRecipeCraftingInterfaces.containsKey(recipe)) {
                    allRecipesIndex.removeRecipe(recipe);
                }
            }

            // Try cleaning up the channel
            cleanupChannelIfEmpty(channel);

            // Loop over the crafting jobs owned by the interface
            Iterator<CraftingJob> craftingJobsIt = craftingInterface.getCraftingJobs();
            while (craftingJobsIt.hasNext()) {
                CraftingJob craftingJob = craftingJobsIt.next();

                // Remove the mapping between interface and job in the network
                removeCraftingJob(channel, craftingJob);

                // Remove the crafting job dependencies
                craftingJobDependencyGraph.removeCraftingJobId(craftingJob);
            }

            return true;
        }
        return false;
    }

    @Override
    public boolean addCraftingInterfaceRecipe(int channel, ICraftingInterface craftingInterface, IRecipeDefinition recipe) {
        IRecipeIndexModifiable recipeIndex = getRecipeIndex(channel);
        Multimap<IRecipeDefinition, ICraftingInterface> recipeCraftingInterfaces = getRecipeCraftingInterfaces(channel);

        // Save the recipes in the index
        recipeIndex.addRecipe(recipe);
        allRecipesIndex.addRecipe(recipe);
        // Save a mapping from each of the recipes to this crafting interface
        boolean changed = recipeCraftingInterfaces.put(recipe, craftingInterface);
        allRecipeCraftingInterfaces.put(recipe, craftingInterface);

        return changed;
    }

    @Override
    public boolean removeCraftingInterfaceRecipe(int channel, ICraftingInterface craftingInterface, IRecipeDefinition recipe) {
        IRecipeIndexModifiable recipeIndex = getRecipeIndex(channel);
        Multimap<IRecipeDefinition, ICraftingInterface> recipeCraftingInterfaces = getRecipeCraftingInterfaces(channel);

        // Remove the mappings from each of the recipes to this crafting interface
        boolean changed = recipeCraftingInterfaces.remove(recipe, craftingInterface);
        allRecipeCraftingInterfaces.remove(recipe, craftingInterface);

        // If the mapping from this recipe to crafting interfaces is empty, remove the recipe from the index
        if (!recipeCraftingInterfaces.containsKey(recipe)) {
            recipeIndex.removeRecipe(recipe);
        }
        if (!allRecipeCraftingInterfaces.containsKey(recipe)) {
            allRecipesIndex.removeRecipe(recipe);
        }

        return changed;
    }

    @Override
    public void scheduleCraftingJob(CraftingJob craftingJob, boolean allowDistribution, Function<IngredientComponent<?, ?>, IIngredientComponentStorage> storageGetter)
            throws UnavailableCraftingInterfacesException {
        Multimap<IRecipeDefinition, ICraftingInterface> recipeInterfaces = getRecipeCraftingInterfaces(craftingJob.getChannel());
        Collection<ICraftingInterface> craftingInterfaces = recipeInterfaces.get(craftingJob.getRecipe())
                .stream()
                .filter(ICraftingInterface::canScheduleCraftingJobs)
                .collect(Collectors.toList());

        if (craftingInterfaces.size() == 0) {
            throw new UnavailableCraftingInterfacesException(craftingJob);
        }

        // If our crafting job amount is larger than 1,
        // and we have multiple crafting interfaces available,
        // split our crafting job so we can distribute
        if (allowDistribution && craftingInterfaces.size() > 1 && craftingJob.getAmount() > 1) {
            Collection<CraftingJob> splitCraftingJobs = CraftingHelpers.splitCraftingJobs(craftingJob,
                    craftingInterfaces.size(), getCraftingJobDependencyGraph(),
                    CraftingHelpers.getGlobalCraftingJobIdentifier());
            for (CraftingJob splitCraftingJob : splitCraftingJobs) {
                scheduleCraftingJob(splitCraftingJob, false, storageGetter);
            }
            return;
        }

        // Find the crafting interface that has the least number of crafting jobs.
        // This will achieve parallelized jobs.
        int bestCraftingInterfaceJobCount = 0;
        ICraftingInterface bestCraftingInterface = null;
        for (ICraftingInterface craftingInterface : craftingInterfaces) {
            int jobCount = craftingInterface.getCraftingJobsCount();
            if (bestCraftingInterface == null || jobCount < bestCraftingInterfaceJobCount) {
                bestCraftingInterfaceJobCount = jobCount;
                bestCraftingInterface = craftingInterface;
                if (bestCraftingInterfaceJobCount == 0) {
                    break; // Break early, as we won't find a better interface than one with zero jobs
                }
            }
        }

        // This should not be null, but let's check to be sure.
        if (bestCraftingInterface != null) {
            // Extract from storage
            bestCraftingInterface.fillCraftingJobBufferFromStorage(craftingJob, storageGetter);

            // Schedule the job in the interface
            bestCraftingInterface.scheduleCraftingJob(craftingJob);
            addCraftingJob(craftingJob.getChannel(), craftingJob, bestCraftingInterface);

            // Store the starting tick in the job
            craftingJob.setStartTick(getCurrentTick());
        }
    }

    protected long getCurrentTick() {
        return ServerLifecycleHooks.getCurrentServer().getLevel(Level.OVERWORLD).getGameTime();
    }

    @Override
    public void onCraftingJobFinished(CraftingJob craftingJob) {
        removeCraftingJob(craftingJob.getChannel(), craftingJob);
        getCraftingJobDependencyGraph().onCraftingJobFinished(craftingJob);
    }

    @Override
    public boolean cancelCraftingJob(int channel, int craftingJobId) {
        CraftingJob craftingJob = getCraftingJob(channel, craftingJobId);
        if (craftingJob != null) {
            cancelCraftingJob(craftingJob);
            return true;
        }
        return false;
    }

    protected void cancelCraftingJob(CraftingJob craftingJob) {
        // First cancel all dependencies
        for (CraftingJob dependency : getCraftingJobDependencyGraph().getDependencies(craftingJob)) {
            cancelCraftingJob(dependency);
        }

        // Remove all job references from the interface
        ICraftingInterface craftingInterface = getCraftingJobInterface(craftingJob.getChannel(), craftingJob.getId());
        if (craftingInterface != null) {
            craftingInterface.cancelCraftingJob(craftingJob.getChannel(), craftingJob.getId());
        }

        // Remove all job references from the network
        onCraftingJobFinished(craftingJob);
    }

    @Override
    public Iterator<CraftingJob> getCraftingJobs(int channel) {
        return new MultitransformIterator<>(getCraftingInterfaces(channel).iterator(),
                ICraftingInterface::getCraftingJobs);
    }

    @Nullable
    @Override
    public CraftingJob getCraftingJob(int channel, int craftingJobId) {
        if (channel == IPositionedAddonsNetwork.WILDCARD_CHANNEL) {
            return allIndexedCraftingJobs.getCraftingJob(craftingJobId);
        }

        // Check for the channel directly
        ICraftingJobIndexModifiable index = indexedCraftingJobs.get(channel);
        if (index != null) {
            CraftingJob craftingJob = index.getCraftingJob(craftingJobId);
            if (craftingJob != null) {
                return craftingJob;
            }
        }

        // Check for the case the crafting job was explicitly started on the wildcard channel
        ICraftingJobIndexModifiable wildcardIndex = indexedCraftingJobs.get(IPositionedAddonsNetwork.WILDCARD_CHANNEL);
        if (wildcardIndex != null) {
            return wildcardIndex.getCraftingJob(craftingJobId);
        }

        return null;
    }

    protected void addCraftingJob(int channel, CraftingJob craftingJob, ICraftingInterface craftingInterface) {
        // Prepare crafting job index
        ICraftingJobIndexModifiable craftingJobIndex = indexedCraftingJobs.get(channel);
        if (craftingJobIndex == null) {
            craftingJobIndex = new CraftingJobIndexDefault();
            indexedCraftingJobs.put(channel, craftingJobIndex);
        }

        // Prepare crafting job to interface mapping
        Int2ObjectMap<ICraftingInterface> craftingJobsToInterface = this.channeledCraftingJobsToInterface.get(channel);
        if (craftingJobsToInterface == null) {
            craftingJobsToInterface = new Int2ObjectOpenHashMap<>();
            this.channeledCraftingJobsToInterface.put(channel, craftingJobsToInterface);
        }

        // Insert into crafting job index
        allIndexedCraftingJobs.addCraftingJob(craftingJob);
        craftingJobIndex.addCraftingJob(craftingJob);

        // Insert into crafting job to interface mapping
        allCraftingJobsToInterface.put(craftingJob.getId(), craftingInterface);
        craftingJobsToInterface.put(craftingJob.getId(), craftingInterface);
    }

    protected void removeCraftingJob(int channel, CraftingJob craftingJob) {
        // Prepare crafting job index
        ICraftingJobIndexModifiable craftingJobIndex = indexedCraftingJobs.get(channel);

        // Prepare crafting job to interface mapping
        Int2ObjectMap<ICraftingInterface> craftingJobsToInterface = this.channeledCraftingJobsToInterface.get(channel);

        // Remove from crafting job index
        allIndexedCraftingJobs.removeCraftingJob(craftingJob);
        if (craftingJobIndex != null) {
            craftingJobIndex.removeCraftingJob(craftingJob);
        }

        // Remove from crafting job to interface mapping
        allCraftingJobsToInterface.remove(craftingJob.getId());
        if (craftingJobsToInterface != null) {
            craftingJobsToInterface.remove(craftingJob.getId());
        }
    }

    @Override
    public <T, M> Iterator<CraftingJob> getCraftingJobs(int channel, IngredientComponent<T, M> ingredientComponent,
                                                        T instance, M matchCondition) {
        if (channel == IPositionedAddonsNetwork.WILDCARD_CHANNEL) {
            return allIndexedCraftingJobs.getCraftingJobs(ingredientComponent, instance, matchCondition);
        }

        // Check for the specific channel
        ICraftingJobIndexModifiable craftingJobIndex = indexedCraftingJobs.get(channel);
        Iterator<CraftingJob> channelIterator;
        if (craftingJobIndex != null) {
            channelIterator = craftingJobIndex.getCraftingJobs(ingredientComponent, instance, matchCondition);
        } else {
            channelIterator = Iterators.forArray();
        }

        // Check for the case the crafting job was explicitly started on the wildcard channel
        ICraftingJobIndexModifiable wildcardCraftingJobIndex = indexedCraftingJobs.get(IPositionedAddonsNetwork.WILDCARD_CHANNEL);
        Iterator<CraftingJob> wildcardChannelIterator;
        if (wildcardCraftingJobIndex != null) {
            wildcardChannelIterator = wildcardCraftingJobIndex.getCraftingJobs(ingredientComponent, instance, matchCondition);
        } else {
            wildcardChannelIterator = Iterators.forArray();
        }

        // Concat both iterators
        return Iterators.concat(channelIterator, wildcardChannelIterator);
    }

    @Override
    public CraftingJobDependencyGraph getCraftingJobDependencyGraph() {
        return craftingJobDependencyGraph;
    }

    @Nullable
    @Override
    public ICraftingInterface getCraftingJobInterface(int channel, int craftingJobId) {
        if (channel == IPositionedAddonsNetwork.WILDCARD_CHANNEL) {
            return allCraftingJobsToInterface.get(craftingJobId);
        }

        // Check for the channel directly
        Int2ObjectMap<ICraftingInterface> craftingJobsToInterface = this.channeledCraftingJobsToInterface.get(channel);
        if (craftingJobsToInterface != null) {
            ICraftingInterface craftingInterface = craftingJobsToInterface.get(craftingJobId);
            if (craftingInterface != null) {
                return craftingInterface;
            }
        }

        // In case the crafting job was explicitly started on the wildcard channel
        Int2ObjectMap<ICraftingInterface> craftingJobsToInterfaceWildcard = this.channeledCraftingJobsToInterface
                .get(IPositionedAddonsNetwork.WILDCARD_CHANNEL);
        if (craftingJobsToInterfaceWildcard != null) {
            return craftingJobsToInterfaceWildcard.get(craftingJobId);
        }

        return null;
    }

    @Override
    public long getRunningTicks(CraftingJob craftingJob) {
        return getCurrentTick() - craftingJob.getStartTick();
    }

    protected void cleanupChannelIfEmpty(int channel) {
        Set<ICraftingInterface> craftingInterfaces = this.craftingInterfaces.get(channel);
        if (craftingInterfaces != null && craftingInterfaces.isEmpty()) {
            this.craftingInterfaces.remove(channel);
            this.recipeIndexes.remove(channel);
            this.recipeCraftingInterfaces.remove(channel);
        }
    }
}

1	package org.cyclops.integratedcrafting.core.network;
2
3	import com.google.common.collect.Iterators;
4	import com.google.common.collect.Multimap;
5	import com.google.common.collect.MultimapBuilder;
6	import com.google.common.collect.Sets;
7	import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
8	import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
9	import it.unimi.dsi.fastutil.ints.IntListIterator;
10	import net.minecraft.world.level.Level;
11	import net.minecraftforge.server.ServerLifecycleHooks;
12	import org.cyclops.commoncapabilities.api.capability.recipehandler.IRecipeDefinition;
13	import org.cyclops.commoncapabilities.api.ingredient.IngredientComponent;
14	import org.cyclops.commoncapabilities.api.ingredient.storage.IIngredientComponentStorage;
15	import org.cyclops.cyclopscore.datastructure.MultitransformIterator;
16	import org.cyclops.integratedcrafting.api.crafting.CraftingJob;
17	import org.cyclops.integratedcrafting.api.crafting.CraftingJobDependencyGraph;
18	import org.cyclops.integratedcrafting.api.crafting.ICraftingInterface;
19	import org.cyclops.integratedcrafting.api.crafting.UnavailableCraftingInterfacesException;
20	import org.cyclops.integratedcrafting.api.network.ICraftingNetwork;
21	import org.cyclops.integratedcrafting.api.recipe.ICraftingJobIndexModifiable;
22	import org.cyclops.integratedcrafting.api.recipe.IRecipeIndexModifiable;
23	import org.cyclops.integratedcrafting.core.CraftingHelpers;
24	import org.cyclops.integratedcrafting.core.CraftingJobIndexDefault;
25	import org.cyclops.integratedcrafting.core.RecipeIndexDefault;
26	import org.cyclops.integrateddynamics.api.network.IPositionedAddonsNetwork;
27
28	import javax.annotation.Nullable;
29	import java.util.Collection;
30	import java.util.Iterator;
31	import java.util.Set;
32	import java.util.function.Function;
33	import java.util.stream.Collectors;
34
35	/**
36	* A crafting handler network with multiple channels.
37	* @author rubensworks
38	*/
39	public class CraftingNetwork implements ICraftingNetwork {	×
40
41	private final Set<ICraftingInterface> allCraftingInterfaces = Sets.newHashSet();	×
42	private final Int2ObjectMap<Set<ICraftingInterface>> craftingInterfaces = new Int2ObjectOpenHashMap<>();	×
43
44	private final Multimap<IRecipeDefinition, ICraftingInterface> allRecipeCraftingInterfaces = newRecipeCraftingInterfacesMap();	×
45	private final Int2ObjectMap<Multimap<IRecipeDefinition, ICraftingInterface>> recipeCraftingInterfaces = new Int2ObjectOpenHashMap<>();	×
46
47	private final IRecipeIndexModifiable allRecipesIndex = new RecipeIndexDefault();	×
48	private final Int2ObjectMap<IRecipeIndexModifiable> recipeIndexes = new Int2ObjectOpenHashMap<>();	×
49
50	private final ICraftingJobIndexModifiable allIndexedCraftingJobs = new CraftingJobIndexDefault();	×
51	private final Int2ObjectMap<ICraftingJobIndexModifiable> indexedCraftingJobs = new Int2ObjectOpenHashMap<>();	×
52
53	private final Int2ObjectMap<ICraftingInterface> allCraftingJobsToInterface = new Int2ObjectOpenHashMap<>();	×
54	private final Int2ObjectMap<Int2ObjectMap<ICraftingInterface>> channeledCraftingJobsToInterface = new Int2ObjectOpenHashMap<>();	×
55
56	private final CraftingJobDependencyGraph craftingJobDependencyGraph = new CraftingJobDependencyGraph();	×
57
58	protected static Multimap<IRecipeDefinition, ICraftingInterface> newRecipeCraftingInterfacesMap() {
59	return MultimapBuilder.hashKeys().treeSetValues(ICraftingInterface.createComparator()).build();	×
60	}
61
62	@Override
63	public int[] getChannels() {
64	return craftingInterfaces.keySet().toIntArray();	×
65	}
66
67	@Override
68	public Set<ICraftingInterface> getCraftingInterfaces(int channel) {
69	if (channel == IPositionedAddonsNetwork.WILDCARD_CHANNEL) {	×
70	return allCraftingInterfaces;	×
71	}
72	Set<ICraftingInterface> craftingInterfaces = this.craftingInterfaces.get(channel);	×
73	if (craftingInterfaces == null) {	×
74	craftingInterfaces = Sets.newTreeSet(ICraftingInterface.createComparator());	×
75	this.craftingInterfaces.put(channel, craftingInterfaces);	×
76	}
77	return craftingInterfaces;	×
78	}
79
80	@Override
81	public Multimap<IRecipeDefinition, ICraftingInterface> getRecipeCraftingInterfaces(int channel) {
82	if (channel == IPositionedAddonsNetwork.WILDCARD_CHANNEL) {	×
83	return allRecipeCraftingInterfaces;	×
84	}
85	Multimap<IRecipeDefinition, ICraftingInterface> recipeCraftingInterfaces = this.recipeCraftingInterfaces.get(channel);	×
86	if (recipeCraftingInterfaces == null) {	×
87	recipeCraftingInterfaces = newRecipeCraftingInterfacesMap();	×
88	this.recipeCraftingInterfaces.put(channel, recipeCraftingInterfaces);	×
89	}
90	return recipeCraftingInterfaces;	×
91	}
92
93	@Override
94	public IRecipeIndexModifiable getRecipeIndex(int channel) {
95	if (channel == IPositionedAddonsNetwork.WILDCARD_CHANNEL) {	×
96	return allRecipesIndex;	×
97	}
98	IRecipeIndexModifiable recipeIndex = this.recipeIndexes.get(channel);	×
99	if (recipeIndex == null) {	×
100	recipeIndex = new RecipeIndexDefault();	×
101	this.recipeIndexes.put(channel, recipeIndex);	×
102	}
103	return recipeIndex;	×
104	}
105
106	@Override
107	public boolean addCraftingInterface(int channel, ICraftingInterface craftingInterface) {
108	// Only process deeper indexes if the interface was not yet present
109	if (getCraftingInterfaces(channel).add(craftingInterface)) {	×
110	allCraftingInterfaces.add(craftingInterface);	×
111	IRecipeIndexModifiable recipeIndex = getRecipeIndex(channel);	×
112	Multimap<IRecipeDefinition, ICraftingInterface> recipeCraftingInterfaces = getRecipeCraftingInterfaces(channel);	×
113	for (IRecipeDefinition recipe : craftingInterface.getRecipes()) {	×
114	// Save the recipes in the index
115	recipeIndex.addRecipe(recipe);	×
116	allRecipesIndex.addRecipe(recipe);	×
117	// Save a mapping from each of the recipes to this crafting interface
118	recipeCraftingInterfaces.put(recipe, craftingInterface);	×
119	allRecipeCraftingInterfaces.put(recipe, craftingInterface);	×
120	}	×
121
122	// Loop over the crafting jobs owned by the interface
123	Iterator<CraftingJob> craftingJobsIt = craftingInterface.getCraftingJobs();	×
124	while (craftingJobsIt.hasNext()) {	×
125	CraftingJob craftingJob = craftingJobsIt.next();	×
126
127	// Store mapping between interface and job in the network
128	addCraftingJob(craftingJob.getChannel(), craftingJob, craftingInterface);	×
129
130	// Add the crafting job dependencies
131	craftingJobDependencyGraph.addCraftingJobId(craftingJob);	×
132	IntListIterator dependencyIt = craftingJob.getDependencyCraftingJobs().iterator();	×
133	while (dependencyIt.hasNext()) {	×
134	craftingJobDependencyGraph.addDependency(craftingJob, dependencyIt.nextInt());	×
135	}
136	}	×
137
138	return true;	×
139	}
140	return false;	×
141	}
142
143	@Override
144	public boolean removeCraftingInterface(int channel, ICraftingInterface craftingInterface) {
145	// Only process deeper indexes if the interface was present
146	if (getCraftingInterfaces(channel).remove(craftingInterface)) {	×
147	allCraftingInterfaces.remove(craftingInterface);	×
148	IRecipeIndexModifiable recipeIndex = getRecipeIndex(channel);	×
149	Multimap<IRecipeDefinition, ICraftingInterface> recipeCraftingInterfaces = getRecipeCraftingInterfaces(channel);	×
150	for (IRecipeDefinition recipe : craftingInterface.getRecipes()) {	×
151	// Remove the mappings from each of the recipes to this crafting interface
152	recipeCraftingInterfaces.remove(recipe, craftingInterface);	×
153	allRecipeCraftingInterfaces.remove(recipe, craftingInterface);	×
154
155	// If the mapping from this recipe to crafting interfaces is empty, remove the recipe from the index
156	if (!recipeCraftingInterfaces.containsKey(recipe)) {	×
157	recipeIndex.removeRecipe(recipe);	×
158	}
159	if (!allRecipeCraftingInterfaces.containsKey(recipe)) {	×
160	allRecipesIndex.removeRecipe(recipe);	×
161	}
162	}	×
163
164	// Try cleaning up the channel
165	cleanupChannelIfEmpty(channel);	×
166
167	// Loop over the crafting jobs owned by the interface
168	Iterator<CraftingJob> craftingJobsIt = craftingInterface.getCraftingJobs();	×
169	while (craftingJobsIt.hasNext()) {	×
170	CraftingJob craftingJob = craftingJobsIt.next();	×
171
172	// Remove the mapping between interface and job in the network
173	removeCraftingJob(channel, craftingJob);	×
174
175	// Remove the crafting job dependencies
176	craftingJobDependencyGraph.removeCraftingJobId(craftingJob);	×
177	}	×
178
179	return true;	×
180	}
181	return false;	×
182	}
183
184	@Override
185	public boolean addCraftingInterfaceRecipe(int channel, ICraftingInterface craftingInterface, IRecipeDefinition recipe) {
186	IRecipeIndexModifiable recipeIndex = getRecipeIndex(channel);	×
187	Multimap<IRecipeDefinition, ICraftingInterface> recipeCraftingInterfaces = getRecipeCraftingInterfaces(channel);	×
188
189	// Save the recipes in the index
190	recipeIndex.addRecipe(recipe);	×
191	allRecipesIndex.addRecipe(recipe);	×
192	// Save a mapping from each of the recipes to this crafting interface
193	boolean changed = recipeCraftingInterfaces.put(recipe, craftingInterface);	×
194	allRecipeCraftingInterfaces.put(recipe, craftingInterface);	×
195
196	return changed;	×
197	}
198
199	@Override
200	public boolean removeCraftingInterfaceRecipe(int channel, ICraftingInterface craftingInterface, IRecipeDefinition recipe) {
201	IRecipeIndexModifiable recipeIndex = getRecipeIndex(channel);	×
202	Multimap<IRecipeDefinition, ICraftingInterface> recipeCraftingInterfaces = getRecipeCraftingInterfaces(channel);	×
203
204	// Remove the mappings from each of the recipes to this crafting interface
205	boolean changed = recipeCraftingInterfaces.remove(recipe, craftingInterface);	×
206	allRecipeCraftingInterfaces.remove(recipe, craftingInterface);	×
207
208	// If the mapping from this recipe to crafting interfaces is empty, remove the recipe from the index
209	if (!recipeCraftingInterfaces.containsKey(recipe)) {	×
210	recipeIndex.removeRecipe(recipe);	×
211	}
212	if (!allRecipeCraftingInterfaces.containsKey(recipe)) {	×
213	allRecipesIndex.removeRecipe(recipe);	×
214	}
215
216	return changed;	×
217	}
218
219	@Override
220	public void scheduleCraftingJob(CraftingJob craftingJob, boolean allowDistribution, Function<IngredientComponent<?, ?>, IIngredientComponentStorage> storageGetter)
221	throws UnavailableCraftingInterfacesException {
222	Multimap<IRecipeDefinition, ICraftingInterface> recipeInterfaces = getRecipeCraftingInterfaces(craftingJob.getChannel());	×
223	Collection<ICraftingInterface> craftingInterfaces = recipeInterfaces.get(craftingJob.getRecipe())	×
224	.stream()	×
225	.filter(ICraftingInterface::canScheduleCraftingJobs)	×
226	.collect(Collectors.toList());	×
227
228	if (craftingInterfaces.size() == 0) {	×
229	throw new UnavailableCraftingInterfacesException(craftingJob);	×
230	}
231
232	// If our crafting job amount is larger than 1,
233	// and we have multiple crafting interfaces available,
234	// split our crafting job so we can distribute
235	if (allowDistribution && craftingInterfaces.size() > 1 && craftingJob.getAmount() > 1) {	×
236	Collection<CraftingJob> splitCraftingJobs = CraftingHelpers.splitCraftingJobs(craftingJob,	×
237	craftingInterfaces.size(), getCraftingJobDependencyGraph(),	×
238	CraftingHelpers.getGlobalCraftingJobIdentifier());	×
239	for (CraftingJob splitCraftingJob : splitCraftingJobs) {	×
240	scheduleCraftingJob(splitCraftingJob, false, storageGetter);	×
241	}	×
242	return;	×
243	}
244
245	// Find the crafting interface that has the least number of crafting jobs.
246	// This will achieve parallelized jobs.
247	int bestCraftingInterfaceJobCount = 0;	×
248	ICraftingInterface bestCraftingInterface = null;	×
249	for (ICraftingInterface craftingInterface : craftingInterfaces) {	×
250	int jobCount = craftingInterface.getCraftingJobsCount();	×
251	if (bestCraftingInterface == null \|\| jobCount < bestCraftingInterfaceJobCount) {	×
252	bestCraftingInterfaceJobCount = jobCount;	×
253	bestCraftingInterface = craftingInterface;	×
254	if (bestCraftingInterfaceJobCount == 0) {	×
255	break; // Break early, as we won't find a better interface than one with zero jobs	×
256	}
257	}
258	}	×
259
260	// This should not be null, but let's check to be sure.
261	if (bestCraftingInterface != null) {	×
262	// Extract from storage
263	bestCraftingInterface.fillCraftingJobBufferFromStorage(craftingJob, storageGetter);	×
264
265	// Schedule the job in the interface
266	bestCraftingInterface.scheduleCraftingJob(craftingJob);	×
267	addCraftingJob(craftingJob.getChannel(), craftingJob, bestCraftingInterface);	×
268
269	// Store the starting tick in the job
270	craftingJob.setStartTick(getCurrentTick());	×
271	}
272	}	×
273
274	protected long getCurrentTick() {
275	return ServerLifecycleHooks.getCurrentServer().getLevel(Level.OVERWORLD).getGameTime();	×
276	}
277
278	@Override
279	public void onCraftingJobFinished(CraftingJob craftingJob) {
280	removeCraftingJob(craftingJob.getChannel(), craftingJob);	×
281	getCraftingJobDependencyGraph().onCraftingJobFinished(craftingJob);	×
282	}	×
283
284	@Override
285	public boolean cancelCraftingJob(int channel, int craftingJobId) {
286	CraftingJob craftingJob = getCraftingJob(channel, craftingJobId);	×
287	if (craftingJob != null) {	×
288	cancelCraftingJob(craftingJob);	×
289	return true;	×
290	}
291	return false;	×
292	}
293
294	protected void cancelCraftingJob(CraftingJob craftingJob) {
295	// First cancel all dependencies
296	for (CraftingJob dependency : getCraftingJobDependencyGraph().getDependencies(craftingJob)) {	×
297	cancelCraftingJob(dependency);	×
298	}	×
299
300	// Remove all job references from the interface
301	ICraftingInterface craftingInterface = getCraftingJobInterface(craftingJob.getChannel(), craftingJob.getId());	×
302	if (craftingInterface != null) {	×
303	craftingInterface.cancelCraftingJob(craftingJob.getChannel(), craftingJob.getId());	×
304	}
305
306	// Remove all job references from the network
307	onCraftingJobFinished(craftingJob);	×
308	}	×
309
310	@Override
311	public Iterator<CraftingJob> getCraftingJobs(int channel) {
312	return new MultitransformIterator<>(getCraftingInterfaces(channel).iterator(),	×
313	ICraftingInterface::getCraftingJobs);
314	}
315
316	@Nullable
317	@Override
318	public CraftingJob getCraftingJob(int channel, int craftingJobId) {
319	if (channel == IPositionedAddonsNetwork.WILDCARD_CHANNEL) {	×
320	return allIndexedCraftingJobs.getCraftingJob(craftingJobId);	×
321	}
322
323	// Check for the channel directly
324	ICraftingJobIndexModifiable index = indexedCraftingJobs.get(channel);	×
325	if (index != null) {	×
326	CraftingJob craftingJob = index.getCraftingJob(craftingJobId);	×
327	if (craftingJob != null) {	×
328	return craftingJob;	×
329	}
330	}
331
332	// Check for the case the crafting job was explicitly started on the wildcard channel
333	ICraftingJobIndexModifiable wildcardIndex = indexedCraftingJobs.get(IPositionedAddonsNetwork.WILDCARD_CHANNEL);	×
334	if (wildcardIndex != null) {	×
335	return wildcardIndex.getCraftingJob(craftingJobId);	×
336	}
337
338	return null;	×
339	}
340
341	protected void addCraftingJob(int channel, CraftingJob craftingJob, ICraftingInterface craftingInterface) {
342	// Prepare crafting job index
343	ICraftingJobIndexModifiable craftingJobIndex = indexedCraftingJobs.get(channel);	×
344	if (craftingJobIndex == null) {	×
345	craftingJobIndex = new CraftingJobIndexDefault();	×
346	indexedCraftingJobs.put(channel, craftingJobIndex);	×
347	}
348
349	// Prepare crafting job to interface mapping
350	Int2ObjectMap<ICraftingInterface> craftingJobsToInterface = this.channeledCraftingJobsToInterface.get(channel);	×
351	if (craftingJobsToInterface == null) {	×
352	craftingJobsToInterface = new Int2ObjectOpenHashMap<>();	×
353	this.channeledCraftingJobsToInterface.put(channel, craftingJobsToInterface);	×
354	}
355
356	// Insert into crafting job index
357	allIndexedCraftingJobs.addCraftingJob(craftingJob);	×
358	craftingJobIndex.addCraftingJob(craftingJob);	×
359
360	// Insert into crafting job to interface mapping
361	allCraftingJobsToInterface.put(craftingJob.getId(), craftingInterface);	×
362	craftingJobsToInterface.put(craftingJob.getId(), craftingInterface);	×
363	}	×
364
365	protected void removeCraftingJob(int channel, CraftingJob craftingJob) {
366	// Prepare crafting job index
367	ICraftingJobIndexModifiable craftingJobIndex = indexedCraftingJobs.get(channel);	×
368
369	// Prepare crafting job to interface mapping
370	Int2ObjectMap<ICraftingInterface> craftingJobsToInterface = this.channeledCraftingJobsToInterface.get(channel);	×
371
372	// Remove from crafting job index
373	allIndexedCraftingJobs.removeCraftingJob(craftingJob);	×
374	if (craftingJobIndex != null) {	×
375	craftingJobIndex.removeCraftingJob(craftingJob);	×
376	}
377
378	// Remove from crafting job to interface mapping
379	allCraftingJobsToInterface.remove(craftingJob.getId());	×
380	if (craftingJobsToInterface != null) {	×
381	craftingJobsToInterface.remove(craftingJob.getId());	×
382	}
383	}	×
384
385	@Override
386	public <T, M> Iterator<CraftingJob> getCraftingJobs(int channel, IngredientComponent<T, M> ingredientComponent,
387	T instance, M matchCondition) {
388	if (channel == IPositionedAddonsNetwork.WILDCARD_CHANNEL) {	×
389	return allIndexedCraftingJobs.getCraftingJobs(ingredientComponent, instance, matchCondition);	×
390	}
391
392	// Check for the specific channel
393	ICraftingJobIndexModifiable craftingJobIndex = indexedCraftingJobs.get(channel);	×
394	Iterator<CraftingJob> channelIterator;
395	if (craftingJobIndex != null) {	×
396	channelIterator = craftingJobIndex.getCraftingJobs(ingredientComponent, instance, matchCondition);	×
397	} else {
398	channelIterator = Iterators.forArray();	×
399	}
400
401	// Check for the case the crafting job was explicitly started on the wildcard channel
402	ICraftingJobIndexModifiable wildcardCraftingJobIndex = indexedCraftingJobs.get(IPositionedAddonsNetwork.WILDCARD_CHANNEL);	×
403	Iterator<CraftingJob> wildcardChannelIterator;
404	if (wildcardCraftingJobIndex != null) {	×
405	wildcardChannelIterator = wildcardCraftingJobIndex.getCraftingJobs(ingredientComponent, instance, matchCondition);	×
406	} else {
407	wildcardChannelIterator = Iterators.forArray();	×
408	}
409
410	// Concat both iterators
411	return Iterators.concat(channelIterator, wildcardChannelIterator);	×
412	}
413
414	@Override
415	public CraftingJobDependencyGraph getCraftingJobDependencyGraph() {
416	return craftingJobDependencyGraph;	×
417	}
418
419	@Nullable
420	@Override
421	public ICraftingInterface getCraftingJobInterface(int channel, int craftingJobId) {
422	if (channel == IPositionedAddonsNetwork.WILDCARD_CHANNEL) {	×
423	return allCraftingJobsToInterface.get(craftingJobId);	×
424	}
425
426	// Check for the channel directly
427	Int2ObjectMap<ICraftingInterface> craftingJobsToInterface = this.channeledCraftingJobsToInterface.get(channel);	×
428	if (craftingJobsToInterface != null) {	×
429	ICraftingInterface craftingInterface = craftingJobsToInterface.get(craftingJobId);	×
430	if (craftingInterface != null) {	×
431	return craftingInterface;	×
432	}
433	}
434
435	// In case the crafting job was explicitly started on the wildcard channel
436	Int2ObjectMap<ICraftingInterface> craftingJobsToInterfaceWildcard = this.channeledCraftingJobsToInterface	×
437	.get(IPositionedAddonsNetwork.WILDCARD_CHANNEL);	×
438	if (craftingJobsToInterfaceWildcard != null) {	×
439	return craftingJobsToInterfaceWildcard.get(craftingJobId);	×
440	}
441
442	return null;	×
443	}
444
445	@Override
446	public long getRunningTicks(CraftingJob craftingJob) {
447	return getCurrentTick() - craftingJob.getStartTick();	×
448	}
449
450	protected void cleanupChannelIfEmpty(int channel) {
451	Set<ICraftingInterface> craftingInterfaces = this.craftingInterfaces.get(channel);	×
452	if (craftingInterfaces != null && craftingInterfaces.isEmpty()) {	×
453	this.craftingInterfaces.remove(channel);	×
454	this.recipeIndexes.remove(channel);	×
455	this.recipeCraftingInterfaces.remove(channel);	×
456	}
457	}	×
458	}

CyclopsMC / IntegratedCrafting / #479011834

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