22182377337

Committed 19 Feb 2026 12:46PM UTC coverage: 44.49% (-1.7%) from 46.183%

Build # 22182377337

Build Type

push

github

Committed by

rubensworks

Commit Message

Fix performance workflow failing

Run Details

2663 of 8850 branches covered (30.09%)

Branch coverage included in aggregate %.

12028 of 24171 relevant lines covered (49.76%)

2.36 hits per line

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

79.34

/src/main/java/org/cyclops/integrateddynamics/core/network/PartNetwork.java

package org.cyclops.integrateddynamics.core.network;

import com.google.common.collect.Lists;
import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
import lombok.Getter;
import lombok.Setter;
import net.minecraft.core.Direction;
import net.minecraft.world.level.block.state.BlockState;
import org.cyclops.cyclopscore.datastructure.CompositeMap;
import org.cyclops.cyclopscore.datastructure.DimPos;
import org.cyclops.cyclopscore.helper.BlockEntityHelpers;
import org.cyclops.integrateddynamics.Capabilities;
import org.cyclops.integrateddynamics.IntegratedDynamics;
import org.cyclops.integrateddynamics.api.block.IVariableContainer;
import org.cyclops.integrateddynamics.api.evaluate.variable.IValue;
import org.cyclops.integrateddynamics.api.evaluate.variable.IVariable;
import org.cyclops.integrateddynamics.api.item.IVariableFacade;
import org.cyclops.integrateddynamics.api.network.FullNetworkListenerAdapter;
import org.cyclops.integrateddynamics.api.network.INetwork;
import org.cyclops.integrateddynamics.api.network.INetworkElement;
import org.cyclops.integrateddynamics.api.network.IPartNetwork;
import org.cyclops.integrateddynamics.api.part.IPartContainer;
import org.cyclops.integrateddynamics.api.part.IPartState;
import org.cyclops.integrateddynamics.api.part.IPartType;
import org.cyclops.integrateddynamics.api.part.PartPos;
import org.cyclops.integrateddynamics.api.part.PartTarget;
import org.cyclops.integrateddynamics.api.part.aspect.IAspectRead;
import org.cyclops.integrateddynamics.api.part.read.IPartStateReader;
import org.cyclops.integrateddynamics.api.part.read.IPartTypeReader;
import org.cyclops.integrateddynamics.api.path.IPathElement;
import org.cyclops.integrateddynamics.core.helper.PartHelpers;

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

/**
 * A network that can hold parts.
 * Note that this network only contains references to the relevant data, it does not contain the actual information.
 * @author rubensworks
 */
public class PartNetwork extends FullNetworkListenerAdapter implements IPartNetwork {

    @Getter
    @Setter
    private INetwork network;
    private Int2ObjectMap<PartPos> partPositions = new Int2ObjectOpenHashMap<>();
    private List<DimPos> variableContainerPositions = Lists.newArrayList();
    private Map<Integer, IVariableFacade> compositeVariableCache = null;
    private Int2ObjectMap<IValue> lazyExpressionValueCache = new Int2ObjectOpenHashMap<>();
    private Int2ObjectMap<DimPos> proxyPositions = new Int2ObjectOpenHashMap<>();

    private volatile boolean partsChanged = false;

    @Override
    public boolean addPart(int partId, PartPos partPos) {
        if(partPositions.containsKey(partId)) {
            return false;
        }
        compositeVariableCache = null;
        partPositions.put(partId, partPos);
        return true;
    }

    @Override
    public IPartState getPartState(int partId) {
        PartPos partPos = partPositions.get(partId);
        return PartHelpers.getPartContainerChecked(partPos.getPos(), partPos.getSide()).getPartState(partPos.getSide());
    }

    @Override
    public IPartType getPartType(int partId) {
        PartPos partPos = partPositions.get(partId);
        return PartHelpers.getPartContainerChecked(partPos.getPos(), partPos.getSide()).getPart(partPos.getSide());
    }

    @Override
    public void removePart(int partId) {
        compositeVariableCache = null;
        partPositions.remove(partId);
    }

    @Override
    public boolean hasPart(int partId) {
        if(!partPositions.containsKey(partId)) {
            return false;
        }
        PartPos partPos = partPositions.get(partId);
        return PartHelpers.getPartContainer(partPos.getPos(), partPos.getSide())
                .map(partContainer -> partContainer.hasPart(partPos.getSide()))
                .orElse(false);
    }

    @Override
    public <V extends IValue> boolean hasPartVariable(int partId, IAspectRead<V, ?> aspect) {
        if(!hasPart(partId)) {
            return false;
        }
        IPartState partState = getPartState(partId);
        if(!(partState instanceof IPartStateReader)) {
            return false;
        }
        IPartType partType = getPartType(partId);
        if(!(partType instanceof IPartTypeReader)) {
            return false;
        }
        try {
            return ((IPartTypeReader) partType).getVariable(partType.getTarget(partPositions.get(partId), partState),
                    (IPartStateReader) partState, aspect) != null;
        } catch (IllegalArgumentException e) {
            return false;
        }
    }

