PHP ObjectManager::contains方法代码示例

 /**
  * {@inheritdoc}
  */
 protected function doUpdate($object, $flush = true)
 {
     if (!$this->manager->contains($object)) {
         $this->manager->persist($object);
     }
     if ($flush) {
         $this->flush($object);
     }
 }

 /**
  * {@inheritdoc}
  */
 public function handle(ApiCallInterface $apiCall)
 {
     if (!$this->objectManager->contains($apiCall)) {
         if ($apiCall->getId() === null) {
             $this->objectManager->persist($apiCall);
         } else {
             $this->objectManager->merge($apiCall);
         }
     }
     $this->objectManager->flush();
 }

 /**
  * {@inheritdoc}
  */
 public function update(Content $content)
 {
     $managed = true;
     if (!$this->om->contains($content)) {
         $managed = false;
         $content = $this->om->merge($content);
     }
     $this->om->flush($content);
     if (!$managed) {
         $this->om->detach($content);
     }
 }

 /**
  * Returns the values of the identifier fields of an entity.
  *
  * Doctrine must know about this entity, that is, the entity must already
  * be persisted or added to the identity map before. Otherwise an
  * exception is thrown.
  *
  * @param  object $entity The entity for which to get the identifier
  *
  * @return array          The identifier values
  *
  * @throws FormException  If the entity does not exist in Doctrine's identity map
  */
 public function getIdentifierValues($entity)
 {
     if (!$this->em->contains($entity)) {
         throw new FormException('Entities passed to the choice field must be managed');
     }
     return $this->classMetadata->getIdentifierValues($entity);
 }

 function it_can_handle_exiting_unmanaged_objects(ObjectManager $objectManager, ApiCallInterface $apiCall)
 {
     $objectManager->contains($apiCall)->willReturn(false);
     $apiCall->getId()->willReturn(1);
     $objectManager->merge($apiCall)->shouldBeCalled();
     $objectManager->flush()->shouldBeCalled();
     $this->handle($apiCall);
 }

 /**
  * Returns the values of the identifier fields of an entity.
  *
  * Doctrine must know about this entity, that is, the entity must already
  * be persisted or added to the identity map before. Otherwise an
  * exception is thrown.
  *
  * @param object $entity The entity for which to get the identifier
  *
  * @return array          The identifier values
  *
  * @throws Exception If the entity does not exist in Doctrine's identity map
  */
 private function getIdentifierValues($entity)
 {
     if (!$this->em->contains($entity)) {
         throw new Exception('Entities passed to the choice field must be managed. Maybe ' . 'persist them in the entity manager?');
     }
     $this->em->initializeObject($entity);
     return $this->classMetadata->getIdentifierValues($entity);
 }

 /**
  * Returns the ID value for an object.
  *
  * This method assumes that the object has a single-column ID.
  *
  * @param object $object The object.
  *
  * @return mixed The ID value.
  */
 public function getIdValue($object)
 {
     if (!$object) {
         return;
     }
     if (!$this->om->contains($object)) {
         throw new RuntimeException('Entities passed to the choice field must be managed. Maybe ' . 'persist them in the entity manager?');
     }
     $this->om->initializeObject($object);
     return current($this->classMetadata->getIdentifierValues($object));
 }

 /**
  * Loads an object using stored reference
  * named by $name
  *
  * @param string $name
  * @throws OutOfBoundsException - if repository does not exist
  * @return object
  */
 public function getReference($name)
 {
     if (!$this->hasReference($name)) {
         throw new \OutOfBoundsException("Reference to: ({$name}) does not exist");
     }
     $reference = $this->references[$name];
     $meta = $this->manager->getClassMetadata(get_class($reference));
     if (!$this->manager->contains($reference) && isset($this->identities[$name])) {
         $reference = $this->manager->getReference($meta->name, $this->identities[$name]);
         $this->references[$name] = $reference;
         // already in identity map
     }
     return $reference;
 }

 /**
  * Returns the (internal) identifier for the object, if it is known to the
  * backend. Otherwise NULL is returned.
  *
  * Note: this returns an identifier even if the object has not been
  * persisted in case of AOP-managed entities. Use isNewObject() if you need
  * to distinguish those cases.
  *
  * @param object $object
  * @return mixed The identifier for the object if it is known, or NULL
  * @api
  * @todo improve try/catch block
  */
 public function getIdentifierByObject($object)
 {
     if ($this->entityManager->contains($object)) {
         try {
             return current($this->entityManager->getUnitOfWork()->getEntityIdentifier($object));
         } catch (\Doctrine\ORM\ORMException $e) {
             return NULL;
         }
     } elseif (property_exists($object, 'FLOW3_Persistence_Identifier')) {
         return \TYPO3\FLOW3\Reflection\ObjectAccess::getProperty($object, 'FLOW3_Persistence_Identifier', TRUE);
     } else {
         return NULL;
     }
 }

 /**
  * Returns the (internal) identifier for the object, if it is known to the
  * backend. Otherwise NULL is returned.
  *
  * Note: this returns an identifier even if the object has not been
  * persisted in case of AOP-managed entities. Use isNewObject() if you need
  * to distinguish those cases.
  *
  * @param object $object
  * @return mixed The identifier for the object if it is known, or NULL
  * @api
  * @todo improve try/catch block
  */
 public function getIdentifierByObject($object)
 {
     if (property_exists($object, 'Persistence_Object_Identifier')) {
         $identifierCandidate = ObjectAccess::getProperty($object, 'Persistence_Object_Identifier', true);
         if ($identifierCandidate !== null) {
             return $identifierCandidate;
         }
     }
     if ($this->entityManager->contains($object)) {
         try {
             return current($this->entityManager->getUnitOfWork()->getEntityIdentifier($object));
         } catch (\Doctrine\ORM\ORMException $exception) {
         }
     }
     return null;
 }

 /**
  * Returns the (internal) identifier for the object, if it is known to the
  * backend. Otherwise NULL is returned.
  *
  * Note: this returns an identifier even if the object has not been
  * persisted in case of AOP-managed entities. Use isNewObject() if you need
  * to distinguish those cases.
  *
  * @param object $object
  * @return mixed The identifier for the object if it is known, or NULL
  * @api
  * @todo improve try/catch block
  */
 public function getIdentifierByObject($object)
 {
     if (property_exists($object, 'Persistence_Object_Identifier')) {
         $identifierCandidate = \TYPO3\Flow\Reflection\ObjectAccess::getProperty($object, 'Persistence_Object_Identifier', TRUE);
         if ($identifierCandidate !== NULL) {
             return $identifierCandidate;
         }
     }
     if ($this->entityManager->contains($object)) {
         try {
             return current($this->entityManager->getUnitOfWork()->getEntityIdentifier($object));
         } catch (\Doctrine\ORM\ORMException $e) {
         }
     }
     return NULL;
 }

 /**
  * (non-PHPdoc)
  *
  * @see \Symfony\Component\Security\Core\User\UserProviderInterface::refreshUser()
  */
 public function refreshUser(UserInterface $user)
 {
     $userClass = get_class($user);
     if (!$this->supportsClass($userClass)) {
         throw new UnsupportedUserException("Unsupported user '" . $userClass . "'");
     }
     /* @var ADH\UserBundle\Entity\User $user */
     if ($this->entityManager->contains($user)) {
         $this->entityManager->refresh($user);
     } else {
         $user = $this->userRepository->findOneById($user->getId());
     }
     if ($user === null) {
         throw new UsernameNotFoundException("User does not exist.");
     }
     return $user;
 }

 /**
  * {@inheritDoc}
  */
 public function supports($object)
 {
     return $this->om->contains($object);
 }

 /**
  * @param ObjectManager|DocumentManager|EntityManager $om
  * @param object                                      $object
  */
 protected function recomputeSingleObjectChangeSet(ObjectManager $om, $object)
 {
     if ($om->contains($object)) {
         $classMetadata = $om->getClassMetadata(get_class($object));
         $uow = $om->getUnitOfWork();
         if ($uow instanceof ODMUnitOfWork) {
             $uow->recomputeSingleDocumentChangeSet($classMetadata, $object);
         } elseif ($uow instanceof ORMUnitOfWork) {
             $uow->recomputeSingleEntityChangeSet($classMetadata, $object);
         }
     }
 }

 /**
  * @param object        $entity        entity
  * @param ObjectManager $entityManager entityManager
  * @param UnitOfWork    $uow           uow
  */
 private function computeViolations($entity, ObjectManager $entityManager, UnitOfWork $uow)
 {
     if (!($handlers = $this->handlerManager->fetch($entity))) {
         return null;
     }
     $list = $this->violationManager->getViolationListNotFixed($entity);
     $list->setFixed(true);
     foreach ($handlers as $handler) {
         $handler->validate($entity, $list);
     }
     $uow->computeChangeSets();
     foreach ($list as $violation) {
         $changeSet = $uow->getEntityChangeSet($violation);
         if (!empty($changeSet) || !$entityManager->contains($violation)) {
             $this->violations[spl_object_hash($violation)] = $violation;
         }
     }
 }