730 lines
25 KiB
Java
730 lines
25 KiB
Java
/*
|
|
* Decompiled with CFR 0.152.
|
|
*
|
|
* Could not load the following classes:
|
|
* com.mojang.datafixers.util.Pair
|
|
* com.mojang.serialization.DataResult
|
|
* com.mojang.serialization.DynamicOps
|
|
* com.mojang.serialization.MapLike
|
|
* com.mojang.serialization.RecordBuilder
|
|
* com.mojang.serialization.RecordBuilder$AbstractStringBuilder
|
|
* it.unimi.dsi.fastutil.bytes.ByteArrayList
|
|
* it.unimi.dsi.fastutil.ints.IntArrayList
|
|
* it.unimi.dsi.fastutil.longs.LongArrayList
|
|
* org.jspecify.annotations.Nullable
|
|
*/
|
|
package net.minecraft.nbt;
|
|
|
|
import com.mojang.datafixers.util.Pair;
|
|
import com.mojang.serialization.DataResult;
|
|
import com.mojang.serialization.DynamicOps;
|
|
import com.mojang.serialization.MapLike;
|
|
import com.mojang.serialization.RecordBuilder;
|
|
import it.unimi.dsi.fastutil.bytes.ByteArrayList;
|
|
import it.unimi.dsi.fastutil.ints.IntArrayList;
|
|
import it.unimi.dsi.fastutil.longs.LongArrayList;
|
|
import java.lang.runtime.SwitchBootstraps;
|
|
import java.nio.ByteBuffer;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Objects;
|
|
import java.util.Optional;
|
|
import java.util.function.BiConsumer;
|
|
import java.util.function.Consumer;
|
|
import java.util.stream.IntStream;
|
|
import java.util.stream.LongStream;
|
|
import java.util.stream.Stream;
|
|
import net.minecraft.nbt.ByteArrayTag;
|
|
import net.minecraft.nbt.ByteTag;
|
|
import net.minecraft.nbt.CollectionTag;
|
|
import net.minecraft.nbt.CompoundTag;
|
|
import net.minecraft.nbt.DoubleTag;
|
|
import net.minecraft.nbt.EndTag;
|
|
import net.minecraft.nbt.FloatTag;
|
|
import net.minecraft.nbt.IntArrayTag;
|
|
import net.minecraft.nbt.IntTag;
|
|
import net.minecraft.nbt.ListTag;
|
|
import net.minecraft.nbt.LongArrayTag;
|
|
import net.minecraft.nbt.LongTag;
|
|
import net.minecraft.nbt.ShortTag;
|
|
import net.minecraft.nbt.StringTag;
|
|
import net.minecraft.nbt.Tag;
|
|
import net.minecraft.util.Util;
|
|
import org.jspecify.annotations.Nullable;
|
|
|
|
public class NbtOps
|
|
implements DynamicOps<Tag> {
|
|
public static final NbtOps INSTANCE = new NbtOps();
|
|
|
|
private NbtOps() {
|
|
}
|
|
|
|
public Tag empty() {
|
|
return EndTag.INSTANCE;
|
|
}
|
|
|
|
public Tag emptyList() {
|
|
return new ListTag();
|
|
}
|
|
|
|
public Tag emptyMap() {
|
|
return new CompoundTag();
|
|
}
|
|
|
|
/*
|
|
* WARNING - Removed back jump from a try to a catch block - possible behaviour change.
|
|
* Enabled aggressive block sorting
|
|
* Enabled unnecessary exception pruning
|
|
* Enabled aggressive exception aggregation
|
|
*/
|
|
public <U> U convertTo(DynamicOps<U> outOps, Tag input) {
|
|
Object object;
|
|
Tag tag = input;
|
|
Objects.requireNonNull(tag);
|
|
Tag tag2 = tag;
|
|
int n = 0;
|
|
switch (SwitchBootstraps.typeSwitch("typeSwitch", new Object[]{EndTag.class, ByteTag.class, ShortTag.class, IntTag.class, LongTag.class, FloatTag.class, DoubleTag.class, ByteArrayTag.class, StringTag.class, ListTag.class, CompoundTag.class, IntArrayTag.class, LongArrayTag.class}, (Object)tag2, n)) {
|
|
default: {
|
|
throw new MatchException(null, null);
|
|
}
|
|
case 0: {
|
|
EndTag ignored = (EndTag)tag2;
|
|
object = outOps.empty();
|
|
return (U)object;
|
|
}
|
|
case 1: {
|
|
byte value;
|
|
ByteTag byteTag = (ByteTag)tag2;
|
|
try {
|
|
byte by;
|
|
value = by = byteTag.value();
|
|
}
|
|
catch (Throwable throwable) {
|
|
throw new MatchException(throwable.toString(), throwable);
|
|
}
|
|
object = outOps.createByte(value);
|
|
return (U)object;
|
|
}
|
|
case 2: {
|
|
short value;
|
|
ShortTag shortTag = (ShortTag)tag2;
|
|
{
|
|
short s;
|
|
value = s = shortTag.value();
|
|
}
|
|
object = outOps.createShort(value);
|
|
return (U)object;
|
|
}
|
|
case 3: {
|
|
int value;
|
|
IntTag intTag = (IntTag)tag2;
|
|
{
|
|
int n2;
|
|
value = n2 = intTag.value();
|
|
}
|
|
object = outOps.createInt(value);
|
|
return (U)object;
|
|
}
|
|
case 4: {
|
|
long value;
|
|
LongTag longTag = (LongTag)tag2;
|
|
{
|
|
long l;
|
|
value = l = longTag.value();
|
|
}
|
|
object = outOps.createLong(value);
|
|
return (U)object;
|
|
}
|
|
case 5: {
|
|
float value;
|
|
FloatTag floatTag = (FloatTag)tag2;
|
|
{
|
|
float f;
|
|
value = f = floatTag.value();
|
|
}
|
|
object = outOps.createFloat(value);
|
|
return (U)object;
|
|
}
|
|
case 6: {
|
|
double value;
|
|
DoubleTag doubleTag = (DoubleTag)tag2;
|
|
{
|
|
double d;
|
|
value = d = doubleTag.value();
|
|
}
|
|
object = outOps.createDouble(value);
|
|
return (U)object;
|
|
}
|
|
case 7: {
|
|
ByteArrayTag byteArrayTag = (ByteArrayTag)tag2;
|
|
object = outOps.createByteList(ByteBuffer.wrap(byteArrayTag.getAsByteArray()));
|
|
return (U)object;
|
|
}
|
|
case 8: {
|
|
String value;
|
|
StringTag stringTag = (StringTag)tag2;
|
|
{
|
|
String string;
|
|
value = string = stringTag.value();
|
|
}
|
|
object = outOps.createString(value);
|
|
return (U)object;
|
|
}
|
|
case 9: {
|
|
ListTag listTag = (ListTag)tag2;
|
|
object = this.convertList(outOps, listTag);
|
|
return (U)object;
|
|
}
|
|
case 10: {
|
|
CompoundTag compoundTag = (CompoundTag)tag2;
|
|
object = this.convertMap(outOps, compoundTag);
|
|
return (U)object;
|
|
}
|
|
case 11: {
|
|
IntArrayTag intArrayTag = (IntArrayTag)tag2;
|
|
object = outOps.createIntList(Arrays.stream(intArrayTag.getAsIntArray()));
|
|
return (U)object;
|
|
}
|
|
case 12:
|
|
}
|
|
LongArrayTag longArrayTag = (LongArrayTag)tag2;
|
|
object = outOps.createLongList(Arrays.stream(longArrayTag.getAsLongArray()));
|
|
return (U)object;
|
|
}
|
|
|
|
public DataResult<Number> getNumberValue(Tag input) {
|
|
return input.asNumber().map(DataResult::success).orElseGet(() -> DataResult.error(() -> "Not a number"));
|
|
}
|
|
|
|
public Tag createNumeric(Number i) {
|
|
return DoubleTag.valueOf(i.doubleValue());
|
|
}
|
|
|
|
public Tag createByte(byte value) {
|
|
return ByteTag.valueOf(value);
|
|
}
|
|
|
|
public Tag createShort(short value) {
|
|
return ShortTag.valueOf(value);
|
|
}
|
|
|
|
public Tag createInt(int value) {
|
|
return IntTag.valueOf(value);
|
|
}
|
|
|
|
public Tag createLong(long value) {
|
|
return LongTag.valueOf(value);
|
|
}
|
|
|
|
public Tag createFloat(float value) {
|
|
return FloatTag.valueOf(value);
|
|
}
|
|
|
|
public Tag createDouble(double value) {
|
|
return DoubleTag.valueOf(value);
|
|
}
|
|
|
|
public Tag createBoolean(boolean value) {
|
|
return ByteTag.valueOf(value);
|
|
}
|
|
|
|
/*
|
|
* Enabled force condition propagation
|
|
* Lifted jumps to return sites
|
|
*/
|
|
public DataResult<String> getStringValue(Tag input) {
|
|
String value;
|
|
if (!(input instanceof StringTag)) return DataResult.error(() -> "Not a string");
|
|
StringTag stringTag = (StringTag)input;
|
|
try {
|
|
String string;
|
|
value = string = stringTag.value();
|
|
}
|
|
catch (Throwable throwable) {
|
|
throw new MatchException(throwable.toString(), throwable);
|
|
}
|
|
return DataResult.success((Object)value);
|
|
}
|
|
|
|
public Tag createString(String value) {
|
|
return StringTag.valueOf(value);
|
|
}
|
|
|
|
public DataResult<Tag> mergeToList(Tag list, Tag value) {
|
|
return NbtOps.createCollector(list).map(collector -> DataResult.success((Object)collector.accept(value).result())).orElseGet(() -> DataResult.error(() -> "mergeToList called with not a list: " + String.valueOf(list), (Object)list));
|
|
}
|
|
|
|
public DataResult<Tag> mergeToList(Tag list, List<Tag> values) {
|
|
return NbtOps.createCollector(list).map(collector -> DataResult.success((Object)collector.acceptAll(values).result())).orElseGet(() -> DataResult.error(() -> "mergeToList called with not a list: " + String.valueOf(list), (Object)list));
|
|
}
|
|
|
|
/*
|
|
* Enabled force condition propagation
|
|
* Lifted jumps to return sites
|
|
*/
|
|
public DataResult<Tag> mergeToMap(Tag map, Tag key, Tag value) {
|
|
CompoundTag compoundTag;
|
|
String stringKey;
|
|
if (!(map instanceof CompoundTag) && !(map instanceof EndTag)) {
|
|
return DataResult.error(() -> "mergeToMap called with not a map: " + String.valueOf(map), (Object)map);
|
|
}
|
|
if (!(key instanceof StringTag)) return DataResult.error(() -> "key is not a string: " + String.valueOf(key), (Object)map);
|
|
StringTag stringTag = (StringTag)key;
|
|
try {
|
|
String string;
|
|
stringKey = string = stringTag.value();
|
|
}
|
|
catch (Throwable throwable) {
|
|
throw new MatchException(throwable.toString(), throwable);
|
|
}
|
|
if (map instanceof CompoundTag) {
|
|
CompoundTag tag = (CompoundTag)map;
|
|
compoundTag = tag.shallowCopy();
|
|
} else {
|
|
compoundTag = new CompoundTag();
|
|
}
|
|
CompoundTag output = compoundTag;
|
|
output.put(stringKey, value);
|
|
return DataResult.success((Object)output);
|
|
}
|
|
|
|
public DataResult<Tag> mergeToMap(Tag map, MapLike<Tag> values) {
|
|
CompoundTag compoundTag;
|
|
if (!(map instanceof CompoundTag) && !(map instanceof EndTag)) {
|
|
return DataResult.error(() -> "mergeToMap called with not a map: " + String.valueOf(map), (Object)map);
|
|
}
|
|
Iterator valuesIterator = values.entries().iterator();
|
|
if (!valuesIterator.hasNext()) {
|
|
if (map == this.empty()) {
|
|
return DataResult.success((Object)this.emptyMap());
|
|
}
|
|
return DataResult.success((Object)map);
|
|
}
|
|
if (map instanceof CompoundTag) {
|
|
CompoundTag tag = (CompoundTag)map;
|
|
compoundTag = tag.shallowCopy();
|
|
} else {
|
|
compoundTag = new CompoundTag();
|
|
}
|
|
CompoundTag output = compoundTag;
|
|
ArrayList missed = new ArrayList();
|
|
valuesIterator.forEachRemaining(entry -> {
|
|
String stringKey;
|
|
Tag key = (Tag)entry.getFirst();
|
|
if (!(key instanceof StringTag)) {
|
|
missed.add(key);
|
|
return;
|
|
}
|
|
StringTag $b$0 = (StringTag)key;
|
|
try {
|
|
String patt1$temp;
|
|
stringKey = patt1$temp = $b$0.value();
|
|
}
|
|
catch (Throwable throwable) {
|
|
throw new MatchException(throwable.toString(), throwable);
|
|
}
|
|
output.put(stringKey, (Tag)entry.getSecond());
|
|
});
|
|
if (!missed.isEmpty()) {
|
|
return DataResult.error(() -> "some keys are not strings: " + String.valueOf(missed), (Object)output);
|
|
}
|
|
return DataResult.success((Object)output);
|
|
}
|
|
|
|
/*
|
|
* Enabled aggressive block sorting
|
|
* Enabled unnecessary exception pruning
|
|
* Enabled aggressive exception aggregation
|
|
*/
|
|
public DataResult<Tag> mergeToMap(Tag map, Map<Tag, Tag> values) {
|
|
CompoundTag compoundTag;
|
|
if (!(map instanceof CompoundTag) && !(map instanceof EndTag)) {
|
|
return DataResult.error(() -> "mergeToMap called with not a map: " + String.valueOf(map), (Object)map);
|
|
}
|
|
if (values.isEmpty()) {
|
|
if (map == this.empty()) {
|
|
return DataResult.success((Object)this.emptyMap());
|
|
}
|
|
return DataResult.success((Object)map);
|
|
}
|
|
if (map instanceof CompoundTag) {
|
|
CompoundTag tag = (CompoundTag)map;
|
|
compoundTag = tag.shallowCopy();
|
|
} else {
|
|
compoundTag = new CompoundTag();
|
|
}
|
|
CompoundTag output = compoundTag;
|
|
ArrayList<Tag> missed = new ArrayList<Tag>();
|
|
for (Map.Entry<Tag, Tag> entry : values.entrySet()) {
|
|
Tag key = entry.getKey();
|
|
if (key instanceof StringTag) {
|
|
StringTag stringTag = (StringTag)key;
|
|
try {
|
|
String string;
|
|
String stringKey = string = stringTag.value();
|
|
output.put(stringKey, entry.getValue());
|
|
continue;
|
|
}
|
|
catch (Throwable throwable) {
|
|
throw new MatchException(throwable.toString(), throwable);
|
|
}
|
|
}
|
|
missed.add(key);
|
|
}
|
|
if (!missed.isEmpty()) {
|
|
return DataResult.error(() -> "some keys are not strings: " + String.valueOf(missed), (Object)output);
|
|
}
|
|
return DataResult.success((Object)output);
|
|
}
|
|
|
|
public DataResult<Stream<Pair<Tag, Tag>>> getMapValues(Tag input) {
|
|
if (input instanceof CompoundTag) {
|
|
CompoundTag tag = (CompoundTag)input;
|
|
return DataResult.success(tag.entrySet().stream().map(entry -> Pair.of((Object)this.createString((String)entry.getKey()), (Object)((Tag)entry.getValue()))));
|
|
}
|
|
return DataResult.error(() -> "Not a map: " + String.valueOf(input));
|
|
}
|
|
|
|
public DataResult<Consumer<BiConsumer<Tag, Tag>>> getMapEntries(Tag input) {
|
|
if (input instanceof CompoundTag) {
|
|
CompoundTag tag = (CompoundTag)input;
|
|
return DataResult.success(c -> {
|
|
for (Map.Entry<String, Tag> entry : tag.entrySet()) {
|
|
c.accept(this.createString(entry.getKey()), entry.getValue());
|
|
}
|
|
});
|
|
}
|
|
return DataResult.error(() -> "Not a map: " + String.valueOf(input));
|
|
}
|
|
|
|
public DataResult<MapLike<Tag>> getMap(Tag input) {
|
|
if (input instanceof CompoundTag) {
|
|
final CompoundTag tag = (CompoundTag)input;
|
|
return DataResult.success((Object)new MapLike<Tag>(){
|
|
|
|
/*
|
|
* Enabled force condition propagation
|
|
* Lifted jumps to return sites
|
|
*/
|
|
public @Nullable Tag get(Tag key) {
|
|
if (!(key instanceof StringTag)) throw new UnsupportedOperationException("Cannot get map entry with non-string key: " + String.valueOf(key));
|
|
StringTag stringTag = (StringTag)key;
|
|
try {
|
|
String string;
|
|
String stringKey = string = stringTag.value();
|
|
return tag.get(stringKey);
|
|
}
|
|
catch (Throwable throwable) {
|
|
throw new MatchException(throwable.toString(), throwable);
|
|
}
|
|
}
|
|
|
|
public @Nullable Tag get(String key) {
|
|
return tag.get(key);
|
|
}
|
|
|
|
public Stream<Pair<Tag, Tag>> entries() {
|
|
return tag.entrySet().stream().map(entry -> Pair.of((Object)NbtOps.this.createString((String)entry.getKey()), (Object)((Tag)entry.getValue())));
|
|
}
|
|
|
|
public String toString() {
|
|
return "MapLike[" + String.valueOf(tag) + "]";
|
|
}
|
|
});
|
|
}
|
|
return DataResult.error(() -> "Not a map: " + String.valueOf(input));
|
|
}
|
|
|
|
public Tag createMap(Stream<Pair<Tag, Tag>> map) {
|
|
CompoundTag tag = new CompoundTag();
|
|
map.forEach(entry -> {
|
|
Tag key = (Tag)entry.getFirst();
|
|
Tag value = (Tag)entry.getSecond();
|
|
if (!(key instanceof StringTag)) throw new UnsupportedOperationException("Cannot create map with non-string key: " + String.valueOf(key));
|
|
StringTag $b$0 = (StringTag)key;
|
|
try {
|
|
String patt1$temp;
|
|
String stringKey = patt1$temp = $b$0.value();
|
|
tag.put(stringKey, value);
|
|
}
|
|
catch (Throwable throwable) {
|
|
throw new MatchException(throwable.toString(), throwable);
|
|
}
|
|
});
|
|
return tag;
|
|
}
|
|
|
|
public DataResult<Stream<Tag>> getStream(Tag input) {
|
|
if (input instanceof CollectionTag) {
|
|
CollectionTag collection = (CollectionTag)input;
|
|
return DataResult.success(collection.stream());
|
|
}
|
|
return DataResult.error(() -> "Not a list");
|
|
}
|
|
|
|
public DataResult<Consumer<Consumer<Tag>>> getList(Tag input) {
|
|
if (input instanceof CollectionTag) {
|
|
CollectionTag collection = (CollectionTag)input;
|
|
return DataResult.success(collection::forEach);
|
|
}
|
|
return DataResult.error(() -> "Not a list: " + String.valueOf(input));
|
|
}
|
|
|
|
public DataResult<ByteBuffer> getByteBuffer(Tag input) {
|
|
if (input instanceof ByteArrayTag) {
|
|
ByteArrayTag array = (ByteArrayTag)input;
|
|
return DataResult.success((Object)ByteBuffer.wrap(array.getAsByteArray()));
|
|
}
|
|
return super.getByteBuffer((Object)input);
|
|
}
|
|
|
|
public Tag createByteList(ByteBuffer input) {
|
|
ByteBuffer wholeBuffer = input.duplicate().clear();
|
|
byte[] bytes = new byte[input.capacity()];
|
|
wholeBuffer.get(0, bytes, 0, bytes.length);
|
|
return new ByteArrayTag(bytes);
|
|
}
|
|
|
|
public DataResult<IntStream> getIntStream(Tag input) {
|
|
if (input instanceof IntArrayTag) {
|
|
IntArrayTag array = (IntArrayTag)input;
|
|
return DataResult.success((Object)Arrays.stream(array.getAsIntArray()));
|
|
}
|
|
return super.getIntStream((Object)input);
|
|
}
|
|
|
|
public Tag createIntList(IntStream input) {
|
|
return new IntArrayTag(input.toArray());
|
|
}
|
|
|
|
public DataResult<LongStream> getLongStream(Tag input) {
|
|
if (input instanceof LongArrayTag) {
|
|
LongArrayTag array = (LongArrayTag)input;
|
|
return DataResult.success((Object)Arrays.stream(array.getAsLongArray()));
|
|
}
|
|
return super.getLongStream((Object)input);
|
|
}
|
|
|
|
public Tag createLongList(LongStream input) {
|
|
return new LongArrayTag(input.toArray());
|
|
}
|
|
|
|
public Tag createList(Stream<Tag> input) {
|
|
return new ListTag(input.collect(Util.toMutableList()));
|
|
}
|
|
|
|
public Tag remove(Tag input, String key) {
|
|
if (input instanceof CompoundTag) {
|
|
CompoundTag tag = (CompoundTag)input;
|
|
CompoundTag result = tag.shallowCopy();
|
|
result.remove(key);
|
|
return result;
|
|
}
|
|
return input;
|
|
}
|
|
|
|
public String toString() {
|
|
return "NBT";
|
|
}
|
|
|
|
public RecordBuilder<Tag> mapBuilder() {
|
|
return new NbtRecordBuilder(this);
|
|
}
|
|
|
|
private static Optional<ListCollector> createCollector(Tag tag) {
|
|
if (tag instanceof EndTag) {
|
|
return Optional.of(new GenericListCollector());
|
|
}
|
|
if (tag instanceof CollectionTag) {
|
|
CollectionTag collection = (CollectionTag)tag;
|
|
if (collection.isEmpty()) {
|
|
return Optional.of(new GenericListCollector());
|
|
}
|
|
CollectionTag collectionTag = collection;
|
|
Objects.requireNonNull(collectionTag);
|
|
CollectionTag collectionTag2 = collectionTag;
|
|
int n = 0;
|
|
return switch (SwitchBootstraps.typeSwitch("typeSwitch", new Object[]{ListTag.class, ByteArrayTag.class, IntArrayTag.class, LongArrayTag.class}, (Object)collectionTag2, n)) {
|
|
default -> throw new MatchException(null, null);
|
|
case 0 -> {
|
|
ListTag list = (ListTag)collectionTag2;
|
|
yield Optional.of(new GenericListCollector(list));
|
|
}
|
|
case 1 -> {
|
|
ByteArrayTag array = (ByteArrayTag)collectionTag2;
|
|
yield Optional.of(new ByteListCollector(array.getAsByteArray()));
|
|
}
|
|
case 2 -> {
|
|
IntArrayTag array = (IntArrayTag)collectionTag2;
|
|
yield Optional.of(new IntListCollector(array.getAsIntArray()));
|
|
}
|
|
case 3 -> {
|
|
LongArrayTag array = (LongArrayTag)collectionTag2;
|
|
yield Optional.of(new LongListCollector(array.getAsLongArray()));
|
|
}
|
|
};
|
|
}
|
|
return Optional.empty();
|
|
}
|
|
|
|
private class NbtRecordBuilder
|
|
extends RecordBuilder.AbstractStringBuilder<Tag, CompoundTag> {
|
|
protected NbtRecordBuilder(NbtOps nbtOps) {
|
|
super((DynamicOps)nbtOps);
|
|
}
|
|
|
|
protected CompoundTag initBuilder() {
|
|
return new CompoundTag();
|
|
}
|
|
|
|
protected CompoundTag append(String key, Tag value, CompoundTag builder) {
|
|
builder.put(key, value);
|
|
return builder;
|
|
}
|
|
|
|
protected DataResult<Tag> build(CompoundTag builder, Tag prefix) {
|
|
if (prefix == null || prefix == EndTag.INSTANCE) {
|
|
return DataResult.success((Object)builder);
|
|
}
|
|
if (prefix instanceof CompoundTag) {
|
|
CompoundTag compound = (CompoundTag)prefix;
|
|
CompoundTag result = compound.shallowCopy();
|
|
for (Map.Entry<String, Tag> entry : builder.entrySet()) {
|
|
result.put(entry.getKey(), entry.getValue());
|
|
}
|
|
return DataResult.success((Object)result);
|
|
}
|
|
return DataResult.error(() -> "mergeToMap called with not a map: " + String.valueOf(prefix), (Object)prefix);
|
|
}
|
|
}
|
|
|
|
private static class GenericListCollector
|
|
implements ListCollector {
|
|
private final ListTag result = new ListTag();
|
|
|
|
private GenericListCollector() {
|
|
}
|
|
|
|
private GenericListCollector(ListTag initial) {
|
|
this.result.addAll(initial);
|
|
}
|
|
|
|
public GenericListCollector(IntArrayList initials) {
|
|
initials.forEach(v -> this.result.add(IntTag.valueOf(v)));
|
|
}
|
|
|
|
public GenericListCollector(ByteArrayList initials) {
|
|
initials.forEach(v -> this.result.add(ByteTag.valueOf(v)));
|
|
}
|
|
|
|
public GenericListCollector(LongArrayList initials) {
|
|
initials.forEach(v -> this.result.add(LongTag.valueOf(v)));
|
|
}
|
|
|
|
@Override
|
|
public ListCollector accept(Tag tag) {
|
|
this.result.add(tag);
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public Tag result() {
|
|
return this.result;
|
|
}
|
|
}
|
|
|
|
private static class ByteListCollector
|
|
implements ListCollector {
|
|
private final ByteArrayList values = new ByteArrayList();
|
|
|
|
public ByteListCollector(byte[] initialValues) {
|
|
this.values.addElements(0, initialValues);
|
|
}
|
|
|
|
@Override
|
|
public ListCollector accept(Tag tag) {
|
|
if (tag instanceof ByteTag) {
|
|
ByteTag byteTag = (ByteTag)tag;
|
|
this.values.add(byteTag.byteValue());
|
|
return this;
|
|
}
|
|
return new GenericListCollector(this.values).accept(tag);
|
|
}
|
|
|
|
@Override
|
|
public Tag result() {
|
|
return new ByteArrayTag(this.values.toByteArray());
|
|
}
|
|
}
|
|
|
|
private static class IntListCollector
|
|
implements ListCollector {
|
|
private final IntArrayList values = new IntArrayList();
|
|
|
|
public IntListCollector(int[] initialValues) {
|
|
this.values.addElements(0, initialValues);
|
|
}
|
|
|
|
@Override
|
|
public ListCollector accept(Tag tag) {
|
|
if (tag instanceof IntTag) {
|
|
IntTag intTag = (IntTag)tag;
|
|
this.values.add(intTag.intValue());
|
|
return this;
|
|
}
|
|
return new GenericListCollector(this.values).accept(tag);
|
|
}
|
|
|
|
@Override
|
|
public Tag result() {
|
|
return new IntArrayTag(this.values.toIntArray());
|
|
}
|
|
}
|
|
|
|
private static class LongListCollector
|
|
implements ListCollector {
|
|
private final LongArrayList values = new LongArrayList();
|
|
|
|
public LongListCollector(long[] initialValues) {
|
|
this.values.addElements(0, initialValues);
|
|
}
|
|
|
|
@Override
|
|
public ListCollector accept(Tag tag) {
|
|
if (tag instanceof LongTag) {
|
|
LongTag longTag = (LongTag)tag;
|
|
this.values.add(longTag.longValue());
|
|
return this;
|
|
}
|
|
return new GenericListCollector(this.values).accept(tag);
|
|
}
|
|
|
|
@Override
|
|
public Tag result() {
|
|
return new LongArrayTag(this.values.toLongArray());
|
|
}
|
|
}
|
|
|
|
private static interface ListCollector {
|
|
public ListCollector accept(Tag var1);
|
|
|
|
default public ListCollector acceptAll(Iterable<Tag> tags) {
|
|
ListCollector collector = this;
|
|
for (Tag tag : tags) {
|
|
collector = collector.accept(tag);
|
|
}
|
|
return collector;
|
|
}
|
|
|
|
default public ListCollector acceptAll(Stream<Tag> tags) {
|
|
return this.acceptAll(tags::iterator);
|
|
}
|
|
|
|
public Tag result();
|
|
}
|
|
}
|
|
|