public function testHasGetMetadata_NamespaceSeperatorIsNotNormalized()
 {
     require_once __DIR__ . "/Documents/GlobalNamespaceDocument.php";
     $driver = AnnotationDriver::create(__DIR__ . '/Documents');
     $dm = $this->getMockDocumentManager($driver);
     $cmf = new ClassMetadataFactory();
     $cmf->setConfiguration($dm->getConfiguration());
     $cmf->setDocumentManager($dm);
     $m1 = $cmf->getMetadataFor("DoctrineGlobal_Article");
     $h1 = $cmf->hasMetadataFor("DoctrineGlobal_Article");
     $h2 = $cmf->hasMetadataFor("\\DoctrineGlobal_Article");
     $m2 = $cmf->getMetadataFor("\\DoctrineGlobal_Article");
     $this->assertNotSame($m1, $m2);
     $this->assertFalse($h2);
     $this->assertTrue($h1);
 }
Beispiel #2
0
 /**
  * {@inheritDoc}
  */
 public function createProxyDefinition($className)
 {
     /* @var $classMetadata \Doctrine\ODM\MongoDB\Mapping\ClassMetadataInfo */
     $classMetadata = $this->metadataFactory->getMetadataFor($className);
     $documentPersister = $this->uow->getDocumentPersister($className);
     $reflectionId = $classMetadata->reflFields[$classMetadata->identifier];
     return new ProxyDefinition(ClassUtils::generateProxyClassName($className, $this->proxyNamespace), $classMetadata->getIdentifierFieldNames(), $classMetadata->getReflectionProperties(), $this->createInitializer($classMetadata, $documentPersister, $reflectionId), $this->createCloner($classMetadata, $documentPersister, $reflectionId));
 }
 /**
  * Gets a reference to the document identified by the given type and identifier
  * without actually loading it.
  *
  * If partial objects are allowed, this method will return a partial object that only
  * has its identifier populated. Otherwise a proxy is returned that automatically
  * loads itself on first access.
  *
  * @return object The document reference.
  */
 public function getReference($documentName, $identifier)
 {
     $class = $this->_metadataFactory->getMetadataFor($documentName);
     // Check identity map first, if its already in there just return it.
     if ($document = $this->_unitOfWork->tryGetById($identifier, $class->rootDocumentName)) {
         return $document;
     }
     $document = $this->_proxyFactory->getProxy($class->name, $identifier);
     $this->_unitOfWork->registerManaged($document, $identifier, array());
     return $document;
 }
Beispiel #4
0
 /**
  * Gets a partial reference to the document identified by the given type and identifier
  * without actually loading it, if the document is not yet loaded.
  *
  * The returned reference may be a partial object if the document is not yet loaded/managed.
  * If it is a partial object it will not initialize the rest of the document state on access.
  * Thus you can only ever safely access the identifier of an document obtained through
  * this method.
  *
  * The use-cases for partial references involve maintaining bidirectional associations
  * without loading one side of the association or to update an document without loading it.
  * Note, however, that in the latter case the original (persistent) document data will
  * never be visible to the application (especially not event listeners) as it will
  * never be loaded in the first place.
  *
  * @param string $documentName The name of the document type.
  * @param mixed $identifier The document identifier.
  * @return object The (partial) document reference.
  */
 public function getPartialReference($documentName, $identifier)
 {
     $class = $this->metadataFactory->getMetadataFor($documentName);
     // Check identity map first, if its already in there just return it.
     if ($document = $this->unitOfWork->tryGetById($identifier, $class->rootDocumentName)) {
         return $document;
     }
     $document = $class->newInstance();
     $class->setIdentifierValue($document, $identifier);
     $this->unitOfWork->registerManaged($document, $identifier, array());
     return $document;
 }
 /**
  * {@inheritdoc}
  */
 public function getMetadataFor($className)
 {
     if (!isset($this->innerLoadedMetadata[$className])) {
         $evm = $this->documentManager->getEventManager();
         if ($evm->hasListeners(Events::PRE_LOAD_CLASSMETADATA)) {
             $eventArgs = new PreLoadClassMetadataEventArgs($className, $this->documentManager);
             $evm->dispatchEvent(Events::PRE_LOAD_CLASSMETADATA, $eventArgs);
         }
         $classMetadata = parent::getMetadataFor($className);
         if ($evm->hasListeners(Events::POST_LOAD_CLASS_METADATA)) {
             $eventArgs = new LoadClassMetadataEventArgs($classMetadata, $this->documentManager);
             $evm->dispatchEvent(Events::POST_LOAD_CLASS_METADATA, $eventArgs);
         }
         $this->innerLoadedMetadata[$className] = $classMetadata;
     }
     return $this->innerLoadedMetadata[$className];
 }
 public function testShardKeyCollectionPerClassInheritanceOverriding()
 {
     $class = $this->factory->getMetadataFor(ShardedCollectionPerClass3::class);
     $this->assertTrue($class->isSharded());
     $this->assertEquals(array('keys' => array('_id' => 'hashed'), 'options' => array()), $class->getShardKey());
 }