Handle changing object data. Fires update event only if something was changed.
@param {Object} data New values for object data holder (this.data).
@return {Object|boolean} Delta if object data (this.data) was updated or false otherwise.
424796
function(data){
      if (this.delegate)
        return this.root.update(data);

      if (data)
      {
        var delta = {};
        var changed = false;

        for (var prop in data)
          if (this.data[prop] !== data[prop])
          {
            changed = true;
            delta[prop] = this.data[prop];
            this.data[prop] = data[prop];
          }

        if (changed)
        {
          this.emit_update(delta);
          return delta;
        }
      }

      return false;
    }
1355088
public void update(int delta) {
		emitter.updateParticle(this, delta);
		life -= delta;
		
		if (life > 0) {
			x += delta * velx;
			y += delta * vely;
		} else {
			engine.release(this);
		}
	}
1186806
function update (data) {
    this.bind()
    this.length = data.length
    this.byteLength = this.length * data.BYTES_PER_ELEMENT
    this.gl.bufferData(this.type, data, this.usage)
  }
260786
function onData( addend ) {
		/**
		* FUNCTION: onData( newVal, encoding, clbk )
		*	Data event handler. Performs addition.
		*
		* @private
		* @param {Number} newVal - streamed data value
		* @param {String} encoding
		* @param {Function} clbk - callback to invoke after performing addition. Function accepts two arguments: [ error, chunk ].
		*/
		return function onData( newVal, encoding, clbk ) {
			clbk( null, newVal+addend );
		}; // end FUNCTION onData()
	}
571201
private void onDataObjectRename(@Observes DataObjectRenamedEvent event) {
        Path updatedPath = event.getPath();
        if (updatedPath != null) {
            try {
                updateDataObject(updatedPath);
            } catch (Exception e) {
                logger.error("Data object couldn't be updated, path: " + updatedPath + ".");
            }
        }
    }
151126
function (data) {
            this.data = data;
            this.isFulfilled = true;

            if (this.parent === null) {
                return;
            }

            this.parent.dispatch(this.name);
        }
701593
function(data){
    var _self = this,
      series = _self.getSeries(),
      fields = _self.get('fields');

    _self.set('data',data);

    Util.each(series,function(item,index){
      if(fields){
        var arr = _self._getSeriesData(item.get('name'),index);
        item.changeData(arr);
      }else{
        if(Util.isArray(data[0])){
          item.changeData(data[index]);
        }else{
          item.changeData(data);
        }
      }
    });
    _self.repaint();
  }
770114
public T updateData(String name, T data) {
        Node<T> node = root.getNode(name);
        T old = null;
        if (node != null) {
            old = node.setData(data);
        }
        return old;
    }
106704
function onServerMessage(data)
    {
        if(data.ev)
        {
            scope.dispatchEvent("onServerMessage",data);
            scope.dispatchEvent(data.ev,data);
        }
    }
408950
def emitDataChanged(self, treeItem):  # TODO: move to BaseTreeItem?
        
        indexLeft, indexRight = self.indexTupleFromItem(treeItem)
        checkItem = self.getItem(indexLeft)
        assert checkItem is treeItem, "{} != {}".format(checkItem, treeItem) # TODO: remove
        self.dataChanged.emit(indexLeft, indexRight)
43248
function defaultUpdateFunction(instance, data) {
    if (instance.isMatreshkaArray) {
        instance.recreate(data);
    } else if (instance.isMatreshkaObject) {
        instance.setData(data, { replaceData: true });
    } else {
        // for other objects just extend them with given data
        nofn.assign(instance, data);
    }
}
354161
function(){
      Dataset.flushChanges(this);

      var deleted = this.getItems();
      var listenHandler = this.listen.item;
      var delta;

      if (deleted.length)
      {
        if (listenHandler)
          for (var i = 0; i < deleted.length; i++)
            deleted[i].removeHandler(listenHandler, this);

        this.emit_itemsChanged(delta = {
          deleted: deleted
        });

        this.members_ = {};
      }

      return delta;
    }
159643
function observableChanged(change) {
  const store = this;
  action(() => {
    store.dataChanges.set(change.name, change.newValue);

    if (store.isSame(store.dataChanges.get(change.name), store.dataServer[change.name])) {
      store.dataChanges.delete(change.name);
    }
  })();
}
451011
function _markAsChanged(treeData, changed) {
        changed.forEach(function (filePath) {
            var objectPath = _filePathToObjectPath(treeData, filePath);
            if (objectPath) {
                treeData = treeData.updateIn(objectPath, _addTimestamp);
            }
        });
        return treeData;
    }
330494
function Delta(modelID) {
  if (false === (this instanceof Delta)) throw new Error('new operator required');
  if (false === (modelID instanceof Attribute.ModelID)) throw new Error('Attribute.ModelID required in constructor');
  this.dateCreated = new Date();
  this.modelID = modelID;
  this.attributeValues = {};
}
703787
void changedValue(Object value) {
		Object oldValue = super.putSilent(VALUE, value);
		if (!Objects.equals(oldValue, value)) {
			fireChange();
		}
	}
1272099
function updateState(newState, data) {
      var prevState = self.state;
      self.state = newState;

      // Only emit when the state changes
      if (prevState !== newState) {
        Pusher.debug('State changed', prevState + ' -> ' + newState);
        self.emit('state_change', {previous: prevState, current: newState});
        self.emit(newState, data);
      }
    }