Add binding arguments to the runtime list.
345483
def append_volume(runtime, source, target, writable=False):
        # type: (List[Text], Text, Text, bool) -> None
        """"""
        runtime.append(u"--volume={}:{}:{}".format(
            docker_windows_path_adjust(source), target,
            "rw" if writable else "ro"))
989755
private void _buildLogicalBinding(
                    final LogicalBinding binding,
                    final StringBuilder stmt,
                    final List<Object> params
                    )
    {
        final int  size = binding.size();

        if (size < 2) {
            throw new IllegalArgumentException(
                            "LogicalBinding with less than two element bindings" );
        }

        final String  logic = (binding instanceof AndBinding) ? _AND_ : _OR_;
        stmt.append( " (" );
        for (int  i = 0; i < size; i++) {
            if (i > 0) {
                stmt.append( logic );
            }
            _buildBinding( binding.getElementAt( i ), stmt, params );
        }
        stmt.append( ")" );
    }
511354
def add_properties_callbacks(cls):
    """"""
    for name in cls._mutators:                                                 #pylint: disable=protected-access
        if not hasattr(cls, name):
            continue
        setattr(cls, name, properties_mutator(cls, name))
    for name in cls._operators:                                                #pylint: disable=protected-access
        if not hasattr(cls, name):
            continue
        setattr(cls, name, properties_operator(cls, name))
    for name in cls._ioperators:                                               #pylint: disable=protected-access
        if not hasattr(cls, name):
            continue
        setattr(cls, name, properties_mutator(cls, name, True))
    return cls
521976
def _namify_arguments(mapping):
    
    result = []
    for name, parameter in mapping.iteritems():
        parameter.name = name
        result.append(parameter)
    return result
614367
private List<String> binds() {
    final ImmutableList.Builder<String> binds = ImmutableList.builder();
    for (final Map.Entry<String, String> entry : job.getVolumes().entrySet()) {
      final String path = entry.getKey();
      final String source = entry.getValue();
      if (Strings.isNullOrEmpty(source)) {
        continue;
      }
      binds.add(source + ":" + path);
    }
    return binds.build();
  }
486985
void add(final Argument argument) {
        if (argument != null) {
            if (argument.multipleValuesAllowed()) {
                Collection<Argument> arguments = map.get(argument.getKey());
                if (arguments == null) {
                    arguments = new ArrayList<>();
                    map.put(argument.getKey(), arguments);
                }
                arguments.add(argument);
            } else {
                set(argument);
            }
        }
    }
1116301
private List<P> createBindableParameters() {

        List<P> bindables = new ArrayList<>(parameters.size());

        for (P parameter : parameters) {
            if (parameter.isBindable()) {
                bindables.add(parameter);
            }
        }

        return bindables;
    }
615458
public void fillArguments(@Nonnull @MustNotContainNull final List<ExpressionTree> arguments) {
    assertNotEmptySlot();

    if (arguments == null) {
      throw new PreprocessorException("[Expression]Argument list is null", this.sourceString, this.includeStack, null);
    }

    if (childElements.length != arguments.size()) {
      throw new PreprocessorException("Wrong argument list size", this.sourceString, this.includeStack, null);
    }

    int i = 0;
    for (ExpressionTree arg : arguments) {
      if (arg == null) {
        throw new PreprocessorException("[Expression]Argument [" + (i + 1) + "] is null", this.sourceString, this.includeStack, null);
      }

      if (!childElements[i].isEmptySlot()) {
        throw new PreprocessorException("[Expression]Non-empty slot detected, it is possible that there is a program error, contact a developer please", this.sourceString, this.includeStack, null);
      }

      final ExpressionTreeElement root = arg.getRoot();
      if (root.isEmptySlot()) {
        throw new PreprocessorException("[Expression]Empty argument [" + (i + 1) + "] detected", this.sourceString, this.includeStack, null);
      }
      childElements[i] = root;
      root.parentTreeElement = this;

      i++;
    }
  }
