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

11.88

/src/main/java/org/cyclops/integrateddynamics/core/item/VariableFacadeHandlerRegistry.java

package org.cyclops.integrateddynamics.core.item;

import com.google.common.collect.Maps;
import net.minecraft.nbt.CompoundTag;
import net.minecraft.network.chat.Component;
import net.minecraft.resources.ResourceLocation;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.item.Item;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.level.Level;
import net.minecraft.world.level.block.state.BlockState;
import net.neoforged.neoforge.common.NeoForge;
import org.cyclops.integrateddynamics.RegistryEntries;
import org.cyclops.integrateddynamics.api.evaluate.EvaluationException;
import org.cyclops.integrateddynamics.api.evaluate.expression.VariableAdapter;
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.evaluate.variable.ValueDeseralizationContext;
import org.cyclops.integrateddynamics.api.item.IVariableFacade;
import org.cyclops.integrateddynamics.api.item.IVariableFacadeClient;
import org.cyclops.integrateddynamics.api.item.IVariableFacadeHandler;
import org.cyclops.integrateddynamics.api.item.IVariableFacadeHandlerRegistry;
import org.cyclops.integrateddynamics.api.network.INetwork;
import org.cyclops.integrateddynamics.api.network.IPartNetwork;
import org.cyclops.integrateddynamics.core.evaluate.variable.ValueHelpers;
import org.cyclops.integrateddynamics.core.evaluate.variable.ValueTypeBoolean;
import org.cyclops.integrateddynamics.core.evaluate.variable.ValueTypes;
import org.cyclops.integrateddynamics.core.helper.L10NValues;
import org.cyclops.integrateddynamics.core.logicprogrammer.event.LogicProgrammerVariableFacadeCreatedEvent;

import javax.annotation.Nullable;
import java.util.Collection;
import java.util.Map;
import java.util.Objects;
import java.util.function.Consumer;

/**
 * The variable facade handler registry.
 * @author rubensworks
 */
public class VariableFacadeHandlerRegistry implements IVariableFacadeHandlerRegistry {

    private static VariableFacadeHandlerRegistry INSTANCE = new VariableFacadeHandlerRegistry();
    public static DummyVariableFacade DUMMY_FACADE = new DummyVariableFacade(L10NValues.VARIABLE_ERROR_INVALIDITEM);

    private final Map<String, IVariableFacadeHandler> handlers = Maps.newHashMap();

    private VariableFacadeHandlerRegistry() {

    }

    /**
     * @return The unique instance.
     */
    public static VariableFacadeHandlerRegistry getInstance() {
        return INSTANCE;
    }

    @Override
    public void registerHandler(IVariableFacadeHandler variableFacadeHandler) {
        handlers.put(variableFacadeHandler.getUniqueName().toString(), variableFacadeHandler);
    }

    @Override
    public IVariableFacade handle(ValueDeseralizationContext valueDeseralizationContext, ItemStack itemStack) {
        if(itemStack.isEmpty() || !itemStack.has(RegistryEntries.DATACOMPONENT_VARIABLE_FACADE)) {
            return DUMMY_FACADE;
        }
        return handle(valueDeseralizationContext, itemStack.get(RegistryEntries.DATACOMPONENT_VARIABLE_FACADE));
    }

    @Override
    public IVariableFacade handle(ValueDeseralizationContext valueDeseralizationContext, CompoundTag tagCompound) {
        if(tagCompound == null) {
            return DUMMY_FACADE;
        }
        if(!tagCompound.contains("_type") || !(tagCompound.contains("_id"))) {
            return DUMMY_FACADE;
        }
        String type = tagCompound.getString("_type").orElseThrow();
        int id = tagCompound.getInt("_id").orElseThrow();
        IVariableFacadeHandler handler = getHandler(ResourceLocation.parse(type));
        if(handler != null) {
            return handler.getVariableFacade(valueDeseralizationContext, id, tagCompound);
        }
        return DUMMY_FACADE;
    }

    @Nullable
    @Override
    public IVariableFacadeHandler getHandler(ResourceLocation type) {
        return handlers.get(type.toString());
    }

