Store the given custom value and call the setter function.
188757
def call_fset(self, obj, value) -> None:
        """"""
        vars(obj)[self.name] = self.fset(obj, value)
479933
public <T> void putCustom(String key, T value) {
        custom.put(key, value);
    }
149614
def set_value(self, value):
        
        parsed_value = self._parse_value(value)
        self.value = parsed_value
1255161
def _set_value(self, entity, value):
    """"""
    if value is not None:
      value = _validate_key(value, entity=entity)
      value = entity._validate_key(value)
    entity._entity_key = value
220428
def setnx(self, key, value):
        """"""
        fut = self.execute(b'SETNX', key, value)
        return wait_convert(fut, bool)
1095931
def set(self, key, value):
        """"""
        self.store[key]=value
        return self.store
988858
function(initialValue, settings) {

		this.value = initialValue;

		this._set = settings.set || this._set;
		this._get = settings.get || this._get;

		// This allows updater to be called without any arguments.
		// selfUpdater flag can be set by things that want to call updater themselves.
		if(!settings.__selfUpdater) {
			var self = this,
				oldUpdater = this.updater;
			this.updater = function() {
				oldUpdater.call(self, self._get(), self.value);
			};
		}


		this._on = settings.on ? settings.on : this._on;
		this._off = settings.off ? settings.off : this._off;
	}
278729
function(value) {
                this.lastValue = this.currentValue;
                this.currentValue = value;
                this.setter.call(this.target, this.target, value, this);
            }
724558
def setattr(self, attr, new_value, close_the_changeset=True):
        """"""
        existing_value = getattr(self, attr, None)
        if existing_value != new_value:
            setattr(self, attr, new_value)
            self._changeset[attr] = new_value

        if close_the_changeset and self._changeset:
            self._call_callbacks()
109493
def setValue(self, key, value):
        
        curr = self._stack[-1]
        curr[key] = value
546831
function set(name, value) {
    validateArgumentsLength(arguments.length, 1);
    var state = getInternalParamsState(this);
    var entries = state.entries;
    var found = false;
    var key = name + '';
    var val = value + '';
    var i = 0;
    var entry;
    for (; i < entries.length; i++) {
      entry = entries[i];
      if (entry.key === key) {
        if (found) entries.splice(i--, 1);
        else {
          found = true;
          entry.value = val;
        }
      }
    }
    if (!found) entries.push({ key: key, value: val });
    if (state.updateURL) state.updateURL();
  }
273474
def set_value(self, obj, value):
        """"""
        if value:
            obj.set_field_value(self.name, value)
        else:
            self.delete_value(obj)
521647
def set(self, name, option, value):
        """"""
        fut = self.execute(b"SET", name, option, value)
        return wait_ok(fut)
941140
def do_set(self, args: argparse.Namespace) -> None:
        """"""

        # Check if param was passed in
        if not args.param:
            return self.show(args)
        param = utils.norm_fold(args.param.strip())

        # Check if value was passed in
        if not args.value:
            return self.show(args, param)
        value = args.value

        # Check if param points to just one settable
        if param not in self.settable:
            hits = [p for p in self.settable if p.startswith(param)]
            if len(hits) == 1:
                param = hits[0]
            else:
                return self.show(args, param)

        # Update the settable's value
        current_value = getattr(self, param)
        value = utils.cast(current_value, value)
        setattr(self, param, value)

        self.poutput('{} - was: {}\nnow: {}\n'.format(param, current_value, value))

        # See if we need to call a change hook for this settable
        if current_value != value:
            onchange_hook = getattr(self, '_onchange_{}'.format(param), None)
            if onchange_hook is not None:
                onchange_hook(old=current_value, new=value)
1331447
def set_value(self, value):
        
        check_call(_LIB.MXProfileSetCounter(self.handle, int(value)))
25406
def set(self, value):
        '''
        
        '''
        with self._lock.exclusive:
            self._value = value
            return value
53957
def set(self, val, default=False, imported=False):
        
        if hasattr(self.validator, '__call__'):
            try:
                val = self.validator(val)
            except Exception as exc:
                raise type(exc)(
                    'Could not validate value for "%s" setting: %s' %
                    (self.name, exc)
                ) from None
        self.value = val
        self.imported = imported
        if default:
            self.default = val
        self.modified = True