Called by the instance manager when a component property is modified

        :param name: The changed property name
        :param old_value: The previous property value
        :param new_value: The new property value
340083
def on_property_change(self, name, old_value, new_value):
        
        if self._registration is not None:
            # use the registration to trigger the service event
            self._registration.set_properties({name: new_value})
1056976
def MI_modifyInstance(self,
                          env,
                          modifiedInstance,
                          previousInstance,
                          propertyList,
                          cimClass):
        # pylint: disable=invalid-name
        

        logger = env.get_logger()
        logger.log_debug('CIMProvider MI_modifyInstance called...')
        if propertyList is not None:
            plist = [p.lower() for p in propertyList]
            filter_instance(modifiedInstance, plist)
            modifiedInstance.update(modifiedInstance.path)
        self.set_instance(env=env,
                          instance=modifiedInstance,
                          previous_instance=previousInstance,
                          cim_class=cimClass)
        logger.log_debug('CIMProvider MI_modifyInstance returning')
477505
function (newValue) {
                    // and no inheritance is involved
                    if (this === self) {
                      // notify the method but ...
                      var value = oldValue;
                      updateValue(newValue);
                      // ... do not update the get value
                      oldValue = value;
                    } else {
                      // with inheritance, simply set the property
                      // as if it was a regular assignment operation
                      setValue(this, prop, newValue);
                    }
                  }
1127027
function(value){
      var oldValue = this.value;
      var newValue = this.proxy ? this.proxy(value) : value;
      var changed = newValue !== oldValue;

      if (changed)
      {
        if (this.setNullOnEmitterDestroy)
        {
          if (oldValue instanceof Emitter)
            oldValue.removeHandler(VALUE_EMMITER_DESTROY_HANDLER, this);
          if (newValue instanceof Emitter)
            newValue.addHandler(VALUE_EMMITER_DESTROY_HANDLER, this);
        }

        this.value = newValue;

        if (!this.locked)
          this.emit_change(oldValue);
      }

      return changed;
    }
1327573
public synchronized void onPropertyValueChanged(Property property, Object oldValue, Object newValue) {
        if (!configuration.isUseGc()) {
            return;
        }
        removeReferenceAndCheckForGC(property, oldValue);

        if (newValue != null && DolphinUtils.isDolphinBean(newValue.getClass())) {
            Instance instance = getInstance(newValue);
            Reference reference = new PropertyReference(propertyToParent.get(property), property, instance);
            if (reference.hasCircularReference()) {
                throw new CircularDependencyException("Circular dependency detected!");
            }
            instance.getReferences().add(reference);
            removeFromGC(instance);
        }
    }
1208243
protected final void firePropertyChange(String propertyName, boolean oldValue, boolean newValue) {
		if (DIRTY_PROPERTY.equals(propertyName)) {
			PropertyChangeEvent evt = new PropertyChangeEvent(this, propertyName, Boolean.valueOf(oldValue), Boolean
					.valueOf(newValue));
			for (Iterator i = dirtyChangeListeners.iterator(); i.hasNext();) {
				((PropertyChangeListener) i.next()).propertyChange(evt);
			}
		}
	}
201070
function (attrName, oldVal, newVal) {

            var property = vcomet.util.hyphenToCamelCase(attrName);

            // The onAttributeChanged callback is triggered whether its observed or as a reflection of a property
            if (el.__observeAttributes[attrName] || el.__reflectProperties[property]) {
                vcomet.triggerAllCallbackEvents(el, config, "onAttributeChanged", [attrName, oldVal, newVal]);
            }

            // The onPropertyChanged callback is triggered when the attribute has changed and its reflect by a property
            if (el.__reflectProperties[property]) {
                el["__" + property] = newVal;
                vcomet.triggerAllCallbackEvents(el, config, "onPropertyChanged", [property, oldVal, newVal]);
            }

        }
871358
def on_service_modify(self, svc_ref, old_properties):
        
        with self._lock:
            if self.reference is None:
                # A previously registered service now matches our filter
                self.on_service_arrival(svc_ref)
            elif svc_ref is self.reference:
                # Notify the property modification
                self._ipopo_instance.update(
                    self, self._value, svc_ref, old_properties
                )
1067591
def modify(name, old_value, new_value)
      @attributes[name] = new_value
      if @modifications && (old_value != new_value)
        original = @modifications[name].first if @modifications[name]
        @modifications[name] = [ (original || old_value), new_value ]
      end
    end
342187
def update(self, value):
        
        key = self.name

        # if it's a variable name (otherwise a constant)
        if isinstance(key, str):
            self.env.swapkey(self.local_name, key, new_value=value)

        self.value = value
1226851
def setField(self, new_value):
        
        self.B = self.B._replace(val=new_value)
448784
function liveAttrsUpdate(newVal) {
		var newAttrs = live.getAttributeParts(newVal),
			name;
		for (name in newAttrs) {
			var newValue = newAttrs[name],
				// `oldAttrs` was set on the last run of setAttrs in this context
				//  (for this element and compute)
				oldValue = oldAttrs[name];
			// Only fire a callback
			//  if the value of the attribute has changed
			if (newValue !== oldValue) {
				// set on DOM attributes (dispatches an "attributes" event as well)
				domMutateNode.setAttribute.call(el, name, newValue);
				// get registered callback for attribute name and fire
				var callback = viewCallbacks.attr(name);
				if (callback) {
					callback(el, {
						attributeName: name,
						scope: scope,
						options: options
					});
				}
			}
			// remove key found in new attrs from old attrs
			delete oldAttrs[name];
		}
		// any attrs left at this point are not set on the element now,
		// so remove them.
		for (name in oldAttrs) {
			domMutateNode.removeAttribute.call(el, name);
		}
		oldAttrs = newAttrs;
	}
379953
def old_properties_names_to_new(self):  # pragma: no cover, never called
        
        for i in itertools.chain(iter(list(self.items.values())),
                                 iter(list(self.templates.values()))):
            i.old_properties_names_to_new()
238612
def update_instance_variable(variable_name, new_value)
      old_value = instance_variable_get(variable_name).freeze

      instance_variable_set(variable_name.to_sym, new_value)

      unless old_value == new_value
        changed_attributes[variable_name.to_s.delete('@').to_sym] = old_value
      end
    end
248436
def _notify_change(self, model, attr, old, new, hint=None, setter=None, callback_invoker=None):
        ''' 

        '''
        # if name changes, update by-name index
        if attr == 'name':
            if old is not None:
                self._all_models_by_name.remove_value(old, model)
            if new is not None:
                self._all_models_by_name.add_value(new, model)

        if hint is None:
            serializable_new = model.lookup(attr).serializable_value(model)
        else:
            serializable_new = None

        event = ModelChangedEvent(self, model, attr, old, new, serializable_new, hint, setter, callback_invoker)
        self._trigger_on_change(event)
400802
protected void firePropertyChange(String name, Object oldValue, Object newValue) {
        _propertyChangeSupport.firePropertyChange(name, oldValue, newValue);
    }
1070092
function (name, value, oldValue) {
                this.$Element.onbind.apply(this, arguments);
                this.onDisabledBind(name, value, oldValue);
            }