20210191346

Committed 14 Dec 2025 03:32PM UTC coverage: 19.514% (-33.5%) from 53.061%

Build # 20210191346

Build Type

push

github

Committed by

rubensworks

Commit Message

Remove deprecations

Run Details

663 of 8728 branches covered (7.6%)

Branch coverage included in aggregate %.

6786 of 29445 relevant lines covered (23.05%)

1.09 hits per line

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

0.0

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

CyclopsMC / IntegratedDynamics / 20210191346

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