@Override public <T> MutableSet<T> empty() { return UnifiedSet.newSet(); }
private void assertContains( Iterable<NodeWithPropertyValues> iterable, NodeWithPropertyValues... expected ) { assertEquals( UnifiedSet.newSetWith( expected ), UnifiedSet.newSet( iterable ) ); }
@Override public <V> MutableSet<V> collectIf( Predicate<? super T> predicate, Function<? super T, ? extends V> function) { return Iterate.collectIf(this.delegate, predicate, function, UnifiedSet.newSet()); }
@Override public <V> MutableSet<V> collectIf( Predicate<? super T> predicate, Function<? super T, ? extends V> function) { return Iterate.collectIf(this.delegate, predicate, function, UnifiedSet.newSet()); }
/** * @deprecated in 7.0. Use {@link org.eclipse.collections.api.ordered.OrderedIterable#zipWithIndex()} instead. */ @Deprecated @Override public MutableSet<Pair<V, Integer>> zipWithIndex() { return this.zipWithIndex(UnifiedSet.<Pair<V, Integer>>newSet(this.size())); }
/** * @deprecated in 7.0. Use {@link org.eclipse.collections.api.ordered.OrderedIterable#zipWithIndex()} instead. */ @Deprecated @Override public MutableSet<Pair<V, Integer>> zipWithIndex() { return this.zipWithIndex(UnifiedSet.<Pair<V, Integer>>newSet(this.size())); }
private static <E> MutableSet<E> newSet(Set<? extends E>... sets) { Comparator<? super E> comparator = extractComparator(sets); if (comparator != null) { // TODO: this should return a SortedSetAdapter once implemented return SetAdapter.adapt(new TreeSet<>(comparator)); } return UnifiedSet.newSet(); }
public FeatureVectorsPartition() { vectors = UnifiedMap.newMap(); recentIDs = UnifiedSet.newSet(); lock = new AutoReadWriteLock(); }
/** * @return all user IDs in the model */ public Collection<String> getAllUserIDs() { Collection<String> allUserIDs = UnifiedSet.newSet(X.size()); X.addAllIDsTo(allUserIDs); return allUserIDs; }
/** * @return all item IDs in the model */ public Collection<String> getAllItemIDs() { Collection<String> allItemIDs = UnifiedSet.newSet(Y.size()); Y.addAllIDsTo(allItemIDs); return allItemIDs; }
@Override public MutableSet<V> toSet() { MutableSet<V> set = UnifiedSet.newSet(); this.forEachWith(Procedures2.<V>addToCollection(), set); return set; }
@Override public MutableSet<V> toSet() { MutableSet<V> set = UnifiedSet.newSet(); this.forEachWith(Procedures2.<V>addToCollection(), set); return set; }
@Override public ImmutableSet<Pair<V, Integer>> zipWithIndex() { return this.zipWithIndex(UnifiedSet.<Pair<V, Integer>>newSet()).toImmutable(); }
public static MutableSet<Character> toUppercaseSet(String string) { MutableSet<Character> characters = UnifiedSet.newSet(); StringIterate.forEachChar(string, new AddUppercaseCharacterToCollection(characters)); return characters; }
@Override public ImmutableSet<T> newWith(T element) { if (!this.contains(element)) { MutableSet<T> result = UnifiedSet.newSet(this); result.add(element); return result.toImmutable(); } return this; }
@Override public <V> ImmutableSet<V> collectIf(Predicate<? super T> predicate, Function<? super T, ? extends V> function) { MutableSet<V> result = UnifiedSet.newSet(); this.forEach(new CollectIfProcedure<>(result, function, predicate)); return result.toImmutable(); }
@Override public boolean anySatisfy(Predicate<? super T> predicate) { MutableSet<T> seenSoFar = UnifiedSet.newSet(); return Iterate.anySatisfy(this.adapted, each -> seenSoFar.add(each) && predicate.accept(each)); }
@Override public <V> ImmutableSet<V> collect(LongToObjectFunction<? extends V> function) { MutableSet<V> set = this.collect(function, UnifiedSet.newSet(this.size())); return set.toImmutable(); }
@Override public boolean retainAllIterable(Iterable<?> iterable) { int oldSize = this.size(); this.removeIfWith(Predicates2.notIn(), UnifiedSet.newSet(iterable)); return this.size() != oldSize; }
@Override public Set<Entry<K, V>> entrySet() { MutableSet<Entry<K, V>> set = UnifiedSet.newSet(this.size()); this.forEachKeyValue((key, value) -> set.add(ImmutableEntry.of(key, value))); return set.toImmutable().castToSet(); }