С версии: 1.0
Наследование: extends Doctrine\Common\Persistence\Mapping\AbstractClassMetadataFactory
Пример #1
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));
 }
Пример #2
0
 /**
  * Create all the mapped document databases in the metadata factory.
  */
 public function createDatabases()
 {
     foreach ($this->metadataFactory->getAllMetadata() as $class) {
         if ($class->isMappedSuperclass || $class->isEmbeddedDocument) {
             continue;
         }
         $this->createDocumentDatabase($class->name);
     }
 }
Пример #3
0
 /**
  * Ensure collections are sharded for all documents that can be loaded with the
  * metadata factory.
  *
  * @param array $indexOptions Options for `ensureIndex` command. It's performed on an existing collections
  *
  * @throws MongoDBException
  */
 public function ensureSharding(array $indexOptions = array())
 {
     foreach ($this->metadataFactory->getAllMetadata() as $class) {
         if ($class->isMappedSuperclass || !$class->isSharded()) {
             continue;
         }
         $this->ensureDocumentSharding($class->name, $indexOptions);
     }
 }
Пример #4
0
 public function setUp()
 {
     $this->dm = $this->getMockDocumentManager();
     $cmf = new ClassMetadataFactory();
     $cmf->setConfiguration($this->dm->getConfiguration());
     $cmf->setDocumentManager($this->dm);
     $map = array();
     foreach ($cmf->getAllMetadata() as $cm) {
         $this->documentCollections[$cm->name] = $this->getMockCollection();
         $this->documentDatabases[$cm->name] = $this->getMockDatabase();
         $this->classMetadatas[$cm->name] = $cm;
     }
     $this->dm->unitOfWork = $this->getMockUnitOfWork();
     $this->dm->metadataFactory = $cmf;
     $this->dm->documentCollections = $this->documentCollections;
     $this->dm->documentDatabases = $this->documentDatabases;
     $this->schemaManager = new SchemaManager($this->dm, $cmf);
     $this->dm->schemaManager = $this->schemaManager;
 }
 /**
  * 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;
 }
Пример #6
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;
 }
 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);
 }
Пример #8
0
 /**
  * {@inheritdoc}
  */
 public function setDocumentManager(DocumentManager $dm)
 {
     parent::setDocumentManager($dm);
     $this->documentManager = $dm;
 }
 public function testShardKeyCollectionPerClassInheritanceOverriding()
 {
     $class = $this->factory->getMetadataFor(ShardedCollectionPerClass3::class);
     $this->assertTrue($class->isSharded());
     $this->assertEquals(array('keys' => array('_id' => 'hashed'), 'options' => array()), $class->getShardKey());
 }