net.lenni0451.mcstructs.converter.codec.MapCodecMerger 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.codec;

import net.lenni0451.mcstructs.converter.DataConverter;
import net.lenni0451.mcstructs.converter.Result;

import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;

class MapCodecMerger {

    public static  Codec of(
            final MapCodec type1, final Function value1,
            final I1 generator
    ) {
        return new Codec() {
            @Override
            public  Result serialize(DataConverter converter, O element) {
                Map map = new HashMap<>();
                Result result = type1.serialize(converter, map, value1.apply(element));
                if (result.isError()) return result.mapError();
                return converter.createMergedMap(map);
            }

            @Override
            public  Result deserialize(DataConverter converter, S data) {
                Result> mapResult = converter.asMap(data);
                if (mapResult.isError()) return mapResult.mapError();

                Map map = mapResult.get();
                Result value1Result = type1.deserialize(converter, data, map);
                if (value1Result.isError()) return value1Result.mapError();
                return Result.success(generator.generate(value1Result.get()));
            }
        };
    }

    public static  Codec of(
            final MapCodec type1, final Function value1,
            final MapCodec type2, final Function value2,
            final I2 generator
    ) {
        return new Codec() {
            @Override
            public  Result serialize(DataConverter converter, O element) {
                Map map = new HashMap<>();
                Result result1 = type1.serialize(converter, map, value1.apply(element));
                if (result1.isError()) return result1.mapError();
                Result result2 = type2.serialize(converter, map, value2.apply(element));
                if (result2.isError()) return result2.mapError();
                return converter.createMergedMap(map);
            }

            @Override
            public  Result deserialize(DataConverter converter, S data) {
                Result> mapResult = converter.asMap(data);
                if (mapResult.isError()) return mapResult.mapError();

                Map map = mapResult.get();
                Result value1Result = type1.deserialize(converter, data, map);
                if (value1Result.isError()) return value1Result.mapError();
                Result value2Result = type2.deserialize(converter, data, map);
                if (value2Result.isError()) return value2Result.mapError();
                return Result.success(generator.generate(value1Result.get(), value2Result.get()));
            }
        };
    }

    public static  Codec of(
            final MapCodec type1, final Function value1,
            final MapCodec type2, final Function value2,
            final MapCodec type3, final Function value3,
            final I3 generator
    ) {
        return new Codec() {
            @Override
            public  Result serialize(DataConverter converter, O element) {
                Map map = new HashMap<>();
                Result result1 = type1.serialize(converter, map, value1.apply(element));
                if (result1.isError()) return result1.mapError();
                Result result2 = type2.serialize(converter, map, value2.apply(element));
                if (result2.isError()) return result2.mapError();
                Result result3 = type3.serialize(converter, map, value3.apply(element));
                if (result3.isError()) return result3.mapError();
                return converter.createMergedMap(map);
            }

            @Override
            public  Result deserialize(DataConverter converter, S data) {
                Result> mapResult = converter.asMap(data);
                if (mapResult.isError()) return mapResult.mapError();

                Map map = mapResult.get();
                Result value1Result = type1.deserialize(converter, data, map);
                if (value1Result.isError()) return value1Result.mapError();
                Result value2Result = type2.deserialize(converter, data, map);
                if (value2Result.isError()) return value2Result.mapError();
                Result value3Result = type3.deserialize(converter, data, map);
                if (value3Result.isError()) return value3Result.mapError();
                return Result.success(generator.generate(value1Result.get(), value2Result.get(), value3Result.get()));
            }
        };
    }

