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/logicprogrammer/OperatorLPElement.java

package org.cyclops.integrateddynamics.core.logicprogrammer;

import com.google.common.collect.Iterables;
import net.minecraft.network.chat.Component;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.inventory.ClickType;
import net.minecraft.world.inventory.Slot;
import net.minecraft.world.item.ItemStack;
import org.cyclops.cyclopscore.helper.IModHelpers;
import org.cyclops.cyclopscore.inventory.SimpleInventory;
import org.cyclops.integrateddynamics.IntegratedDynamics;
import org.cyclops.integrateddynamics.RegistryEntries;
import org.cyclops.integrateddynamics.api.evaluate.operator.IOperator;
import org.cyclops.integrateddynamics.api.evaluate.variable.IValueType;
import org.cyclops.integrateddynamics.api.evaluate.variable.IValueTypeCategory;
import org.cyclops.integrateddynamics.api.evaluate.variable.ValueDeseralizationContext;
import org.cyclops.integrateddynamics.api.item.IOperatorVariableFacade;
import org.cyclops.integrateddynamics.api.item.IVariableFacade;
import org.cyclops.integrateddynamics.api.item.IVariableFacadeHandler;
import org.cyclops.integrateddynamics.api.item.IVariableFacadeHandlerRegistry;
import org.cyclops.integrateddynamics.api.logicprogrammer.IConfigRenderPattern;
import org.cyclops.integrateddynamics.api.logicprogrammer.ILogicProgrammerElement;
import org.cyclops.integrateddynamics.api.logicprogrammer.ILogicProgrammerElementType;
import org.cyclops.integrateddynamics.client.gui.container.ContainerScreenLogicProgrammerBase;
import org.cyclops.integrateddynamics.core.evaluate.operator.Operators;
import org.cyclops.integrateddynamics.core.evaluate.variable.ValueHelpers;
import org.cyclops.integrateddynamics.core.evaluate.variable.ValueTypes;
import org.cyclops.integrateddynamics.core.item.OperatorVariableFacade;
import org.cyclops.integrateddynamics.core.item.ValueTypeVariableFacade;
import org.cyclops.integrateddynamics.core.logicprogrammer.client.OperatorLPElementClient;
import org.cyclops.integrateddynamics.core.logicprogrammer.client.RenderPattern;
import org.cyclops.integrateddynamics.inventory.container.ContainerLogicProgrammerBase;

import java.util.function.Consumer;

/**
 * Element for operator.
 *
 * @author rubensworks
 */
public class OperatorLPElement implements ILogicProgrammerElement<RenderPattern, ContainerScreenLogicProgrammerBase, ContainerLogicProgrammerBase, OperatorLPElementClient<?>> {

    private final IOperator operator;
    private IVariableFacade[] inputVariables;
    private boolean focused = false;

    private OperatorLPElementClient<?> client;

    public OperatorLPElement(IOperator operator) {
        this.operator = operator;
        if (IModHelpers.get().getMinecraftHelpers().isClientSide()) {
            this.client = constructClient();
        }
    }

    private OperatorLPElementClient<?> constructClient() {
        return new OperatorLPElementClient<>(this);
    }

    @Override
    public OperatorLPElementClient<?> getClient() {
        return client;
    }

    @Override
    public ILogicProgrammerElementType getType() {
        return LogicProgrammerElementTypes.OPERATOR;
    }

    @Override
    public String getMatchString() {
        return getOperator().getLocalizedNameFull().getString().toLowerCase();
    }

    @Override
    public boolean matchesInput(IValueType valueType) {
        for (IValueType operatorIn : getOperator().getInputTypes()) {
            if (ValueHelpers.correspondsTo(operatorIn, valueType)) {
                return true;
            }
        }
        return false;
    }

    @Override
    public boolean matchesOutput(IValueType valueType) {
        return ValueHelpers.correspondsTo(getOperator().getOutputType(), valueType);
    }

