Adds all bindings from the given tuple.
426149
public Tuple addAll( Tuple tuple)
    {
    if( tuple != null)
      {
      for( Iterator<VarBindingDef> bindings = tuple.getBindings(); bindings.hasNext();)
        {
        add( bindings.next());
        }
      }

    return this;
    }
949012
private void addTypeSubstitutions(Map<Wrapper<ExprNode>, SoyType> substitutionsToAdd) {
    for (Map.Entry<Wrapper<ExprNode>, SoyType> entry : substitutionsToAdd.entrySet()) {
      ExprNode expr = entry.getKey().get();
      // Get the existing type
      SoyType previousType = expr.getType();
      for (TypeSubstitution subst = substitutions; subst != null; subst = subst.parent) {
        if (ExprEquivalence.get().equivalent(subst.expression, expr)) {
          previousType = subst.type;
          break;
        }
      }

      // If the new type is different than the current type, then add a new type substitution.
      if (!entry.getValue().equals(previousType)) {
        substitutions = new TypeSubstitution(substitutions, expr, entry.getValue());
      }
    }
  }
1126846
public void addAll(Map<K, V> m) {
    if (m instanceof CollectionValuedMap<?, ?>) {
      throw new UnsupportedOperationException();
    }
    for (Map.Entry<K, V> e : m.entrySet()) {
      add(e.getKey(), e.getValue());
    }
  }
465441
private <T> void addBinding(Class<T> type, BindingAmp<T> binding)
  {
    synchronized (_bindingSetMap) {
      BindingSet<T> set = (BindingSet) _bindingSetMap.get(type);

      if (set == null) {
        set = new BindingSet<>(type);
        _bindingSetMap.put(type, set);
      }

      set.addBinding(binding);
    }
  }
714629
public static FilterParams fromTuples(Object... tuples) {
		StringValueMap map = StringValueMap.fromTuplesArray(tuples);
		return new FilterParams(map);
	}
307051
def add(self,attrlist,attrvalues):
        '''
        
        '''
        for i,d in enumerate(attrlist):
            self[d] = attrvalues[i]
1349654
public boolean add(final List<LongTuple<T>> list, boolean remove_added_elements) {
        return add(list, remove_added_elements, null);
    }
111593
public void addAll(ExampleSet data)
	{
		for (int i=0;i<data.size();i++)
			add(data.x(i), data.y(i), data.id(i));

	}
1064464
def add_bindict(self, items):
		
		if not isinstance(items, list):
			items = items.items()
		for key, value in items:
			self.add_net16string(key).add_net32string(value)
		return self.add(b"\x00\x00")
197449
def add_metadata(self, operands):
        
        if not isinstance(operands, (list, tuple)):
            raise TypeError("expected a list or tuple of metadata values, "
                            "got %r" % (operands,))
        operands = self._fix_metadata_operands(operands)
        key = tuple(operands)
        if key not in self._metadatacache:
            n = len(self.metadata)
            md = values.MDValue(self, operands, name=str(n))
            self._metadatacache[key] = md
        else:
            md = self._metadatacache[key]
        return md
172692
def _make_tuple(self, env):
    """"""
    t = runtime.Tuple(self, env, dict2tuple)
    # A tuple also provides its own schema spec
    schema = schema_spec_from_tuple(t)
    t.attach_schema(schema)
    return t
5757
public Binder append(Class<?>[] types, Object... values) {
        return new Binder(this, new Insert(type().parameterCount(), types, values));
    }
817240
@Override
	@SuppressWarnings("unchecked")
	public boolean addAll(Collection<? extends E> c) {
		if(c.isEmpty()) return false;
		if(c instanceof Set) return addAll((Set<? extends E>)c);
		else throw new UnsupportedOperationException("May only add sets");
	}
1270127
@Override
  public <T> Iterable<Binding<T>> bindings(Class<T> type)
  {
    BindingSet<T> set = (BindingSet) _bindingSetMap.get(type);

    if (set != null) {
      return (Iterable) set;
    }
    else {
      return Collections.EMPTY_LIST;
    }
  }
516154
def __wrap_with_tuple(self) -> tuple:
        """"""
        l = list()
        length = len(self.data)
        while self.idx < length:
            l.append(self.__parse())
        return tuple(l)
520802
public void addAll(IntBitSet set) {
        int i;

        if (set.data.length > data.length) {
            resize(set.data.length);
        }

        for (i = 0; i < set.data.length; i++) {
            data[i] |= set.data[i];
        }
    }
1257046
def add_attrs(self, *args, _order=[], **kwargs):
        
        for arg in args:
            if isinstance(arg, (tuple, list)):
                key, color = arg
                self.attrs[key] = (None, color)
            else:
                self.attrs[arg] = (None, None)
        if not _order:
            for key, value in kwargs.items():
                self.attrs[key] = (value, None)
        else:
            for key in _order:
                self.attrs[key] = (kwargs[key], None)