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

77.59

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

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

import lombok.ToString;
import net.minecraft.ChatFormatting;
import net.minecraft.network.chat.Component;
import net.minecraft.network.chat.MutableComponent;
import net.minecraft.world.level.storage.ValueInput;
import net.minecraft.world.level.storage.ValueOutput;
import org.cyclops.cyclopscore.helper.IModHelpers;
import org.cyclops.integrateddynamics.GeneralConfig;
import org.cyclops.integrateddynamics.api.evaluate.EvaluationException;
import org.cyclops.integrateddynamics.api.evaluate.variable.IValueTypeNumber;
import org.cyclops.integrateddynamics.core.helper.L10NValues;

import java.text.NumberFormat;
import java.util.Locale;

/**
 * Value type with values that are doubles.
 * @author rubensworks
 */
public class ValueTypeDouble extends ValueTypeBase<ValueTypeDouble.ValueDouble> implements IValueTypeNumber<ValueTypeDouble.ValueDouble> {

    public ValueTypeDouble() {
        super("double", IModHelpers.get().getBaseHelpers().RGBToInt(235, 234, 23), ChatFormatting.YELLOW, ValueTypeDouble.ValueDouble.class);
    }

    @Override
    public ValueDouble getDefault() {
        return ValueDouble.of(0D);
    }

    @Override
    public MutableComponent toCompactString(ValueDouble value) {
        return Component.literal(Double.toString(value.getRawValue()));
    }

    @Override
    public void serialize(ValueOutput valueOutput, ValueDouble value) {
        valueOutput.putDouble("v", value.getRawValue());
    }

    @Override
    public ValueDouble deserialize(ValueInput valueInput) {
        return ValueDouble.of(valueInput.getDoubleOr("v", 0));
    }

    @Override
    public String toString(ValueDouble value) {
        return Double.toString(value.getRawValue());
    }

    @Override
    public ValueDouble parseString(String value) throws EvaluationException {
        try {
            return ValueDouble.of(Double.parseDouble(value));
        } catch (NumberFormatException e) {
            throw new EvaluationException(Component.translatable(L10NValues.OPERATOR_ERROR_PARSE, value,
                    Component.translatable(getTranslationKey())));
        }
    }

    @Override
    public boolean isZero(ValueDouble a) {
        return a.getRawValue() == 0D;
    }

    @Override
    public boolean isOne(ValueDouble a) {
        return a.getRawValue() == 1D;
    }

    @Override
    public ValueDouble add(ValueDouble a, ValueDouble b) {
        return ValueDouble.of(a.getRawValue() + b.getRawValue());
    }

    @Override
    public ValueDouble subtract(ValueDouble a, ValueDouble b) {
        return ValueDouble.of(a.getRawValue() - b.getRawValue());
    }

    @Override
    public ValueDouble multiply(ValueDouble a, ValueDouble b) {
        return ValueDouble.of(a.getRawValue() * b.getRawValue());
    }

    @Override
    public ValueDouble divide(ValueDouble a, ValueDouble b) {
        return ValueDouble.of(a.getRawValue() / b.getRawValue());
    }

    @Override
    public ValueDouble max(ValueDouble a, ValueDouble b) {
        return ValueDouble.of(Math.max(a.getRawValue(), b.getRawValue()));
    }

    @Override
    public ValueDouble min(ValueDouble a, ValueDouble b) {
        return ValueDouble.of(Math.min(a.getRawValue(), b.getRawValue()));
    }

    @Override
    public ValueDouble increment(ValueDouble a) {
        return ValueDouble.of(a.getRawValue() + 1D);
    }

    @Override
    public ValueDouble decrement(ValueDouble a) {
        return ValueDouble.of(a.getRawValue() - 1D);
    }

    @Override
    public ValueDouble modulus(ValueDouble a, ValueDouble b) {
        return ValueDouble.of(a.getRawValue() % b.getRawValue());
    }

    @Override
    public boolean greaterThan(ValueDouble a, ValueDouble b) {
        return a.getRawValue() > b.getRawValue();
    }

    @Override
    public boolean lessThan(ValueDouble a, ValueDouble b) {
        return a.getRawValue() < b.getRawValue();
    }

    @Override
    public ValueTypeInteger.ValueInteger round(ValueDouble a) {
        return ValueTypeInteger.ValueInteger.of((int) Math.round(a.getRawValue()));
    }

    @Override
    public ValueTypeInteger.ValueInteger ceil(ValueDouble a) {
        return ValueTypeInteger.ValueInteger.of((int) Math.ceil(a.getRawValue()));
    }