    @Override
    public Collection<String> getHandlerNames() {
        return handlers.keySet();
    }

    @Override
    public <F extends IVariableFacade> void write(ValueDeseralizationContext valueDeseralizationContext, CompoundTag tagCompound, F variableFacade, IVariableFacadeHandler<F> handler) {
        tagCompound.putString("_type", handler.getUniqueName().toString());
        tagCompound.putInt("_id", variableFacade.getId());
        handler.setVariableFacade(valueDeseralizationContext, tagCompound, variableFacade);
    }

    @Override
    public <F extends IVariableFacade> ItemStack writeVariableFacadeItem(ItemStack itemStack, F variableFacade, IVariableFacadeHandler<F> variableFacadeHandler) {
        if(itemStack.isEmpty()) {
            return ItemStack.EMPTY;
        }
        itemStack = itemStack.copy();
        CompoundTag tag = new CompoundTag();
        this.write(ValueDeseralizationContext.ofAllEnabled(), tag, variableFacade, variableFacadeHandler);
        itemStack.set(RegistryEntries.DATACOMPONENT_VARIABLE_FACADE, tag);
        return itemStack;
    }

    @Override
    public <F extends IVariableFacade> ItemStack writeVariableFacadeItem(boolean generateId, ItemStack itemStack, IVariableFacadeHandler<F> variableFacadeHandler, IVariableFacadeFactory<F> variableFacadeFactory, Level level, @Nullable Player player, @Nullable BlockState blockState) {
        if(itemStack.isEmpty()) {
            return ItemStack.EMPTY;
        }
        itemStack = itemStack.copy();
        CompoundTag tag = new CompoundTag();
        F variableFacade = writeVariableFacade(generateId, itemStack, variableFacadeHandler, variableFacadeFactory, ValueDeseralizationContext.of(level));
        if (player != null) {
            NeoForge.EVENT_BUS.post(new LogicProgrammerVariableFacadeCreatedEvent(player, variableFacade, blockState));
        }
        this.write(ValueDeseralizationContext.of(level), tag, variableFacade, variableFacadeHandler);
        itemStack.set(RegistryEntries.DATACOMPONENT_VARIABLE_FACADE, tag);
        return itemStack;
    }

    @Override
    public <F extends IVariableFacade> F writeVariableFacade(boolean generateId, ItemStack itemStack, IVariableFacadeHandler<F> variableFacadeHandler, IVariableFacadeFactory<F> variableFacadeFactory, ValueDeseralizationContext valueDeseralizationContext) {
        if(itemStack.isEmpty()) {
            return null;
        }
        CompoundTag tag = Objects.requireNonNullElseGet(itemStack.get(RegistryEntries.DATACOMPONENT_VARIABLE_FACADE), CompoundTag::new).copy();
        IVariableFacade previousVariableFacade = this.handle(valueDeseralizationContext, tag);
        F variableFacade;
        if(generateId && previousVariableFacade.getId() > -1) {
            variableFacade = variableFacadeFactory.create(previousVariableFacade.getId());
        } else {
            variableFacade = variableFacadeFactory.create(generateId);
        }
        itemStack.set(RegistryEntries.DATACOMPONENT_VARIABLE_FACADE, tag);
        return variableFacade;
    }

    @Override
    public <F extends IVariableFacade> ItemStack copy(boolean generateId, ItemStack itemStack) {
        ItemStack copy = itemStack.copy();
        int newId = generateId ? VariableFacadeBase.generateId() : -1;
        CompoundTag tagCopy = itemStack.get(RegistryEntries.DATACOMPONENT_VARIABLE_FACADE).copy();
        tagCopy.putInt("_id", newId);
        copy.set(RegistryEntries.DATACOMPONENT_VARIABLE_FACADE, tagCopy);
        return copy;
    }

    /**
     * Variable facade used for items that have no (valid) information on them.
     */
    public static class DummyVariableFacade extends VariableFacadeBase {