    public static  Codec of(
            final MapCodec type1, final Function value1,
            final MapCodec type2, final Function value2,
            final MapCodec type3, final Function value3,
            final MapCodec type4, final Function value4,
            final I4 generator
    ) {
        return new Codec() {
            @Override
            public  Result serialize(DataConverter converter, O element) {
                Map map = new HashMap<>();
                Result result1 = type1.serialize(converter, map, value1.apply(element));
                if (result1.isError()) return result1.mapError();
                Result result2 = type2.serialize(converter, map, value2.apply(element));
                if (result2.isError()) return result2.mapError();
                Result result3 = type3.serialize(converter, map, value3.apply(element));
                if (result3.isError()) return result3.mapError();
                Result result4 = type4.serialize(converter, map, value4.apply(element));
                if (result4.isError()) return result4.mapError();
                return converter.createMergedMap(map);
            }

            @Override
            public  Result deserialize(DataConverter converter, S data) {
                Result> mapResult = converter.asMap(data);
                if (mapResult.isError()) return mapResult.mapError();

                Map map = mapResult.get();
                Result value1Result = type1.deserialize(converter, data, map);
                if (value1Result.isError()) return value1Result.mapError();
                Result value2Result = type2.deserialize(converter, data, map);
                if (value2Result.isError()) return value2Result.mapError();
                Result value3Result = type3.deserialize(converter, data, map);
                if (value3Result.isError()) return value3Result.mapError();
                Result value4Result = type4.deserialize(converter, data, map);
                if (value4Result.isError()) return value4Result.mapError();
                return Result.success(generator.generate(value1Result.get(), value2Result.get(), value3Result.get(), value4Result.get()));
            }
        };
    }

    public static  Codec of(
            final MapCodec type1, final Function value1,
            final MapCodec type2, final Function value2,
            final MapCodec type3, final Function value3,
            final MapCodec type4, final Function value4,
            final MapCodec type5, final Function value5,
            final I5 generator
    ) {
        return new Codec() {
            @Override
            public  Result serialize(DataConverter converter, O element) {
                Map map = new HashMap<>();
                Result result1 = type1.serialize(converter, map, value1.apply(element));
                if (result1.isError()) return result1.mapError();
                Result result2 = type2.serialize(converter, map, value2.apply(element));
                if (result2.isError()) return result2.mapError();
                Result result3 = type3.serialize(converter, map, value3.apply(element));
                if (result3.isError()) return result3.mapError();
                Result result4 = type4.serialize(converter, map, value4.apply(element));
                if (result4.isError()) return result4.mapError();
                Result result5 = type5.serialize(converter, map, value5.apply(element));
                if (result5.isError()) return result5.mapError();
                return converter.createMergedMap(map);
            }

            @Override
            public  Result deserialize(DataConverter converter, S data) {
                Result> mapResult = converter.asMap(data);
                if (mapResult.isError()) return mapResult.mapError();

                Map map = mapResult.get();
                Result value1Result = type1.deserialize(converter, data, map);
                if (value1Result.isError()) return value1Result.mapError();
                Result value2Result = type2.deserialize(converter, data, map);
                if (value2Result.isError()) return value2Result.mapError();
                Result value3Result = type3.deserialize(converter, data, map);
                if (value3Result.isError()) return value3Result.mapError();
                Result value4Result = type4.deserialize(converter, data, map);
                if (value4Result.isError()) return value4Result.mapError();
                Result value5Result = type5.deserialize(converter, data, map);
                if (value5Result.isError()) return value5Result.mapError();
                return Result.success(generator.generate(value1Result.get(), value2Result.get(), value3Result.get(), value4Result.get(), value5Result.get()));
            }
        };
    }

    public static  Codec of(
            final MapCodec type1, final Function value1,
            final MapCodec type2, final Function value2,
            final MapCodec type3, final Function value3,
            final MapCodec type4, final Function value4,
            final MapCodec type5, final Function value5,
            final MapCodec type6, final Function value6,
            final I6 generator
    ) {
        return new Codec() {
            @Override
            public  Result serialize(DataConverter converter, O element) {
                Map map = new HashMap<>();
                Result result1 = type1.serialize(converter, map, value1.apply(element));
                if (result1.isError()) return result1.mapError();
                Result result2 = type2.serialize(converter, map, value2.apply(element));
                if (result2.isError()) return result2.mapError();
                Result result3 = type3.serialize(converter, map, value3.apply(element));
                if (result3.isError()) return result3.mapError();
                Result result4 = type4.serialize(converter, map, value4.apply(element));
                if (result4.isError()) return result4.mapError();
                Result result5 = type5.serialize(converter, map, value5.apply(element));
                if (result5.isError()) return result5.mapError();
                Result result6 = type6.serialize(converter, map, value6.apply(element));
                if (result6.isError()) return result6.mapError();
                return converter.createMergedMap(map);
            }

            @Override
            public  Result deserialize(DataConverter converter, S data) {
                Result> mapResult = converter.asMap(data);
                if (mapResult.isError()) return mapResult.mapError();

                Map map = mapResult.get();
                Result value1Result = type1.deserialize(converter, data, map);
                if (value1Result.isError()) return value1Result.mapError();
                Result value2Result = type2.deserialize(converter, data, map);
                if (value2Result.isError()) return value2Result.mapError();
                Result value3Result = type3.deserialize(converter, data, map);
                if (value3Result.isError()) return value3Result.mapError();
                Result value4Result = type4.deserialize(converter, data, map);
                if (value4Result.isError()) return value4Result.mapError();
                Result value5Result = type5.deserialize(converter, data, map);
                if (value5Result.isError()) return value5Result.mapError();
                Result value6Result = type6.deserialize(converter, data, map);
                if (value6Result.isError()) return value6Result.mapError();
                return Result.success(generator.generate(value1Result.get(), value2Result.get(), value3Result.get(), value4Result.get(), value5Result.get(), value6Result.get()));
            }
        };
    }

