Adds the given once-only tuples to this combiner.
483091
public TupleCombinerBuilder once( TupleRef... tupleRefs)
    {
    for( TupleRef tupleRef : tupleRefs)
      {
      tupleCombiner_.addOnceTuple( tupleRef);
      }
    return this;
    }
1000721
public final <T3> Tuple3<T1, T2, T3> concat(T3 value) {
        return new Tuple3<>(v1, v2, value);
    }
750579
def set_combiner(value, mutator, *args, **kwargs):
    
    value.add(mutator(*args, **kwargs))
    return value
188213
@SuppressWarnings("unchecked")
        public <Coll extends CollectionFuncSup<T>> Coll add(T t) {
                Collection<T> coll = (Collection<T>) iterable;
                coll.add(t);
                return (Coll) this;
        }
414975
public void addSubtypes(NamedType... subtypes) {

    if (this.subtypeList == null) {
      this.subtypeList = new ArrayList<>();
    }
    this.subtypeList.addAll(Arrays.asList(subtypes));
  }
417865
public void addMultipleItems(int times, final Object... values) {
		for (int i = 0; i < times; i++) {
            addItemAsArray(values);
        }
	}
566973
public void addAll(T... items) {
        synchronized (mLock) {
            if (mOriginalValues != null) {
                Collections.addAll(mOriginalValues, items);
            } else {
                Collections.addAll(mObjects, items);
            }
        }
        if (mNotifyOnChange) notifyDataSetChanged();
    }
148295
def add(self, k, count=1):
        
        self.counts[k] += count
        self.total += count
856720
private static TupleCombiner asCombiner( JsonObject json)
    {
    try
      {
      TupleCombiner tupleCombiner = new TupleCombiner();

      Optional.ofNullable( json.getJsonNumber( TUPLES_KEY))
        .ifPresent( n -> tupleCombiner.setTupleSize( n.intValue()));

      Optional.ofNullable( json.getJsonArray( INCLUDE_KEY))
        .map( includes -> includes.getValuesAs( JsonString.class).stream())
        .orElse( Stream.empty())
        .map( JsonString::getString)
        .forEach( var -> {
          try
            {
            try
              {
              tupleCombiner.addIncludedVar( var);
              }
            catch( Exception e)
              {
              throw new GeneratorSetException( e.getMessage());
              }
            }
          catch( Exception e)
            {
            throw new GeneratorSetException( "Error defining included variables", e);
            }
          });

      Optional.ofNullable( json.getJsonArray( EXCLUDE_KEY))
        .map( excludes -> excludes.getValuesAs( JsonString.class).stream())
        .orElse( Stream.empty())
        .map( JsonString::getString)
        .forEach( var -> {
          try
            {
            try
              {
              tupleCombiner.addExcludedVar( var);
              }
            catch( Exception e)
              {
              throw new GeneratorSetException( e.getMessage());
              }
            }
          catch( Exception e)
            {
            throw new GeneratorSetException( "Error defining excluded variables", e);
            }
          });

      Optional.ofNullable( json.getJsonArray( ONCE_KEY))
        .map( onceTuples -> onceTuples.getValuesAs( JsonObject.class).stream())
        .orElse( Stream.empty())
        .forEach( onceTuple -> {
          try
            {
            try
              {
              tupleCombiner.addOnceTuple( asTupleRef( onceTuple));
              }
            catch( Exception e)
              {
              throw new GeneratorSetException( e.getMessage());
              }
            }
          catch( Exception e)
            {
            throw new GeneratorSetException( "Error defining once tuples", e);
            }
          });


      return tupleCombiner;
      }
    catch( GeneratorSetException e)
      {
      throw new GeneratorSetException( "Error defining combiner", e);
      }
    }
1097821
public final <T2, T3> Tuple3<T1, T2, T3> concat(Tuple2<T2, T3> tuple) {
        return new Tuple3<>(v1, tuple.v1, tuple.v2);
    }
236515
public final <T5> Tuple5<T1, T2, T3, T4, T5> concat(Tuple1<T5> tuple) {
        return new Tuple5<>(v1, v2, v3, v4, tuple.v1);
    }
714629
public static FilterParams fromTuples(Object... tuples) {
		StringValueMap map = StringValueMap.fromTuplesArray(tuples);
		return new FilterParams(map);
	}
818104
public static <L, R> Tuple<L, R> newTuple (L left, R right)
    {
        return new Tuple<L, R>(left, right);
    }
246031
public int addAll(Iterable<? extends KTypeCursor<? extends KType>> iterable) {
    int size = 0;
    for (KTypeCursor<? extends KType> cursor : iterable) {
      add(cursor.value);
      size++;
    }
    return size;
  }
1239804
public int addLast(Iterable<? extends KTypeCursor<? extends KType>> iterable) {
    int size = 0;
    for (KTypeCursor<? extends KType> cursor : iterable) {
      addLast(cursor.value);
      size++;
    }
    return size;
  }
1210440
private Set<Tuple> getOnceTupleDefs( final List<VarDef> combinedVars)
    {
    try
      {
      return
        new HashSet<Tuple>(
          IteratorUtils.toList(
            IteratorUtils.transformedIterator(
              getOnceTuples(),
              tupleRef -> toTuple( combinedVars, tupleRef))));
      }
    catch( Exception e)
      {
      throw new IllegalStateException( "Invalid once-only tuple definition", e);
      }
    }
426149
public Tuple addAll( Tuple tuple)
    {
    if( tuple != null)
      {
      for( Iterator<VarBindingDef> bindings = tuple.getBindings(); bindings.hasNext();)
        {
        add( bindings.next());
        }
      }

    return this;
    }