Called when a property of an ACE associated with this ACL changes.

@param EntryInterface $entry
@param string         $name
@param mixed          $oldValue
@param mixed          $newValue
326118
private function onEntryPropertyChanged(EntryInterface $entry, $name, $oldValue, $newValue)
    {
        foreach ($this->listeners as $listener) {
            $listener->propertyChanged($entry, $name, $oldValue, $newValue);
        }
    }
677655
private function updateOldAceProperty($name, array $changes)
    {
        list($old, $new) = $changes;
        $currentIds = array();

        for ($i = 0, $c = count($new); $i < $c; ++$i) {
            $ace = $new[$i];

            if (null !== $ace->getId()) {
                $currentIds[$ace->getId()] = true;
            }
        }

        for ($i = 0, $c = count($old); $i < $c; ++$i) {
            $ace = $old[$i];

            if (!isset($currentIds[$ace->getId()])) {
                $this->connection->executeQuery($this->getDeleteAccessControlEntrySql($ace->getId()));
                unset($this->loadedAces[$ace->getId()]);
            }
        }
    }
515130
public function hydrateFromEntry(EntryInterface $entry)
    {
        $this->dn = $entry->getDn();

        $this->attributes = array();

        foreach ($entry->getAttributes() as $name => $data) {
            $attr = new NodeAttribute($name);
            $attr->add($data);
            $this->mergeAttribute($attr);
        }

        $this->snapshot();
    }
725718
public function renameForeignKey($oldName, $newName)
    {
        if (!$this->hasForeignKey($oldName)) {
            throw SchemaException::tableForeignKeyDoesNotExist($this->getName(), $oldName);
        }

        if ($this->hasForeignKey($newName)) {
            throw SchemaException::tableForeignKeyAlreadyExists($this->getName(), $newName);
        }

        $this->foreignKeys[$oldName]->setName($newName);
        $this->foreignKeys[$newName] = $this->foreignKeys[$oldName];
        unset($this->foreignKeys[$oldName]);
    }
1020292
public function beforeNodePropertyChange(NodeInterface $node, $propertyName, $oldValue, $value)
    {
        if (!$this->eventEmittingService->isEnabled()) {
            return;
        }

        if (count($this->currentNodeAddEvents) > 0) {
            // add is currently running, during that; we do not want any update events
            return;
        }
        if ($oldValue === $value) {
            return;
        }
        if (!isset($this->changedNodes[$node->getContextPath()])) {
            $this->changedNodes[$node->getContextPath()] = ['node' => $node];
        }
        if (!isset($this->changedNodes[$node->getContextPath()]['oldLabel'])) {
            $this->changedNodes[$node->getContextPath()]['oldLabel'] = $node->getLabel();
        }

        $this->changedNodes[$node->getContextPath()]['old'][$propertyName] = $oldValue;
        $this->changedNodes[$node->getContextPath()]['new'][$propertyName] = $value;
    }
400802
protected void firePropertyChange(String name, Object oldValue, Object newValue) {
        _propertyChangeSupport.firePropertyChange(name, oldValue, newValue);
    }
340405
public function setEntry($language, $entryId, $entryValue)
    {
        $language   = (string)$language;
        $entryId    = (string)$entryId;
        $entryValue = (string)$entryValue;
        if (!isset($this->entries[$language]) && $entryValue) {
            $this->entries[$language] = array();
        }
        if ($entryValue) {
            $this->entries[$language][$entryId] = $entryValue;
        } else {
            if (isset($this->entries[$language][$entryId])) {
                unset($this->entries[$language][$entryId]);
            }
        }
        return $this;
    }
1318273
public function addAttributeValues(Entry $entry, string $attribute, array $values)
    {
        $con = $this->getConnectionResource();

        if (!@ldap_mod_add($con, $entry->getDn(), [$attribute => $values])) {
            throw new LdapException(sprintf('Could not add values to entry "%s", attribute %s: %s.', $entry->getDn(), $attribute, ldap_error($con)));
        }
    }
87118
public void setValue (String name, String value)
    {
        String oldValue = getValue(name, (String)null);
        _prefs.put(name, value);
        _propsup.firePropertyChange(name, oldValue, value);
    }
