Add the given {@link TupleCombiner} instances to this generator.
431501
public TupleGeneratorBuilder combiners( TupleCombiner... combiners)
    {
    for( TupleCombiner combiner : combiners)
      {
      tupleGenerator_.addCombiner( combiner);
      }
    return this;
    }
309375
public void addNodes(NodeIterator iterator)
  {

    if (!m_mutable)
      throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");

    if (null != iterator)  // defensive to fix a bug that Sanjiva reported.
    {
      Node obj;

      while (null != (obj = iterator.nextNode()))
      {
        addElement(obj);
      }
    }

    // checkDups();
  }
789936
public void addTupleInput(Path path, Schema targetSchema, TupleMapper<ITuple, NullWritable> tupleMapper) {
		addInput(path, new TupleInputFormat(targetSchema), tupleMapper);
	}
1150779
def _multi_blockify(tuples, dtype=None):
    

    # group by dtype
    grouper = itertools.groupby(tuples, lambda x: x[2].dtype)

    new_blocks = []
    for dtype, tup_block in grouper:

        values, placement = _stack_arrays(list(tup_block), dtype)

        block = make_block(values, placement=placement)
        new_blocks.append(block)

    return new_blocks
700252
public UnionTypeBuilder addAlternates(ImmutableList<JSType> list) {
    for (int i = 0; i < list.size(); i++) {
      addAlternate(list.get(i));
    }
    return this;
  }
885739
@Override
	public boolean addAll(Collection<? extends E> c) {
		if(c.isEmpty()) return false;
		combine();
		if(combined==null) {
			combined = new HashSet<>(c);
			return true;
		} else {
			return combined.addAll(c);
		}
	}
1337699
private Tuple toTuple( List<VarDef> combinedVars, TupleRef tupleRef)
    {
    if( tupleRef.size() != getTupleSize())
      {
      throw new IllegalStateException( String.valueOf( tupleRef) + " does not match combiner tuple size=" + getTupleSize());
      }

    Tuple tuple = new Tuple();
    for( Iterator<VarBinding> bindings = tupleRef.getVarBindings(); bindings.hasNext(); )
      {
      VarBinding binding = bindings.next();
      VarDef var = findVarPath( combinedVars, binding.getVar());
      if( var == null)
        {
        throw new IllegalStateException( "Var=" + binding.getVar() + " is not included in this combination");
        }

      VarValueDef value = var.getValue( binding.getValue());
      if( value == null)
        {
        throw new IllegalStateException( "Value=" + binding.getValue() + " is not defined for var=" + binding.getVar());
        }

      if( !value.isValid())
        {
        throw new IllegalStateException( "Value=" + binding.getValue() + " is a failure value for var=" + binding.getVar());
        }

      tuple.add( new VarBindingDef( var, value));
      }

    return tuple;
    }
476655
private void addPairs() {
		GvmCluster<S,K> cj = clusters[count];
		int c = count - 1; //index at which new pairs registered for existing clusters
		for (int i = 0; i < count; i++) {
			GvmCluster<S,K> ci = clusters[i];
			GvmClusterPair<S,K> pair = new GvmClusterPair<S,K>(ci, cj);
			ci.pairs[c] = pair;
			cj.pairs[i] = pair;
			pairs.add(pair);
		}
		
	}
452273
public static <T1, T2, T3> Tuple3<T1, T2, T3> tuple(T1 v1, T2 v2, T3 v3) {
        return new Tuple3<>(v1, v2, v3);
    }
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);
      }
    }
336698
public AggGroupSet addGroupSet() {
        AggGroupSet aggGroupSet = new AggGroupSet();
        if (m_groupSetList == null) {
            m_groupSetList = new ArrayList<AggGroupSet>();
        }
        m_groupSetList.add(aggGroupSet);
        return aggGroupSet;
    }
750579
def set_combiner(value, mutator, *args, **kwargs):
    
    value.add(mutator(*args, **kwargs))
    return value
947513
public static <T> boolean addAll(Collection<T> target, Iterable<? extends T> iterable) {
        if (iterable instanceof Collection) {
            return target.addAll((Collection<? extends T>) iterable);
        }
        return Iterators.addAll(target, iterable.iterator());
    }
303939
private CompositeExecutionContext addAll(List<ExecutionContext> contexts) {
        this.elements = new ImmutableList.Builder().addAll(contexts).build();
        return this;
    }
427568
public static Tuple of( Collection<VarBindingDef> tupleBindings)
    {
    Tuple tuple = new Tuple();
    
    boolean bindingsCompatible;
    Iterator<VarBindingDef> bindings;
    VarBindingDef nextBinding;
    for( bindings = tupleBindings.iterator(),
           bindingsCompatible = true; 

         bindings.hasNext()
           && (bindingsCompatible = isBindingCompatible( tuple, (nextBinding = bindings.next())));

         tuple.add( nextBinding));
    
    return
      bindingsCompatible && tuple.isCompatible()
      ? tuple
      : null;
    }
1259439
@Override
    public void add(Iterable<? extends Statement> statements, Resource... contexts) throws RepositoryException {
        Iterator <? extends Statement> iter = statements.iterator();
        while(iter.hasNext()){
            Statement st = iter.next();
            add(st, mergeResource(st.getContext(), contexts));
        }
    }
711350
public void setCombiners( List<TupleCombiner> combiners)
    {
    combiners_ = new ArrayList<TupleCombiner>();
    if( combiners != null)
      {
      combiners_.addAll( combiners);
      }
    }