    @Override
    public Component getName() {
        return getOperator().getLocalizedNameFull();
    }

    @Override
    public void loadTooltip(Consumer<Component> tooltipAdder) {
        getOperator().loadTooltip(tooltipAdder, true);
    }

    @Override
    public IConfigRenderPattern getRenderPattern() {
        if (getOperator().getRenderPattern() == null) {
            throw new IllegalStateException("Tried to render a (possibly virtual) operator with a null render pattern: "
                    + getOperator().getUniqueName());
        }
        return getOperator().getRenderPattern();
    }

    @Override
    public void onInputSlotUpdated(Player player, int slotId, ItemStack itemStack) {
        IVariableFacade variableFacade = IntegratedDynamics._instance.getRegistryManager().getRegistry(IVariableFacadeHandlerRegistry.class).handle(ValueDeseralizationContext.of(player.level()), itemStack);
        inputVariables[slotId] = variableFacade;
    }

    @Override
    public boolean canWriteElementPre() {
        for (IVariableFacade inputVariable : inputVariables) {
            if (inputVariable == null || !inputVariable.isValid()) {
                return false;
            }
        }
        return true;
    }

    protected int[] getVariableIds(IVariableFacade[] inputVariables) {
        int[] variableIds = new int[inputVariables.length];
        for (int i = 0; i < inputVariables.length; i++) {
            variableIds[i] = inputVariables[i].getId();
        }
        return variableIds;
    }

    @Override
    public ItemStack writeElement(Player player, ItemStack itemStack) {
        IVariableFacadeHandlerRegistry registry = IntegratedDynamics._instance.getRegistryManager().getRegistry(IVariableFacadeHandlerRegistry.class);
        int[] variableIds = getVariableIds(inputVariables);
        return registry.writeVariableFacadeItem(!player.level().isClientSide(), itemStack, Operators.REGISTRY,
                new OperatorVariableFacadeFactory(operator, variableIds), player.level(), player, RegistryEntries.BLOCK_LOGIC_PROGRAMMER.get().defaultBlockState());
    }

    @Override
    public void loadElement(IVariableFacade variableFacade) {
        if (variableFacade instanceof OperatorVariableFacade operatorVariableFacade) {
            int[] variableIds = operatorVariableFacade.getVariableIds();
            this.inputVariables = new IVariableFacade[variableIds.length];
            for (int i = 0; i < variableIds.length; i++) {
                IValueType valueType = operator.getInputTypes()[i];
                if (valueType instanceof IValueTypeCategory<?> valueTypeCategory) {
                    valueType = Iterables.getFirst(valueTypeCategory.getElements(), ValueTypes.BOOLEAN);
                }
                this.inputVariables[i] = new ValueTypeVariableFacade(variableIds[i], valueType, valueType.getDefault());
            }
        }
    }

    @Override
    public void setValueInContainer(ContainerLogicProgrammerBase container) {
        SimpleInventory inputSlots = container.getTemporaryInputSlots();
        for (int i = 0; i < inputSlots.getContainerSize(); i++) {
            ItemStack itemStack = IntegratedDynamics._instance.getRegistryManager().getRegistry(IVariableFacadeHandlerRegistry.class).writeVariableFacadeItem(new ItemStack(RegistryEntries.ITEM_VARIABLE), inputVariables[i], (IVariableFacadeHandler) ValueTypes.REGISTRY);
            inputSlots.setItem(i, itemStack);
        }
    }

    @Override
    public boolean canCurrentlyReadFromOtherItem() {
        return true;
    }

    @Override
    public void activate() {
        this.inputVariables = new IVariableFacade[getRenderPattern().getSlotPositions().length];
    }

    @Override
    public void deactivate() {
        this.inputVariables = null;
    }

    @Override
    public Component validate() {
        return getOperator().validateTypes(ValueHelpers.from(inputVariables));
    }

    @Override
    public int getColor() {
        return getOperator().getOutputType().getDisplayColor();
    }