    @Override
    public <V extends IValue> IVariable<V> getPartVariable(int partId, IAspectRead<V, ?> aspect) {
        return ((IPartStateReader) getPartState(partId)).getVariable(aspect);
    }

    protected Map<Integer, IVariableFacade> getVariableCache() {
        if(compositeVariableCache == null) {
            // Create a new composite map view on the existing variable containers in this network.
            CompositeMap<Integer, IVariableFacade> compositeMap = new CompositeMap<>();
            for(Iterator<DimPos> it = variableContainerPositions.iterator(); it.hasNext();) {
                DimPos dimPos = it.next();
                if (dimPos.isLoaded()) {
                    IVariableContainer variableContainer = BlockEntityHelpers.getCapability(dimPos, null, Capabilities.VariableContainer.BLOCK).orElse(null);
                    if (variableContainer != null) {
                        compositeMap.addElement(variableContainer.getVariableCache());
                    } else {
                        IntegratedDynamics.clog(org.apache.logging.log4j.Level.ERROR, "The variable container at " + dimPos + " was invalid, skipping.");
                        it.remove();
                    }
                }
            }
            // Also check parts
            for(PartPos partPos : partPositions.values()) {
                if (partPos.getPos().isLoaded()) {
                    IPartContainer partContainer = PartHelpers.getPartContainerChecked(partPos.getPos(), partPos.getSide());
                    partContainer.getCapability(Capabilities.VariableContainer.PART, network, this, PartTarget.fromCenter(partPos))
                            .ifPresent(variableContainer -> compositeMap.addElement(variableContainer.getVariableCache()));
                }
            }
            compositeVariableCache = compositeMap;
        }
        return compositeVariableCache;
    }

    @Override
    public boolean hasVariableFacade(int variableId) {
        return getVariableCache().containsKey(variableId);
    }

    @Override
    public IVariableFacade getVariableFacade(int variableId) {
        return getVariableCache().get(variableId);
    }

    @Override
    public void setValue(int id, IValue value) {
        lazyExpressionValueCache.put(id, value);
    }

    @Override
    public boolean hasValue(int id) {
        return lazyExpressionValueCache.containsKey(id);
    }

    @Override
    public IValue getValue(int id) {
        return lazyExpressionValueCache.get(id);
    }

    @Override
    public void removeValue(int id) {
        lazyExpressionValueCache.remove(id);
    }

    @Override
    public boolean addVariableContainer(DimPos dimPos) {
        compositeVariableCache = null;
        return variableContainerPositions.add(dimPos);
    }

    @Override
    public void removeVariableContainer(DimPos dimPos) {
        compositeVariableCache = null;
        variableContainerPositions.remove(dimPos);
    }

    @Override
    public boolean addProxy(int proxyId, DimPos dimPos) {
        if(proxyPositions.containsKey(proxyId)) {
            return false;
        }
        proxyPositions.put(proxyId, dimPos);
        return true;
    }

    @Override
    public void removeProxy(int proxyId) {
        proxyPositions.remove(proxyId);
    }

    @Override
    public DimPos getProxy(int proxyId) {
        return proxyPositions.get(proxyId);
    }

    @Override
    public void notifyPartsChanged() {
        this.partsChanged = true;
    }

    private void onPartsChanged() {

    }

    @Override
    public void update() {
        // Signal parts of any changes
        if (partsChanged) {
            this.partsChanged = false;
            onPartsChanged();
        }
    }

    @Override
    public boolean removePathElement(IPathElement pathElement, Direction side, BlockState blockState) {
        notifyPartsChanged();
        return true;
    }

    @Override
    public void invalidateElement(INetworkElement element) {
        compositeVariableCache = null;
        super.invalidateElement(element);
    }

    @Override
    public void revalidateElement(INetworkElement element) {
        compositeVariableCache = null;
        super.revalidateElement(element);
    }
}

