Updates the current collection of values from the sub-properties and notifies the listeners.
480195
private void updateFromProperties() {
        // Get value from all properties: use a new collection so that equals() returns false
        List<R> newValues = new ArrayList<R>();
        for (ReadableProperty<R> master : properties) {
            newValues.add(master.getValue());
        }

        // Notify slaves
        setValue(newValues);
    }
47848
protected void doNotifyListenersOfRemovedValues(Set<R> oldItems) {
        List<SetValueChangeListener<R>> listenersCopy = new ArrayList<SetValueChangeListener<R>>(listeners);
        Set<R> unmodifiable = Collections.unmodifiableSet(oldItems);
        for (SetValueChangeListener<R> listener : listenersCopy) {
            listener.valuesRemoved(this, unmodifiable);
        }
    }
824583
function update(parent$, newValue) {
  parent$.value = newValue;
  notifyListeners(parent$.listeners, newValue);
}
1069743
private void update(final Map<String, Object> values) {

		for (final Entry<String, Object> entry : values.entrySet()) {

			update(entry.getKey(), entry.getValue());
		}
	}
1350429
private void addListeners() {
	    this.min.xProperty().addListener((observable, oldValue, nValue) -> {
	        final double currentMin = nValue.doubleValue();
	        final double currentMax = getMaxX();
	        if (currentMax < currentMin) {
	            // min-max constrain is broken
	            maxXProperty().set(currentMin);
	        }
	    });
	    this.min.yProperty().addListener((observable, oValue, nValue) -> {
	        final double currentMin = nValue.doubleValue();
	        final double currentMax = getMaxY();
	        if (currentMax < currentMin) {
	            // min-max constrain is broken
	            maxYProperty().set(currentMin);
	        }
	    });
	    this.max.xProperty().addListener((observable, oValue, nValue) -> {
	        final double currentMax = nValue.doubleValue();
	        final double currentMin = getMinX();
	        if (currentMax < currentMin) {
	            // min-max constrain is broken
	            minXProperty().set(currentMax);
	        }
	    });
	    this.max.yProperty().addListener((observable, oValue, nValue) -> {
	        final double currentMax = nValue.doubleValue();
	        final double currentMin = getMinY();
	        if (currentMax < currentMin) {
	            // min-max constrain is broken
	            minYProperty().set(currentMax);
	        }
	    });
	}
1014760
public void updateStatus(long time,Object currentValue){
		this.currentStatus.setTime(time);
		this.currentStatus.setLastValue(currentValue);
	}
1139032
private void updateWarnings() {
		boolean oldWarnings = hasWarnings;
		hasWarnings = false;
		if (validationResults.getHasWarnings()) {
			hasWarnings = true;
		}
		else {
			Iterator childIter = children.iterator();
			while (childIter.hasNext()) {
				ValidationResultsModel childModel = (ValidationResultsModel) childIter.next();
				if (childModel.getHasWarnings()) {
					hasWarnings = true;
					break;
				}
			}
		}
		firePropertyChange(HAS_WARNINGS_PROPERTY, oldWarnings, hasWarnings);
	}
1119691
function() {
      inputEx.KeyValueField.superclass.initEvents.call(this);

      this.inputs[0].updatedEvt.subscribe(this.onSelectFieldChange, this, true); 
   }
955051
def update_subtotals(self, current, sub_key):
        

        if not self.sub_counts.get(sub_key):
            self.sub_counts[sub_key] = {}
        for item in current:
            try:
                self.sub_counts[sub_key][item] += 1
            except KeyError:
                self.sub_counts[sub_key][item] = 1
1314993
public void update(final Collection<T> values) throws DataAccessException {
        jdbcTemplate.execute(new ConnectionCallback<Object>() {
            @Override
            public Object doInConnection(Connection connection) throws SQLException, DataAccessException {
                crud.update(connection, values);
                return null;
            }
        });
    }