        private static final IVariable VARIABLE_TRUE = new VariableAdapter<ValueTypeBoolean.ValueBoolean>() {
            @Override
            public IValueType<ValueTypeBoolean.ValueBoolean> getType() {
                return ValueTypes.BOOLEAN;
            }

            @Override
            public ValueTypeBoolean.ValueBoolean getValue() throws EvaluationException {
                return ValueTypeBoolean.ValueBoolean.of(true);
            }
        };

        private final String unlocalizedError;

        public DummyVariableFacade(String unlocalizedError) {
            super(false);
            this.unlocalizedError = unlocalizedError;
        }

        @Override
        public <V extends IValue> IVariable<V> getVariable(INetwork network, IPartNetwork partNetwork) {
            return VARIABLE_TRUE;
        }

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

        @Override
        public void validate(INetwork network, IPartNetwork partNetwork, IValidator validator, IValueType containingValueType) {
            if (!ValueHelpers.correspondsTo(containingValueType, ValueTypes.BOOLEAN)) {
                validator.addError(Component.translatable(unlocalizedError));
            }
        }

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

        @Override
        protected IVariableFacadeClient constructClient() {
            return new DummyVariableFacadeClient();
        }

        @Override
        public void appendHoverText(Consumer<Component> tooltipAdder, Item.TooltipContext context) {

        }
    }

}