1	package org.cyclops.integrateddynamics.core.network;
2
3	import com.google.common.collect.Lists;
4	import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
5	import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
6	import lombok.Getter;
7	import lombok.Setter;
8	import net.minecraft.core.Direction;
9	import net.minecraft.world.level.block.state.BlockState;
10	import org.cyclops.cyclopscore.datastructure.CompositeMap;
11	import org.cyclops.cyclopscore.datastructure.DimPos;
12	import org.cyclops.cyclopscore.helper.BlockEntityHelpers;
13	import org.cyclops.integrateddynamics.Capabilities;
14	import org.cyclops.integrateddynamics.IntegratedDynamics;
15	import org.cyclops.integrateddynamics.api.block.IVariableContainer;
16	import org.cyclops.integrateddynamics.api.evaluate.variable.IValue;
17	import org.cyclops.integrateddynamics.api.evaluate.variable.IVariable;
18	import org.cyclops.integrateddynamics.api.item.IVariableFacade;
19	import org.cyclops.integrateddynamics.api.network.FullNetworkListenerAdapter;
20	import org.cyclops.integrateddynamics.api.network.INetwork;
21	import org.cyclops.integrateddynamics.api.network.INetworkElement;
22	import org.cyclops.integrateddynamics.api.network.IPartNetwork;
23	import org.cyclops.integrateddynamics.api.part.IPartContainer;
24	import org.cyclops.integrateddynamics.api.part.IPartState;
25	import org.cyclops.integrateddynamics.api.part.IPartType;
26	import org.cyclops.integrateddynamics.api.part.PartPos;
27	import org.cyclops.integrateddynamics.api.part.PartTarget;
28	import org.cyclops.integrateddynamics.api.part.aspect.IAspectRead;
29	import org.cyclops.integrateddynamics.api.part.read.IPartStateReader;
30	import org.cyclops.integrateddynamics.api.part.read.IPartTypeReader;
31	import org.cyclops.integrateddynamics.api.path.IPathElement;
32	import org.cyclops.integrateddynamics.core.helper.PartHelpers;
33
34	import java.util.Iterator;
35	import java.util.List;
36	import java.util.Map;
37
38	/**
39	* A network that can hold parts.
40	* Note that this network only contains references to the relevant data, it does not contain the actual information.
41	* @author rubensworks
42	*/
43	public class PartNetwork extends FullNetworkListenerAdapter implements IPartNetwork {	2✔
44
45	@Getter	×
46	@Setter	×
47	private INetwork network;
48	private Int2ObjectMap<PartPos> partPositions = new Int2ObjectOpenHashMap<>();	5✔
49	private List<DimPos> variableContainerPositions = Lists.newArrayList();	3✔
50	private Map<Integer, IVariableFacade> compositeVariableCache = null;	3✔
51	private Int2ObjectMap<IValue> lazyExpressionValueCache = new Int2ObjectOpenHashMap<>();	5✔
52	private Int2ObjectMap<DimPos> proxyPositions = new Int2ObjectOpenHashMap<>();	5✔
53
54	private volatile boolean partsChanged = false;	4✔
55
56	@Override
57	public boolean addPart(int partId, PartPos partPos) {
58	if(partPositions.containsKey(partId)) {	5!
59	return false;	×
60	}
61	compositeVariableCache = null;	3✔
62	partPositions.put(partId, partPos);	6✔
63	return true;	2✔
64	}
65
66	@Override
67	public IPartState getPartState(int partId) {
68	PartPos partPos = partPositions.get(partId);	6✔
69	return PartHelpers.getPartContainerChecked(partPos.getPos(), partPos.getSide()).getPartState(partPos.getSide());	9✔
70	}
71
72	@Override
73	public IPartType getPartType(int partId) {
74	PartPos partPos = partPositions.get(partId);	6✔
75	return PartHelpers.getPartContainerChecked(partPos.getPos(), partPos.getSide()).getPart(partPos.getSide());	9✔
76	}
77
78	@Override
79	public void removePart(int partId) {
80	compositeVariableCache = null;	3✔
81	partPositions.remove(partId);	5✔
82	}	1✔
83
84	@Override
85	public boolean hasPart(int partId) {
86	if(!partPositions.containsKey(partId)) {	5✔
87	return false;	2✔
88	}
89	PartPos partPos = partPositions.get(partId);	6✔
90	return PartHelpers.getPartContainer(partPos.getPos(), partPos.getSide())	8✔
91	.map(partContainer -> partContainer.hasPart(partPos.getSide()))	8✔
92	.orElse(false);	4✔
93	}
94
95	@Override
96	public <V extends IValue> boolean hasPartVariable(int partId, IAspectRead<V, ?> aspect) {
97	if(!hasPart(partId)) {	4✔
98	return false;	2✔
99	}
100	IPartState partState = getPartState(partId);	4✔
101	if(!(partState instanceof IPartStateReader)) {	3!
102	return false;	×
103	}
104	IPartType partType = getPartType(partId);	4✔
105	if(!(partType instanceof IPartTypeReader)) {	3!
106	return false;	×
107	}
108	try {
109	return ((IPartTypeReader) partType).getVariable(partType.getTarget(partPositions.get(partId), partState),	18!
110	(IPartStateReader) partState, aspect) != null;
111	} catch (IllegalArgumentException e) {	×
112	return false;	×
113	}
114	}
115
116	@Override
117	public <V extends IValue> IVariable<V> getPartVariable(int partId, IAspectRead<V, ?> aspect) {
118	return ((IPartStateReader) getPartState(partId)).getVariable(aspect);	7✔
119	}
120
121	protected Map<Integer, IVariableFacade> getVariableCache() {
122	if(compositeVariableCache == null) {	3✔
123	// Create a new composite map view on the existing variable containers in this network.
124	CompositeMap<Integer, IVariableFacade> compositeMap = new CompositeMap<>();	4✔
125	for(Iterator<DimPos> it = variableContainerPositions.iterator(); it.hasNext();) {	7✔
126	DimPos dimPos = it.next();	4✔
127	if (dimPos.isLoaded()) {	3!
128	IVariableContainer variableContainer = BlockEntityHelpers.getCapability(dimPos, null, Capabilities.VariableContainer.BLOCK).orElse(null);	8✔
129	if (variableContainer != null) {	2!
130	compositeMap.addElement(variableContainer.getVariableCache());	5✔
131	} else {
132	IntegratedDynamics.clog(org.apache.logging.log4j.Level.ERROR, "The variable container at " + dimPos + " was invalid, skipping.");	×
133	it.remove();	×
134	}
135	}
136	}	1✔
137	// Also check parts
138	for(PartPos partPos : partPositions.values()) {	12✔
139	if (partPos.getPos().isLoaded()) {	4!
140	IPartContainer partContainer = PartHelpers.getPartContainerChecked(partPos.getPos(), partPos.getSide());	6✔
141	partContainer.getCapability(Capabilities.VariableContainer.PART, network, this, PartTarget.fromCenter(partPos))	10✔
142	.ifPresent(variableContainer -> compositeMap.addElement(variableContainer.getVariableCache()));	6✔
143	}
144	}	1✔
145	compositeVariableCache = compositeMap;	3✔
146	}
147	return compositeVariableCache;	3✔
148	}
149
150	@Override
151	public boolean hasVariableFacade(int variableId) {
152	return getVariableCache().containsKey(variableId);	6✔
153	}
154
155	@Override
156	public IVariableFacade getVariableFacade(int variableId) {
157	return getVariableCache().get(variableId);	7✔
158	}
159
160	@Override
161	public void setValue(int id, IValue value) {
162	lazyExpressionValueCache.put(id, value);	6✔
163	}	1✔
164
165	@Override
166	public boolean hasValue(int id) {
167	return lazyExpressionValueCache.containsKey(id);	5✔
168	}
169
170	@Override
171	public IValue getValue(int id) {
172	return lazyExpressionValueCache.get(id);	6✔
173	}
174
175	@Override
176	public void removeValue(int id) {
177	lazyExpressionValueCache.remove(id);	5✔
178	}	1✔
179
180	@Override
181	public boolean addVariableContainer(DimPos dimPos) {
182	compositeVariableCache = null;	3✔
183	return variableContainerPositions.add(dimPos);	5✔
184	}
185
186	@Override
187	public void removeVariableContainer(DimPos dimPos) {
188	compositeVariableCache = null;	3✔
189	variableContainerPositions.remove(dimPos);	5✔
190	}	1✔
191
192	@Override
193	public boolean addProxy(int proxyId, DimPos dimPos) {
194	if(proxyPositions.containsKey(proxyId)) {	5!
195	return false;	×
196	}
197	proxyPositions.put(proxyId, dimPos);	6✔
198	return true;	2✔
199	}
200
201	@Override
202	public void removeProxy(int proxyId) {
203	proxyPositions.remove(proxyId);	5✔
204	}	1✔
205
206	@Override
207	public DimPos getProxy(int proxyId) {
208	return proxyPositions.get(proxyId);	6✔
209	}
210
211	@Override
212	public void notifyPartsChanged() {
213	this.partsChanged = true;	3✔
214	}	1✔
215
216	private void onPartsChanged() {
217
218	}	×
219
220	@Override
221	public void update() {
222	// Signal parts of any changes
223	if (partsChanged) {	3!
224	this.partsChanged = false;	×
225	onPartsChanged();	×
226	}
227	}	1✔
228
229	@Override
230	public boolean removePathElement(IPathElement pathElement, Direction side, BlockState blockState) {
231	notifyPartsChanged();	2✔
232	return true;	2✔
233	}
234
235	@Override
236	public void invalidateElement(INetworkElement element) {
237	compositeVariableCache = null;	3✔
238	super.invalidateElement(element);	3✔
239	}	1✔
240
241	@Override
242	public void revalidateElement(INetworkElement element) {
243	compositeVariableCache = null;	×
244	super.revalidateElement(element);	×
245	}	×
246	}

CyclopsMC / IntegratedDynamics / 22182377337

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