com.github.simonharmonicminor.juu.collection.immutable.ImmutableTreeSet Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of java-useful-utils Show documentation
Just some useful utils for everyday coding
There is a newer version: 1.2
package com.github.simonharmonicminor.juu.collection.immutable;

import com.github.simonharmonicminor.juu.monad.Try;

import java.io.Serializable;
import java.util.*;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.Stream;

import static com.github.simonharmonicminor.juu.collection.immutable.Immutable.*;
import static com.github.simonharmonicminor.juu.collection.immutable.ImmutableCollectionUtils.setEquals;
import static com.github.simonharmonicminor.juu.collection.immutable.ImmutableCollectionUtils.setToString;

public class ImmutableTreeSet implements ImmutableNavigableSet, Serializable {
    private final TreeSet treeSet;

    public static > ImmutableTreeSet of(Iterable iterable) {
        Objects.requireNonNull(iterable);
        return new ImmutableTreeSet<>(iterable, null);
    }

    public static  ImmutableTreeSet ofSortedSet(SortedSet sortedSet) {
        Objects.requireNonNull(sortedSet);
        return new ImmutableTreeSet<>(sortedSet, true);
    }

    public static  ImmutableTreeSet of(Iterable iterable, Comparator comparator) {
        Objects.requireNonNull(iterable);
        return new ImmutableTreeSet<>(iterable, comparator);
    }

    ImmutableTreeSet(Iterable iterable, Comparator comparator) {
        Objects.requireNonNull(iterable);
        treeSet = new TreeSet<>(comparator);
        for (T t : iterable) {
            treeSet.add(t);
        }
    }

    ImmutableTreeSet(SortedSet sortedSet, boolean needsCloning) {
        if (sortedSet instanceof TreeSet) {
            this.treeSet = needsCloning ? new TreeSet<>(sortedSet) : (TreeSet) sortedSet;
        } else {
            this.treeSet = new TreeSet<>(sortedSet);
        }
    }

    private static  ImmutableTreeSet newImmutableTreeSet(
            SortedSet treeSet, boolean needsCloning) {
        if (treeSet.isEmpty()) return emptyTreeSet();
        return new ImmutableTreeSet<>(treeSet, needsCloning);
    }

    private static  ImmutableHashSet newImmutableHashSetWithoutCloning(HashSet hashSet) {
        if (hashSet.isEmpty()) return emptyHashSet();
        return new ImmutableHashSet<>(hashSet, false);
    }

    private Optional tryGetElement(Supplier supplier) {
        return Try.of(supplier::get)
                .map(Optional::ofNullable)
                .orElse(Optional.empty());
    }

    @Override
    public Optional lower(T t) {
        return tryGetElement(() -> treeSet.lower(t));
    }

    @Override
    public Optional floor(T t) {
        return tryGetElement(() -> treeSet.floor(t));
    }

    @Override
    public Optional ceiling(T t) {
        return tryGetElement(() -> treeSet.ceiling(t));
    }

    @Override
    public Optional higher(T t) {
        return tryGetElement(() -> treeSet.higher(t));
    }

    @Override
    public ImmutableNavigableSet reversedOrderSet() {
        return newImmutableTreeSet(treeSet.descendingSet(), true);
    }

    @Override
    public Iterator reversedOrderIterator() {
        return treeSet.descendingIterator();
    }

    private ImmutableNavigableSet tryGetSubSet(Supplier> supplier) {
        return Try.of(supplier::get)
                .orElse(emptyTreeSet());
    }

    @Override
    public ImmutableNavigableSet subSet(T fromElement, boolean fromInclusive, T toElement, boolean toInclusive) {
        return tryGetSubSet(() ->
                newImmutableTreeSet(
                        treeSet.subSet(fromElement, fromInclusive, toElement, toInclusive),
                        true));
    }

    @Override
    public ImmutableNavigableSet headSet(T toElement, boolean inclusive) {
        return tryGetSubSet(() ->
                newImmutableTreeSet(
                        treeSet.headSet(toElement, inclusive),
                        true));
    }

    @Override
    public ImmutableNavigableSet tailSet(T fromElement, boolean inclusive) {
        return tryGetSubSet(() ->
                newImmutableTreeSet(
                        treeSet.tailSet(fromElement, inclusive),
                        true));
    }

    @Override
    public NavigableSet toMutableNavigableSet() {
        return new TreeSet<>(treeSet);
    }

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

    @Override
    public ImmutableSortedSet subSet(T fromElement, T toElement) {
        return tryGetSubSet(() ->
                newImmutableTreeSet(
                        treeSet.subSet(fromElement, toElement),
                        true));
    }

    @Override
    public ImmutableSortedSet headSet(T toElement) {
        return tryGetSubSet(() ->
                newImmutableTreeSet(
                        treeSet.headSet(toElement),
                        true));
    }

    @Override
    public ImmutableSortedSet tailSet(T fromElement) {
        return tryGetSubSet(() ->
                newImmutableTreeSet(
                        treeSet.tailSet(fromElement),
                        true));
    }

    @Override
    public Optional first() {
        return tryGetElement(treeSet::first);
    }

    @Override
    public Optional last() {
        return tryGetElement(treeSet::last);
    }

    @Override
    public SortedSet toMutableSortedSet() {
        return toMutableNavigableSet();
    }

    @Override
    public ImmutableSet concatWith(Iterable iterable) {
        TreeSet newTreeSet = new TreeSet<>(treeSet);
        for (T t : iterable) {
            newTreeSet.add(t);
        }
        return newImmutableTreeSet(newTreeSet, false);
    }

    @Override
    public  ImmutableSet map(Function mapper) {
        Objects.requireNonNull(mapper);
        HashSet hashSet = new HashSet<>(size());
        for (T t : this) {
            hashSet.add(mapper.apply(t));
        }
        return newImmutableHashSetWithoutCloning(hashSet);
    }

    @Override
    public  ImmutableSet flatMap(Function> mapper) {
        Objects.requireNonNull(mapper);
        HashSet hashSet = new HashSet<>();
        for (T t : this) {
            for (R r : mapper.apply(t)) {
                hashSet.add(r);
            }
        }
        return newImmutableHashSetWithoutCloning(hashSet);
    }

    @Override
    public ImmutableSet filter(Predicate predicate) {
        Objects.requireNonNull(predicate);
        TreeSet newTreeSet = new TreeSet<>(comparator());
        for (T t : this) {
            if (predicate.test(t)) newTreeSet.add(t);
        }
        return newImmutableTreeSet(newTreeSet, false);
    }

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

    @Override
    public boolean contains(Object element) {
        return treeSet.contains(element);
    }

    @Override
    public ImmutableList toList() {
        return listOf(treeSet);
    }

    @Override
    public ImmutableSet toSet() {
        return this;
    }

    @Override
    public Stream parallelStream() {
        return treeSet.parallelStream();
    }

    @Override
    public Stream stream() {
        return treeSet.stream();
    }

    @Override
    public Iterator iterator() {
        return treeSet.iterator();
    }

    @Override
    public boolean equals(Object o) {
        return setEquals(this, o);
    }

    @Override
    public int hashCode() {
        return Objects.hash(treeSet);
    }

    @Override
    public String toString() {
        return setToString(this);
    }
}