Resets the atom's value to `newval`, returning `newval`.

        :param newval: The new value to set.
189339
def reset(self, newval):
        '''
        
        '''
        oldval = self._state.get()
        self._state.set(newval)
        self.notify_watches(oldval, newval)
        return newval
104924
public void addNextValue(Object val) {
    long newVal = Long.parseLong(val.toString());
    if (this.maxVal < newVal) {
      this.maxVal = newVal;
    }
  }
1006106
def NewRow(self, value=""):
        
        newrow = self.row_class()
        newrow.row = self.size + 1
        newrow.table = self
        headers = self._Header()
        for header in headers:
            newrow[header] = value
        return newrow
1069760
public function setValue($new_value) {
    if (gettype($new_value) !== 'object') {
      return parent::setValue($new_value);
    }

    $new_props = $this->getSetProps($new_value);

    foreach ($new_props as $new_prop) {
      $this->setProp($new_prop, $new_value->{$new_prop});
    }

    return $this;
  }
1124243
public void setValue(Object newValue) {
        synchronized (lock) {
            // Allow only once.
            if (ready) {
                return;
            }

            result = newValue;
            ready = true;
            if (waiters > 0) {
                lock.notifyAll();
            }
        }

        notifyListeners();
    }
913408
def set(self, name, value):
        """"""
        old_val = self.values.get(name)
        if old_val != value:
            self.values[name] = value
            return True
        else:
            return False
502397
def _reset_values(self, instance):
        """"""
        self.value = None
        self.reference.value = None
        instance.__dict__.pop(self.field_name, None)
        instance.__dict__.pop(self.reference.field_name, None)
        self.reference.delete_cached_value(instance)
1373869
def reset(self):
        
        self.p_lmbda = 0.0
        self.q_lmbda = 0.0
        self.mu_vmin = 0.0
        self.mu_vmax = 0.0
498038
def reset(self):
        
        self._count = 0
        self._sum = float(0)
        self._min = float('inf')
        self._max = float(0)
875568
function(newVal) {

		var old = this.value;

		// Setter may return the value if setter
		// is for a value maintained exclusively by this compute.
		var setVal = this._set(newVal, old);

		// If the setter updated this.value, just return that.
		if(this._setUpdates) {
			return this.value;
		}

		// If the computed function has dependencies,
		// we should call the getter.
		if (this.hasDependencies) {
			return this._get();
		}

		// Setting may not fire a change event, in which case
		// the value must be read
		this.updater(setVal === undefined ? this._get() : setVal, old);

		return this.value;
	}
983444
def set(self, value):
        
        old_value = self._value
        old_raw_str_value = self.raw_str_value

        self.type.set_item_value(self, value)

        new_value = self._value

        if old_value is not_set and new_value is not_set:
            # Nothing to report
            return

        if self.section:
            self.section.dispatch_event(
                self.section.hooks.item_value_changed,
                item=self,
                old_value=old_value,
                new_value=new_value,
                old_raw_str_value=old_raw_str_value,
                new_raw_str_value=self.raw_str_value
            )
260667
def set_referencevalue(self, val):
        """"""
        assert len(val) == len(self._coord["crval"])
        self._coord["crval"] = val[::-1]
538475
public void setValue(Object newValue)
    {
    	if (NOT_KNOWN.equals(newValue))
    	{
        	m_proxyField.updateValue();
    		m_proxyField.setNotKnown(true);
    		return;
    	}
    	if (UNKNOWN.equals(newValue))
    	{
    		m_proxyField.reset();
        	m_proxyField.updateValue();
    		return;
    	}
    	m_proxyField.setValue(newValue);
    	m_proxyField.updateValue();
    }
488325
def update(self, instance, oldValue, newValue):
    """"""
    self.__set__(instance,
                 self.__get__(instance, None) + newValue - (oldValue or 0))
1181100
def _pfp__set_value(self, new_val):
        
        if not isinstance(new_val, Field):
            new_val = utils.binary(utils.string_escape(new_val))
        super(String, self)._pfp__set_value(new_val)
561831
def _setVal(self, name, val, defVal = None):
        """"""
        if val == defVal:
            return
        if not hasattr(self, "vals"):
            self.vals = {}
        self.vals[name] = val
383994
public final void setNewVertexValue(VV newValue) {
		if (setNewVertexValueCalled) {
			throw new IllegalStateException("setNewVertexValue should only be called at most once per updateVertex");
		}
		setNewVertexValueCalled = true;

		outVertex.f1 = newValue;

		out.collect(Either.Left(outVertex));
	}