Adds a binding to this tuple.
185221
public Tuple add( VarBindingDef binding)
    {
    if( binding != null)
      {
      VarDef var = binding.getVarDef();
      if( var == null)
        {
        throw new IllegalArgumentException( "Invalid binding=" + binding + ": variable undefined");
        }

      VarValueDef value = binding.getValueDef();
      if( value == null)
        {
        throw new IllegalArgumentException( "Invalid binding=" + binding + ": value undefined");
        }
      
      remove( var);

      bindings_.put( var, binding);
      properties_.addAll( value.getProperties().iterator());
      }

    return this;
    }
1126670
public void add(int var, Type t) {
    Set<Integer> tVars = t.getTypeVariables();
    Set<Integer> intersection = Sets.intersection(tVars, bindings.keySet());
    Preconditions.checkArgument(intersection.size() == 0,
        "Tried to replace %s with %s, but already have bindings for %s", var, t, intersection);
    Preconditions.checkArgument(!tVars.contains(var),
        "Recursive replacement: tried to replace %s with %s", var, t);
    
    Map<Integer, Type> newBinding = Maps.newHashMap();
    newBinding.put(var, t);
    for (int boundVar : bindings.keySet()) {
      bindings.put(boundVar, bindings.get(boundVar).substitute(newBinding));
    }
    bindings.put(var, t);
  }
369958
def set_bind(self):
        
        FloatEntry.set_bind(self)
        self.bind('<Next>', lambda e: self.set(self.fmin))
        self.bind('<Prior>', lambda e: self.set(self.fmax))
960979
public <T extends Sink> void addSinkType(String typeName, Class<T> sinkClass) {
        LOG.info("Adding sinkType: " + typeName + " -> " + sinkClass.getCanonicalName());
        
        Multibinder<TypeHolder> bindings
            = Multibinder.newSetBinder(binder(), TypeHolder.class);
        bindings.addBinding().toInstance(new TypeHolder(typeName, sinkClass));
    }
487002
public function add(Bind $bind)
    {
        $dependency = $bind->getBound();
        $dependency->register($this->container, $bind);
    }
1175144
def addBinding(self, node, value):
        
        # assert value.source in (node, node.parent):
        for scope in self.scopeStack[::-1]:
            if value.name in scope:
                break
        existing = scope.get(value.name)

        if (existing and not isinstance(existing, Builtin) and
                not self.differentForks(node, existing.source)):

            parent_stmt = self.getParent(value.source)
            if isinstance(existing, Importation) and isinstance(parent_stmt, FOR_TYPES):
                self.report(messages.ImportShadowedByLoopVar,
                            node, value.name, existing.source)

            elif scope is self.scope:
                if (isinstance(parent_stmt, ast.comprehension) and
                        not isinstance(self.getParent(existing.source),
                                       (FOR_TYPES, ast.comprehension))):
                    self.report(messages.RedefinedInListComp,
                                node, value.name, existing.source)
                elif not existing.used and value.redefines(existing):
                    if value.name != '_' or isinstance(existing, Importation):
                        if not is_typing_overload(existing, self.scopeStack):
                            self.report(messages.RedefinedWhileUnused,
                                        node, value.name, existing.source)

            elif isinstance(existing, Importation) and value.redefines(existing):
                existing.redefined.append(node)

        if value.name in self.scope:
            # then assume the rebound name is used as a global or within a loop
            value.used = self.scope[value.name].used

        self.scope[value.name] = value
809925
public Binder append(Class<?> type, Object value) {
        return new Binder(this, new Insert(type().parameterCount(), new Class[]{type}, value));
    }
212714
public void addBinding(Property<?> value) {
    if (value.getName() == null || value.getName().isEmpty()) {
      throw new IllegalArgumentException("property name must not be empty");
    }
    getBindings().put(value.getName(), value);
  }
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")
221998
def extend(self, *bindings):
        
        self._bindings.extend(self._preprocess(bindings))
        return self
831804
protected void addCustomBindings(final DocWorkUnit currentWorkUnit) {
        final String tagFilterPrefix = getTagPrefix();
        Arrays.stream(currentWorkUnit.getClassDoc().inlineTags())
                .filter(t -> t.name().startsWith(tagFilterPrefix))
                .forEach(t -> currentWorkUnit.setProperty(t.name().substring(tagFilterPrefix.length()), t.text()));
    }
1299811
public ConditionalMultibind<T> addBinding(TypeLiteral<T> target)
  {
    multibinder.addBinding().to(target);
    return this;
  }
309464
def bind_to_instance(self, instance):
        
        self.binding = instance
        self.middleware.append(instance)
956040
public void add(T value) {
        Element<T> element = new Element<T>(bundle, value);
        element.previous = tail;
        if (tail != null) tail.next = element;
        tail = element;
        if (head == null) head = element;
    }
5757
public Binder append(Class<?>[] types, Object... values) {
        return new Binder(this, new Insert(type().parameterCount(), types, values));
    }
411916
private void insert(String binding) {
		currentInput.insert(cursorPos, binding);
		cursorPos += binding.length();

		// reset view
		resetMainPart();
	}
309402
public TupleCombiner addOnceTuple( TupleRef tupleRef)
    {
    if( tupleRef != null)
      {
      if( tupleRef.size() != getTupleSize())
        {
        throw new IllegalArgumentException( "Once-only tuple=" + tupleRef + " has size=" + tupleRef.size() + ", expected size=" + getTupleSize());
        }
      onceTuples_.add( tupleRef);
      }
    
    return this;
    }