
org.eclipse.collections.impl.set.immutable.AbstractImmutableSet Maven / Gradle / Ivy
/*
* Copyright (c) 2022 Goldman Sachs and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* and Eclipse Distribution License v. 1.0 which accompany this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*/
package org.eclipse.collections.impl.set.immutable;
import java.util.Collection;
import java.util.Iterator;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import org.eclipse.collections.api.LazyIterable;
import org.eclipse.collections.api.RichIterable;
import org.eclipse.collections.api.block.function.Function;
import org.eclipse.collections.api.block.function.Function2;
import org.eclipse.collections.api.block.function.primitive.BooleanFunction;
import org.eclipse.collections.api.block.function.primitive.ByteFunction;
import org.eclipse.collections.api.block.function.primitive.CharFunction;
import org.eclipse.collections.api.block.function.primitive.DoubleFunction;
import org.eclipse.collections.api.block.function.primitive.FloatFunction;
import org.eclipse.collections.api.block.function.primitive.IntFunction;
import org.eclipse.collections.api.block.function.primitive.LongFunction;
import org.eclipse.collections.api.block.function.primitive.ShortFunction;
import org.eclipse.collections.api.block.predicate.Predicate;
import org.eclipse.collections.api.block.predicate.Predicate2;
import org.eclipse.collections.api.block.procedure.Procedure;
import org.eclipse.collections.api.collection.MutableCollection;
import org.eclipse.collections.api.factory.Sets;
import org.eclipse.collections.api.factory.primitive.BooleanSets;
import org.eclipse.collections.api.factory.primitive.ByteSets;
import org.eclipse.collections.api.factory.primitive.CharSets;
import org.eclipse.collections.api.factory.primitive.DoubleSets;
import org.eclipse.collections.api.factory.primitive.FloatSets;
import org.eclipse.collections.api.factory.primitive.IntSets;
import org.eclipse.collections.api.factory.primitive.LongSets;
import org.eclipse.collections.api.factory.primitive.ShortSets;
import org.eclipse.collections.api.list.MutableList;
import org.eclipse.collections.api.multimap.MutableMultimap;
import org.eclipse.collections.api.multimap.set.ImmutableSetMultimap;
import org.eclipse.collections.api.ordered.OrderedIterable;
import org.eclipse.collections.api.partition.set.PartitionImmutableSet;
import org.eclipse.collections.api.partition.set.PartitionMutableSet;
import org.eclipse.collections.api.set.ImmutableSet;
import org.eclipse.collections.api.set.MutableSet;
import org.eclipse.collections.api.set.ParallelUnsortedSetIterable;
import org.eclipse.collections.api.set.SetIterable;
import org.eclipse.collections.api.set.UnsortedSetIterable;
import org.eclipse.collections.api.set.primitive.ImmutableBooleanSet;
import org.eclipse.collections.api.set.primitive.ImmutableByteSet;
import org.eclipse.collections.api.set.primitive.ImmutableCharSet;
import org.eclipse.collections.api.set.primitive.ImmutableDoubleSet;
import org.eclipse.collections.api.set.primitive.ImmutableFloatSet;
import org.eclipse.collections.api.set.primitive.ImmutableIntSet;
import org.eclipse.collections.api.set.primitive.ImmutableLongSet;
import org.eclipse.collections.api.set.primitive.ImmutableShortSet;
import org.eclipse.collections.api.set.primitive.MutableBooleanSet;
import org.eclipse.collections.api.set.primitive.MutableByteSet;
import org.eclipse.collections.api.set.primitive.MutableCharSet;
import org.eclipse.collections.api.set.primitive.MutableDoubleSet;
import org.eclipse.collections.api.set.primitive.MutableFloatSet;
import org.eclipse.collections.api.set.primitive.MutableIntSet;
import org.eclipse.collections.api.set.primitive.MutableLongSet;
import org.eclipse.collections.api.set.primitive.MutableShortSet;
import org.eclipse.collections.api.tuple.Pair;
import org.eclipse.collections.impl.block.factory.Functions;
import org.eclipse.collections.impl.block.factory.Predicates;
import org.eclipse.collections.impl.block.procedure.CollectIfProcedure;
import org.eclipse.collections.impl.block.procedure.CollectProcedure;
import org.eclipse.collections.impl.block.procedure.FlatCollectProcedure;
import org.eclipse.collections.impl.block.procedure.MultimapEachPutProcedure;
import org.eclipse.collections.impl.block.procedure.MultimapPutProcedure;
import org.eclipse.collections.impl.block.procedure.PartitionPredicate2Procedure;
import org.eclipse.collections.impl.block.procedure.PartitionProcedure;
import org.eclipse.collections.impl.block.procedure.RejectProcedure;
import org.eclipse.collections.impl.block.procedure.SelectInstancesOfProcedure;
import org.eclipse.collections.impl.block.procedure.SelectProcedure;
import org.eclipse.collections.impl.collection.immutable.AbstractImmutableCollection;
import org.eclipse.collections.impl.lazy.parallel.set.NonParallelUnsortedSetIterable;
import org.eclipse.collections.impl.list.mutable.FastList;
import org.eclipse.collections.impl.multimap.set.UnifiedSetMultimap;
import org.eclipse.collections.impl.partition.set.PartitionUnifiedSet;
import org.eclipse.collections.impl.set.mutable.UnifiedSet;
import org.eclipse.collections.impl.utility.Iterate;
import org.eclipse.collections.impl.utility.internal.SetIterables;
/**
* This class is the parent class for all ImmutableSets. All implementations of ImmutableSet must implement the Set
* interface so anArraySet.equals(anImmutableSet) can return true when the contents and order are the same.
*/
public abstract class AbstractImmutableSet extends AbstractImmutableCollection
implements ImmutableSet, Set
{
@Override
public Set castToSet()
{
return this;
}
protected int nullSafeHashCode(Object element)
{
return element == null ? 0 : element.hashCode();
}
@Override
public ImmutableSet newWith(T element)
{
if (!this.contains(element))
{
MutableSet result = Sets.mutable.withAll(this);
result.add(element);
return result.toImmutable();
}
return this;
}
@Override
public ImmutableSet newWithout(T element)
{
if (this.contains(element))
{
MutableSet result = Sets.mutable.withAll(this);
result.remove(element);
return result.toImmutable();
}
return this;
}
@Override
public ImmutableSet newWithAll(Iterable extends T> elements)
{
MutableSet result = Sets.mutable.withAll(elements);
result.addAll(this);
return result.toImmutable();
}
@Override
public ImmutableSet newWithoutAll(Iterable extends T> elements)
{
MutableSet result = Sets.mutable.withAll(this);
this.removeAllFrom(elements, result);
return result.toImmutable();
}
@Override
public ImmutableSet tap(Procedure super T> procedure)
{
this.forEach(procedure);
return this;
}
@Override
public ImmutableSet select(Predicate super T> predicate)
{
MutableList intermediateResult = FastList.newList();
this.forEach(new SelectProcedure<>(predicate, intermediateResult));
return Sets.immutable.withAll(intermediateResult);
}
@Override
public ImmutableSet selectWith(Predicate2 super T, ? super P> predicate, P parameter)
{
return this.select(Predicates.bind(predicate, parameter));
}
@Override
public ImmutableSet reject(Predicate super T> predicate)
{
MutableList intermediateResult = FastList.newList();
this.forEach(new RejectProcedure<>(predicate, intermediateResult));
return Sets.immutable.withAll(intermediateResult);
}
@Override
public ImmutableSet rejectWith(Predicate2 super T, ? super P> predicate, P parameter)
{
return this.reject(Predicates.bind(predicate, parameter));
}
@Override
public PartitionImmutableSet partition(Predicate super T> predicate)
{
PartitionMutableSet partitionMutableSet = new PartitionUnifiedSet<>();
this.forEach(new PartitionProcedure<>(predicate, partitionMutableSet));
return partitionMutableSet.toImmutable();
}
@Override
public PartitionImmutableSet partitionWith(Predicate2 super T, ? super P> predicate, P parameter)
{
PartitionMutableSet partitionMutableSet = new PartitionUnifiedSet<>();
this.forEach(new PartitionPredicate2Procedure<>(predicate, parameter, partitionMutableSet));
return partitionMutableSet.toImmutable();
}
@Override
public ImmutableSet selectInstancesOf(Class clazz)
{
MutableSet result = Sets.mutable.withInitialCapacity(this.size());
this.forEach(new SelectInstancesOfProcedure<>(clazz, result));
return result.toImmutable();
}
@Override
public ImmutableSet collect(Function super T, ? extends V> function)
{
MutableSet result = Sets.mutable.empty();
this.forEach(new CollectProcedure<>(function, result));
return result.toImmutable();
}
@Override
public ImmutableBooleanSet collectBoolean(BooleanFunction super T> booleanFunction)
{
MutableBooleanSet result = BooleanSets.mutable.empty();
return this.collectBoolean(booleanFunction, result).toImmutable();
}
@Override
public ImmutableByteSet collectByte(ByteFunction super T> byteFunction)
{
MutableByteSet result = ByteSets.mutable.empty();
return this.collectByte(byteFunction, result).toImmutable();
}
@Override
public ImmutableCharSet collectChar(CharFunction super T> charFunction)
{
MutableCharSet result = CharSets.mutable.empty();
return this.collectChar(charFunction, result).toImmutable();
}
@Override
public ImmutableDoubleSet collectDouble(DoubleFunction super T> doubleFunction)
{
MutableDoubleSet result = DoubleSets.mutable.empty();
return this.collectDouble(doubleFunction, result).toImmutable();
}
@Override
public ImmutableFloatSet collectFloat(FloatFunction super T> floatFunction)
{
MutableFloatSet result = FloatSets.mutable.empty();
return this.collectFloat(floatFunction, result).toImmutable();
}
@Override
public ImmutableIntSet collectInt(IntFunction super T> intFunction)
{
MutableIntSet result = IntSets.mutable.empty();
return this.collectInt(intFunction, result).toImmutable();
}
@Override
public ImmutableLongSet collectLong(LongFunction super T> longFunction)
{
MutableLongSet result = LongSets.mutable.empty();
return this.collectLong(longFunction, result).toImmutable();
}
@Override
public ImmutableShortSet collectShort(ShortFunction super T> shortFunction)
{
MutableShortSet result = ShortSets.mutable.empty();
return this.collectShort(shortFunction, result).toImmutable();
}
@Override
public ImmutableSet collectWith(Function2 super T, ? super P, ? extends V> function, P parameter)
{
return this.collect(Functions.bind(function, parameter));
}
@Override
public ImmutableSet collectIf(Predicate super T> predicate, Function super T, ? extends V> function)
{
MutableSet result = Sets.mutable.empty();
this.forEach(new CollectIfProcedure<>(result, function, predicate));
return result.toImmutable();
}
@Override
public ImmutableSet flatCollect(Function super T, ? extends Iterable> function)
{
MutableSet result = Sets.mutable.empty();
this.forEach(new FlatCollectProcedure<>(function, result));
return result.toImmutable();
}
@Override
public ImmutableSet toImmutable()
{
return this;
}
protected abstract class ImmutableSetIterator
implements Iterator
{
private int next; // next entry to return, defaults to 0
protected abstract T getElement(int i);
@Override
public boolean hasNext()
{
return this.next < AbstractImmutableSet.this.size();
}
@Override
public T next()
{
return this.getElement(this.next++);
}
@Override
public void remove()
{
throw new UnsupportedOperationException("Cannot remove from an ImmutableSet");
}
}
@Override
public ImmutableSetMultimap groupBy(Function super T, ? extends V> function)
{
return this.groupBy(function, UnifiedSetMultimap.newMultimap()).toImmutable();
}
@Override
public > R groupBy(Function super T, ? extends V> function, R target)
{
this.forEach(MultimapPutProcedure.on(target, function));
return target;
}
@Override
public ImmutableSetMultimap groupByEach(Function super T, ? extends Iterable> function)
{
return this.groupByEach(function, UnifiedSetMultimap.newMultimap()).toImmutable();
}
@Override
public > R groupByEach(Function super T, ? extends Iterable> function, R target)
{
this.forEach(MultimapEachPutProcedure.on(target, function));
return target;
}
/**
* @deprecated in 6.0. Use {@link OrderedIterable#zip(Iterable)} instead.
*/
@Override
@Deprecated
public ImmutableSet> zip(Iterable that)
{
if (that instanceof Collection || that instanceof RichIterable)
{
int thatSize = Iterate.sizeOf(that);
UnifiedSet> target = UnifiedSet.newSet(Math.min(this.size(), thatSize));
return this.zip(that, target).toImmutable();
}
return this.zip(that, Sets.mutable.empty()).toImmutable();
}
/**
* @deprecated in 6.0. Use {@link OrderedIterable#zipWithIndex()} instead.
*/
@Override
@Deprecated
public ImmutableSet> zipWithIndex()
{
return this.zipWithIndex(Sets.mutable.withInitialCapacity(this.size())).toImmutable();
}
@Override
protected MutableCollection newMutable(int size)
{
return Sets.mutable.withInitialCapacity(size);
}
@Override
public ImmutableSet union(SetIterable extends T> set)
{
return SetIterables.union(this, set).toImmutable();
}
@Override
public > R unionInto(SetIterable extends T> set, R targetSet)
{
return SetIterables.unionInto(this, set, targetSet);
}
@Override
public ImmutableSet intersect(SetIterable extends T> set)
{
return SetIterables.intersect(this, set).toImmutable();
}
@Override
public > R intersectInto(SetIterable extends T> set, R targetSet)
{
return SetIterables.intersectInto(this, set, targetSet);
}
@Override
public ImmutableSet difference(SetIterable extends T> subtrahendSet)
{
return SetIterables.difference(this, subtrahendSet).toImmutable();
}
@Override
public > R differenceInto(SetIterable extends T> subtrahendSet, R targetSet)
{
return SetIterables.differenceInto(this, subtrahendSet, targetSet);
}
@Override
public ImmutableSet symmetricDifference(SetIterable extends T> setB)
{
return SetIterables.symmetricDifference(this, setB).toImmutable();
}
@Override
public > R symmetricDifferenceInto(SetIterable extends T> set, R targetSet)
{
return SetIterables.symmetricDifferenceInto(this, set, targetSet);
}
@Override
public boolean isSubsetOf(SetIterable extends T> candidateSuperset)
{
return SetIterables.isSubsetOf(this, candidateSuperset);
}
@Override
public boolean isProperSubsetOf(SetIterable extends T> candidateSuperset)
{
return SetIterables.isProperSubsetOf(this, candidateSuperset);
}
@Override
public ImmutableSet> powerSet()
{
return (ImmutableSet>) (ImmutableSet>) SetIterables.immutablePowerSet(this);
}
@Override
public LazyIterable> cartesianProduct(SetIterable set)
{
return SetIterables.cartesianProduct(this, set);
}
@Override
public ParallelUnsortedSetIterable asParallel(ExecutorService executorService, int batchSize)
{
Objects.requireNonNull(executorService);
if (batchSize < 1)
{
throw new IllegalArgumentException("batchSize must be greater than zero, but was: " + batchSize);
}
return new NonParallelUnsortedSetIterable<>(this);
}
}