Assigns a new value to a Replicant.
@param replicant {object} - The Replicant to assign.
@param value {*} - The new value to assign.
333192
function assign(replicant, value) {
	const oldValue = replicant.value;
	replicant._ignoreProxy = true;
	replicant.__value = shared._proxyRecursive(replicant, value, '/');
	replicant._ignoreProxy = false;
	replicant.revision++;
	replicant.emit('change', value, oldValue);

	replicant.log.replicants('Assigned:', value);

	emitToClients(replicant.namespace, 'replicant:assignment', {
		name: replicant.name,
		namespace: replicant.namespace,
		newValue: value,
		revision: replicant.revision
	});

	saveReplicant(replicant);
}
363501
public void put(Interval1D<K> interval, V value) {
    Node<K, V> origNode = get(interval);
    if (origNode != null) {
      //System.err.println("Dupe is being put into the map. Interval: " + interval +
      //        "\n\tOld: " + origNode.getValue() + " New: " + value);
      origNode.setValue(value);
    } else {
      root = randomizedInsert(root, interval, value);
    }
  }
1208183
def set(self, prop, value):
        

        prop_parts = prop.split(".")
        if self.copy_dict:
            new_dict = copy.deepcopy(self.obj)
        else:
            new_dict = self.obj
        pointer = None
        parts_length = len(prop_parts) - 1
        for i, part in enumerate(prop_parts):
            if pointer is None and i == parts_length:
                new_dict[part] = value
            elif pointer is None:
                pointer = new_dict.get(part)
            elif i == parts_length:
                pointer[part] = value
            else:
                pointer = pointer.get(part)
        return new_dict
1083858
def update(self, value: Union[RawValue, Value],
               raw: bool = False) -> "InstanceNode":
        
        newval = self.schema_node.from_raw(
            value, self.json_pointer()) if raw else value
        return self._copy(newval)
102547
@Override
    public void set(String propName, Object value) {
        if (propName.equals("deleteDescendants")) {
            setDeleteDescendants(((Boolean) value));
        }
        if (propName.equals("returnDeleted")) {
            setReturnDeleted(((Boolean) value));
        }
        super.set(propName, value);
    }
1121207
function saveReplicant(replicant) {
	if (!replicant.opts.persistent) {
		return;
	}

	if (_pendingSave.has(replicant)) {
		return;
	}

	_pendingSave.add(replicant);
	replicant.log.replicants('Will persist value at end of current tick.');

	process.nextTick(() => {
		_pendingSave.delete(replicant);

		if (!replicant.opts.persistent) {
			return;
		}

		let {value} = replicant;
		if (typeof value === 'object') {
			value = JSON.stringify(value);
		} else if (typeof value === 'undefined') {
			value = '';
		}

		try {
			stores[replicant.namespace].setItem(`${replicant.name}.rep`, value);
			replicant.log.replicants('Value successfully persisted.');
		} catch (error) {
			replicant.log.error('Failed to persist value:', error);
		}
	});
}
420879
def set_value(self, visual_property, value):
        
        if visual_property is None or value is None:
            raise ValueError('Both VP and value are required.')

        new_value = [
            {
                'visualProperty': visual_property,
                "value": value
            }
        ]
        requests.put(self.url, data=json.dumps(new_value), headers=HEADERS)
816217
@ObjectiveCName("changeWithValue:")
    public boolean change(@Nullable T value) {
        if (this.value != null && value != null && value.equals(this.value)) {
            return false;
        }

        // No need in sync. We are not expected complex sync of value models
        this.value = value;

        notify(value);

        return true;
    }
1221639
protected void setInternalValue(String newValue, boolean repaintIsNotNeeded) {
        super.setInternalValue(newValue);
        extension.setSignature(newValue, changingVariables || repaintIsNotNeeded);
    }
1366251
function disableReplication (id, rev, opts0, callback0) {
    const { opts, callback } = getCallback(opts0, callback0)
    const req = {
      db: '_replicator',
      method: 'DELETE',
      path: id,
      qs: Object.assign(opts, { rev: rev })
    }
    return relax(req, callback)
  }
735091
@Override
    public void setValue(Object instance, String propertyName, Object value) {
        if (!isWriteIgnored(instance, propertyName)) {
            PropertyProxyUtils.getPropertyAccessor(this.conversionService, this.useDirectFieldAccess, instance).setPropertyValue(propertyName, value);
        }
    }
298160
private void setRealValue(String value) {

        if (!Objects.equal(value, m_realValue)) {
            m_realValue = value;
            ValueChangeEvent.fire(this, value);
        }
    }
612166
function setValue (obj, prop, value) {
  if (value !== undefined && obj[prop] === undefined) {
    obj[prop] = value
  }
}
734793
public void set(T value) {
        try {
            lock.writeLock().lock();

            this.value = value;
        } finally {
            lock.writeLock().unlock();
        }
    }
1352035
public void setValue(Object toEntity, Object newValue) throws IllegalAccessException,
            InvocationTargetException
    {
        Object propertyValue = getter.invoke(toEntity);
        if (propertyValue != null)
            nestedWriter.setValue(propertyValue, newValue);
    }
515400
function(value, salt) {
    Object.defineProperty(this, '_value', { value: new Uint8Array(value) });
    Object.defineProperty(this, '_salt', { value: new Uint8Array(salt) });
}
1286259
public void put(String id, Object value) {

    Object old = this.id2valueMap.put(id, value);
    if ((old != null) && (old != value)) {
      this.duplicateIdErrors.add(this.bundle.errorDuplicateObjectWithKey(value, id));
    }
  }