PHP EventManager::hasListeners方法代码示例

 /**
  * Get the subscribed event systems
  *
  * @param \Doctrine\ORM\Mapping\ClassMetadata $metadata The entity metadata.
  * @param string $eventName                             The entity lifecycle event.
  *
  * @return integer Bitmask of subscribed event systems.
  */
 public function getSubscribedSystems(ClassMetadata $metadata, $eventName)
 {
     $invoke = self::INVOKE_NONE;
     if (isset($metadata->lifecycleCallbacks[$eventName])) {
         $invoke |= self::INVOKE_CALLBACKS;
     }
     if (isset($metadata->entityListeners[$eventName])) {
         $invoke |= self::INVOKE_LISTENERS;
     }
     if ($this->eventManager->hasListeners($eventName)) {
         $invoke |= self::INVOKE_MANAGER;
     }
     return $invoke;
 }

 /**
  * Dispatches postHydrate event for specified entity or enqueues it for later dispatching
  *
  * @param object $entity
  */
 public function dispatchPostHydrate($entity)
 {
     $className = get_class($entity);
     if (!$this->eventManager->hasListeners(Events::postHydrate)) {
         return;
     }
     if (isset($this->hints[Query::HINT_INTERNAL_ITERATION])) {
         $this->eventManager->dispatchEvent(Events::postHydrate, new LifecycleEventArgs($entity, $this->entityManager));
     } else {
         if (!isset($this->entities[$className])) {
             $this->entities[$className] = array();
         }
         $this->entities[$className][] = $entity;
     }
 }

 /**
  * Creates a new database.
  *
  * @param string $name The database name
  *
  * @return Database
  *
  * @throws Exception If the database could not be created.
  */
 public function createDatabase($name)
 {
     if (preg_match('@[^a-z0-9\\_\\$\\(\\)+\\-]@', $name)) {
         throw new InvalidDatabasenameException(sprintf('The database name %s is invalid. The database name must match the following pattern (a-z0-9_$()+-)', $name));
     }
     if ($this->eventManager->hasListeners(Events::PRE_CREATE_DATABASE)) {
         // @codeCoverageIgnoreStart
         $this->eventManager->dispatchEvent(Events::PRE_CREATE_DATABASE, new EventArgs($this, $name));
         // @codeCoverageIgnoreEnd
     }
     $response = $this->client->request('PUT', sprintf('/%s', $name));
     if (412 === $response->getStatusCode()) {
         throw new Exception(sprintf('The database "%s" already exist', $name));
     }
     $json = (string) $response->getBody();
     $value = JSONEncoder::decode($json);
     if (isset($value['error'])) {
         throw new Exception(sprintf('[%s] Failed to create database "%s". (%s)', $value['error'], $name, $value['reason']));
     }
     $database = $this->wrapDatabase($name);
     if ($this->eventManager->hasListeners(Events::POST_CREATE_DATABASE)) {
         // @codeCoverageIgnoreStart
         $this->eventManager->dispatchEvent(Events::POST_CREATE_DATABASE, new EventArgs($database));
         // @codeCoverageIgnoreEnd
     }
     return $database;
 }

 /**
  * Construct an entity object
  *
  * @param ClassMetadata $class
  * @param object $document
  */
 public function hydrateEntity(ClassMetadata $class, $document)
 {
     // TODO: add support for different result set types from different clients
     // perhaps by wrapping documents in a layer of abstraction
     $data = $document->getData();
     $fields = array_merge($document->hasFields() ? $document->getFields() : array(), array('_version' => $document->getVersion()));
     foreach ($fields as $name => $value) {
         if (isset($class->parameters[$name])) {
             $data[$name] = $value;
         } else {
             foreach ($class->parameters as $param => $mapping) {
                 if ($mapping->name == $name) {
                     $data[$param] = $value;
                     break;
                 }
             }
         }
     }
     $data[$class->getIdentifier()] = $document->getId();
     if (method_exists($document, 'getScore')) {
         $data['score'] = $document->getScore();
     }
     $entity = $this->sm->getSerializer()->deserialize($class->className, json_encode($data));
     if ($this->evm->hasListeners(Events::postLoad)) {
         $this->evm->dispatchEvent(Events::postLoad, new Event\LifecycleEventArgs($entity, $this->sm));
     }
     return $entity;
 }

 /**
  * Executes the queued restorations.
  */
 private function executeRestores()
 {
     $deletedFieldName = $this->configuration->getDeletedFieldName();
     $persisters = array();
     foreach ($this->restoreBy as $className => $criterias) {
         $persister = $this->getDocumentPersister($className);
         $persisters[$className] = $persister;
         foreach ($criterias as $criteria) {
             $persister->addRestoreBy($criteria);
         }
     }
     $documentRestores = array();
     foreach ($this->documentRestores as $document) {
         $className = get_class($document);
         $documentRestores[$className][] = $document;
         $persister = $this->getDocumentPersister($className);
         $persisters[$className] = $persister;
         $persister->addRestore($document);
     }
     foreach ($persisters as $className => $persister) {
         $persister->executeRestores();
         $class = $this->dm->getClassMetadata($className);
         if (isset($documentRestores[$className])) {
             $documents = $documentRestores[$className];
             foreach ($documents as $document) {
                 $class->setFieldValue($document, $deletedFieldName, null);
                 if ($this->eventManager->hasListeners(Events::postRestore)) {
                     $this->eventManager->dispatchEvent(Events::postRestore, new Event\LifecycleEventArgs($document, $this));
                 }
             }
         }
     }
 }

 /**
  * {@inheritDoc}
  */
 protected function doLoadMetadata($class, $parent, $rootEntityFound, array $nonSuperclassParents)
 {
     /* @var $class \Doctrine\OXM\Mapping\ClassMetadata */
     /* @var $parent \Doctrine\OXM\Mapping\ClassMetadata */
     if ($parent) {
         $class->setIdGeneratorType($parent->generatorType);
         $this->addInheritedFields($class, $parent);
         $class->setXmlNamespaces($parent->xmlNamespaces);
         $class->setIdentifier($parent->identifier);
         $class->setLifecycleCallbacks($parent->lifecycleCallbacks);
         $class->setChangeTrackingPolicy($parent->changeTrackingPolicy);
         $class->parent = $parent->getName();
     }
     // Invoke driver
     try {
         $this->driver->loadMetadataForClass($class->getName(), $class);
     } catch (ReflectionException $e) {
         throw MappingException::reflectionFailure($class->getName(), $e);
     }
     $xmlNamespace = empty($class->xmlNamespaces) ? '' : $class->xmlNamespaces[0]['url'];
     foreach ($class->xmlNamespaces as $namespaceData) {
         if (empty($namespaceData['prefix'])) {
             $xmlNamespace = $namespaceData['url'];
         }
     }
     $xmlName = $class->getXmlName();
     // Ignore duplicate binding issues -- at least for now
     /*
     if ( $this->isEntity($class) && array_key_exists($xmlName, $this->xmlToClassMap) && array_key_exists($xmlNamespace, $this->xmlToClassMap[$xmlName])) {
     			if ($this->xmlToClassMap[$xmlName][$xmlNamespace] == $class->getName() || $this->xmlToClassMap[$xmlName][$xmlNamespace] == '\\' . $class->getName()) {
     				// Ignore
     	        } else {
     		throw MappingException::duplicateXmlNameBinding($class->getName(), $class->getXmlName());
     	        }
     }
     */
     // The previous test should be sufficent for us to just assume that the namespace/alternative is fine
     if (!empty($parent)) {
         $this->alternativeClassMap[$parent->getName()][$xmlNamespace] = $class->getName();
     }
     if (!$class->isMappedSuperclass) {
         $this->xmlToClassMap[$xmlName][$xmlNamespace] = $class->getName();
     }
     if ($parent && !$parent->isMappedSuperclass) {
         if ($parent->generatorType) {
             $class->setIdGeneratorType($parent->generatorType);
         }
         if ($parent->idGenerator) {
             $class->setIdGenerator($parent->idGenerator);
         }
     } else {
         $this->completeIdGeneratorMapping($class);
     }
     $class->setParentClasses($nonSuperclassParents);
     // Todo - ensure that root elements have an ID mapped
     if ($this->evm->hasListeners(Events::loadClassMetadata)) {
         $eventArgs = new LoadClassMetadataEventArgs($class, $this);
         $this->evm->dispatchEvent(Events::loadClassMetadata, $eventArgs);
     }
 }

 /**
  * Hydrate array of MongoDB document data into the given document object.
  *
  * @param object $document  The document object to hydrate the data into.
  * @param array $data The array of document data.
  * @return array $values The array of hydrated values.
  */
 public function hydrate($document, $data)
 {
     $metadata = $this->dm->getClassMetadata(get_class($document));
     // Invoke preLoad lifecycle events and listeners
     if (isset($metadata->lifecycleCallbacks[Events::preLoad])) {
         $args = array(&$data);
         $metadata->invokeLifecycleCallbacks(Events::preLoad, $document, $args);
     }
     if ($this->evm->hasListeners(Events::preLoad)) {
         $this->evm->dispatchEvent(Events::preLoad, new PreLoadEventArgs($document, $this->dm, $data));
     }
     // Use the alsoLoadMethods on the document object to transform the data before hydration
     if (isset($metadata->alsoLoadMethods)) {
         foreach ($metadata->alsoLoadMethods as $fieldName => $method) {
             if (isset($data[$fieldName])) {
                 $document->{$method}($data[$fieldName]);
             }
         }
     }
     if ($this->hydratorFactory !== null) {
         $data = $this->hydratorFactory->getHydratorFor($metadata->name)->hydrate($document, $data);
     } else {
         $data = $this->doGenericHydration($metadata, $document, $data);
     }
     // Invoke the postLoad lifecycle callbacks and listeners
     if (isset($metadata->lifecycleCallbacks[Events::postLoad])) {
         $metadata->invokeLifecycleCallbacks(Events::postLoad, $document);
     }
     if ($this->evm->hasListeners(Events::postLoad)) {
         $this->evm->dispatchEvent(Events::postLoad, new LifecycleEventArgs($document, $this->dm));
     }
     return $data;
 }

 /**
  * Get the subscribed event systems
  *
  * @param ClassMetadata $metadata
  * @param string        $eventName The entity lifecycle event.
  *
  * @return integer                 Bitmask of subscribed event systems.
  */
 public function getSubscribedSystems(ClassMetadata $metadata, $eventName)
 {
     $invoke = self::INVOKE_NONE;
     if ($metadata && isset($metadata->lifecycleCallbacks[$eventName])) {
         $invoke |= self::INVOKE_CALLBACKS;
     }
     /*
      * Not implemented for phpcr-odm at the moment.
      *
     if (isset($metadata->documentListeners[$eventName])) {
         $invoke |= self::INVOKE_LISTENERS;
     }
     */
     if ($this->eventManager->hasListeners($eventName)) {
         $invoke |= self::INVOKE_MANAGER;
     }
     return $invoke;
 }

 /**
  * Actually load the metadata from the underlying metadata
  *
  * @param ClassMetadataInterface|ClassMetadata $class
  * @param ClassMetadataInterface|ClassMetadata $parent
  * @param bool $rootEntityFound
  * @param array $nonSuperclassParents
  */
 protected function doLoadMetadata($class, $parent, $rootEntityFound, array $nonSuperclassParents)
 {
     //Manipulates $classMetadata;
     $this->driver->loadMetadataForClass($class->getName(), $class);
     if ($this->evm->hasListeners(Events::loadClassMetadata)) {
         $eventArgs = new LoadClassMetadataEventArgs($class, $this->sm);
         $this->evm->dispatchEvent(Events::loadClassMetadata, $eventArgs);
     }
 }

 public function save(array &$a, array $options = array())
 {
     if ($this->eventManager->hasListeners(Events::preSave)) {
         $this->eventManager->dispatchEvent(Events::preSave, new EventArgs($this, $a));
     }
     $result = $this->doSave($a, $options);
     if ($this->eventManager->hasListeners(Events::postSave)) {
         $this->eventManager->dispatchEvent(Events::postSave, new EventArgs($this, $result));
     }
     return $result;
 }

 /**
  * {@inheritdoc}
  */
 protected function doLoadMetadata($class, $parent, $rootEntityFound, array $nonSuperclassParents)
 {
     if ($this->getDriver()) {
         $this->getDriver()->loadMetadataForClass($class->getName(), $class);
     }
     if ($this->evm->hasListeners(Event::loadClassMetadata)) {
         $eventArgs = new Event\LoadClassMetadataEventArgs($class, $this->objectAdapterManager);
         $this->evm->dispatchEvent(Event::loadClassMetadata, $eventArgs);
     }
     $this->validateRuntimeMetadata($class, $parent);
 }

 /** @proxy */
 public function selectCollection($name)
 {
     if ($this->eventManager->hasListeners(Events::preSelectCollection)) {
         $this->eventManager->dispatchEvent(Events::preSelectCollection, new EventArgs($this, $name));
     }
     $collection = $this->doSelectCollection($name);
     if ($this->eventManager->hasListeners(Events::postSelectCollection)) {
         $this->eventManager->dispatchEvent(Events::postSelectCollection, new EventArgs($this, $collection));
     }
     return $collection;
 }

 /**
  * @param ObjectManager $om
  *
  * @return MetadataFactory
  */
 protected function getMetadataFactory(ObjectManager $om, EventManager $evm)
 {
     if ($this->metadataFactory === null) {
         $driverFactory = DriverFactory::instance();
         if ($evm->hasListeners(Events::REGISTER_DRIVER_METADATA)) {
             $eventArgs = new RegisterDriverMetadataEventArgs($driverFactory, $om);
             $evm->dispatchEvent(Events::REGISTER_DRIVER_METADATA, $eventArgs);
         }
         $this->metadataFactory = new MetadataFactory($driverFactory->driversFromManager($om));
     }
     return $this->metadataFactory;
 }

 /** @proxy */
 public function selectDatabase($name)
 {
     if ($this->eventManager->hasListeners(Events::preSelectDatabase)) {
         $this->eventManager->dispatchEvent(Events::preSelectDatabase, new EventArgs($this, $name));
     }
     $this->initialize();
     $database = $this->wrapDatabase($name);
     if ($this->eventManager->hasListeners(Events::postSelectDatabase)) {
         $this->eventManager->dispatchEvent(Events::postSelectDatabase, new EventArgs($this, $database));
     }
     return $database;
 }

 /**
  * @param TableDiff $diff
  * @param array $columnSql
  */
 protected function onSchemaAlterTable(TableDiff $diff, &$sql)
 {
     if (null === $this->_eventManager) {
         return false;
     }
     if (!$this->_eventManager->hasListeners(Events::onSchemaAlterTable)) {
         return false;
     }
     $eventArgs = new SchemaAlterTableEventArgs($diff, $this);
     $this->_eventManager->dispatchEvent(Events::onSchemaAlterTable, $eventArgs);
     $sql = array_merge($sql, $eventArgs->getSql());
     return $eventArgs->isDefaultPrevented();
 }