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

52.83

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

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

import net.minecraft.ChatFormatting;
import net.minecraft.network.chat.Component;
import net.minecraft.resources.ResourceLocation;
import net.minecraft.world.level.storage.ValueInput;
import org.cyclops.cyclopscore.helper.IModHelpers;
import org.cyclops.integrateddynamics.Reference;
import org.cyclops.integrateddynamics.api.evaluate.EvaluationException;
import org.cyclops.integrateddynamics.api.evaluate.variable.IValue;
import org.cyclops.integrateddynamics.api.evaluate.variable.IValueType;
import org.cyclops.integrateddynamics.core.helper.L10NValues;
import org.cyclops.integrateddynamics.core.logicprogrammer.ValueTypeLPElementBase;
import org.cyclops.integrateddynamics.core.logicprogrammer.ValueTypeStringLPElement;

import javax.annotation.Nullable;
import java.util.function.Consumer;

/**
 * Base implementation of a value type.
 * @author rubensworks
 */
public abstract class ValueTypeBase<V extends IValue> implements IValueType<V> {

    private final String typeName;
    private final int color;
    private final ChatFormatting colorFormat;
    private final Class<V> valueClass;
    private ValueTypeBaseClient<V> client;

    private String translationKey = null;

    public ValueTypeBase(String typeName, int color, ChatFormatting colorFormat, Class<V> valueClass) {
        this.typeName = typeName;
        this.color = color;
        this.colorFormat = colorFormat;
        this.valueClass = valueClass;
        if(IModHelpers.get().getMinecraftHelpers().isModdedEnvironment() && IModHelpers.get().getMinecraftHelpers().isClientSide()) {
            this.client = constructClient();
            this.client.registerModelResourceLocation();
        }
    }

    protected ValueTypeBaseClient<V> constructClient() {
        return new ValueTypeBaseClient<>(this);
    }

    @Override
    public ValueTypeBaseClient<V> getClient() {
        return client;
    }

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

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

    @Override
    public ResourceLocation getUniqueName() {
        return ResourceLocation.fromNamespaceAndPath(getModId(), getTypeName());
    }

    protected String getUnlocalizedPrefix() {
        return "valuetype." + getModId() + getTypeNamespace() + getTypeName();
    }

    protected String getTypeNamespace() {
        return ".";
    }

    @Override
    public String getTranslationKey() {
        return translationKey != null ? translationKey : (translationKey = getUnlocalizedPrefix());
    }

    @Override
    public String getTypeName() {
        return this.typeName;
    }

    @Override
    public int getDisplayColor() {
        return this.color;
    }

    @Override
    public ChatFormatting getDisplayColorFormat() {
        return this.colorFormat;
    }

    @Override
    public boolean correspondsTo(IValueType<?> valueType) {
        return this == valueType;
    }

    @Override
    public void loadTooltip(Consumer<Component> tooltipAdder, boolean appendOptionalInfo, @Nullable V value) {
        String typeName = IModHelpers.get().getL10NHelpers().localize(getTranslationKey());
        tooltipAdder.accept(Component.translatable(L10NValues.VALUETYPE_TOOLTIP_TYPENAME, getDisplayColorFormat() + typeName));
        if(appendOptionalInfo) {
            IModHelpers.get().getL10NHelpers().addOptionalInfo(tooltipAdder, getUnlocalizedPrefix());
        }
    }

    @Override
    public Component canDeserialize(ValueInput valueInput) {
        try {
            deserialize(valueInput);
            return null;
        } catch (IllegalArgumentException e) {
            return Component.translatable(L10NValues.VALUETYPE_ERROR_INVALIDINPUT, valueInput);
        }
    }

    @Override
    public V materialize(V value) throws EvaluationException {
        return value;
    }

    @Override
    public V parseString(String value) throws EvaluationException {
        throw new UnsupportedOperationException("parseString is not supported on value type " + this);
    }

    @Override
    public String toString(V value) {
        throw new UnsupportedOperationException("toString is not supported on value type " + this);
    }

    @Override
    public String toString() {
        return IModHelpers.get().getL10NHelpers().localize(getTranslationKey());
    }

    @Override
    public ValueTypeLPElementBase createLogicProgrammerElement() {
        return new ValueTypeStringLPElement(this);
    }

    protected String getModId() {
        return Reference.MOD_ID;
    }

    @Override
    public V cast(IValue value) throws EvaluationException {
        try {
            return this.valueClass.cast(value);
        } catch (ClassCastException e) {
            throw new EvaluationException(Component.translatable(L10NValues.OPERATOR_ERROR_CAST_ILLEGAL,
                    Component.translatable(value.getType().getTranslationKey()),
                    Component.translatable(this.getTranslationKey()),
                    value.getType().toCompactString(value)
            ));
        }
    }
}

