42509239591

Committed 08 Nov 2026 06:17PM UTC coverage: 58.582% (+0.2%) from 58.341%

Build # 42509239591

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #1781 from CyclopsMC/feature/expression-cards-26

Upmerge expressions in the Logic Programmer to 26.1

Coverage Stats

5827 of 13562 branches covered (42.97%)

Branch coverage included in aggregate %.

26150 of 41023 relevant lines covered (63.74%)

3.34 hits per line

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

67.65

/src/main/java/org/cyclops/integrateddynamics/core/evaluate/variable/ValueObjectTypeItemStack.java

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

import net.minecraft.advancements.criterion.ItemPredicate;
import net.minecraft.core.registries.BuiltInRegistries;
import net.minecraft.network.chat.Component;
import net.minecraft.network.chat.MutableComponent;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.level.storage.ValueInput;
import net.minecraft.world.level.storage.ValueOutput;
import org.cyclops.commoncapabilities.api.capability.itemhandler.ItemMatch;
import org.cyclops.cyclopscore.helper.IModHelpers;
import org.cyclops.integrateddynamics.api.advancement.criterion.ValuePredicate;
import org.cyclops.integrateddynamics.api.evaluate.EvaluationException;
import org.cyclops.integrateddynamics.api.evaluate.variable.IValueTypeNamed;
import org.cyclops.integrateddynamics.api.evaluate.variable.IValueTypeNullable;
import org.cyclops.integrateddynamics.api.evaluate.variable.IValueTypeUniquelyNamed;
import org.cyclops.integrateddynamics.core.logicprogrammer.ValueTypeItemStackLPElement;
import org.cyclops.integrateddynamics.core.logicprogrammer.ValueTypeLPElementBase;

import java.util.Objects;
import java.util.Optional;

/**
 * Value type with values that are itemstacks.
 * @author rubensworks
 */
