Injects the Change Detection Strategy

@param ChangeDetectionStrategyInterface $changeDetectionStrategy The strategy to use for detecting changes
@return void
965677
public function injectChangeDetectionStrategy(ChangeDetectionStrategyInterface $changeDetectionStrategy)
    {
        $this->changeDetectionStrategy = $changeDetectionStrategy;
        $this->changeDetectionStrategy->setFileMonitor($this);
    }
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);
        }
    }
576297
private void fireTangoQualityChangeEvent(TangoQualityChange tangoQualityChange, EventData eventData) {
        TangoQualityChangeEvent tangoQualityChangeEvent =
                new TangoQualityChangeEvent(tangoQualityChange, eventData);
        // Notifying those that are interested in this event
        ArrayList<EventListener> listeners = event_listeners.getListeners(ITangoQualityChangeListener.class);
        for (EventListener eventListener : listeners) {
            ((ITangoQualityChangeListener) eventListener).qualityChange(tangoQualityChangeEvent);
        }
    }
1082555
protected function hasChanged($doctrineChangeSet, $entity)
    {
        if (empty($doctrineChangeSet)) {
            return false;
        }

        $metaInformation = $this->metaInformationFactory->loadInformation($entity);

        $documentChangeSet = array();

        /* Check all Solr fields on this entity and check if this field is in the change set */
        foreach ($metaInformation->getFields() as $field) {
            if (array_key_exists($field->name, $doctrineChangeSet)) {
                $documentChangeSet[] = $field->name;
            }
        }

        return count($documentChangeSet) > 0;
    }
448595
private void fireTangoChangeEvent(TangoChange tangoChange, EventData eventData) {
        TangoChangeEvent change_event = new TangoChangeEvent(tangoChange, eventData);
        ArrayList<EventListener>    listeners = event_listeners.getListeners(ITangoChangeListener.class);
        for (EventListener eventListener : listeners) {
            ((ITangoChangeListener) eventListener).change(change_event);
        }
    }
1218027
public function action($contentTypeName, array $changeRequest)
    {
        foreach ($changeRequest as $recordId => $actionData) {
            if ($actionData === null) {
                continue;
            }

            $repo = $this->em->getRepository($contentTypeName);
            foreach ($actionData as $action => $fieldData) {
                if (!$entity = $repo->find($recordId)) {
                    continue;
                }
                $this->modifyContentTypeRecord($repo, $entity, $action, $fieldData);
            }
        }
    }
851612
public function detectChanges()
    {
        clearstatcache(true, $this->path);

        if (! $this->exists && $this->files->exists($this->path)) {
            $this->lastModified = $this->files->lastModified($this->path);
            $this->exists = true;

            return [new Event($this, Event::RESOURCE_CREATED)];
        } elseif ($this->exists && ! $this->files->exists($this->path)) {
            $this->exists = false;

            return [new Event($this, Event::RESOURCE_DELETED)];
        } elseif ($this->exists && $this->isModified()) {
            $this->lastModified = $this->files->lastModified($this->path);

            return [new Event($this, Event::RESOURCE_MODIFIED)];
        }

        return [];
    }
952386
public void setUnChanged() {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "setUnChanged");
    changed = false;
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "setUnChanged");
  }
262267
public void addStrategy(MappingStrategy strategy)
    {
        if (strategies == null)
        {
            strategies = new ArrayList<>();
        }
        strategies.add(strategy);
    }
1113372
protected void doHandleChanged() {
		// If there is an associated action, execute it
		if (getActionOnChange() != null) {
			final ActionEvent event = new ActionEvent(this, getActionCommand(), getActionObject());
			final boolean isCAT = isCurrentAjaxTrigger();
			Runnable later = new Runnable() {
				@Override
				public void run() {
					getActionOnChange().execute(event);
					if (isCAT && UIContextHolder.getCurrent().getFocussed() == null) {
						setFocussed();
					}
				}
			};

			invokeLater(later);
		} else if (AjaxHelper.isCurrentAjaxTrigger(this) && UIContextHolder.getCurrent().getFocussed() == null) {
			setFocussed();
		}
	}
1012898
public function triggerSubscriptionChanged(GatewayInterface $gateway, SubscriptionInterface $subscription, ChangeInterface $change)
    {
        $this->trigger(self::ON_SUBSCRIPTION_CHANGED, $gateway, $subscription, $change);
    }
549841
public void setSuggestionStrategy(SuggestionStrategy suggestionStrategy) {
        switch (suggestionStrategy) {
        case OCR:
            setBoolOption(8, true);
            break;
        case TYPO:
            setBoolOption(8, false);
            break;
        }
    }
210392
public function getHasChanged()
	{
		if($this->_dependencies!==null)
		{
			foreach($this->_dependencies as $dependency)
				if($dependency->getHasChanged())
					return true;
		}
		return false;
	}
586897
public function addEditTracking()
    {
//        Old code
//        $changer = new \MUtil_Model_Type_ChangeTracker($this, 1, 0);
//
//        $changer->apply('gto_valid_from_manual',  'gto_valid_from');
//        $changer->apply('gto_valid_until_manual', 'gto_valid_until');

        $this->addDependency(new OffOnElementsDependency('gto_valid_from_manual',  'gto_valid_from', 'readonly', $this));
        $this->addDependency(new OffOnElementsDependency('gto_valid_until_manual', 'gto_valid_until', 'readonly', $this));

        $this->set('gto_valid_until', 'validators[dateAfter]',
              new \MUtil_Validate_Date_DateAfter('gto_valid_from')
              );

        return $this;
    }
949970
final public function commitChanges()
    {
        if (null !== $this->changes) {
            $this->lastCommittedEventSequenceNumber = $this->changes->lastSequenceNumber();
            $this->changes->commit();
        }
    }
352202
function(oThis, sChangeType) {
		var oLayout = oThis.getParent();
		if (oLayout) {
			oLayout.contentChanged(oThis, sChangeType);
		}
	}
7843
public function addChangeSet($tracked,$eventMask)
    {
        if($tracked instanceof TrackedObject){
            $path = $tracked->getResource();
            if($this->fileOnly && !$tracked->getResource() instanceof FileResource){
                return;
            }
        }else{
            $path = $tracked;
        }
        $event = new FilesystemEvent($path,$eventMask);
        $id = md5($path);
        $this->changeSet[$id] = $event;
    }