    @Override
    public ValueTypeInteger.ValueInteger floor(ValueDouble a) {
        return ValueTypeInteger.ValueInteger.of((int) Math.floor(a.getRawValue()));
    }

    @Override
    public ValueTypeString.ValueString compact(ValueDouble a) {
        NumberFormat nf = NumberFormat.getCompactNumberInstance(
            Locale.US,
            GeneralConfig.numberCompactUseLongStyle ? NumberFormat.Style.LONG : NumberFormat.Style.SHORT
        );
        nf.setMinimumFractionDigits(GeneralConfig.numberCompactMinimumFractionDigits);
        nf.setMaximumFractionDigits(GeneralConfig.numberCompactMaximumFractionDigits);
        nf.setMinimumIntegerDigits(GeneralConfig.numberCompactMinimumIntegerDigits);
        nf.setMaximumIntegerDigits(GeneralConfig.numberCompactMaximumIntegerDigits);
        return ValueTypeString.ValueString.of(nf.format(a.getRawValue()));
    }

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

    @ToString
    public static class ValueDouble extends ValueBase {

        private final double value;

        private ValueDouble(double value) {
            super(ValueTypes.DOUBLE);
            this.value = value;
        }

        public static ValueDouble of(double value) {
            return new ValueDouble(value);
        }

        public double getRawValue() {
            return value;
        }

        @Override
        public boolean equals(Object o) {
            return o instanceof ValueDouble && ((ValueDouble) o).value == this.value;
        }

        @Override
        public int hashCode() {
            return getType().hashCode() + ((int) value * 100);
        }
    }

}