public class ValueObjectTypeItemStack extends ValueObjectTypeBase<ValueObjectTypeItemStack.ValueItemStack> implements
        IValueTypeNamed<ValueObjectTypeItemStack.ValueItemStack>,
        IValueTypeUniquelyNamed<ValueObjectTypeItemStack.ValueItemStack>,
        IValueTypeNullable<ValueObjectTypeItemStack.ValueItemStack> {

    public ValueObjectTypeItemStack() {
        // TODO: in next major, prefix the global interact names of operators on items with item instead of itemstack.
        super("itemstack", ValueObjectTypeItemStack.ValueItemStack.class);
    }

    @Override
    public String getExpressionName() {
        return "Item";
    }

    public static MutableComponent getItemStackDisplayNameUsSafe(ItemStack itemStack) throws NoSuchMethodException {
        return !itemStack.isEmpty()
                ? (itemStack.getHoverName().copy().append((itemStack.getCount() > 1 ? " (" + itemStack.getCount() + ")" : "")))
                : Component.literal("");
    }

    public static MutableComponent getItemStackDisplayNameSafe(ItemStack itemStack) {
        // Certain mods may call client-side only methods,
        // so call a server-side-safe fallback method if that fails.
        try {
            return getItemStackDisplayNameUsSafe(itemStack);
        } catch (NoSuchMethodException e) {
            return Component.translatable(itemStack.getItem().getDescriptionId());
        }
    }

    @Override
    public ValueItemStack getDefault() {
        return ValueItemStack.of(ItemStack.EMPTY);
    }

    @Override
    public MutableComponent toCompactString(ValueItemStack value) {
        return ValueObjectTypeItemStack.getItemStackDisplayNameSafe(value.getRawValue());
    }

    @Override
    public void serialize(ValueOutput valueOutput, ValueItemStack value) {
        valueOutput = valueOutput.child("v");
        ItemStack itemStack;
        itemStack = value.getRawValue();
        int count = itemStack.getCount();
        if (itemStack.getCount() > 99) {
            itemStack = itemStack.copy();
            itemStack.setCount(99);
        }
        if (count > 99) {
            valueOutput.putInt("ExtendedCount", count);
        }
        valueOutput.store("stack", ItemStack.OPTIONAL_CODEC, itemStack);
    }

    @Override
    public ValueItemStack deserialize(ValueInput valueInput) {
        valueInput = valueInput.child("v").orElseThrow();
        ItemStack itemStack = valueInput.read("stack", ItemStack.OPTIONAL_CODEC).orElseThrow();
        valueInput.getInt("ExtendedCount").ifPresent(itemStack::setCount);
        return ValueItemStack.of(itemStack);
    }

    @Override
    public String getName(ValueItemStack a) {
        return toCompactString(a).getString();
    }

    @Override
    public boolean isNull(ValueItemStack a) {
        return a.getRawValue().isEmpty();
    }

    @Override
    public ValueTypeLPElementBase createLogicProgrammerElement() {
        return new ValueTypeItemStackLPElement<>(this, new ValueTypeItemStackLPElement.IItemStackToValue<ValueObjectTypeItemStack.ValueItemStack>() {
            @Override
            public boolean isNullable() {
                return true;
            }

            @Override
            public Component validate(ItemStack itemStack) {
                return null;
            }

            @Override
            public ValueObjectTypeItemStack.ValueItemStack getValue(ItemStack itemStack) {
                return ValueObjectTypeItemStack.ValueItemStack.of(itemStack);
            }

            @Override
            public ItemStack getValueAsItemStack(ValueItemStack value) {
                return value.getRawValue();
            }
        });
    }

    @Override
    public ValueItemStack materialize(ValueItemStack value) throws EvaluationException {
        return ValueItemStack.of(value.getRawValue().copy());
    }

    @Override
    public String getUniqueName(ValueItemStack value) {
        ItemStack itemStack = value.getRawValue();
        return !itemStack.isEmpty() ? BuiltInRegistries.ITEM.getKey(itemStack.getItem()).toString() : "";
    }

    public static class ValueItemStack extends ValueBase {

        private final ItemStack itemStack;

        private ValueItemStack(ItemStack itemStack) {
            super(ValueTypes.OBJECT_ITEMSTACK);
            this.itemStack = Objects.requireNonNull(itemStack, "Attempted to create a ValueItemStack for a null ItemStack.");
        }

        public static ValueItemStack of(ItemStack itemStack) {
            return new ValueItemStack(itemStack);
        }

        public ItemStack getRawValue() {
            return itemStack;
        }

        @Override
        public boolean equals(Object o) {
            return o instanceof ValueItemStack && ItemMatch.areItemStacksEqual(((ValueItemStack) o).itemStack, this.itemStack, ItemMatch.EXACT);
        }

        @Override
        public int hashCode() {
            return 37 + IModHelpers.get().getItemStackHelpers().getItemStackHashCode(itemStack);
        }

        @Override
        public String toString() {
            return "ValueItemStack(itemStack=" + this.itemStack + ")";
        }
    }

    public static class ValueItemStackPredicate extends ValuePredicate<ValueItemStack> {

        private final Optional<ItemPredicate> itemPredicate;

        public ValueItemStackPredicate(Optional<ItemPredicate> itemPredicate) {
            super(Optional.of(ValueTypes.OBJECT_ITEMSTACK), Optional.empty(), Optional.empty());
            this.itemPredicate = itemPredicate;
        }

        public Optional<ItemPredicate> getItemPredicate() {
            return itemPredicate;
        }

        @Override
        protected boolean testTyped(ValueItemStack value) {
            return super.testTyped(value) && (itemPredicate.isEmpty() || itemPredicate.get().test(value.getRawValue()));
        }
    }

}

