static <T> LinkedHashSet<T> wrap(LinkedHashMap<T, Object> map) { return new LinkedHashSet<>(map); }
@Override public LinkedHashSet<T> remove(T element) { final LinkedHashMap<T, Object> newMap = map.remove(element); return (newMap == map) ? this : new LinkedHashSet<>(newMap); }
@Override public LinkedHashSet<T> init() { if (map.isEmpty()) { throw new UnsupportedOperationException("tail of empty set"); } else { return new LinkedHashSet<>(map.init()); } }
/** * Add the given element to this set, replacing existing one if it is already contained. * <p> * Note that this method has a worst-case linear complexity. * * @param element The element to be added. * @return A new set containing all elements of this set and also {@code element}. */ @Override public LinkedHashSet<T> add(T element) { return contains(element) ? this : new LinkedHashSet<>(map.put(element, element)); }
/** * {@code readResolve} method for the serialization proxy pattern. * <p> * Returns a logically equivalent instance of the enclosing class. The presence of this method causes the * serialization system to translate the serialization proxy back into an instance of the enclosing class * upon deserialization. * * @return A deserialized instance of the enclosing class. */ private Object readResolve() { return map.isEmpty() ? LinkedHashSet.empty() : new LinkedHashSet<>(map); } }
@Override public <U> LinkedHashSet<U> flatMap(Function<? super T, ? extends Iterable<? extends U>> mapper) { Objects.requireNonNull(mapper, "mapper is null"); if (isEmpty()) { return empty(); } else { final LinkedHashMap<U, Object> that = foldLeft(LinkedHashMap.empty(), (tree, t) -> addAll(tree, mapper.apply(t))); return new LinkedHashSet<>(that); } }
@Override public LinkedHashSet<T> replace(T currentElement, T newElement) { if (!Objects.equals(currentElement, newElement) && contains(currentElement)) { final Tuple2<T, Object> currentPair = Tuple.of(currentElement, currentElement); final Tuple2<T, Object> newPair = Tuple.of(newElement, newElement); final LinkedHashMap<T, Object> newMap = map.replace(currentPair, newPair); return new LinkedHashSet<>(newMap); } else { return this; } }
@Override public <U> LinkedHashSet<U> map(Function<? super T, ? extends U> mapper) { Objects.requireNonNull(mapper, "mapper is null"); if (isEmpty()) { return empty(); } else { final LinkedHashMap<U, Object> that = foldLeft(LinkedHashMap.empty(), (tree, t) -> { final U u = mapper.apply(t); return tree.put(u, u); }); return new LinkedHashSet<>(that); } }
/** * Creates a LinkedHashSet of the given elements. * * <pre><code>LinkedHashSet.of(1, 2, 3, 4)</code></pre> * * @param <T> Component type of the LinkedHashSet. * @param elements Zero or more elements. * @return A set containing the given elements. * @throws NullPointerException if {@code elements} is null */ @SafeVarargs public static <T> LinkedHashSet<T> of(T... elements) { Objects.requireNonNull(elements, "elements is null"); LinkedHashMap<T, Object> map = LinkedHashMap.empty(); for (T element : elements) { map = map.put(element, element); } return map.isEmpty() ? LinkedHashSet.empty() : new LinkedHashSet<>(map); }
/** * Creates a LinkedHashSet of the given elements. * * @param elements Set elements * @param <T> The value type * @return A new LinkedHashSet containing the given entries */ @SuppressWarnings("unchecked") public static <T> LinkedHashSet<T> ofAll(Iterable<? extends T> elements) { Objects.requireNonNull(elements, "elements is null"); if (elements instanceof LinkedHashSet) { return (LinkedHashSet<T>) elements; } else { final LinkedHashMap<T, Object> mao = addAll(LinkedHashMap.empty(), elements); return mao.isEmpty() ? empty() : new LinkedHashSet<>(mao); } }
/** * Adds all of the given elements to this set, replacing existing one if they are not already contained. * <p> * Note that this method has a worst-case quadratic complexity. * * @param elements The elements to be added. * @return A new set containing all elements of this set and the given {@code elements}, if not already contained. */ @Override public LinkedHashSet<T> addAll(Iterable<? extends T> elements) { Objects.requireNonNull(elements, "elements is null"); if (isEmpty() && elements instanceof LinkedHashSet) { @SuppressWarnings("unchecked") final LinkedHashSet<T> set = (LinkedHashSet<T>) elements; return set; } final LinkedHashMap<T, Object> that = addAll(map, elements); if (that.size() == map.size()) { return this; } else { return new LinkedHashSet<>(that); } }
return this; } else { return new LinkedHashSet<>(that);
static <T> LinkedHashSet<T> wrap(LinkedHashMap<T, Object> map) { return new LinkedHashSet<>(map); }
@Override public LinkedHashSet<T> remove(T element) { final LinkedHashMap<T, Object> newMap = map.remove(element); return (newMap == map) ? this : new LinkedHashSet<>(newMap); }
@Override public LinkedHashSet<T> init() { if (map.isEmpty()) { throw new UnsupportedOperationException("tail of empty set"); } else { return new LinkedHashSet<>(map.init()); } }
/** * Add the given element to this set, replacing existing one if it is already contained. * <p> * Note that this method has a worst-case linear complexity. * * @param element The element to be added. * @return A new set containing all elements of this set and also {@code element}. */ @Override public LinkedHashSet<T> add(T element) { return contains(element) ? this : new LinkedHashSet<>(map.put(element, element)); }
/** * {@code readResolve} method for the serialization proxy pattern. * <p> * Returns a logically equivalent instance of the enclosing class. The presence of this method causes the * serialization system to translate the serialization proxy back into an instance of the enclosing class * upon deserialization. * * @return A deserialized instance of the enclosing class. */ private Object readResolve() { return map.isEmpty() ? LinkedHashSet.empty() : new LinkedHashSet<>(map); } }
@Override public LinkedHashSet<T> replace(T currentElement, T newElement) { if (!Objects.equals(currentElement, newElement) && contains(currentElement)) { final Tuple2<T, Object> currentPair = Tuple.of(currentElement, currentElement); final Tuple2<T, Object> newPair = Tuple.of(newElement, newElement); final LinkedHashMap<T, Object> newMap = map.replace(currentPair, newPair); return new LinkedHashSet<>(newMap); } else { return this; } }
@Override public <U> LinkedHashSet<U> flatMap(Function<? super T, ? extends Iterable<? extends U>> mapper) { Objects.requireNonNull(mapper, "mapper is null"); if (isEmpty()) { return empty(); } else { final LinkedHashMap<U, Object> that = foldLeft(LinkedHashMap.empty(), (tree, t) -> addAll(tree, mapper.apply(t))); return new LinkedHashSet<>(that); } }
@Override public <U> LinkedHashSet<U> map(Function<? super T, ? extends U> mapper) { Objects.requireNonNull(mapper, "mapper is null"); if (isEmpty()) { return empty(); } else { final LinkedHashMap<U, Object> that = foldLeft(LinkedHashMap.empty(), (tree, t) -> { final U u = mapper.apply(t); return tree.put(u, u); }); return new LinkedHashSet<>(that); } }