16552051255

Committed 27 Jul 2025 01:58PM UTC coverage: 53.206% (+8.0%) from 45.161%

Build # 16552051255

Build Type

push

github

Committed by

rubensworks

Commit Message

Resolve minor TODOs

Run Details

2888 of 8740 branches covered (33.04%)

Branch coverage included in aggregate %.

17341 of 29280 relevant lines covered (59.22%)

3.08 hits per line

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

37.25

/src/main/java/org/cyclops/integrateddynamics/core/evaluate/operator/CurriedOperator.java

package org.cyclops.integrateddynamics.core.evaluate.operator;

import com.google.common.collect.Lists;
import net.minecraft.network.chat.Component;
import net.minecraft.network.chat.MutableComponent;
import net.minecraft.resources.ResourceLocation;
import net.minecraft.world.level.storage.ValueInput;
import net.minecraft.world.level.storage.ValueOutput;
import org.cyclops.integrateddynamics.Reference;
import org.cyclops.integrateddynamics.api.evaluate.EvaluationException;
import org.cyclops.integrateddynamics.api.evaluate.operator.IOperator;
import org.cyclops.integrateddynamics.api.evaluate.operator.IOperatorSerializer;
import org.cyclops.integrateddynamics.api.evaluate.variable.IValue;
import org.cyclops.integrateddynamics.api.evaluate.variable.IValueType;
import org.cyclops.integrateddynamics.api.evaluate.variable.IVariable;
import org.cyclops.integrateddynamics.api.logicprogrammer.IConfigRenderPattern;
import org.cyclops.integrateddynamics.core.evaluate.variable.ValueHelpers;
import org.cyclops.integrateddynamics.core.evaluate.variable.ValueTypes;
import org.cyclops.integrateddynamics.core.evaluate.variable.Variable;
import org.cyclops.integrateddynamics.core.helper.L10NValues;
import org.jetbrains.annotations.Nullable;

import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.function.Consumer;

/**
 * An operator that is partially being applied.
 * @author rubensworks
 */
public class CurriedOperator implements IOperator {

    private final IOperator baseOperator;
    private final IVariable[] appliedVariables;

    public CurriedOperator(IOperator baseOperator, IVariable... appliedVariables) {
        this.baseOperator = baseOperator;
        this.appliedVariables = appliedVariables;
    }

    protected String getAppliedSymbol() {
        String symbol = "";
        for (IVariable appliedVariable : appliedVariables) {
            symbol += appliedVariable.getType().getTypeName() + ";";
        }
        return symbol;
    }

    @Override
    public String getSymbol() {
        StringBuilder sb = new StringBuilder();
        sb.append(baseOperator.getSymbol());
        sb.append(" [");
        sb.append(getAppliedSymbol());
        sb.append("]");
        return sb.toString();
    }

    @Override
    public ResourceLocation getUniqueName() {
        return ResourceLocation.parse("curried_operator");
    }

    @Override
    public String getInteractName() {
        return "curried_operator";
    }

    @Nullable
    @Override
    public String getGlobalInteractNamePrefix() {
        return null;
    }

    @Override
    public boolean shouldAlsoPrefixLocalScope() {
        return false;
    }

    @Override
    public String getTranslationKey() {
        return baseOperator.getTranslationKey();
    }

    @Override
    public String getUnlocalizedCategoryName() {
        return baseOperator.getUnlocalizedCategoryName();
    }

    @Override
    public MutableComponent getLocalizedNameFull() {
        return Component.translatable(L10NValues.OPERATOR_APPLIED_OPERATORNAME,
                baseOperator.getLocalizedNameFull(), getAppliedSymbol());
    }

    @Override
    public void loadTooltip(Consumer<Component> tooltipAdder, boolean appendOptionalInfo) {
        baseOperator.loadTooltip(tooltipAdder, appendOptionalInfo);
        tooltipAdder.accept(Component.translatable(L10NValues.OPERATOR_APPLIED_TYPE, getAppliedSymbol()));
    }

    @Override
    public IValueType[] getInputTypes() {
        IValueType[] baseInputTypes = baseOperator.getInputTypes();
        return Arrays.copyOfRange(baseInputTypes, appliedVariables.length, baseInputTypes.length);
    }

    @Override
    public IValueType getOutputType() {
        return baseOperator.getOutputType();
    }

    protected IVariable[] deriveFullInputVariables(IVariable[] partialInput) {
        IVariable[] fullInput = new IVariable[Math.min(baseOperator.getRequiredInputLength(), partialInput.length + appliedVariables.length)];
        for (int i = 0; i < appliedVariables.length; i++) {
            fullInput[i] = appliedVariables[i];
        }
        System.arraycopy(partialInput, 0, fullInput, appliedVariables.length, fullInput.length - appliedVariables.length);
        return fullInput;
    }

