16552051255

Committed 27 Jul 2025 01:58PM UTC coverage: 53.206% (+8.0%) from 45.161%

Build # 16552051255

Build Type

push

github

Committed by

rubensworks

Commit Message

Resolve minor TODOs

Run Details

2888 of 8740 branches covered (33.04%)

Branch coverage included in aggregate %.

17341 of 29280 relevant lines covered (59.22%)

3.08 hits per line

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

24.14

/src/main/java/org/cyclops/integrateddynamics/core/evaluate/variable/ValueTypeLong.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 ValueTypeLong extends ValueTypeBase<ValueTypeLong.ValueLong> implements IValueTypeNumber<ValueTypeLong.ValueLong> {

    public ValueTypeLong() {
        super("long", IModHelpers.get().getBaseHelpers().RGBToInt(215, 254, 23), ChatFormatting.YELLOW, ValueTypeLong.ValueLong.class);
    }

    @Override
    public ValueLong getDefault() {
        return ValueLong.of(0L);
    }

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

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

    @Override
    public ValueLong deserialize(ValueInput valueInput) {
        return ValueLong.of(valueInput.getLong("v").orElseThrow());
    }

    @Override
    public String toString(ValueLong value) {
        return Long.toString(value.getRawValue());
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    @Override
    public ValueTypeString.ValueString compact(ValueLong 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(ValueLong a) {
        return toCompactString(a).getString();
    }

    @ToString
    public static class ValueLong extends ValueBase {

        private final long value;

        private ValueLong(long value) {
            super(ValueTypes.LONG);
            this.value = value;
        }

        public static ValueLong of(long value) {
            return new ValueLong(value);
        }

        public long getRawValue() {
            return value;
        }

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

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

}

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 ValueTypeLong extends ValueTypeBase<ValueTypeLong.ValueLong> implements IValueTypeNumber<ValueTypeLong.ValueLong> {
23
24	public ValueTypeLong() {
25	super("long", IModHelpers.get().getBaseHelpers().RGBToInt(215, 254, 23), ChatFormatting.YELLOW, ValueTypeLong.ValueLong.class);	11✔
26	}	1✔
27
28	@Override
29	public ValueLong getDefault() {
30	return ValueLong.of(0L);	×
31	}
32
33	@Override
34	public MutableComponent toCompactString(ValueLong value) {
35	return Component.literal(Long.toString(value.getRawValue()));	×
36	}
37
38	@Override
39	public void serialize(ValueOutput valueOutput, ValueLong value) {
40	valueOutput.putLong("v", value.getRawValue());	×
41	}	×
42
43	@Override
44	public ValueLong deserialize(ValueInput valueInput) {
45	return ValueLong.of(valueInput.getLong("v").orElseThrow());	×
46	}
47
48	@Override
49	public String toString(ValueLong value) {
50	return Long.toString(value.getRawValue());	×
51	}
52
53	@Override
54	public ValueLong parseString(String value) throws EvaluationException {
55	try {
56	return ValueLong.of(Long.parseLong(value));	×
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(ValueLong a) {
65	return a.getRawValue() == 0L;	8!
66	}
67
68	@Override
69	public boolean isOne(ValueLong a) {
70	return a.getRawValue() == 1L;	×
71	}
72
73	@Override
74	public ValueLong add(ValueLong a, ValueLong b) {
75	return ValueLong.of(a.getRawValue() + b.getRawValue());	×
76	}
77
78	@Override
79	public ValueLong subtract(ValueLong a, ValueLong b) {
80	return ValueLong.of(a.getRawValue() - b.getRawValue());	×
81	}
82
83	@Override
84	public ValueLong multiply(ValueLong a, ValueLong b) {
85	return ValueLong.of(a.getRawValue() * b.getRawValue());	×
86	}
87
88	@Override
89	public ValueLong divide(ValueLong a, ValueLong b) {
90	return ValueLong.of(a.getRawValue() / b.getRawValue());	×
91	}
92
93	@Override
94	public ValueLong max(ValueLong a, ValueLong b) {
95	return ValueLong.of(Math.max(a.getRawValue(), b.getRawValue()));	×
96	}
97
98	@Override
99	public ValueLong min(ValueLong a, ValueLong b) {
100	return ValueLong.of(Math.min(a.getRawValue(), b.getRawValue()));	×
101	}
102
103	@Override
104	public ValueLong increment(ValueLong a) {
105	return ValueLong.of(a.getRawValue() + 1L);	×
106	}
107
108	@Override
109	public ValueLong decrement(ValueLong a) {
110	return ValueLong.of(a.getRawValue() - 1L);	×
111	}
112
113	@Override
114	public ValueLong modulus(ValueLong a, ValueLong b) {
115	return ValueLong.of(a.getRawValue() % b.getRawValue());	×
116	}
117
118	@Override
119	public boolean greaterThan(ValueLong a, ValueLong b) {
120	return a.getRawValue() > b.getRawValue();	×
121	}
122
123	@Override
124	public boolean lessThan(ValueLong a, ValueLong b) {
125	return a.getRawValue() < b.getRawValue();	×
126	}
127
128	@Override
129	public ValueTypeInteger.ValueInteger round(ValueLong a) {
130	return ValueTypeInteger.ValueInteger.of((int) a.getRawValue());	×
131	}
132
133	@Override
134	public ValueTypeInteger.ValueInteger ceil(ValueLong a) {
135	return ValueTypeInteger.ValueInteger.of((int) a.getRawValue());	×
136	}
137
138	@Override
139	public ValueTypeInteger.ValueInteger floor(ValueLong a) {
140	return ValueTypeInteger.ValueInteger.of((int) a.getRawValue());	×
141	}
142
143	@Override
144	public ValueTypeString.ValueString compact(ValueLong a) {
145	NumberFormat nf = NumberFormat.getCompactNumberInstance(	×
146	Locale.US,
147	GeneralConfig.numberCompactUseLongStyle ? NumberFormat.Style.LONG : NumberFormat.Style.SHORT	×
148	);
149	nf.setMinimumFractionDigits(GeneralConfig.numberCompactMinimumFractionDigits);	×
150	nf.setMaximumFractionDigits(GeneralConfig.numberCompactMaximumFractionDigits);	×
151	nf.setMinimumIntegerDigits(GeneralConfig.numberCompactMinimumIntegerDigits);	×
152	nf.setMaximumIntegerDigits(GeneralConfig.numberCompactMaximumIntegerDigits);	×
153	return ValueTypeString.ValueString.of(nf.format(a.getRawValue()));	×
154	}
155
156	@Override
157	public String getName(ValueLong a) {
158	return toCompactString(a).getString();	×
159	}
160
161	@ToString	×
162	public static class ValueLong extends ValueBase {
163
164	private final long value;
165
166	private ValueLong(long value) {
167	super(ValueTypes.LONG);	3✔
168	this.value = value;	3✔
169	}	1✔
170
171	public static ValueLong of(long value) {
172	return new ValueLong(value);	5✔
173	}
174
175	public long getRawValue() {
176	return value;	3✔
177	}
178
179	@Override
180	public boolean equals(Object o) {
181	return o instanceof ValueLong && ((ValueLong) o).value == this.value;	14!
182	}
183
184	@Override
185	public int hashCode() {
186	return getType().hashCode() + (int) value;	8✔
187	}
188	}
189
190	}

CyclopsMC / IntegratedDynamics / 16552051255

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