com.opsbears.webcomponents.immutable.ImmutableTreeMap Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of immutable Show documentation
Immutable map, list, etc implementations
The newest version!
package com.opsbears.webcomponents.immutable;

import javax.annotation.Nonnull;
import javax.annotation.ParametersAreNonnullByDefault;
import java.util.*;
import java.util.TreeMap;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 *
 * @param 
 * @param 
 *
 * TODO more efficient map copying. (See TreeMap source code.)
 */
@ParametersAreNonnullByDefault
public class ImmutableTreeMap implements ImmutableSortedMap {
    private final SortedMap backingMap;

    public ImmutableTreeMap() {
        super();
        backingMap = Collections.unmodifiableSortedMap(new TreeMap<>());
    }

    public ImmutableTreeMap(Map data) {
        super();
        backingMap = Collections.unmodifiableSortedMap(new TreeMap<>(data));
    }

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

    @Override
    public boolean isEmpty() {
        return backingMap.isEmpty();
    }

    @Override
    public boolean containsKey(Object o) {
        return backingMap.containsKey(o);
    }

    @Override
    public boolean containsValue(Object o) {
        return backingMap.containsValue(o);
    }

    @Override
    public V get(Object o) {
        return backingMap.get(o);
    }

    @Override
    @Nonnull
    public ImmutableSortedSet keySet() {
        return new ImmutableTreeSet(backingMap.keySet());
    }

    @Override
    public ImmutableSet> immutableEntrySet() {
        return backingMap.entrySet().stream().map(entry -> new Entry<>(entry.getKey(), entry.getValue())).collect(Collectors.toCollection(ImmutableTreeSet::new));
    }

    @Override
    public ImmutableTreeMap withPut(
        K key,
        V value
    ) {
        Map newMap = new TreeMap<>(this);
        newMap.put(key, value);
        return new ImmutableTreeMap<>(newMap);
    }

    @Override
    public ImmutableSortedMap withRemove(Object key) {
        Map newMap = new TreeMap<>(this);
        //noinspection SuspiciousMethodCalls
        newMap.remove(key);
        return new ImmutableTreeMap<>(newMap);
    }

    @Override
    public ImmutableSortedMap withPutAll(Map other) {
        Map newMap = new TreeMap<>();
        newMap.putAll(this);
        newMap.putAll(other);
        return new ImmutableTreeMap<>(newMap);
    }

    @Override
    public ImmutableSortedMap withClear() {
        return new ImmutableTreeMap<>();
    }

    @Override
    public ImmutableSortedMap withReplaceAll(BiFunction var1) {
        Map newMap = new TreeMap<>(this);
        newMap.replaceAll(var1);
        return new ImmutableTreeMap<>(newMap);
    }

    @Override
    public ImmutableSortedMap withPutIfAbsent(
        K var1,
        V var2
    ) {
        Map newMap = new TreeMap<>(this);
        newMap.putIfAbsent(var1, var2);
        return new ImmutableTreeMap<>(newMap);
    }

    @Override
    public ImmutableSortedMap withRemove(
        Object var1,
        Object var2
    ) {
        Map newMap = new TreeMap<>(this);
        //noinspection SuspiciousMethodCalls
        newMap.remove(var1, var2);
        return new ImmutableTreeMap<>(newMap);
    }

    @Override
    public ImmutableSortedMap withReplace(
        K var1,
        V var2,
        V var3
    ) {
        Map newMap = new TreeMap<>(this);
        newMap.replace(var1, var2, var3);
        return new ImmutableTreeMap<>(newMap);
    }

    @Override
    public ImmutableSortedMap withReplace(
        K var1,
        V var2
    ) {
        Map newMap = new TreeMap<>(this);
        newMap.replace(var1, var2);
        return new ImmutableTreeMap<>(newMap);
    }

    @Override
    public ImmutableSortedMap withComputeIfAbsent(
        K var1,
        Function var2
    ) {
        Map newMap = new TreeMap<>(this);
        newMap.computeIfAbsent(var1, var2);
        return new ImmutableTreeMap<>(newMap);
    }

    @Override
    public ImmutableSortedMap withComputeIfPresent(
        K var1,
        BiFunction var2
    ) {
        Map newMap = new TreeMap<>(this);
        newMap.computeIfPresent(var1, var2);
        return new ImmutableTreeMap<>(newMap);
    }

    @Override
    public ImmutableSortedMap withCompute(
        K var1,
        BiFunction var2
    ) {
        Map newMap = new TreeMap<>(this);
        newMap.compute(var1, var2);
        return new ImmutableTreeMap<>(newMap);
    }

    @Override
    public ImmutableSortedMap withMerge(
        K var1,
        V var2,
        BiFunction var3
    ) {
        Map newMap = new TreeMap<>(this);
        newMap.merge(var1, var2, var3);
        return new ImmutableTreeMap<>(newMap);
    }

    @Override
    @Nonnull
    public ImmutableCollection values() {
        return new ImmutableArrayList<>(backingMap.values());
    }

    @Override
    public Set> entrySet() {
        return backingMap.entrySet();
    }

    @Override
    public Comparator comparator() {
        return backingMap.comparator();
    }

    @Nonnull
    @Override
    public ImmutableSortedMap subMap(
        K var1,
        K var2
    ) {
        return new ImmutableTreeMap<>(backingMap.subMap(var1, var2));
    }

    @Nonnull
    @Override
    public ImmutableSortedMap headMap(K var1) {
        return new ImmutableTreeMap<>(backingMap.headMap(var1));
    }

    @Nonnull
    @Override
    public ImmutableSortedMap tailMap(K var1) {
        return new ImmutableTreeMap<>(backingMap.tailMap(var1));
    }

    @Override
    public K firstKey() {
        return backingMap.firstKey();
    }

    @Override
    public K lastKey() {
        return backingMap.lastKey();
    }

    public class Entry implements com.opsbears.webcomponents.immutable.ImmutableMap.Entry {
        private final K key;
        private final V value;

        public Entry(
            K key,
            V value
        ) {
            this.key = key;
            this.value = value;
        }

        @Override
        public ImmutableMap.Entry withValue(V value) {
            return new Entry<>(key, value);
        }

        @Override
        public K getKey() {
            return key;
        }

        @Override
        public V getValue() {
            return value;
        }
    }
}