1	package org.cyclops.integrateddynamics.core.evaluate.variable;
2
3	import net.minecraft.advancements.criterion.ItemPredicate;
4	import net.minecraft.core.registries.BuiltInRegistries;
5	import net.minecraft.network.chat.Component;
6	import net.minecraft.network.chat.MutableComponent;
7	import net.minecraft.world.item.ItemStack;
8	import net.minecraft.world.level.storage.ValueInput;
9	import net.minecraft.world.level.storage.ValueOutput;
10	import org.cyclops.commoncapabilities.api.capability.itemhandler.ItemMatch;
11	import org.cyclops.cyclopscore.helper.IModHelpers;
12	import org.cyclops.integrateddynamics.api.advancement.criterion.ValuePredicate;
13	import org.cyclops.integrateddynamics.api.evaluate.EvaluationException;
14	import org.cyclops.integrateddynamics.api.evaluate.variable.IValueTypeNamed;
15	import org.cyclops.integrateddynamics.api.evaluate.variable.IValueTypeNullable;
16	import org.cyclops.integrateddynamics.api.evaluate.variable.IValueTypeUniquelyNamed;
17	import org.cyclops.integrateddynamics.core.logicprogrammer.ValueTypeItemStackLPElement;
18	import org.cyclops.integrateddynamics.core.logicprogrammer.ValueTypeLPElementBase;
19
20	import java.util.Objects;
21	import java.util.Optional;
22
23	/**
24	* Value type with values that are itemstacks.
25	* @author rubensworks
26	*/
27	public class ValueObjectTypeItemStack extends ValueObjectTypeBase<ValueObjectTypeItemStack.ValueItemStack> implements
28	IValueTypeNamed<ValueObjectTypeItemStack.ValueItemStack>,
29	IValueTypeUniquelyNamed<ValueObjectTypeItemStack.ValueItemStack>,
30	IValueTypeNullable<ValueObjectTypeItemStack.ValueItemStack> {
31
32	public ValueObjectTypeItemStack() {
33	// TODO: in next major, prefix the global interact names of operators on items with item instead of itemstack.
34	super("itemstack", ValueObjectTypeItemStack.ValueItemStack.class);	4 ✔
35	}	1 ✔
36
37	@Override
38	public String getExpressionName() {
39	return "Item";	2 ✔
40	}
41
42	public static MutableComponent getItemStackDisplayNameUsSafe(ItemStack itemStack) throws NoSuchMethodException {
43	return !itemStack.isEmpty()	4 !
44	? (itemStack.getHoverName().copy().append((itemStack.getCount() > 1 ? " (" + itemStack.getCount() + ")" : "")))	×
45	: Component.literal("");	2 ✔
46	}
47
48	public static MutableComponent getItemStackDisplayNameSafe(ItemStack itemStack) {
49	// Certain mods may call client-side only methods,
50	// so call a server-side-safe fallback method if that fails.
51	try {
52	return getItemStackDisplayNameUsSafe(itemStack);	3 ✔
53	} catch (NoSuchMethodException e) {	×
54	return Component.translatable(itemStack.getItem().getDescriptionId());	×
55	}
56	}
57
58	@Override
59	public ValueItemStack getDefault() {
60	return ValueItemStack.of(ItemStack.EMPTY);	×
61	}
62
63	@Override
64	public MutableComponent toCompactString(ValueItemStack value) {
65	return ValueObjectTypeItemStack.getItemStackDisplayNameSafe(value.getRawValue());	4 ✔
66	}
67
68	@Override
69	public void serialize(ValueOutput valueOutput, ValueItemStack value) {
70	valueOutput = valueOutput.child("v");	4 ✔
71	ItemStack itemStack;
72	itemStack = value.getRawValue();	3 ✔
73	int count = itemStack.getCount();	3 ✔
74	if (itemStack.getCount() > 99) {	4 ✔
75	itemStack = itemStack.copy();	3 ✔
76	itemStack.setCount(99);	3 ✔
77	}
78	if (count > 99) {	3 ✔
79	valueOutput.putInt("ExtendedCount", count);	4 ✔
80	}
81	valueOutput.store("stack", ItemStack.OPTIONAL_CODEC, itemStack);	5 ✔
82	}	1 ✔
83
84	@Override
85	public ValueItemStack deserialize(ValueInput valueInput) {
86	valueInput = valueInput.child("v").orElseThrow();	6 ✔
87	ItemStack itemStack = valueInput.read("stack", ItemStack.OPTIONAL_CODEC).orElseThrow();	7 ✔
88	valueInput.getInt("ExtendedCount").ifPresent(itemStack::setCount);	9 ✔
89	return ValueItemStack.of(itemStack);	3 ✔
90	}
91
92	@Override
93	public String getName(ValueItemStack a) {
94	return toCompactString(a).getString();	×
95	}
96
97	@Override
98	public boolean isNull(ValueItemStack a) {
99	return a.getRawValue().isEmpty();	×
100	}
101
102	@Override
103	public ValueTypeLPElementBase createLogicProgrammerElement() {
104	return new ValueTypeItemStackLPElement<>(this, new ValueTypeItemStackLPElement.IItemStackToValue<ValueObjectTypeItemStack.ValueItemStack>() {	17 ✔
105	@Override
106	public boolean isNullable() {
107	return true;	×
108	}
109
110	@Override
111	public Component validate(ItemStack itemStack) {
112	return null;	×
113	}
114
115	@Override
116	public ValueObjectTypeItemStack.ValueItemStack getValue(ItemStack itemStack) {
117	return ValueObjectTypeItemStack.ValueItemStack.of(itemStack);	×
118	}
119
120	@Override
121	public ItemStack getValueAsItemStack(ValueItemStack value) {
122	return value.getRawValue();	×
123	}
124	});
125	}
126
127	@Override
128	public ValueItemStack materialize(ValueItemStack value) throws EvaluationException {
129	return ValueItemStack.of(value.getRawValue().copy());	5 ✔
130	}
131
132	@Override
133	public String getUniqueName(ValueItemStack value) {
134	ItemStack itemStack = value.getRawValue();	×
135	return !itemStack.isEmpty() ? BuiltInRegistries.ITEM.getKey(itemStack.getItem()).toString() : "";	×
136	}
137
138	public static class ValueItemStack extends ValueBase {
139
140	private final ItemStack itemStack;
141
142	private ValueItemStack(ItemStack itemStack) {
143	super(ValueTypes.OBJECT_ITEMSTACK);	3 ✔
144	this.itemStack = Objects.requireNonNull(itemStack, "Attempted to create a ValueItemStack for a null ItemStack.");	6 ✔
145	}	1 ✔
146
147	public static ValueItemStack of(ItemStack itemStack) {
148	return new ValueItemStack(itemStack);	5 ✔
149	}
150
151	public ItemStack getRawValue() {
152	return itemStack;	3 ✔
153	}
154
155	@Override
156	public boolean equals(Object o) {
157	return o instanceof ValueItemStack && ItemMatch.areItemStacksEqual(((ValueItemStack) o).itemStack, this.itemStack, ItemMatch.EXACT);	15 !
158	}
159
160	@Override
161	public int hashCode() {
162	return 37 + IModHelpers.get().getItemStackHelpers().getItemStackHashCode(itemStack);	×
163	}
164
165	@Override
166	public String toString() {
167	return "ValueItemStack(itemStack=" + this.itemStack + ")";	5 ✔
168	}
169	}
170
171	public static class ValueItemStackPredicate extends ValuePredicate<ValueItemStack> {
172
173	private final Optional<ItemPredicate> itemPredicate;
174
175	public ValueItemStackPredicate(Optional<ItemPredicate> itemPredicate) {
176	super(Optional.of(ValueTypes.OBJECT_ITEMSTACK), Optional.empty(), Optional.empty());	6 ✔
177	this.itemPredicate = itemPredicate;	3 ✔
178	}	1 ✔
179
180	public Optional<ItemPredicate> getItemPredicate() {
181	return itemPredicate;	×
182	}
183
184	@Override
185	protected boolean testTyped(ValueItemStack value) {
186	return super.testTyped(value) && (itemPredicate.isEmpty() \|\| itemPredicate.get().test(value.getRawValue()));	20 !
187	}
188	}
189
190	}

CyclopsMC / IntegratedDynamics / 42509239591

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