1	package org.cyclops.integrateddynamics.core.item;
2
3	import com.google.common.collect.Maps;
4	import net.minecraft.nbt.CompoundTag;
5	import net.minecraft.network.chat.Component;
6	import net.minecraft.resources.ResourceLocation;
7	import net.minecraft.world.entity.player.Player;
8	import net.minecraft.world.item.Item;
9	import net.minecraft.world.item.ItemStack;
10	import net.minecraft.world.level.Level;
11	import net.minecraft.world.level.block.state.BlockState;
12	import net.neoforged.neoforge.common.NeoForge;
13	import org.cyclops.integrateddynamics.RegistryEntries;
14	import org.cyclops.integrateddynamics.api.evaluate.EvaluationException;
15	import org.cyclops.integrateddynamics.api.evaluate.expression.VariableAdapter;
16	import org.cyclops.integrateddynamics.api.evaluate.variable.IValue;
17	import org.cyclops.integrateddynamics.api.evaluate.variable.IValueType;
18	import org.cyclops.integrateddynamics.api.evaluate.variable.IVariable;
19	import org.cyclops.integrateddynamics.api.evaluate.variable.ValueDeseralizationContext;
20	import org.cyclops.integrateddynamics.api.item.IVariableFacade;
21	import org.cyclops.integrateddynamics.api.item.IVariableFacadeClient;
22	import org.cyclops.integrateddynamics.api.item.IVariableFacadeHandler;
23	import org.cyclops.integrateddynamics.api.item.IVariableFacadeHandlerRegistry;
24	import org.cyclops.integrateddynamics.api.network.INetwork;
25	import org.cyclops.integrateddynamics.api.network.IPartNetwork;
26	import org.cyclops.integrateddynamics.core.evaluate.variable.ValueHelpers;
27	import org.cyclops.integrateddynamics.core.evaluate.variable.ValueTypeBoolean;
28	import org.cyclops.integrateddynamics.core.evaluate.variable.ValueTypes;
29	import org.cyclops.integrateddynamics.core.helper.L10NValues;
30	import org.cyclops.integrateddynamics.core.logicprogrammer.event.LogicProgrammerVariableFacadeCreatedEvent;
31
32	import javax.annotation.Nullable;
33	import java.util.Collection;
34	import java.util.Map;
35	import java.util.Objects;
36	import java.util.function.Consumer;
37
38	/**
39	* The variable facade handler registry.
40	* @author rubensworks
41	*/
42	public class VariableFacadeHandlerRegistry implements IVariableFacadeHandlerRegistry {
43
44	private static VariableFacadeHandlerRegistry INSTANCE = new VariableFacadeHandlerRegistry();	4✔
45	public static DummyVariableFacade DUMMY_FACADE = new DummyVariableFacade(L10NValues.VARIABLE_ERROR_INVALIDITEM);	6✔
46
47	private final Map<String, IVariableFacadeHandler> handlers = Maps.newHashMap();	3✔
48
49	private VariableFacadeHandlerRegistry() {	2✔
50
51	}	1✔
52
53	/**
54	* @return The unique instance.
55	*/
56	public static VariableFacadeHandlerRegistry getInstance() {
57	return INSTANCE;	2✔
58	}
59
60	@Override
61	public void registerHandler(IVariableFacadeHandler variableFacadeHandler) {
62	handlers.put(variableFacadeHandler.getUniqueName().toString(), variableFacadeHandler);	8✔
63	}	1✔
64
65	@Override
66	public IVariableFacade handle(ValueDeseralizationContext valueDeseralizationContext, ItemStack itemStack) {
67	if(itemStack.isEmpty() \|\| !itemStack.has(RegistryEntries.DATACOMPONENT_VARIABLE_FACADE)) {	×
68	return DUMMY_FACADE;	×
69	}
70	return handle(valueDeseralizationContext, itemStack.get(RegistryEntries.DATACOMPONENT_VARIABLE_FACADE));	×
71	}
72
73	@Override
74	public IVariableFacade handle(ValueDeseralizationContext valueDeseralizationContext, CompoundTag tagCompound) {
75	if(tagCompound == null) {	×
76	return DUMMY_FACADE;	×
77	}
78	if(!tagCompound.contains("_type") \|\| !(tagCompound.contains("_id"))) {	×
79	return DUMMY_FACADE;	×
80	}
81	String type = tagCompound.getString("_type").orElseThrow();	×
82	int id = tagCompound.getInt("_id").orElseThrow();	×
83	IVariableFacadeHandler handler = getHandler(ResourceLocation.parse(type));	×
84	if(handler != null) {	×
85	return handler.getVariableFacade(valueDeseralizationContext, id, tagCompound);	×
86	}
87	return DUMMY_FACADE;	×
88	}
89
90	@Nullable
91	@Override
92	public IVariableFacadeHandler getHandler(ResourceLocation type) {
93	return handlers.get(type.toString());	×
94	}
95
96	@Override
97	public Collection<String> getHandlerNames() {
98	return handlers.keySet();	×
99	}
100
101	@Override
102	public <F extends IVariableFacade> void write(ValueDeseralizationContext valueDeseralizationContext, CompoundTag tagCompound, F variableFacade, IVariableFacadeHandler<F> handler) {
103	tagCompound.putString("_type", handler.getUniqueName().toString());	×
104	tagCompound.putInt("_id", variableFacade.getId());	×
105	handler.setVariableFacade(valueDeseralizationContext, tagCompound, variableFacade);	×
106	}	×
107
108	@Override
109	public <F extends IVariableFacade> ItemStack writeVariableFacadeItem(ItemStack itemStack, F variableFacade, IVariableFacadeHandler<F> variableFacadeHandler) {
110	if(itemStack.isEmpty()) {	×
111	return ItemStack.EMPTY;	×
112	}
113	itemStack = itemStack.copy();	×
114	CompoundTag tag = new CompoundTag();	×
115	this.write(ValueDeseralizationContext.ofAllEnabled(), tag, variableFacade, variableFacadeHandler);	×
116	itemStack.set(RegistryEntries.DATACOMPONENT_VARIABLE_FACADE, tag);	×
117	return itemStack;	×
118	}
119
120	@Override
121	public <F extends IVariableFacade> ItemStack writeVariableFacadeItem(boolean generateId, ItemStack itemStack, IVariableFacadeHandler<F> variableFacadeHandler, IVariableFacadeFactory<F> variableFacadeFactory, Level level, @Nullable Player player, @Nullable BlockState blockState) {
122	if(itemStack.isEmpty()) {	×
123	return ItemStack.EMPTY;	×
124	}
125	itemStack = itemStack.copy();	×
126	CompoundTag tag = new CompoundTag();	×
127	F variableFacade = writeVariableFacade(generateId, itemStack, variableFacadeHandler, variableFacadeFactory, ValueDeseralizationContext.of(level));	×
128	if (player != null) {	×
129	NeoForge.EVENT_BUS.post(new LogicProgrammerVariableFacadeCreatedEvent(player, variableFacade, blockState));	×
130	}
131	this.write(ValueDeseralizationContext.of(level), tag, variableFacade, variableFacadeHandler);	×
132	itemStack.set(RegistryEntries.DATACOMPONENT_VARIABLE_FACADE, tag);	×
133	return itemStack;	×
134	}
135
136	@Override
137	public <F extends IVariableFacade> F writeVariableFacade(boolean generateId, ItemStack itemStack, IVariableFacadeHandler<F> variableFacadeHandler, IVariableFacadeFactory<F> variableFacadeFactory, ValueDeseralizationContext valueDeseralizationContext) {
138	if(itemStack.isEmpty()) {	×
139	return null;	×
140	}
141	CompoundTag tag = Objects.requireNonNullElseGet(itemStack.get(RegistryEntries.DATACOMPONENT_VARIABLE_FACADE), CompoundTag::new).copy();	×
142	IVariableFacade previousVariableFacade = this.handle(valueDeseralizationContext, tag);	×
143	F variableFacade;
144	if(generateId && previousVariableFacade.getId() > -1) {	×
145	variableFacade = variableFacadeFactory.create(previousVariableFacade.getId());	×
146	} else {
147	variableFacade = variableFacadeFactory.create(generateId);	×
148	}
149	itemStack.set(RegistryEntries.DATACOMPONENT_VARIABLE_FACADE, tag);	×
150	return variableFacade;	×
151	}
152
153	@Override
154	public <F extends IVariableFacade> ItemStack copy(boolean generateId, ItemStack itemStack) {
155	ItemStack copy = itemStack.copy();	×
156	int newId = generateId ? VariableFacadeBase.generateId() : -1;	×
157	CompoundTag tagCopy = itemStack.get(RegistryEntries.DATACOMPONENT_VARIABLE_FACADE).copy();	×
158	tagCopy.putInt("_id", newId);	×
159	copy.set(RegistryEntries.DATACOMPONENT_VARIABLE_FACADE, tagCopy);	×
160	return copy;	×
161	}
162
163	/**
164	* Variable facade used for items that have no (valid) information on them.
165	*/
166	public static class DummyVariableFacade extends VariableFacadeBase {
167
168	private static final IVariable VARIABLE_TRUE = new VariableAdapter<ValueTypeBoolean.ValueBoolean>() {	8✔
169	@Override
170	public IValueType<ValueTypeBoolean.ValueBoolean> getType() {
171	return ValueTypes.BOOLEAN;	×
172	}
173
174	@Override
175	public ValueTypeBoolean.ValueBoolean getValue() throws EvaluationException {
176	return ValueTypeBoolean.ValueBoolean.of(true);	×
177	}
178	};
179
180	private final String unlocalizedError;
181
182	public DummyVariableFacade(String unlocalizedError) {
183	super(false);	3✔
184	this.unlocalizedError = unlocalizedError;	3✔
185	}	1✔
186
187	@Override
188	public <V extends IValue> IVariable<V> getVariable(INetwork network, IPartNetwork partNetwork) {
189	return VARIABLE_TRUE;	×
190	}
191
192	@Override
193	public boolean isValid() {
194	return false;	×
195	}
196
197	@Override
198	public void validate(INetwork network, IPartNetwork partNetwork, IValidator validator, IValueType containingValueType) {
199	if (!ValueHelpers.correspondsTo(containingValueType, ValueTypes.BOOLEAN)) {	×
200	validator.addError(Component.translatable(unlocalizedError));	×
201	}
202	}	×
203
204	@Override
205	public IValueType getOutputType() {
206	return ValueTypes.CATEGORY_ANY;	×
207	}
208
209	@Override
210	protected IVariableFacadeClient constructClient() {
211	return new DummyVariableFacadeClient();	×
212	}
213
214	@Override
215	public void appendHoverText(Consumer<Component> tooltipAdder, Item.TooltipContext context) {
216
217	}	×
218	}
219
220	}

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