    public static  Codec of(
            final MapCodec type1, final Function value1,
            final MapCodec type2, final Function value2,
            final MapCodec type3, final Function value3,
            final MapCodec type4, final Function value4,
            final MapCodec type5, final Function value5,
            final MapCodec type6, final Function value6,
            final MapCodec type7, final Function value7,
            final I7 generator
    ) {
        return new Codec() {
            @Override
            public  Result serialize(DataConverter converter, O element) {
                Map map = new HashMap<>();
                Result result1 = type1.serialize(converter, map, value1.apply(element));
                if (result1.isError()) return result1.mapError();
                Result result2 = type2.serialize(converter, map, value2.apply(element));
                if (result2.isError()) return result2.mapError();
                Result result3 = type3.serialize(converter, map, value3.apply(element));
                if (result3.isError()) return result3.mapError();
                Result result4 = type4.serialize(converter, map, value4.apply(element));
                if (result4.isError()) return result4.mapError();
                Result result5 = type5.serialize(converter, map, value5.apply(element));
                if (result5.isError()) return result5.mapError();
                Result result6 = type6.serialize(converter, map, value6.apply(element));
                if (result6.isError()) return result6.mapError();
                Result result7 = type7.serialize(converter, map, value7.apply(element));
                if (result7.isError()) return result7.mapError();
                return converter.createMergedMap(map);
            }

            @Override
            public  Result deserialize(DataConverter converter, S data) {
                Result> mapResult = converter.asMap(data);
                if (mapResult.isError()) return mapResult.mapError();

                Map map = mapResult.get();
                Result value1Result = type1.deserialize(converter, data, map);
                if (value1Result.isError()) return value1Result.mapError();
                Result value2Result = type2.deserialize(converter, data, map);
                if (value2Result.isError()) return value2Result.mapError();
                Result value3Result = type3.deserialize(converter, data, map);
                if (value3Result.isError()) return value3Result.mapError();
                Result value4Result = type4.deserialize(converter, data, map);
                if (value4Result.isError()) return value4Result.mapError();
                Result value5Result = type5.deserialize(converter, data, map);
                if (value5Result.isError()) return value5Result.mapError();
                Result value6Result = type6.deserialize(converter, data, map);
                if (value6Result.isError()) return value6Result.mapError();
                Result value7Result = type7.deserialize(converter, data, map);
                if (value7Result.isError()) return value7Result.mapError();
                return Result.success(generator.generate(value1Result.get(), value2Result.get(), value3Result.get(), value4Result.get(), value5Result.get(), value6Result.get(), value7Result.get()));
            }
        };
    }


    @FunctionalInterface
    public interface I1 {
        O generate(T1 t1);
    }

    @FunctionalInterface
    public interface I2 {
        O generate(T1 t1, T2 t2);
    }

    @FunctionalInterface
    public interface I3 {
        O generate(T1 t1, T2 t2, T3 t3);
    }

    @FunctionalInterface
    public interface I4 {
        O generate(T1 t1, T2 t2, T3 t3, T4 t4);
    }

    @FunctionalInterface
    public interface I5 {
        O generate(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5);
    }

    @FunctionalInterface
    public interface I6 {
        O generate(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6);
    }

    @FunctionalInterface
    public interface I7 {
        O generate(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7);
    }

}