Triggers the old_binding to possibly send to its group.
500211
def post_change_receiver(self, instance: Model, action: Action, **kwargs):
        
        try:
            old_group_names = instance.__instance_groups.observers[self]
        except (ValueError, KeyError):
            old_group_names = set()

        if action == Action.DELETE:
            new_group_names = set()
        else:
            new_group_names = set(self.group_names(instance))

        # if post delete, new_group_names should be []

        # Django DDP had used the ordering of DELETE, UPDATE then CREATE for good reasons.
        self.send_messages(
            instance,
            old_group_names - new_group_names,
            Action.DELETE,
            **kwargs
        )
        # the object has been updated so that its groups are not the same.
        self.send_messages(
            instance,
            old_group_names & new_group_names,
            Action.UPDATE,
            **kwargs
        )

        #
        self.send_messages(
            instance,
            new_group_names - old_group_names,
            Action.CREATE,
            **kwargs
        )
266103
void set(Instant effectiveFrom, T value) {
		T oldValue = get();
		values.put(effectiveFrom, value);
		notifyListeners(oldValue, value);
	}
1209853
function (args, propertyName) {
                if (this._cfg) {
                    this.onbind(propertyName, this._transform(this._cfg.bind[propertyName].transform, args.newValue, "toWidget"), args.oldValue);
                }
            }
1141289
private void updateValue() {
        if (list != null) {
            int oldCount = this.count;
            this.count = list.getSelectedIndices().length;
            maybeNotifyListeners(oldCount, count);
        }
    }
1203058
def dispatch(self, receiver):
        ''' 

        '''
        super(ModelChangedEvent, self).dispatch(receiver)
        if hasattr(receiver, '_document_model_changed'):
            receiver._document_model_changed(self)
1055498
function rebindCallback(target, source, postSetCallback) {
  var i = 2, n = arguments.length, method;
  while (++i < n) target[method = arguments[i]] = doRebind(target, source, source[method], postSetCallback);
  return target;
}
615879
public void sessionMaxInactiveTimeSet(ISession session, int old, int newval) {
        _sessionStateEventDispatcher.sessionMaxInactiveTimeSet(session, old, newval);

    }
54203
function _trigger(element, name, value, autoRemove) {
        var key = "data-ld-" + name;
        if (value !== undefined && value !== null) {
            element.setAttribute(key, value);
            if (autoRemove) {
                window.setTimeout(element.removeAttribute.bind(element, key));
            }
        } else {
            element.removeAttribute(key);
        }
    }
569491
private void updateValue() {
        if (table != null) {
            int oldCount = this.count;
            this.count = table.getRowCount();
            maybeNotifyListeners(oldCount, count);
        }
    }
371766
function (name, value, oldValue) {
            // it doesn't make sense to bind both index and value,
            // so we just state that the index takes precedence on the value

            if (name === "selectedIndex") {
                this._domElt.selectedIndex = value;
                this.setValueInDataModel();
                if (!this.isIndexValid(value)) {
                    this.setIndexInDataModel();
                }
            } else if (name === "value") {
                this._domElt.selectedIndex = this.getIndex(value);
                this.setIndexInDataModel();
                // if selectedIndex is set to -1 and value is bound we modify the data model to change the value to ''
                if (this._domElt.selectedIndex === -1) {
                    this.setValueInDataModel();
                }
            }
            this.onDisabledBind(name, value, oldValue);
        }
347512
void addSelectionBinding(ReadOnlyObjectProperty<Change> currentChange) {
    currentChange.addListener(
        (observable, oldValue, newValue) -> getSelectionModel().select(newValue)
    );
  }
336855
def update_property(self, name, old_value, new_value):
        # type: (str, Any, Any) -> None
        
        with self._lock:
            self.__safe_handlers_callback(
                "on_property_change", name, old_value, new_value
            )
733714
function triggerAndReturn(context, eventName, data) {
    var event = $.Event(eventName)
    $(context).trigger(event, data)
    return !event.defaultPrevented
  }
6497
function resolveBindingValue(oldValue, value) {
    if (value === undefined && oldValue === null) {
      return value;
    }
    return (value === null || value === undefined) ? oldValue : value;
  }
907961
public void filterReset() {
        if (displayerSettings.isFilterEnabled()) {

            List<DataSetGroup> groupOpList = new ArrayList<DataSetGroup>();
            for (String columnId : columnSelectionMap.keySet()) {
                DataSetGroup groupOp = dataSetHandler.getGroupOperation(columnId);
                groupOpList.add(groupOp);

            }
            columnSelectionMap.clear();

            // Notify to those interested parties the reset event.
            if (displayerSettings.isFilterNotificationEnabled()) {
                for (DisplayerListener listener : listenerList) {
                    if (currentFilter != null) {
                        listener.onFilterReset(this, currentFilter);
                    }
                    listener.onFilterReset(this, groupOpList);
                }
            }
            // Apply the selection to this displayer
            if (displayerSettings.isFilterSelfApplyEnabled()) {
                boolean applied = false;

                if (currentFilter != null) {
                    if (dataSetHandler.unfilter(currentFilter)) {
                        applied = true;
                    }
                }
                for (DataSetGroup groupOp : groupOpList) {
                    if (dataSetHandler.drillUp(groupOp)) {
                        applied = true;
                    }
                }
                if (applied) {
                    redraw();
                }
            }
            if (currentFilter != null) {
                currentFilter = null;
            }
        }
    }
742042
function (propertyName, newValue) {
            if (!this._cfg) {
                return;
            }
            if (propertyName === "items" && this._cfg.bind.hasOwnProperty(propertyName)) {
                var oldValue = this.getProperty(propertyName);
                this._cfg[propertyName] = newValue;
                this._onBoundPropertyChange(propertyName, newValue, oldValue);
            } else {
                this.$TemplateBasedWidget.setWidgetProperty.apply(this, arguments);
            }
        }
775463
void notifyAcceptBind(Bind bindParameter) throws IllegalStateException {
        lock.lock();
        try {
            if (request == null) {
                request = new BindRequest(bindParameter, responseHandler);
                requestCondition.signal();
            } else {
                throw new IllegalStateException("Already waiting for acceptance bind");
            }
        } finally {
            lock.unlock();
        }
    }