1	package org.cyclops.integrateddynamics.core.evaluate.variable;
2
3	import net.minecraft.ChatFormatting;
4	import net.minecraft.network.chat.Component;
5	import net.minecraft.resources.ResourceLocation;
6	import net.minecraft.world.level.storage.ValueInput;
7	import org.cyclops.cyclopscore.helper.IModHelpers;
8	import org.cyclops.integrateddynamics.Reference;
9	import org.cyclops.integrateddynamics.api.evaluate.EvaluationException;
10	import org.cyclops.integrateddynamics.api.evaluate.variable.IValue;
11	import org.cyclops.integrateddynamics.api.evaluate.variable.IValueType;
12	import org.cyclops.integrateddynamics.core.helper.L10NValues;
13	import org.cyclops.integrateddynamics.core.logicprogrammer.ValueTypeLPElementBase;
14	import org.cyclops.integrateddynamics.core.logicprogrammer.ValueTypeStringLPElement;
15
16	import javax.annotation.Nullable;
17	import java.util.function.Consumer;
18
19	/**
20	* Base implementation of a value type.
21	* @author rubensworks
22	*/
23	public abstract class ValueTypeBase<V extends IValue> implements IValueType<V> {
24
25	private final String typeName;
26	private final int color;
27	private final ChatFormatting colorFormat;
28	private final Class<V> valueClass;
29	private ValueTypeBaseClient<V> client;
30
31	private String translationKey = null;	3✔
32
33	public ValueTypeBase(String typeName, int color, ChatFormatting colorFormat, Class<V> valueClass) {	2✔
34	this.typeName = typeName;	3✔
35	this.color = color;	3✔
36	this.colorFormat = colorFormat;	3✔
37	this.valueClass = valueClass;	3✔
38	if(IModHelpers.get().getMinecraftHelpers().isModdedEnvironment() && IModHelpers.get().getMinecraftHelpers().isClientSide()) {	8!
39	this.client = constructClient();	×
40	this.client.registerModelResourceLocation();	×
41	}
42	}	1✔
43
44	protected ValueTypeBaseClient<V> constructClient() {
45	return new ValueTypeBaseClient<>(this);	×
46	}
47
48	@Override
49	public ValueTypeBaseClient<V> getClient() {
50	return client;	×
51	}
52
53	@Override
54	public boolean isCategory() {
55	return false;	2✔
56	}
57
58	@Override
59	public boolean isObject() {
60	return false;	×
61	}
62
63	@Override
64	public ResourceLocation getUniqueName() {
65	return ResourceLocation.fromNamespaceAndPath(getModId(), getTypeName());	6✔
66	}
67
68	protected String getUnlocalizedPrefix() {
69	return "valuetype." + getModId() + getTypeNamespace() + getTypeName();	8✔
70	}
71
72	protected String getTypeNamespace() {
73	return ".";	2✔
74	}
75
76	@Override
77	public String getTranslationKey() {
78	return translationKey != null ? translationKey : (translationKey = getUnlocalizedPrefix());	12✔
79	}
80
81	@Override
82	public String getTypeName() {
83	return this.typeName;	3✔
84	}
85
86	@Override
87	public int getDisplayColor() {
88	return this.color;	×
89	}
90
91	@Override
92	public ChatFormatting getDisplayColorFormat() {
93	return this.colorFormat;	×
94	}
95
96	@Override
97	public boolean correspondsTo(IValueType<?> valueType) {
98	return this == valueType;	7✔
99	}
100
101	@Override
102	public void loadTooltip(Consumer<Component> tooltipAdder, boolean appendOptionalInfo, @Nullable V value) {
103	String typeName = IModHelpers.get().getL10NHelpers().localize(getTranslationKey());	×
104	tooltipAdder.accept(Component.translatable(L10NValues.VALUETYPE_TOOLTIP_TYPENAME, getDisplayColorFormat() + typeName));	×
105	if(appendOptionalInfo) {	×
106	IModHelpers.get().getL10NHelpers().addOptionalInfo(tooltipAdder, getUnlocalizedPrefix());	×
107	}
108	}	×
109
110	@Override
111	public Component canDeserialize(ValueInput valueInput) {
112	try {
113	deserialize(valueInput);	×
114	return null;	×
115	} catch (IllegalArgumentException e) {	×
116	return Component.translatable(L10NValues.VALUETYPE_ERROR_INVALIDINPUT, valueInput);	×
117	}
118	}
119
120	@Override
121	public V materialize(V value) throws EvaluationException {
122	return value;	×
123	}
124
125	@Override
126	public V parseString(String value) throws EvaluationException {
127	throw new UnsupportedOperationException("parseString is not supported on value type " + this);	×
128	}
129
130	@Override
131	public String toString(V value) {
132	throw new UnsupportedOperationException("toString is not supported on value type " + this);	×
133	}
134
135	@Override
136	public String toString() {
137	return IModHelpers.get().getL10NHelpers().localize(getTranslationKey());	×
138	}
139
140	@Override
141	public ValueTypeLPElementBase createLogicProgrammerElement() {
142	return new ValueTypeStringLPElement(this);	×
143	}
144
145	protected String getModId() {
146	return Reference.MOD_ID;	2✔
147	}
148
149	@Override
150	public V cast(IValue value) throws EvaluationException {
151	try {
152	return this.valueClass.cast(value);	6✔
153	} catch (ClassCastException e) {	1✔
154	throw new EvaluationException(Component.translatable(L10NValues.OPERATOR_ERROR_CAST_ILLEGAL,	11✔
155	Component.translatable(value.getType().getTranslationKey()),	7✔
156	Component.translatable(this.getTranslationKey()),	6✔
157	value.getType().toCompactString(value)	4✔
158	));
159	}
160	}
161	}

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