/* INPUT SETTER METHODS
***********************************************************************
420055
public function setInputAddress($name, $address, $populationType = NULL)
    {
        $input = $this->getInput($name);
        $input->address = $address;
        $input->populationType = $populationType;
        return $this;
    }
790524
protected function _setValue(&$input, $param)
    {
        $value = $param->value();
        if (!$param->isEmpty()) {
            $input['value'] = $value;
        } else {
            $input['value'] = '';
        }

        return $input;
    }
626546
function setAttributeValues(dom) {
  // List of input types here https://www.w3.org/TR/html5/forms.html#the-input-element

  // Limit scope to inputs only as textareas do not retain their value when cloned
  let elems = dom.find(
    `input[type=text], input[type=search], input[type=tel], input[type=url], input[type=email],
     input[type=password], input[type=number], input[type=checkbox], input[type=radio]`
  );

  percyJQuery(elems).each(function() {
    let elem = percyJQuery(this);
    switch(elem.attr('type')) {
      case 'checkbox':
      case 'radio':
        if (elem.is(':checked')) {
          elem.attr('checked', '');
        }
        break;
      default:
        elem.attr('value', elem.val());
    }
  });

  return dom;
}
585701
public function setInput($data, $encoding = '')
    {
        $this->_input    = $data;
        $this->_encoding = $encoding;
        $this->reset();
    }
970547
public void setInputs(Collection<String> inputs) {
    List<String> newInputs = new ArrayList<String>();
    if (inputs != null) {
      newInputs.addAll(inputs);
    }
    this.inputs = newInputs;
  }
810041
public function setInputData($inputData = array())
    {
        $this->inputData = $inputData;
        $this->logger->debug(__FUNCTION__, 'Input Data => ' . json_encode($this->inputData));

        return $this;
    }
394385
public function setInput($input)
    {
        $inputArray = explode(' ', $input);
        
        array_shift($inputArray);
        
        $this->input = join(' ', $inputArray);
    }
545750
function fixInputChange(input) {
    let files;
    Object.defineProperty(input, 'files', {
        set(v) { files = v; dispatchEvent(input, 'change'); },
        get(v) { return files }
    });
}
71002
public void setInput( I input ) {
		this.inputImage = input;

		// reset the state flag so that everything need sto be computed
		if( stale != null ) {
			for( int i = 0; i < stale.length; i++) {
				boolean a[] = stale[i];
				for( int j = 0; j < a.length; j++ ) {
					a[j] = true;
				}
			}
		}
	}
181524
function resetInput() {
  var $modal = getModal();
  var $input = getInput();

  _removeClass$getTopMargin$fadeIn$show$addClass.removeClass($modal, 'show-input');
  $input.value = '';
  $input.setAttribute('type', _defaultParams2['default'].inputType);
  $input.setAttribute('placeholder', _defaultParams2['default'].inputPlaceholder);

  resetInputError();
}
311086
function inputUserAttrs(name, inputAttrs) {
    const { class: classname, className, ...attrs } = inputAttrs
    let textAttrs = {
      id: name + '-' + data.lastID,
      title: attrs.description || attrs.label || name.toUpperCase(),
      name: name,
      type: attrs.type || 'text',
      className: [`fld-${name}`, (classname || className || '').trim()],
    }
    const label = `<label for="${textAttrs.id}">${i18n[name] || ''}</label>`

    const optionInputs = ['checkbox', 'checkbox-group', 'radio-group']
    if (!optionInputs.includes(textAttrs.type)) {
      textAttrs.className.push('form-control')
    }

    textAttrs = Object.assign({}, attrs, textAttrs)
    const textInput = `<input ${attrString(textAttrs)}>`
    const inputWrap = `<div class="input-wrap">${textInput}</div>`
    return `<div class="form-group ${name}-wrap">${label}${inputWrap}</div>`
  }
40304
public function set( $key, $value = null, $inputValidate = null )
    {

        // decide on the level of input validation
        if( $inputValidate === null ) {
            $inputValidate = static::$inputValidate;
        }

        // set a array / Symfony ParameterBag of properties
        if( is_array($key) || ( $key instanceof \Traversable ) ) {
            $numSet = 0;
            foreach( $key as $_key => $_value ) {
                $numSet += call_user_func( array($this,__FUNCTION__), $_key, $_value, $inputValidate ) ? 1 : 0;
            }
            return $numSet;
        }

        // readonly safety check
        if( $this->readOnlySafetyCheck() ) {
            return false;
        }

        // You can't set a objects id externally
        if( in_array( $key, static::$unsetableProperties ) ) {
            return false;
        }

        // late load. You can't set a property on a unloaded object
        $this->load();

        switch( true ) {

            // got key or we're configured to accept any inputs
            case $inputValidate === self::VALIDATE_DISABLE:
            case array_key_exists( $key, $this->data ):

                if( $value === '' ) {
                    $value = null;
                }

                // validate item ?
                // implementation undecided
                $callback = array( $this, "set_{$key}" );

                $value = is_callable( $callback )
                    ? call_user_func( $callback, $value, $inputValidate )
                    : $value
                    ;

                // anything changed?
                if( isset( $this->data[$key] ) and $this->data[$key] === $value ) {
                    return false;
                }

                $this->initalPropertySet( $key, $value );
                $this->data[$key] = $value;
                return true;

            // unknown property. Class configured to ignore.
            case $inputValidate === self::VALIDATE_STRIP:

                return false;

            // unknown property. Class configured for Exception.
            case $inputValidate === self::VALIDATE_EXCEPTION:

                throw new BadPropertyException( $key, $this, "set() VALIDATE_EXCEPTION." );

            // odd that we should have got this far.
            // debugging check - ensure $inputValidate is one of our allowed inputs
            case !in_array( $inputValidate, array( self::VALIDATE_DISABLE, self::VALIDATE_STRIP, self::VALIDATE_EXCEPTION ), true ):

                throw new \InvalidArgumentException("Bad argument `{$inputValidate}` argument passed to ->set(,,\$inputValidate);");
                return false;

        }

        return false;

    }
477413
public void setInput(INDArray input) {
        this.input = input;
        if (this.layers == null) {
            init();
        }
        if (input != null) {
            if (input.length() == 0)
                throw new IllegalArgumentException(
                        "Invalid input: length 0 (shape: " + Arrays.toString(input.shape()) + ")");

            // FIXME: int cast
            setInputMiniBatchSize((int) input.size(0));
        }
    }
350026
function fill(form_id, data) {
        this._checkInit(form_id);
        for (var input_name in data) {
            if (this._collection[form_id].has(input_name)) {
                this.set(form_id, input_name, data[input_name]);
            }
        }
    }
649065
function($input, settings_element) {
			var i, n, values, option;
	
			var data_raw = $input.attr(attr_data);
	
			if (!data_raw) {
				var value = $.trim($input.val() || '');
				if (!settings.allowEmptyOption && !value.length) return;
				values = value.split(settings.delimiter);
				for (i = 0, n = values.length; i < n; i++) {
					option = {};
					option[field_label] = values[i];
					option[field_value] = values[i];
					settings_element.options.push(option);
				}
				settings_element.items = values;
			} else {
				settings_element.options = JSON.parse(data_raw);
				for (i = 0, n = settings_element.options.length; i < n; i++) {
					settings_element.items.push(settings_element.options[i][field_value]);
				}
			}
		}
574811
function (name, value, oldValue) {
                this.$InputElement.onbind.apply(this, arguments);
                if (name === "value") {
                    value = (value != null) ? value + "" : "";
                    if (value) {
                        this._removePlaceholder();
                    }
                    this._domElt.value = value;
                    this._setPlaceholder();
                }
            }
791167
public void setInputUpdates(java.util.Collection<InputUpdate> inputUpdates) {
        if (inputUpdates == null) {
            this.inputUpdates = null;
            return;
        }

        this.inputUpdates = new java.util.ArrayList<InputUpdate>(inputUpdates);
    }