io.polyglotted.common.util.MapBuilder Maven / Gradle / Ivy

Go to download
package io.polyglotted.common.util;

import com.google.common.collect.ImmutableBiMap;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSortedMap;
import io.polyglotted.common.model.MapResult;
import io.polyglotted.common.model.MapResult.ImmutableMapResult;
import io.polyglotted.common.model.MapResult.ImmutableResult;
import io.polyglotted.common.model.MapResult.SimpleMapResult;
import lombok.AccessLevel;
import lombok.RequiredArgsConstructor;

import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Supplier;

import static io.polyglotted.common.util.ReflectionUtil.fieldValue;

@SuppressWarnings({"unchecked", "unused", "WeakerAccess"})
public interface MapBuilder> {
    MapBuilder put(K key, V value);

    MapBuilder putList(K key, List values);

    MapBuilder putAll(Map map);

    int size();

    M build();

    MapResult result();

    ImmutableResult immutable();

    static > ImmutableBiMap immutableBiMap(MapBuilder builder) { return immutableBiMap(builder.build()); }

    static  ImmutableBiMap immutableBiMap(Map map) { return ImmutableBiMap.copyOf(map); }

    static > ImmutableSortedMap immutableSortedMap(MapBuilder bl) { return immutableSortedMap(bl.build()); }

    static  ImmutableSortedMap immutableSortedMap(Map map) { return ImmutableSortedMap.copyOf(map); }

    static  ImmutableMapBuilder immutableMapBuilder() { return immutableMapBuilder(ImmutableMap::builder); }

    static  ImmutableMapBuilder immutableMapBuilder(Supplier> s) { return new ImmutableMapBuilder<>(s.get()); }

    static  ImmutableMap immutableMap() { return ImmutableMap.of(); }

    static  ImmutableMap immutableMap(K k1, V v1) { return MapBuilder.immutableMapBuilder().put(k1, v1).build(); }

    static  ImmutableMap immutableMap(K k1, V v1, K k2, V v2) {
        return MapBuilder.immutableMapBuilder().put(k1, v1).put(k2, v2).build();
    }

    static  ImmutableMap immutableMap(K k1, V v1, K k2, V v2, K k3, V v3) {
        return MapBuilder.immutableMapBuilder().put(k1, v1).put(k2, v2).put(k3, v3).build();
    }

    static  ImmutableMap immutableMap(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4) {
        return MapBuilder.immutableMapBuilder().put(k1, v1).put(k2, v2).put(k3, v3).put(k4, v4).build();
    }

    static  ImmutableMap immutableMap(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5) {
        return MapBuilder.immutableMapBuilder().put(k1, v1).put(k2, v2).put(k3, v3).put(k4, v4).put(k5, v5).build();
    }

    static  ImmutableMap immutableMap(Map map) { return MapBuilder.immutableMapBuilder().putAll(map).build(); }

    static  SimpleMapBuilder simpleMapBuilder() { return simpleMapBuilder(LinkedHashMap::new); }

    static  SimpleMapBuilder simpleMapBuilder(Supplier> supplier) { return new SimpleMapBuilder<>(supplier.get()); }

    static  Map simpleMap() { return new LinkedHashMap<>(); }

    static  Map simpleMap(K k1, V v1) { return MapBuilder.simpleMapBuilder().put(k1, v1).build(); }

    static  Map simpleMap(K k1, V v1, K k2, V v2) { return MapBuilder.simpleMapBuilder().put(k1, v1).put(k2, v2).build(); }

    static  Map simpleMap(K k1, V v1, K k2, V v2, K k3, V v3) {
        return MapBuilder.simpleMapBuilder().put(k1, v1).put(k2, v2).put(k3, v3).build();
    }

    static  Map simpleMap(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4) {
        return MapBuilder.simpleMapBuilder().put(k1, v1).put(k2, v2).put(k3, v3).put(k4, v4).build();
    }

    static  Map simpleMap(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5) {
        return MapBuilder.simpleMapBuilder().put(k1, v1).put(k2, v2).put(k3, v3).put(k4, v4).put(k5, v5).build();
    }

    static  Map simpleMap(Map map) { return MapBuilder.simpleMapBuilder().putAll(map).build(); }

    @RequiredArgsConstructor(access = AccessLevel.PRIVATE) class ImmutableMapBuilder implements MapBuilder> {
        private final ImmutableMap.Builder builder;

        @Override public ImmutableMapBuilder put(K key, V value) { if (value != null) builder.put(key, value); return this; }

        @Override public ImmutableMapBuilder putList(K key, List values) {
            if (values != null && !values.isEmpty()) builder.put(key, (V) values); return this;
        }

        @Override public ImmutableMapBuilder putAll(Map map) {
            for (Map.Entry e : map.entrySet()) { put(e.getKey(), e.getValue()); } return this;
        }

        @Override public int size() { return fieldValue(builder, "size"); }

        @Override public ImmutableMap build() { return builder.build(); }

        @Override public MapResult result() { return immutable(); }

        @Override public ImmutableResult immutable() { return new ImmutableMapResult((ImmutableMap) builder.build()); }
    }

    @RequiredArgsConstructor(access = AccessLevel.PRIVATE) class SimpleMapBuilder implements MapBuilder> {
        private final Map builder;

        @Override public SimpleMapBuilder put(K key, V value) { if (value != null) builder.put(key, value); return this; }

        @Override public SimpleMapBuilder putList(K key, List values) {
            if (values != null && !values.isEmpty()) builder.put(key, (V) values); return this;
        }

        @Override public SimpleMapBuilder putAll(Map map) {
            for (Map.Entry e : map.entrySet()) { put(e.getKey(), e.getValue()); } return this;
        }

        @Override public int size() { return builder.size(); }

        @Override public Map build() { return builder; }

        @Override public MapResult result() {
            return builder instanceof MapResult ? (MapResult) builder : new SimpleMapResult((Map) builder);
        }

        @Override public ImmutableResult immutable() { return new ImmutableMapResult(ImmutableMap.copyOf((Map) builder)); }
    }
}