    protected IValueType[] deriveFullInputTypes(IValueType[] partialInput) {
        IValueType[] fullInput = new IValueType[Math.min(baseOperator.getRequiredInputLength(), partialInput.length + appliedVariables.length)];
        for (int i = 0; i < appliedVariables.length; i++) {
            fullInput[i] = appliedVariables[i].getType();
        }
        System.arraycopy(partialInput, 0, fullInput, appliedVariables.length, fullInput.length - appliedVariables.length);
        return fullInput;
    }

    @Override
    public IValueType getConditionalOutputType(IVariable[] input) {
        return baseOperator.getConditionalOutputType(deriveFullInputVariables(input));
    }

    @Override
    public IValue evaluate(IVariable[] input) throws EvaluationException {
        return baseOperator.evaluate(deriveFullInputVariables(input));
    }

    @Override
    public int getRequiredInputLength() {
        return baseOperator.getRequiredInputLength() - appliedVariables.length;
    }

    @Override
    public MutableComponent validateTypes(IValueType[] input) {
        return baseOperator.validateTypes(deriveFullInputTypes(input));
    }

    @Override
    public IConfigRenderPattern getRenderPattern() {
        return IConfigRenderPattern.NONE;
    }

    @Override
    public IOperator materialize() throws EvaluationException {
        IVariable[] variables = new IVariable[appliedVariables.length];
        for (int i = 0; i < appliedVariables.length; i++) {
            IVariable appliedVariable = appliedVariables[i];
            variables[i] = new Variable<>(appliedVariable.getType(), appliedVariable.getType().materialize(appliedVariable.getValue()));
        }
        return new CurriedOperator(baseOperator, variables);
    }

    public IOperator getBaseOperator() {
        return baseOperator;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof CurriedOperator)) return false;
        CurriedOperator that = (CurriedOperator) o;
        return Objects.equals(baseOperator, that.baseOperator) &&
                Arrays.equals(appliedVariables, that.appliedVariables);
    }

    @Override
    public int hashCode() {
        int result = Objects.hash(baseOperator);
        result = 31 * result + Arrays.hashCode(appliedVariables);
        return result;
    }

    public static class Serializer implements IOperatorSerializer<CurriedOperator> {

        @Override
        public boolean canHandle(IOperator operator) {
            return operator instanceof CurriedOperator;
        }

        @Override
        public ResourceLocation getUniqueName() {
            return ResourceLocation.fromNamespaceAndPath(Reference.MOD_ID, "curry");
        }

        @Override
        public void serialize(ValueOutput valueOutput, CurriedOperator operator) {
            Operators.REGISTRY.serialize(valueOutput.child("baseOperator"), operator.baseOperator);
            ValueOutput.ValueOutputList list = valueOutput.childrenList("values");
            for (int i = 0; i < operator.appliedVariables.length; i++) {
                IVariable appliedVariable = operator.appliedVariables[i];
                IValue value;
                try {
                    value = appliedVariable.getValue();
                } catch (EvaluationException e) {
                    value = appliedVariable.getType().getDefault();
                }
                ValueOutput valueTag = list.addChild();
                IValueType valueType = value.getType();
                valueTag.putString("valueType", valueType.getUniqueName().toString());
                ValueHelpers.serializeRaw(valueTag.child("value"), value);
            }
        }

        @Override
        public CurriedOperator deserialize(ValueInput valueInput) throws EvaluationException {
            ValueInput.ValueInputList list = valueInput.childrenList("values").orElseThrow();
            List<IVariable> variables = Lists.newArrayList();
            for (ValueInput valuetag : list) {
                IValueType valueType = ValueTypes.REGISTRY.getValueType(ResourceLocation.parse(valuetag.getString("valueType").orElseThrow()));
                IValue value = ValueHelpers.deserializeRaw(valuetag.child("value").orElseThrow(), valueType);
                variables.add(new Variable(valueType, value));
            }
            IOperator baseOperator = Objects.requireNonNull(Operators.REGISTRY.deserialize(valueInput.child("baseOperator").orElseThrow()));
            return new CurriedOperator(baseOperator, variables.toArray(new IVariable[0]));
        }
    }
}