1304730
@Override
  public void removeEntry(AclEntry entry) {
    switch (entry.getType()) {
      case NAMED_USER:
      case NAMED_GROUP:
      case MASK:
        super.removeEntry(entry);
        return;
      case OWNING_USER:
        Mode modeOwner = new Mode(mMode);
        modeOwner.setOwnerBits(Mode.Bits.NONE);
        if (mAccessAcl != null) {
          // overwrite the owner actions from the access ACL.
          modeOwner.setOwnerBits(new Mode(mAccessAcl.mMode).getOwnerBits());
        }
        mMode = modeOwner.toShort();
        return;
      case OWNING_GROUP:
        Mode modeGroup = new Mode(mMode);
        modeGroup.setGroupBits(Mode.Bits.NONE);
        if (mAccessAcl != null) {
          // overwrite the group actions from the access ACL.
          modeGroup.setGroupBits(new Mode(mAccessAcl.mMode).getGroupBits());
        }
        mMode = modeGroup.toShort();
        return;
      case OTHER:
        Mode modeOther = new Mode(mMode);
        modeOther.setOtherBits(Mode.Bits.NONE);
        if (mAccessAcl != null) {
          // overwrite the other actions from the access ACL.
          modeOther.setOtherBits(new Mode(mAccessAcl.mMode).getOtherBits());
        }
        mMode = modeOther.toShort();
        return;
      default:
        throw new IllegalStateException("Unknown ACL entry type: " + entry.getType());
    }
  }
1224998
public void addAppConfigurationEntry(String name, AppConfigurationEntry... entry) {
		final AppConfigurationEntry[] existing = dynamicEntries.get(name);
		final AppConfigurationEntry[] updated;
		if (existing == null) {
			updated = Arrays.copyOf(entry, entry.length);
		}
		else {
			updated = merge(existing, entry);
		}
		dynamicEntries.put(name, updated);
	}
1217668
public static function addName(string $name, int $initValue = 0)
    {
        if(static::$isInited)
        {
            throw new \RuntimeException('addName failed, AtomicManager was inited');
        }
        static::$atomics[$name] = $initValue;
    }
944569
public function update(string $key, $oldValue, $newValue, AbstractElement $element)
	{
		if (!isset($this->index[$key])) {
			throw new MissingAttrIndexException("Attribute index \"$key\" is not defined.");
		}

		$id = $element->getId();

		if (isset($this->index[$key][$oldValue][$id])) {
			unset($this->index[$key][$oldValue][$id]);
		} else {
			throw new MissingElementException("Old value of \"$id\" is not indexed.");
		}

		$this->index[$key][$newValue][$id] = $element;
	}
667366
private function createNode($name, $entry = null, $entryAttribute = null)
    {
        $document = $this->getDocument();

        try {
            $node = $document->createElement($name);
        } catch (\DOMException $e) {
            $node = $document->createElement($entry ?: $this->entry);

            if (is_string($name)) {
                $node->setAttribute($entryAttribute ?: $this->entryAttribute, $name);
            }
        }

        return $node;
    }
414022
function (name, value, oldValue) {
                this.$InputElement.onbind.apply(this, arguments);
                if (name === "checked") {
                    this._domElt.checked = value;
                }
            }
1353064
public function generateDiff($key, $oldValue, $newValue)
    {
        $this->diff[$key] = [
            self::OLD_VALUE => $oldValue,
            self::NEW_VALUE => $newValue
        ];
    }
172698
public function modifyProperty($user, $newValue, $property = self::LOGIN_PROPERTY)
    {
        $this->checkProperty($property, true);

        $propertyObject = $this->properties[$property];
        if (is_string($propertyObject)) {
            $this->properties[$property] = $propertyObject = new ReflectionProperty($user, $propertyObject);
        }

        $propertyObject->setAccessible(true);
        $propertyObject->setValue($user, $newValue);

        $oid = spl_object_hash($user);
        if (!array_key_exists($oid, $this->lazyValueCache)) {
            $this->lazyValueCache[$oid] = array();
        }

        $this->lazyValueCache[$oid][$property] = $newValue;
    }