Delete a property and trigger change if necessary.
509738
function del (obj, key) {
	  var ob = obj.__ob__;
	  if (obj._isVue || (ob && ob.vmCount)) {
	    "development" !== 'production' && warn(
	      'Avoid deleting properties on a Vue instance or its root $data ' +
	      '- just set it to null.'
	    );
	    return
	  }
	  if (!hasOwn(obj, key)) {
	    return
	  }
	  delete obj[key];
	  if (!ob) {
	    return
	  }
	  ob.dep.notify();
	}
579368
function(obj, propName)
{
	if (obj instanceof conbo.EventDispatcher)
	{
		var options = {property:propName, value:obj[propName]};
		
		obj.dispatchEvent(new conbo.ConboEvent('change:'+propName, options));
		obj.dispatchEvent(new conbo.ConboEvent('change', options));
	}
}
189235
public void changeProperty(String propertyName, Object propertyValue)
            throws ShanksException {
        this.properties.put(propertyName, propertyValue);
        this.checkStatus();
    }
1191472
function(compute, newValue, oldValue, batchNum) {
            // Only trigger event when value has changed
            if (newValue !== oldValue) {
                can.batch.trigger(compute, batchNum ? {
                        type: "change",
                        batchNum: batchNum
                    } : 'change', [
                        newValue,
                        oldValue
                    ]);
            }
        }
1175784
def delete(self, data=None):
        """"""
        if not self.can_delete:
            raise JSSMethodNotAllowedError(self.__class__.__name__)
        if data:
            self.jss.delete(self.url, data)
        else:
            self.jss.delete(self.url)
193754
function(value, attr) {
          if (!self._pending[attr] && !self._silent[attr]) {
            delete self.changed[attr];
          }
        }
742256
public void resetProperty(T property)
    {
        String propertyName = getTranslator().getPropertyName(property);

        if (properties.resetToDefault(propertyName))
        {
            firePropertyReset(property);
        }
    }
1195718
function(oThis) {
		var oControl = oThis.getControl();
		if (oControl) {
			PositionContainer.cleanUpControl(oControl);
			oControl.detachEvent("_change", onPropertyChanges, oThis);
		}
	}
778311
function stopWatchingForValueChange() {
	  if (!activeElement) {
	    return;
	  }

	  // delete restores the original property definition
	  delete activeElement.value;

	  if (activeElement.detachEvent) {
	    activeElement.detachEvent('onpropertychange', handlePropertyChange);
	  } else {
	    activeElement.removeEventListener('propertychange', handlePropertyChange, false);
	  }

	  activeElement = null;
	  activeElementInst = null;
	  activeElementValue = null;
	  activeElementValueProp = null;
	}
1258837
public void firePropertyChange(PropertyChangeEvent evt) {
		Object oldValue = evt.getOldValue();
		Object newValue = evt.getNewValue();
		if (ObjectUtils.nullSafeEquals(oldValue, newValue)) {
			return;
		}

		String propertyName = evt.getPropertyName();
		PropertyChangeSupport child = null;
		if (children != null) {
			if (children != null && propertyName != null) {
				child = (PropertyChangeSupport) children.get(propertyName);
			}
		}

		if (listeners != null) {
			Object[] listenerList = listeners.getListenerList();
			for (int i = 0; i <= listenerList.length - 2; i += 2) {
				if (listenerList[i] == PropertyChangeListener.class) {
					((PropertyChangeListener) listenerList[i + 1]).propertyChange(evt);
				}
			}
		}

		if (child != null) {
			child.firePropertyChange(evt);
		}
	}
537343
function(source, propertyName)
	{
		if (!conbo.isAccessor(source, propertyName) && !conbo.isFunc(source, propertyName))
		{
			if (source instanceof conbo.EventDispatcher)
			{
				conbo.makeBindable(source, [propertyName]);
			}
			else
			{
				conbo.warn('It will not be possible to detect changes to "'+propertyName+'" because "'+source.toString()+'" is not an EventDispatcher');
			}
		}
	}
512430
public void propertyChange(PropertyChangeEvent evt) {
		if (evt.getPropertyName() == HAS_ERRORS_PROPERTY)
			updateErrors();
		else if (evt.getPropertyName() == HAS_WARNINGS_PROPERTY)
			updateWarnings();
		else if (evt.getPropertyName() == HAS_INFO_PROPERTY)
			updateInfo();
	}
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);
			}
		}
	}
568338
function(ev, attr, how, newVal, oldVal) {
                    // when a change happens, create the named event.
                    can.batch.trigger(this, {
                            type: attr,
                            batchNum: ev.batchNum
                        }, [newVal, oldVal]);

                    if (how === "remove" || how === "add") {
                        can.batch.trigger(this, {
                                type: "__keys",
                                batchNum: ev.batchNum
                            });
                    }
                }
499060
def delete(self):
        """"""
        response = self.http_request(self._url, 'DELETE')
        if response.status != 204:
            self.raise_http_error(response)
323429
function(ev, model, collection, options) {
      if ((ev == 'add' || ev == 'remove') && collection != this) return;
      if (ev == 'destroy') {
        this._remove(model, options);
      }
      if (model && ev === 'change:' + model.idAttribute) {
        delete this._byId[model.previous(model.idAttribute)];
        this._byId[model.id] = model;
      }
      this.trigger.apply(this, arguments);
    }
919777
public void removePropertyChangeListener (String propertyName, java.beans.PropertyChangeListener listener)
    {
        this.propertyChangeDelegate.removePropertyChangeListener(propertyName, listener);
    }