net.lenni0451.mcstructs.converter.DataConverter Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of converter Show documentation
A minecraft data structure library with the goal of being compliant with the vanilla client
There is a newer version: 2.5.5
package net.lenni0451.mcstructs.converter;

import javax.annotation.Nullable;
import java.util.*;

public interface DataConverter {

     N convertTo(final DataConverter converter, @Nullable final T element);

    default  T convertFrom(final DataConverter converter, @Nullable final N element) {
        return converter.convertTo(this, element);
    }

    default  N convertList(final DataConverter to, final T list) {
        List in = this.asList(list).orElse(new ArrayList<>());
        List out = new ArrayList<>();
        for (T element : in) out.add(this.convertTo(to, element));
        return to.createList(out);
    }

    default  N convertMap(final DataConverter to, final T map) {
        Map in = this.asMap(map).orElse(new HashMap<>());
        Map out = new HashMap<>();
        for (Map.Entry entry : in.entrySet()) out.put(this.convertTo(to, entry.getKey()), this.convertTo(to, entry.getValue()));
        return to.createUnsafeMap(out);
    }

    T createBoolean(final boolean value);

    Result asBoolean(final T element);

    T createNumber(final Number number);

    Result asNumber(final T element);

    default T createByte(final byte value) {
        return this.createNumber(value);
    }

    default T createShort(final short value) {
        return this.createNumber(value);
    }

    default T createInt(final int value) {
        return this.createNumber(value);
    }

    default T createLong(final long value) {
        return this.createNumber(value);
    }

    default T createFloat(final float value) {
        return this.createNumber(value);
    }

    default T createDouble(final double value) {
        return this.createNumber(value);
    }

    T createString(final String value);

    Result asString(final T element);

    default T createList(final List values) {
        return this.mergeList(null, values).get();
    }

    default T emptyList() {
        return this.createList(Collections.emptyList());
    }

    Result mergeList(@Nullable final T list, final List values);

    default Result mergeList(@Nullable final T list, final T... values) {
        return this.mergeList(list, Arrays.asList(values));
    }

    Result> asList(final T element);

    T createUnsafeMap(final Map values);

    default T emptyMap() {
        return this.createUnsafeMap(Collections.emptyMap());
    }

    default Result createMergedMap(final Map values) {
        T map = this.emptyMap();
        for (Map.Entry entry : values.entrySet()) {
            Result mergedMap = this.mergeMap(map, entry.getKey(), entry.getValue());
            if (mergedMap.isError()) return mergedMap;
            map = mergedMap.get();
        }
        return Result.success(map);
    }

    Result mergeMap(@Nullable final T map, final Map values);

    default Result mergeMap(@Nullable final T map, final T key, final T value) {
        return this.mergeMap(map, Collections.singletonMap(key, value));
    }

    default Result mergeMap(@Nullable final T map, final T... keyValue) {
        if (keyValue.length % 2 != 0) return Result.error("Key-Value pairs must be even");
        Map mapValues = new HashMap<>();
        for (int i = 0; i < keyValue.length; i += 2) mapValues.put(keyValue[i], keyValue[i + 1]);
        return this.mergeMap(map, mapValues);
    }

    Result> asMap(final T element);

    Result> asStringTypeMap(final T element);

    boolean put(final T map, final String key, final T value);

    T createByteArray(final byte[] value);

    Result asByteArray(final T element);

    T createIntArray(final int[] value);

    Result asIntArray(final T element);

    T createLongArray(final long[] value);

    Result asLongArray(final T element);

}