Handles entity changed events that are sent by our embedd entity.

@param EntityChangedEvent $embedded_entity_event
192919
public function onEntityChanged(EntityChangedEvent $embedded_entity_event)
    {
        $value_changed_event = $embedded_entity_event->getValueChangedEvent();

        $this->propagateValueChangedEvent(
            new ValueChangedEvent(
                array(
                    'attribute_name' => $value_changed_event->getAttributeName(),
                    'prev_value' => $value_changed_event->getOldValue(),
                    'value' => $value_changed_event->getNewValue(),
                    'embedded_event' => $embedded_entity_event
                )
            )
        );
    }
179651
protected void handlePostEvent()
    {
        EntityMetadata metadata = getEntityMetadata();
        if (!kunderaQuery.isDeleteUpdate())
        {
            persistenceDelegeator.getEventDispatcher().fireEventListeners(metadata, null, PostLoad.class);
        }
    }
448677
private function computeScheduleInsertsChangeSets() : void
    {
        foreach ($this->documentInsertions as $document) {
            $class = $this->dm->getClassMetadata(get_class($document));
            if ($class->isEmbeddedDocument) {
                continue;
            }

            $this->computeChangeSet($class, $document);
        }
    }
1182477
protected void safeExecuteChangeListener(CmsEntity entity, I_CmsEntityChangeListener listener) {

        try {
            listener.onEntityChange(entity);
        } catch (Exception e) {
            String stack = CmsClientStringUtil.getStackTrace(e, "<br />");
            CmsDebugLog.getInstance().printLine("<br />" + e.getMessage() + "<br />" + stack);
        }
    }
819155
public void itemStateChanged(ItemEvent e) {
        if (e.getStateChange() == ItemEvent.DESELECTED) {
            // disable text entry
            m_customPIDField.setEditable(false);
        } else if (e.getStateChange() == ItemEvent.SELECTED) {
            // enable text entry
            m_customPIDField.setEditable(true);
        }
    }
1223725
protected function afterSave(EntityInterface $entity): void
    {
        $argv = compact('entity');
        $argv = $this->getEventManager()->prepareArgs($argv);

        $this->getEventManager()->trigger("{$this->event_prefix}_save_after", $this, $argv);
        if ($this->entity_event_prefix) {
            $this->getEventManager()->trigger("{$this->entity_event_prefix}_save_after", $this, $argv);
        }
    }
468581
public function beforeSave(Event $event, EntityInterface $entity, \ArrayObject $options): void
    {
        if (!$entity->isNew() && $entity->dirty()) {
            $saveHash = Security::hash(md5(uniqid()));
            if (empty($entity->save_hash)) {
                $entity->save_hash = $saveHash;
                $entity->dirty('save_hash', false);
            }

            $this->_dirtyFields[$entity->id] = $this->_extractDirtyFields($entity);
            $this->_applySaveHash($entity, $saveHash);
        }
    }
352113
protected function propagateEntityChangedEvent(EntityChangedEvent $event)
    {
        foreach ($this->listeners as $listener) {
            $listener->onEntityChanged($event);
        }
    }
1021841
void onFilterChangedEvent(@Observes FilterChangedEvent filterChangedEvent) {
        checkNotNull("filterChangedEvent",
                     filterChangedEvent);
        if (filterChangedEvent.getContext().equals(dataSetFilterEditor)) {
            final DataSetFilter old = filterChangedEvent.getOldFilter();
            final DataSetFilter f = filterChangedEvent.getFilter();
            updateColumnsRestrictedByFilter(old,
                                            f);
        }
    }
1359356
public function postUpdate(PageInterface $page, LifecycleEventArgs $event)
    {
        /** @var \Doctrine\ORM\EntityManagerInterface $em */
        $em = $event->getObjectManager();
        $uow = $em->getUnitOfWork();

        $changeSet = $uow->getEntityChangeSet($page);
        if (array_key_exists('enabled', $changeSet)) {
            if ($page->isEnabled()) {
                $this->discardPageRedirections($page);
            } else {
                $this->buildPageRedirections($page);
            }
        }
    }