596587
function() {

		if (this._property_changed_listener && (this._value_container.getValue() != this._property_container)) {

			// currently listening to the parent's old data source
			this._property_changed_listener && this._property_container.removePropertyListener(this._property_changed_listener);
			this._enumerable_changed_listener && this._property_container.removeListener(this._enumerable_changed_listener);
			this._property_changed_listener = null;
			this._enumerable_changed_listener = null;
			this._property_container = null;

		}

		this._queueForRefresh();

	}
854877
public void updateValue()
    {
        try
        {
            Method method = m_propertyMetadata.getSetMethod();
            //Object convertedValue = ValidationUtils.convertTo(getClazz(), m_currentValue);
            if (m_currentValue == null && method.getParameterTypes()[0].isPrimitive())
            {
                method.invoke(m_proxyObject.getObject(), ConvertUtils.getPrimitiveTypeForNull(method.getParameterTypes()[0]));
            }
            else
            {
                method.invoke(m_proxyObject.getObject(), m_currentValue);
            }
            m_useCurrentValue = false;
            m_notKnown = false;
        }
        catch (Exception e)
        {
            throw new RuntimeException(e);
        }
    }
667087
def updateFromKwargs(self, properties, kwargs, collector, **unused):
        """'"""
        properties[self.name] = self.getFromKwargs(kwargs)
511343
def updateobjects(self, updatedvalues):
        
        if not self._updatedset:
            self.scheduler.emergesend(FlowUpdaterNotification(self, FlowUpdaterNotification.DATAUPDATED))
        self._updatedset.update(set(updatedvalues).intersection(self._savedresult))
24381
private void addListeners() {
	    this.min.xProperty().addListener((observable, oldValue, nValue) -> {
            final int currentMin = nValue.intValue();
            final int currentMax = getMaxX();
            if (currentMax < currentMin) {
                // min-max constrain is broken
                maxXProperty().set(currentMin);
            }
        });
        this.min.yProperty().addListener((observable, oValue, nValue) -> {
            final int currentMin = nValue.intValue();
            final int currentMax = getMaxY();
            if (currentMax < currentMin) {
                // min-max constrain is broken
                maxYProperty().set(currentMin);
            }
        });
        this.min.zProperty().addListener((observable, oValue, nValue) -> {
            final int currentMin = nValue.intValue();
            final int currentMax = getMaxZ();
            if (currentMax < currentMin) {
                // min-max constrain is broken
                maxZProperty().set(currentMin);
            }
        });
        this.max.xProperty().addListener((observable, oValue, nValue) -> {
            final int currentMax = nValue.intValue();
            final int currentMin = getMinX();
            if (currentMax < currentMin) {
                // min-max constrain is broken
                minXProperty().set(currentMax);
            }
        });
        this.max.yProperty().addListener((observable, oValue, nValue) -> {
            final int currentMax = nValue.intValue();
            final int currentMin = getMinY();
            if (currentMax < currentMin) {
                // min-max constrain is broken
                minYProperty().set(currentMax);
            }
        });
        this.max.zProperty().addListener((observable, oValue, nValue) -> {
            final int currentMax = nValue.intValue();
            final int currentMin = getMinZ();
            if (currentMax < currentMin) {
                // min-max constrain is broken
                minZProperty().set(currentMax);
            }
        });
    }
619592
function()
	{
		if(this._collectionBinder)
		{
			this._collectionBinder.refreshIndexedBinders();
		}
		else
		{
			if(this._modelBindersMap)
			{
				this._modelBindersMap.refreshIndexedBinders();
			}
			if(this.subviews !== null)
			{
				for(var i = 0, l = this.subviews.length; i < l; i++) this.subviews[i].refreshIndexedBinders();
			}
		}
	}
1208626
def _update(self):
        """"""
        self.dataChanged.emit(self.createIndex(0, 0), self.createIndex(
            len(self.collection), len(self.header)))