Stores the members of the set resulting from the union
of all the given sets.
761807
function sunionstore(destination /* key-1, key-N, req*/) {
  var args = slice.call(arguments, 1)
    , req = typeof args[args.length-1] === 'object'
      ? args[args.length - 1] : null;
  var list = this.sunion.apply(this, args);
  if(list.length) {
    this.setKey(
      destination, new Set(list), undefined, undefined, undefined, req);
  }
  return list.length;
}
1267000
def frommembers(cls, members=()):
        """"""
        return cls.fromint(sum(map(cls._map.__getitem__, set(members))))
199034
def sunion(self, *other_sets):
        
        return self.db.sunion([self.key] + [s.key for s in other_sets])
402031
protected final Set<?> set(Object... datas) {
    Set<Object> items = CollectUtils.newHashSet();
    for (Object obj : datas) {
      if (obj instanceof Class<?>) {
        items.add(buildInnerReference((Class<?>) obj));
      } else {
        items.add(obj);
      }
    }
    return items;
  }
1037757
public static <K, V> void putSetMult(Map<K, Set<V>> map, K key,
            Collection<? extends V> values) {
        for (V value : values) {
            putSet(map, key, value);
        }
    }
642138
public VarSetBuilder members( Stream<IVarDef> members)
    {
    members.forEach( member -> varSet_.addMember( member));
    return this;
    }
493048
public static IntSet or (IntSet... sets)
    {
        checkNotNull(sets);
        IntSet result = create();
        for (IntSet set : sets) {
            result.addAll(set);
        }
        return result;
    }
1059266
public static <T> Set<T> toSet(Iterable<T> items) {
    Set<T> set = new HashSet<T>();
    addAll(set, items);
    return set;
  }
1026104
private void createNonPersistentSubsets()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(this, tc, "createNonPersistentSubsets");
    
    for(int i=0; i<subsets.length; i++)
    {
      createNonPersistentSubset(getReliability(i));
    }
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "createNonPersistentSubsets");
  }
495926
public static function union(Set $a, Set $b) : Set
    {
        return new self(array_merge($a->toArray(), $b->toArray()));
    }
498804
@Nonnull
    public static <E> Set<E> union(@Nullable final Set<E> pColl1, @Nullable final Set<E> pColl2)
    {
        final Set<E> result = new HashSet<>();
        if (pColl1 != null) {
            result.addAll(pColl1);
        }
        if (pColl2 != null) {
            result.addAll(pColl2);
        }
        return Collections.unmodifiableSet(result);
    }
11255
public static <T> Set<T> union(Set<T> setA, Set<T> setB) {
        Set<T> union = new HashSet<T>(setA);
        union.addAll(setB);
        return union;
    }
1179567
private SortedSet<String> mergeSets(SortedSet<String> primary, Set<String> secondary) {
    SortedSet<String> result = primary;
    if (!secondary.isEmpty()) {
      result = new TreeSet<>();
      result.addAll(primary);
      result.addAll(secondary);
    }
    return result;
  }
484541
public ClassInfoList union(final ClassInfoList... others) {
        final Set<ClassInfo> reachableClassesUnion = new LinkedHashSet<>(this);
        final Set<ClassInfo> directlyRelatedClassesUnion = new LinkedHashSet<>(directlyRelatedClasses);
        for (final ClassInfoList other : others) {
            reachableClassesUnion.addAll(other);
            directlyRelatedClassesUnion.addAll(other.directlyRelatedClasses);
        }
        return new ClassInfoList(reachableClassesUnion, directlyRelatedClassesUnion, sortByName);
    }
1161265
public static <T> Set<T> iterableToSet(Iterable<T> iterable) {
        if (iterable == null) {
            return Collections.emptySet();
        }
        if (iterable instanceof Set) {
            return (Set<T>) iterable;
        }
        Iterator<T> i = iterable.iterator();
        if (i.hasNext()) {
            Set<T> list = new HashSet<>();
            while (i.hasNext()) {
                list.add(i.next());
            }
            return list;
        }
        return Collections.emptySet();
    }
1247370
def members(self, as_set=False):
        """"""
        if as_set:
            return frozenset(map(self._members.__getitem__, self._indexes()))
        return tuple(map(self._members.__getitem__, self._indexes()))
318976
@Override
  public void fillAssignedKeys(Set<String> keys)
  {
    TreeSet<String> subKeys = new TreeSet<>();
    
    for (ExprKraken expr : _exprs) {
      subKeys.clear();
      
      expr.fillAssignedKeys(subKeys);
      
      keys.addAll(subKeys);
    }
  }