465642
public function onChangeEmail(SubscriberEvent $event)
    {
        $this->listRepository->changeEmailAddress(
            $event->getListId(),
            $event->getSubscriber(),
            $event->getOldEmail()
        );
    }
652456
private void process() {
    metadata = new EmbeddedMetadata(field);

    // Make sure the class has @Embeddable annotation
    if (!clazz.isAnnotationPresent(Embeddable.class)) {
      String message = String.format("Class %s must have %s annotation", clazz.getName(),
          Embeddable.class.getName());
      throw new EntityManagerException(message);
    }

    // Check the mapped name and indexed attributes
    Embedded embeddedAnnotation = field.getField().getAnnotation(Embedded.class);
    String mappedName = embeddedAnnotation.name();
    if (mappedName == null || mappedName.trim().length() == 0) {
      mappedName = field.getName();
    }
    metadata.setMappedName(mappedName);
    metadata.setIndexed(embeddedAnnotation.indexed());
    metadata.setOptional(embeddedAnnotation.optional());

    // If there is an annotation for storing the embedded with Imploded
    // strategy...
    if (field.getField().isAnnotationPresent(Imploded.class)) {
      metadata.setStorageStrategy(StorageStrategy.IMPLODED);
    }
    processFields();
  }
1332326
def m2m_changed_entity_signal_handler(sender, instance, action, **kwargs):
    
    if action == 'post_add' or action == 'post_remove' or action == 'post_clear':
        save_entity_signal_handler(sender, instance, **kwargs)
1237327
public void addEntityChangeHandler(String entityId, ValueChangeHandler<CmsEntity> handler) {

        CmsEntity entity = m_entityBackend.getEntity(entityId);
        if (entity != null) {
            entity.addValueChangeHandler(handler);
        }
    }
186365
public void resourceChanged(IResourceChangeEvent event) {
		HashSet<IResource> changedElements= new HashSet<IResource>();

		try {
			IResourceDelta delta= event.getDelta();
			if (delta != null)
				delta.accept(new ProjectErrorVisitor(changedElements));
		} catch (CoreException e) {
			VdmUIPlugin.printe(e);
		}

		if (!changedElements.isEmpty()) {
			boolean hasChanges= false;
			synchronized (this) {
				if (fResourcesWithMarkerChanges.isEmpty()) {
					fResourcesWithMarkerChanges= changedElements;
					hasChanges= true;
				} else {
					hasChanges= fResourcesWithMarkerChanges.addAll(changedElements);
				}
			}
			if (hasChanges) {
				fireChanges();
			}
		}
	}
514846
public function onFlush(OnFlushEventArgs $eventArgs)
    {
        $em = $eventArgs->getEntityManager();
        $uow = $em->getUnitOfWork();

        foreach ($uow->getScheduledEntityInsertions() as $entity) {
            $this->debug('Inserting entity '.get_class($entity).'. Fields: '.
                             json_encode($uow->getEntityChangeSet($entity)));
        }

        foreach ($uow->getScheduledEntityUpdates() as $entity) {
            $add = '';
            if (method_exists($entity, '__toString')) {
                $add = ' '.$entity->__toString();
            } elseif (method_exists($entity, 'getId')) {
                $add = ' with id '.$entity->getId();
            }

            $this->debug('Updating entity '.get_class($entity).$add.'. Data: '.
                             json_encode($uow->getEntityChangeSet($entity)));
        }

        foreach ($uow->getScheduledEntityDeletions() as $entity) {
            $add = '';
            if (method_exists($entity, '__toString')) {
                $add = ' '.$entity->__toString();
            } elseif (method_exists($entity, 'getId')) {
                $add = ' with id '.$entity->getId();
            }

            $this->debug('Deleting entity '.get_class($entity).$add.'.');
        }
    }
951462
private void fireTangoInterfaceChangeEvent(TangoInterfaceChange tangoChange, EventData eventData) {
        TangoInterfaceChangeEvent event = new TangoInterfaceChangeEvent(tangoChange, eventData);
        ArrayList<EventListener>    listeners = event_listeners.getListeners(ITangoInterfaceChangeListener.class);
        for (EventListener eventListener : listeners) {
            ((ITangoInterfaceChangeListener) eventListener).interface_change(event);
        }
    }