    @Override
    public String getSymbol() {
        return getOperator().getSymbol();
    }

    @Override
    public boolean isFor(IVariableFacade variableFacade) {
        if (variableFacade instanceof IOperatorVariableFacade) {
            IOperatorVariableFacade operatorFacade = (IOperatorVariableFacade) variableFacade;
            if (operatorFacade.isValid()) {
                return getOperator() == operatorFacade.getOperator();
            }
        }
        return false;
    }

    @Override
    public boolean isItemValidForSlot(int slotId, ItemStack itemStack) {
        return itemStack.getItem() == RegistryEntries.ITEM_VARIABLE.get();
    }

    @Override
    public boolean slotClick(int slotId, Slot slot, int mouseButton, ClickType clickType, Player player) {
        return false;
    }

    @Override
    public int getItemStackSizeLimit() {
        return 1;
    }

    public IOperator getOperator() {
        return this.operator;
    }

    public IVariableFacade[] getInputVariables() {
        return this.inputVariables;
    }

    public void setInputVariables(IVariableFacade[] inputVariables) {
        this.inputVariables = inputVariables;
    }

    public boolean isFocused() {
        return focused;
    }

    public void setFocused(boolean focused) {
        this.focused = focused;
    }

    public boolean equals(final Object o) {
        if (o == this) return true;
        if (!(o instanceof OperatorLPElement)) return false;
        final OperatorLPElement other = (OperatorLPElement) o;
        if (!other.canEqual((Object) this)) return false;
        final Object this$operator = this.getOperator();
        final Object other$operator = other.getOperator();
        if (this$operator == null ? other$operator != null : !this$operator.equals(other$operator)) return false;
        if (!java.util.Arrays.deepEquals(this.getInputVariables(), other.getInputVariables())) return false;
        if (this.isFocused() != other.isFocused()) return false;
        return true;
    }

    protected boolean canEqual(final Object other) {
        return other instanceof OperatorLPElement;
    }

    public int hashCode() {
        final int PRIME = 59;
        int result = 1;
        final Object $operator = this.getOperator();
        result = result * PRIME + ($operator == null ? 43 : $operator.hashCode());
        result = result * PRIME + java.util.Arrays.deepHashCode(this.getInputVariables());
        result = result * PRIME + (this.isFocused() ? 79 : 97);
        return result;
    }

    public String toString() {
        return "OperatorLPElement(operator=" + this.getOperator() + ", inputVariables=" + java.util.Arrays.deepToString(this.getInputVariables()) + ", focused=" + this.isFocused() + ")";
    }

    public static class OperatorVariableFacadeFactory implements IVariableFacadeHandlerRegistry.IVariableFacadeFactory<IOperatorVariableFacade> {

        private final IOperator operator;
        private final int[] variableIds;

        public OperatorVariableFacadeFactory(IOperator operator, int[] variableIds) {
            this.operator = operator;
            this.variableIds = variableIds;
        }

        @Override
        public IOperatorVariableFacade create(boolean generateId) {
            return new OperatorVariableFacade(generateId, operator, variableIds);
        }

        @Override
        public IOperatorVariableFacade create(int id) {
            return new OperatorVariableFacade(id, operator, variableIds);
        }
    }

}

