22186773560

Committed 19 Feb 2026 02:52PM UTC coverage: 52.603% (+0.2%) from 52.363%

Build # 22186773560

Build Type

push

github

Committed by

web-flow

Commit Message

Remove Lombok dependency (#1604)

Run Details

2911 of 8664 branches covered (33.6%)

Branch coverage included in aggregate %.

17683 of 30486 relevant lines covered (58.0%)

3.01 hits per line

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

79.31

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

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

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();
    }

    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);
        }

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

CyclopsMC / IntegratedDynamics / 22186773560

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