958999
protected void applyContext( ShuttleListBinding binding, Map context ) {
        if( context.containsKey(MODEL_KEY) ) {
            binding.setModel((ListModel) context.get(MODEL_KEY));
        }
        if( context.containsKey(SELECTABLE_ITEMS_HOLDER_KEY) ) {
            binding.setSelectableItemsHolder((ValueModel) context.get(SELECTABLE_ITEMS_HOLDER_KEY));
        }
        if( context.containsKey(SELECTED_ITEMS_HOLDER_KEY) ) {
            binding.setSelectedItemsHolder((ValueModel) context.get(SELECTED_ITEMS_HOLDER_KEY));
        }
        if( context.containsKey(RENDERER_KEY) ) {
            binding.setRenderer((ListCellRenderer) context.get(RENDERER_KEY));
        }
        if( context.containsKey(COMPARATOR_KEY) ) {
            binding.setComparator((Comparator) context.get(COMPARATOR_KEY));
        }
        if( context.containsKey(SELECTED_ITEM_TYPE_KEY) ) {
            binding.setSelectedItemType((Class) context.get(SELECTED_ITEM_TYPE_KEY));
        }
        if( context.containsKey(FORM_ID) ) {
            binding.setFormId((String) context.get(FORM_ID));
        }
    }
563764
def _bind(self, args, kwargs, partial=False):
        """"""

        arguments = OrderedDict()

        parameters = iter(self.parameters.values())
        parameters_ex = ()
        arg_vals = iter(args)

        if partial:
            # Support for binding arguments to 'functools.partial' objects.
            # See 'functools.partial' case in 'signature()' implementation
            # for details.
            for param_name, param in self.parameters.items():
                if param._partial_kwarg and param_name not in kwargs:
                    # Simulating 'functools.partial' behavior
                    kwargs[param_name] = param.default

        while True:
            # Let's iterate through the positional arguments and corresponding
            # parameters
            try:
                arg_val = next(arg_vals)
            except StopIteration:
                # No more positional arguments
                try:
                    param = next(parameters)
                except StopIteration:
                    # No more parameters. That's it. Just need to check that
                    # we have no `kwargs` after this while loop
                    break
                else:
                    if param.kind == _VAR_POSITIONAL:
                        # That's OK, just empty *args.  Let's start parsing
                        # kwargs
                        break
                    elif param.name in kwargs:
                        if param.kind == _POSITIONAL_ONLY:
                            msg = (
                                "{arg!r} parameter is positional only, "
                                "but was passed as a keyword"
                            )
                            msg = msg.format(arg=param.name)
                            raise TypeError(msg)
                        parameters_ex = (param,)
                        break
                    elif param.kind == _VAR_KEYWORD or param.default is not _empty:
                        # That's fine too - we have a default value for this
                        # parameter.  So, lets start parsing `kwargs`, starting
                        # with the current parameter
                        parameters_ex = (param,)
                        break
                    else:
                        if partial:
                            parameters_ex = (param,)
                            break
                        else:
                            msg = "{arg!r} parameter lacking default value"
                            msg = msg.format(arg=param.name)
                            raise TypeError(msg)
            else:
                # We have a positional argument to process
                try:
                    param = next(parameters)
                except StopIteration:
                    raise TypeError("too many positional arguments")
                else:
                    if param.kind in (_VAR_KEYWORD, _KEYWORD_ONLY):
                        # Looks like we have no parameter for this positional
                        # argument
                        raise TypeError("too many positional arguments")

                    if param.kind == _VAR_POSITIONAL:
                        # We have an '*args'-like argument, let's fill it with
                        # all positional arguments we have left and move on to
                        # the next phase
                        values = [arg_val]
                        values.extend(arg_vals)
                        arguments[param.name] = tuple(values)
                        break

                    if param.name in kwargs:
                        raise TypeError(
                            "multiple values for argument "
                            "{arg!r}".format(arg=param.name)
                        )

                    arguments[param.name] = arg_val

        # Now, we iterate through the remaining parameters to process
        # keyword arguments
        kwargs_param = None
        for param in itertools.chain(parameters_ex, parameters):
            if param.kind == _POSITIONAL_ONLY:
                # This should never happen in case of a properly built
                # Signature object (but let's have this check here
                # to ensure correct behaviour just in case)
                raise TypeError(
                    "{arg!r} parameter is positional only, "
                    "but was passed as a keyword".format(arg=param.name)
                )

            if param.kind == _VAR_KEYWORD:
                # Memorize that we have a '**kwargs'-like parameter
                kwargs_param = param
                continue

            param_name = param.name
            try:
                arg_val = kwargs.pop(param_name)
            except KeyError:
                # We have no value for this parameter.  It's fine though,
                # if it has a default value, or it is an '*args'-like
                # parameter, left alone by the processing of positional
                # arguments.
                if (
                    not partial
                    and param.kind != _VAR_POSITIONAL
                    and param.default is _empty
                ):
                    raise TypeError(
                        "{arg!r} parameter lacking default value".format(arg=param_name)
                    )

            else:
                arguments[param_name] = arg_val

        if kwargs:
            if kwargs_param is not None:
                # Process our '**kwargs'-like parameter
                arguments[kwargs_param.name] = kwargs
            else:
                raise TypeError("too many keyword arguments")

        return self._bound_arguments_cls(self, arguments)