1	package org.cyclops.integrateddynamics.core.logicprogrammer;
2
3	import com.google.common.collect.Iterables;
4	import net.minecraft.network.chat.Component;
5	import net.minecraft.world.entity.player.Player;
6	import net.minecraft.world.inventory.ClickType;
7	import net.minecraft.world.inventory.Slot;
8	import net.minecraft.world.item.ItemStack;
9	import org.cyclops.cyclopscore.helper.IModHelpers;
10	import org.cyclops.cyclopscore.inventory.SimpleInventory;
11	import org.cyclops.integrateddynamics.IntegratedDynamics;
12	import org.cyclops.integrateddynamics.RegistryEntries;
13	import org.cyclops.integrateddynamics.api.evaluate.operator.IOperator;
14	import org.cyclops.integrateddynamics.api.evaluate.variable.IValueType;
15	import org.cyclops.integrateddynamics.api.evaluate.variable.IValueTypeCategory;
16	import org.cyclops.integrateddynamics.api.evaluate.variable.ValueDeseralizationContext;
17	import org.cyclops.integrateddynamics.api.item.IOperatorVariableFacade;
18	import org.cyclops.integrateddynamics.api.item.IVariableFacade;
19	import org.cyclops.integrateddynamics.api.item.IVariableFacadeHandler;
20	import org.cyclops.integrateddynamics.api.item.IVariableFacadeHandlerRegistry;
21	import org.cyclops.integrateddynamics.api.logicprogrammer.IConfigRenderPattern;
22	import org.cyclops.integrateddynamics.api.logicprogrammer.ILogicProgrammerElement;
23	import org.cyclops.integrateddynamics.api.logicprogrammer.ILogicProgrammerElementType;
24	import org.cyclops.integrateddynamics.client.gui.container.ContainerScreenLogicProgrammerBase;
25	import org.cyclops.integrateddynamics.core.evaluate.operator.Operators;
26	import org.cyclops.integrateddynamics.core.evaluate.variable.ValueHelpers;
27	import org.cyclops.integrateddynamics.core.evaluate.variable.ValueTypes;
28	import org.cyclops.integrateddynamics.core.item.OperatorVariableFacade;
29	import org.cyclops.integrateddynamics.core.item.ValueTypeVariableFacade;
30	import org.cyclops.integrateddynamics.core.logicprogrammer.client.OperatorLPElementClient;
31	import org.cyclops.integrateddynamics.core.logicprogrammer.client.RenderPattern;
32	import org.cyclops.integrateddynamics.inventory.container.ContainerLogicProgrammerBase;
33
34	import java.util.function.Consumer;
35
36	/**
37	* Element for operator.
38	*
39	* @author rubensworks
40	*/
41	public class OperatorLPElement implements ILogicProgrammerElement<RenderPattern, ContainerScreenLogicProgrammerBase, ContainerLogicProgrammerBase, OperatorLPElementClient<?>> {
42
43	private final IOperator operator;
44	private IVariableFacade[] inputVariables;
45	private boolean focused = false;	×
46
47	private OperatorLPElementClient<?> client;
48
49	public OperatorLPElement(IOperator operator) {	×
50	this.operator = operator;	×
51	if (IModHelpers.get().getMinecraftHelpers().isClientSide()) {	×
52	this.client = constructClient();	×
53	}
54	}	×
55
56	private OperatorLPElementClient<?> constructClient() {
57	return new OperatorLPElementClient<>(this);	×
58	}
59
60	@Override
61	public OperatorLPElementClient<?> getClient() {
62	return client;	×
63	}
64
65	@Override
66	public ILogicProgrammerElementType getType() {
67	return LogicProgrammerElementTypes.OPERATOR;	×
68	}
69
70	@Override
71	public String getMatchString() {
72	return getOperator().getLocalizedNameFull().getString().toLowerCase();	×
73	}
74
75	@Override
76	public boolean matchesInput(IValueType valueType) {
77	for (IValueType operatorIn : getOperator().getInputTypes()) {	×
78	if (ValueHelpers.correspondsTo(operatorIn, valueType)) {	×
79	return true;	×
80	}
81	}
82	return false;	×
83	}
84
85	@Override
86	public boolean matchesOutput(IValueType valueType) {
87	return ValueHelpers.correspondsTo(getOperator().getOutputType(), valueType);	×
88	}
89
90	@Override
91	public Component getName() {
92	return getOperator().getLocalizedNameFull();	×
93	}
94
95	@Override
96	public void loadTooltip(Consumer<Component> tooltipAdder) {
97	getOperator().loadTooltip(tooltipAdder, true);	×
98	}	×
99
100	@Override
101	public IConfigRenderPattern getRenderPattern() {
102	if (getOperator().getRenderPattern() == null) {	×
103	throw new IllegalStateException("Tried to render a (possibly virtual) operator with a null render pattern: "	×
104	+ getOperator().getUniqueName());	×
105	}
106	return getOperator().getRenderPattern();	×
107	}
108
109	@Override
110	public void onInputSlotUpdated(Player player, int slotId, ItemStack itemStack) {
111	IVariableFacade variableFacade = IntegratedDynamics._instance.getRegistryManager().getRegistry(IVariableFacadeHandlerRegistry.class).handle(ValueDeseralizationContext.of(player.level()), itemStack);	×
112	inputVariables[slotId] = variableFacade;	×
113	}	×
114
115	@Override
116	public boolean canWriteElementPre() {
117	for (IVariableFacade inputVariable : inputVariables) {	×
118	if (inputVariable == null \|\| !inputVariable.isValid()) {	×
119	return false;	×
120	}
121	}
122	return true;	×
123	}
124
125	protected int[] getVariableIds(IVariableFacade[] inputVariables) {
126	int[] variableIds = new int[inputVariables.length];	×
127	for (int i = 0; i < inputVariables.length; i++) {	×
128	variableIds[i] = inputVariables[i].getId();	×
129	}
130	return variableIds;	×
131	}
132
133	@Override
134	public ItemStack writeElement(Player player, ItemStack itemStack) {
135	IVariableFacadeHandlerRegistry registry = IntegratedDynamics._instance.getRegistryManager().getRegistry(IVariableFacadeHandlerRegistry.class);	×
136	int[] variableIds = getVariableIds(inputVariables);	×
137	return registry.writeVariableFacadeItem(!player.level().isClientSide(), itemStack, Operators.REGISTRY,	×
138	new OperatorVariableFacadeFactory(operator, variableIds), player.level(), player, RegistryEntries.BLOCK_LOGIC_PROGRAMMER.get().defaultBlockState());	×
139	}
140
141	@Override
142	public void loadElement(IVariableFacade variableFacade) {
143	if (variableFacade instanceof OperatorVariableFacade operatorVariableFacade) {	×
144	int[] variableIds = operatorVariableFacade.getVariableIds();	×
145	this.inputVariables = new IVariableFacade[variableIds.length];	×
146	for (int i = 0; i < variableIds.length; i++) {	×
147	IValueType valueType = operator.getInputTypes()[i];	×
148	if (valueType instanceof IValueTypeCategory<?> valueTypeCategory) {	×
149	valueType = Iterables.getFirst(valueTypeCategory.getElements(), ValueTypes.BOOLEAN);	×
150	}
151	this.inputVariables[i] = new ValueTypeVariableFacade(variableIds[i], valueType, valueType.getDefault());	×
152	}
153	}
154	}	×
155
156	@Override
157	public void setValueInContainer(ContainerLogicProgrammerBase container) {
158	SimpleInventory inputSlots = container.getTemporaryInputSlots();	×
159	for (int i = 0; i < inputSlots.getContainerSize(); i++) {	×
160	ItemStack itemStack = IntegratedDynamics._instance.getRegistryManager().getRegistry(IVariableFacadeHandlerRegistry.class).writeVariableFacadeItem(new ItemStack(RegistryEntries.ITEM_VARIABLE), inputVariables[i], (IVariableFacadeHandler) ValueTypes.REGISTRY);	×
161	inputSlots.setItem(i, itemStack);	×
162	}
163	}	×
164
165	@Override
166	public boolean canCurrentlyReadFromOtherItem() {
167	return true;	×
168	}
169
170	@Override
171	public void activate() {
172	this.inputVariables = new IVariableFacade[getRenderPattern().getSlotPositions().length];	×
173	}	×
174
175	@Override
176	public void deactivate() {
177	this.inputVariables = null;	×
178	}	×
179
180	@Override
181	public Component validate() {
182	return getOperator().validateTypes(ValueHelpers.from(inputVariables));	×
183	}
184
185	@Override
186	public int getColor() {
187	return getOperator().getOutputType().getDisplayColor();	×
188	}
189
190	@Override
191	public String getSymbol() {
192	return getOperator().getSymbol();	×
193	}
194
195	@Override
196	public boolean isFor(IVariableFacade variableFacade) {
197	if (variableFacade instanceof IOperatorVariableFacade) {	×
198	IOperatorVariableFacade operatorFacade = (IOperatorVariableFacade) variableFacade;	×
199	if (operatorFacade.isValid()) {	×
200	return getOperator() == operatorFacade.getOperator();	×
201	}
202	}
203	return false;	×
204	}
205
206	@Override
207	public boolean isItemValidForSlot(int slotId, ItemStack itemStack) {
208	return itemStack.getItem() == RegistryEntries.ITEM_VARIABLE.get();	×
209	}
210
211	@Override
212	public boolean slotClick(int slotId, Slot slot, int mouseButton, ClickType clickType, Player player) {
213	return false;	×
214	}
215
216	@Override
217	public int getItemStackSizeLimit() {
218	return 1;	×
219	}
220
221	public IOperator getOperator() {
222	return this.operator;	×
223	}
224
225	public IVariableFacade[] getInputVariables() {
226	return this.inputVariables;	×
227	}
228
229	public void setInputVariables(IVariableFacade[] inputVariables) {
230	this.inputVariables = inputVariables;	×
231	}	×
232
233	public boolean isFocused() {
234	return focused;	×
235	}
236
237	public void setFocused(boolean focused) {
238	this.focused = focused;	×
239	}	×
240
241	public boolean equals(final Object o) {
242	if (o == this) return true;	×
243	if (!(o instanceof OperatorLPElement)) return false;	×
244	final OperatorLPElement other = (OperatorLPElement) o;	×
245	if (!other.canEqual((Object) this)) return false;	×
246	final Object this$operator = this.getOperator();	×
247	final Object other$operator = other.getOperator();	×
248	if (this$operator == null ? other$operator != null : !this$operator.equals(other$operator)) return false;	×
249	if (!java.util.Arrays.deepEquals(this.getInputVariables(), other.getInputVariables())) return false;	×
250	if (this.isFocused() != other.isFocused()) return false;	×
251	return true;	×
252	}
253
254	protected boolean canEqual(final Object other) {
255	return other instanceof OperatorLPElement;	×
256	}
257
258	public int hashCode() {
259	final int PRIME = 59;	×
260	int result = 1;	×
261	final Object $operator = this.getOperator();	×
262	result = result * PRIME + ($operator == null ? 43 : $operator.hashCode());	×
263	result = result * PRIME + java.util.Arrays.deepHashCode(this.getInputVariables());	×
264	result = result * PRIME + (this.isFocused() ? 79 : 97);	×
265	return result;	×
266	}
267
268	public String toString() {
269	return "OperatorLPElement(operator=" + this.getOperator() + ", inputVariables=" + java.util.Arrays.deepToString(this.getInputVariables()) + ", focused=" + this.isFocused() + ")";	×
270	}
271
272	public static class OperatorVariableFacadeFactory implements IVariableFacadeHandlerRegistry.IVariableFacadeFactory<IOperatorVariableFacade> {
273
274	private final IOperator operator;
275	private final int[] variableIds;
276
277	public OperatorVariableFacadeFactory(IOperator operator, int[] variableIds) {	×
278	this.operator = operator;	×
279	this.variableIds = variableIds;	×
280	}	×
281
282	@Override
283	public IOperatorVariableFacade create(boolean generateId) {
284	return new OperatorVariableFacade(generateId, operator, variableIds);	×
285	}
286
287	@Override
288	public IOperatorVariableFacade create(int id) {
289	return new OperatorVariableFacade(id, operator, variableIds);	×
290	}
291	}
292
293	}

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