1	package org.cyclops.integrateddynamics.core.evaluate.operator;
2
3	import com.google.common.collect.Lists;
4	import net.minecraft.network.chat.Component;
5	import net.minecraft.network.chat.MutableComponent;
6	import net.minecraft.resources.ResourceLocation;
7	import net.minecraft.world.level.storage.ValueInput;
8	import net.minecraft.world.level.storage.ValueOutput;
9	import org.cyclops.integrateddynamics.Reference;
10	import org.cyclops.integrateddynamics.api.evaluate.EvaluationException;
11	import org.cyclops.integrateddynamics.api.evaluate.operator.IOperator;
12	import org.cyclops.integrateddynamics.api.evaluate.operator.IOperatorSerializer;
13	import org.cyclops.integrateddynamics.api.evaluate.variable.IValue;
14	import org.cyclops.integrateddynamics.api.evaluate.variable.IValueType;
15	import org.cyclops.integrateddynamics.api.evaluate.variable.IVariable;
16	import org.cyclops.integrateddynamics.api.logicprogrammer.IConfigRenderPattern;
17	import org.cyclops.integrateddynamics.core.evaluate.variable.ValueHelpers;
18	import org.cyclops.integrateddynamics.core.evaluate.variable.ValueTypes;
19	import org.cyclops.integrateddynamics.core.evaluate.variable.Variable;
20	import org.cyclops.integrateddynamics.core.helper.L10NValues;
21	import org.jetbrains.annotations.Nullable;
22
23	import java.util.Arrays;
24	import java.util.List;
25	import java.util.Objects;
26	import java.util.function.Consumer;
27
28	/**
29	* An operator that is partially being applied.
30	* @author rubensworks
31	*/
32	public class CurriedOperator implements IOperator {
33
34	private final IOperator baseOperator;
35	private final IVariable[] appliedVariables;
36
37	public CurriedOperator(IOperator baseOperator, IVariable... appliedVariables) {	2✔
38	this.baseOperator = baseOperator;	3✔
39	this.appliedVariables = appliedVariables;	3✔
40	}	1✔
41
42	protected String getAppliedSymbol() {
43	String symbol = "";	×
44	for (IVariable appliedVariable : appliedVariables) {	×
45	symbol += appliedVariable.getType().getTypeName() + ";";	×
46	}
47	return symbol;	×
48	}
49
50	@Override
51	public String getSymbol() {
52	StringBuilder sb = new StringBuilder();	×
53	sb.append(baseOperator.getSymbol());	×
54	sb.append(" [");	×
55	sb.append(getAppliedSymbol());	×
56	sb.append("]");	×
57	return sb.toString();	×
58	}
59
60	@Override
61	public ResourceLocation getUniqueName() {
62	return ResourceLocation.parse("curried_operator");	×
63	}
64
65	@Override
66	public String getInteractName() {
67	return "curried_operator";	×
68	}
69
70	@Nullable
71	@Override
72	public String getGlobalInteractNamePrefix() {
73	return null;	×
74	}
75
76	@Override
77	public boolean shouldAlsoPrefixLocalScope() {
78	return false;	×
79	}
80
81	@Override
82	public String getTranslationKey() {
83	return baseOperator.getTranslationKey();	4✔
84	}
85
86	@Override
87	public String getUnlocalizedCategoryName() {
88	return baseOperator.getUnlocalizedCategoryName();	×
89	}
90
91	@Override
92	public MutableComponent getLocalizedNameFull() {
93	return Component.translatable(L10NValues.OPERATOR_APPLIED_OPERATORNAME,	×
94	baseOperator.getLocalizedNameFull(), getAppliedSymbol());	×
95	}
96
97	@Override
98	public void loadTooltip(Consumer<Component> tooltipAdder, boolean appendOptionalInfo) {
99	baseOperator.loadTooltip(tooltipAdder, appendOptionalInfo);	×
100	tooltipAdder.accept(Component.translatable(L10NValues.OPERATOR_APPLIED_TYPE, getAppliedSymbol()));	×
101	}	×
102
103	@Override
104	public IValueType[] getInputTypes() {
105	IValueType[] baseInputTypes = baseOperator.getInputTypes();	4✔
106	return Arrays.copyOfRange(baseInputTypes, appliedVariables.length, baseInputTypes.length);	9✔
107	}
108
109	@Override
110	public IValueType getOutputType() {
111	return baseOperator.getOutputType();	4✔
112	}
113
114	protected IVariable[] deriveFullInputVariables(IVariable[] partialInput) {
115	IVariable[] fullInput = new IVariable[Math.min(baseOperator.getRequiredInputLength(), partialInput.length + appliedVariables.length)];	12✔
116	for (int i = 0; i < appliedVariables.length; i++) {	9✔
117	fullInput[i] = appliedVariables[i];	7✔
118	}
119	System.arraycopy(partialInput, 0, fullInput, appliedVariables.length, fullInput.length - appliedVariables.length);	13✔
120	return fullInput;	2✔
121	}
122
123	protected IValueType[] deriveFullInputTypes(IValueType[] partialInput) {
124	IValueType[] fullInput = new IValueType[Math.min(baseOperator.getRequiredInputLength(), partialInput.length + appliedVariables.length)];	12✔
125	for (int i = 0; i < appliedVariables.length; i++) {	9✔
126	fullInput[i] = appliedVariables[i].getType();	8✔
127	}
128	System.arraycopy(partialInput, 0, fullInput, appliedVariables.length, fullInput.length - appliedVariables.length);	13✔
129	return fullInput;	2✔
130	}
131
132	@Override
133	public IValueType getConditionalOutputType(IVariable[] input) {
134	return baseOperator.getConditionalOutputType(deriveFullInputVariables(input));	7✔
135	}
136
137	@Override
138	public IValue evaluate(IVariable[] input) throws EvaluationException {
139	return baseOperator.evaluate(deriveFullInputVariables(input));	7✔
140	}
141
142	@Override
143	public int getRequiredInputLength() {
144	return baseOperator.getRequiredInputLength() - appliedVariables.length;	8✔
145	}
146
147	@Override
148	public MutableComponent validateTypes(IValueType[] input) {
149	return baseOperator.validateTypes(deriveFullInputTypes(input));	7✔
150	}
151
152	@Override
153	public IConfigRenderPattern getRenderPattern() {
154	return IConfigRenderPattern.NONE;	×
155	}
156
157	@Override
158	public IOperator materialize() throws EvaluationException {
159	IVariable[] variables = new IVariable[appliedVariables.length];	×
160	for (int i = 0; i < appliedVariables.length; i++) {	×
161	IVariable appliedVariable = appliedVariables[i];	×
162	variables[i] = new Variable<>(appliedVariable.getType(), appliedVariable.getType().materialize(appliedVariable.getValue()));	×
163	}
164	return new CurriedOperator(baseOperator, variables);	×
165	}
166
167	public IOperator getBaseOperator() {
168	return baseOperator;	×
169	}
170
171	@Override
172	public boolean equals(Object o) {
173	if (this == o) return true;	3!
174	if (!(o instanceof CurriedOperator)) return false;	3!
175	CurriedOperator that = (CurriedOperator) o;	3✔
176	return Objects.equals(baseOperator, that.baseOperator) &&	11!
177	Arrays.equals(appliedVariables, that.appliedVariables);	4!
178	}
179
180	@Override
181	public int hashCode() {
182	int result = Objects.hash(baseOperator);	×
183	result = 31 * result + Arrays.hashCode(appliedVariables);	×
184	return result;	×
185	}
186
187	public static class Serializer implements IOperatorSerializer<CurriedOperator> {	3✔
188
189	@Override
190	public boolean canHandle(IOperator operator) {
191	return operator instanceof CurriedOperator;	3✔
192	}
193
194	@Override
195	public ResourceLocation getUniqueName() {
196	return ResourceLocation.fromNamespaceAndPath(Reference.MOD_ID, "curry");	4✔
197	}
198
199	@Override
200	public void serialize(ValueOutput valueOutput, CurriedOperator operator) {
201	Operators.REGISTRY.serialize(valueOutput.child("baseOperator"), operator.baseOperator);	×
202	ValueOutput.ValueOutputList list = valueOutput.childrenList("values");	×
203	for (int i = 0; i < operator.appliedVariables.length; i++) {	×
204	IVariable appliedVariable = operator.appliedVariables[i];	×
205	IValue value;
206	try {
207	value = appliedVariable.getValue();	×
208	} catch (EvaluationException e) {	×
209	value = appliedVariable.getType().getDefault();	×
210	}	×
211	ValueOutput valueTag = list.addChild();	×
212	IValueType valueType = value.getType();	×
213	valueTag.putString("valueType", valueType.getUniqueName().toString());	×
214	ValueHelpers.serializeRaw(valueTag.child("value"), value);	×
215	}
216	}	×
217
218	@Override
219	public CurriedOperator deserialize(ValueInput valueInput) throws EvaluationException {
220	ValueInput.ValueInputList list = valueInput.childrenList("values").orElseThrow();	×
221	List<IVariable> variables = Lists.newArrayList();	×
222	for (ValueInput valuetag : list) {	×
223	IValueType valueType = ValueTypes.REGISTRY.getValueType(ResourceLocation.parse(valuetag.getString("valueType").orElseThrow()));	×
224	IValue value = ValueHelpers.deserializeRaw(valuetag.child("value").orElseThrow(), valueType);	×
225	variables.add(new Variable(valueType, value));	×
226	}	×
227	IOperator baseOperator = Objects.requireNonNull(Operators.REGISTRY.deserialize(valueInput.child("baseOperator").orElseThrow()));	×
228	return new CurriedOperator(baseOperator, variables.toArray(new IVariable[0]));	×
229	}
230	}
231	}

CyclopsMC / IntegratedDynamics / 16552051255

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