624442
private void bindButtonEnabling() {
        final BooleanBinding bexpr = new BooleanBinding() {

            @Override
            protected boolean computeValue() {
                return !(object().sourcePath() != null && object().sourcePath().exists() && object().sourcePath().isDirectory()
                        && object().targetPath() != null && object().targetPath().exists() && object().targetPath().isDirectory());
            }
        };

        final ChangeListener<File> cl = new ChangeListener<File>() {

            @Override
            public void changed(final ObservableValue<? extends File> observable, final File oldValue, final File newValue) {
                bexpr.invalidate();
            }
        };

        object().pSourcePath().addListener(cl);
        object().pTargetPath().addListener(cl);

        view().getStartButton().disableProperty().bind(bexpr);

        final SimpleListProperty<FileComparison> filteredListProperty = new SimpleListProperty<>(view().getTable().getItems());
        view().getExportCSV().disableProperty().bind(filteredListProperty.emptyProperty());

        final SimpleListProperty<FileComparison> listProperty = new SimpleListProperty<>(object().pLastResult());
        view().getMissing().disableProperty().bind(listProperty.emptyProperty());
        view().getDowngraded().disableProperty().bind(listProperty.emptyProperty());
        view().getNewer().disableProperty().bind(listProperty.emptyProperty());
        view().getSame().disableProperty().bind(listProperty.emptyProperty());
        view().getUpdated().disableProperty().bind(listProperty.emptyProperty());
        view().getUpgraded().disableProperty().bind(listProperty.emptyProperty());
    }
1171077
private void _buildInBinding(
                    final InBinding binding,
                    final StringBuilder stmt,
                    final List<Object> params
                    )
    {
        // It's OK if null is contained.
//        if (n_values == 0) {
//            throw new SearchException( "invalid InBinding: empty value list" );
//        }


        // T.p
        _buildProperty( binding.getProperty(), stmt );
        //throws SearchException

        // T.p IN LIST(
        stmt.append( _IN_LIST_ ).append( "(" );

        // T.p IN LIST(v_1, v_2, ..., v_n
        boolean  containsNull = false;
        int  n_valuesAdded = 0;

        for (Object  value : binding.getValues()) {
            if (value == null) {
                containsNull = true;
            } else {
                if (n_valuesAdded > 0) {
                    stmt.append( "," );
                }
                _buildParameter( value, stmt, params );
                n_valuesAdded++;
            }
        }

        if (binding.isNullContained()  ||  containsNull) {
            if (n_valuesAdded > 0) {
                stmt.append( "," );
            }
            // T.p IN LIST(v_1, v_2, ..., v_n, nil
            stmt.append( _NIL_ );
        }

        // T.p IN LIST(v_1, v_2, ..., v_n)
        stmt.append( ")" );
    }
743231
protected void addArg(Object value) {
        if (value instanceof Enum) {
            value = ((Enum<?>) value).name();
        }
        args.add(value);
    }
523877
protected function bindNamedParameters(): void
    {
        foreach ($this->getValues() as $key => $value) {
            $value = $this->toScalar($value);
            $this->getWrappedStatement()->bindValue(sprintf(':%s', $key), $value, $this->getPdoType($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")
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);
    }
  }
532328
public void addArgAttrs(List<Attribute> result) {
        int i;
        int max;
        Alternative ab;

        max = alternatives.size();
        for (i = 0; i < max; i++) {
            ab = alternatives.get(i);
            ab.addArgAttrs(result);
        }
    }