1	package org.cyclops.integrateddynamics.core.evaluate.variable;
2
3	import lombok.ToString;
4	import net.minecraft.ChatFormatting;
5	import net.minecraft.network.chat.Component;
6	import net.minecraft.network.chat.MutableComponent;
7	import net.minecraft.world.level.storage.ValueInput;
8	import net.minecraft.world.level.storage.ValueOutput;
9	import org.cyclops.cyclopscore.helper.IModHelpers;
10	import org.cyclops.integrateddynamics.GeneralConfig;
11	import org.cyclops.integrateddynamics.api.evaluate.EvaluationException;
12	import org.cyclops.integrateddynamics.api.evaluate.variable.IValueTypeNumber;
13	import org.cyclops.integrateddynamics.core.helper.L10NValues;
14
15	import java.text.NumberFormat;
16	import java.util.Locale;
17
18	/**
19	* Value type with values that are doubles.
20	* @author rubensworks
21	*/
22	public class ValueTypeDouble extends ValueTypeBase<ValueTypeDouble.ValueDouble> implements IValueTypeNumber<ValueTypeDouble.ValueDouble> {
23
24	public ValueTypeDouble() {
25	super("double", IModHelpers.get().getBaseHelpers().RGBToInt(235, 234, 23), ChatFormatting.YELLOW, ValueTypeDouble.ValueDouble.class);	11✔
26	}	1✔
27
28	@Override
29	public ValueDouble getDefault() {
30	return ValueDouble.of(0D);	3✔
31	}
32
33	@Override
34	public MutableComponent toCompactString(ValueDouble value) {
35	return Component.literal(Double.toString(value.getRawValue()));	5✔
36	}
37
38	@Override
39	public void serialize(ValueOutput valueOutput, ValueDouble value) {
40	valueOutput.putDouble("v", value.getRawValue());	5✔
41	}	1✔
42
43	@Override
44	public ValueDouble deserialize(ValueInput valueInput) {
45	return ValueDouble.of(valueInput.getDoubleOr("v", 0));	6✔
46	}
47
48	@Override
49	public String toString(ValueDouble value) {
50	return Double.toString(value.getRawValue());	4✔
51	}
52
53	@Override
54	public ValueDouble parseString(String value) throws EvaluationException {
55	try {
56	return ValueDouble.of(Double.parseDouble(value));	4✔
57	} catch (NumberFormatException e) {	×
58	throw new EvaluationException(Component.translatable(L10NValues.OPERATOR_ERROR_PARSE, value,	×
59	Component.translatable(getTranslationKey())));	×
60	}
61	}
62
63	@Override
64	public boolean isZero(ValueDouble a) {
65	return a.getRawValue() == 0D;	9✔
66	}
67
68	@Override
69	public boolean isOne(ValueDouble a) {
70	return a.getRawValue() == 1D;	9✔
71	}
72
73	@Override
74	public ValueDouble add(ValueDouble a, ValueDouble b) {
75	return ValueDouble.of(a.getRawValue() + b.getRawValue());	7✔
76	}
77
78	@Override
79	public ValueDouble subtract(ValueDouble a, ValueDouble b) {
80	return ValueDouble.of(a.getRawValue() - b.getRawValue());	7✔
81	}
82
83	@Override
84	public ValueDouble multiply(ValueDouble a, ValueDouble b) {
85	return ValueDouble.of(a.getRawValue() * b.getRawValue());	7✔
86	}
87
88	@Override
89	public ValueDouble divide(ValueDouble a, ValueDouble b) {
90	return ValueDouble.of(a.getRawValue() / b.getRawValue());	7✔
91	}
92
93	@Override
94	public ValueDouble max(ValueDouble a, ValueDouble b) {
95	return ValueDouble.of(Math.max(a.getRawValue(), b.getRawValue()));	7✔
96	}
97
98	@Override
99	public ValueDouble min(ValueDouble a, ValueDouble b) {
100	return ValueDouble.of(Math.min(a.getRawValue(), b.getRawValue()));	7✔
101	}
102
103	@Override
104	public ValueDouble increment(ValueDouble a) {
105	return ValueDouble.of(a.getRawValue() + 1D);	×
106	}
107
108	@Override
109	public ValueDouble decrement(ValueDouble a) {
110	return ValueDouble.of(a.getRawValue() - 1D);	×
111	}
112
113	@Override
114	public ValueDouble modulus(ValueDouble a, ValueDouble b) {
115	return ValueDouble.of(a.getRawValue() % b.getRawValue());	×
116	}
117
118	@Override
119	public boolean greaterThan(ValueDouble a, ValueDouble b) {
120	return a.getRawValue() > b.getRawValue();	10✔
121	}
122
123	@Override
124	public boolean lessThan(ValueDouble a, ValueDouble b) {
125	return a.getRawValue() < b.getRawValue();	×
126	}
127
128	@Override
129	public ValueTypeInteger.ValueInteger round(ValueDouble a) {
130	return ValueTypeInteger.ValueInteger.of((int) Math.round(a.getRawValue()));	6✔
131	}
132
133	@Override
134	public ValueTypeInteger.ValueInteger ceil(ValueDouble a) {
135	return ValueTypeInteger.ValueInteger.of((int) Math.ceil(a.getRawValue()));	6✔
136	}
137
138	@Override
139	public ValueTypeInteger.ValueInteger floor(ValueDouble a) {
140	return ValueTypeInteger.ValueInteger.of((int) Math.floor(a.getRawValue()));	6✔
141	}
142
143	@Override
144	public ValueTypeString.ValueString compact(ValueDouble a) {
145	NumberFormat nf = NumberFormat.getCompactNumberInstance(	3✔
146	Locale.US,
147	GeneralConfig.numberCompactUseLongStyle ? NumberFormat.Style.LONG : NumberFormat.Style.SHORT	3!
148	);
149	nf.setMinimumFractionDigits(GeneralConfig.numberCompactMinimumFractionDigits);	3✔
150	nf.setMaximumFractionDigits(GeneralConfig.numberCompactMaximumFractionDigits);	3✔
151	nf.setMinimumIntegerDigits(GeneralConfig.numberCompactMinimumIntegerDigits);	3✔
152	nf.setMaximumIntegerDigits(GeneralConfig.numberCompactMaximumIntegerDigits);	3✔
153	return ValueTypeString.ValueString.of(nf.format(a.getRawValue()));	6✔
154	}
155
156	@Override
157	public String getName(ValueDouble a) {
158	return toCompactString(a).getString();	5✔
159	}
160
161	@ToString	×
162	public static class ValueDouble extends ValueBase {
163
164	private final double value;
165
166	private ValueDouble(double value) {
167	super(ValueTypes.DOUBLE);	3✔
168	this.value = value;	3✔
169	}	1✔
170
171	public static ValueDouble of(double value) {
172	return new ValueDouble(value);	5✔
173	}
174
175	public double getRawValue() {
176	return value;	3✔
177	}
178
179	@Override
180	public boolean equals(Object o) {
181	return o instanceof ValueDouble && ((ValueDouble) o).value == this.value;	14!
182	}
183
184	@Override
185	public int hashCode() {
186	return getType().hashCode() + ((int) value * 100);	×
187	}
188	}
189
190	}

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