PHP Mapping\ClassMetadataInfo类代码示例

 /**
  * Convert thrift class spec to doctrine ClassMetadataInfo
  *
  * @param $className
  * @return ClassMetadataInfo
  * @throws \Doctrine\ODM\MongoDB\Mapping\MappingException
  * @throws \Exception
  */
 public function read($className)
 {
     $cmi = new ClassMetadataInfo($className);
     $types = array(TType::BOOL => 'bool', TType::I32 => 'integer', TType::I64 => 'integer', TType::DOUBLE => 'float', TType::UTF7 => 'string', TType::UTF8 => 'string', TType::LST => 'many', TType::STRUCT => 'one', TType::MAP => 'hash');
     $spec = $this->loadSpec($className);
     foreach ($spec as $id => $fieldSpec) {
         if (!isset($types[$fieldSpec['type']])) {
             throw new \Exception('Unknown thrift -> doctrine type conversion');
         }
         $type = $types[$fieldSpec['type']];
         if ($fieldSpec['type'] == TType::LST) {
             // list
             if ($fieldSpec['etype'] == TType::STRUCT) {
                 // list of structs
                 $mapping = array('fieldName' => $fieldSpec['var'], 'name' => $id . '_' . $fieldSpec['var'], 'embedded' => true, 'type' => $type, 'targetDocument' => substr($fieldSpec['elem']['class'], 1));
             } else {
                 // list of simple types
                 $mapping = array('fieldName' => $fieldSpec['var'], 'name' => $id . '_' . $fieldSpec['var'], 'type' => 'hash');
             }
         } elseif ($fieldSpec['type'] == TType::STRUCT) {
             // single struct
             $mapping = array('fieldName' => $fieldSpec['var'], 'name' => $id . '_' . $fieldSpec['var'], 'embedded' => true, 'type' => $type, 'targetDocument' => substr($fieldSpec['class'], 1));
         } else {
             // simple field
             $mapping = array('fieldName' => $fieldSpec['var'], 'name' => $id . '_' . $fieldSpec['var'], 'type' => $type);
         }
         $cmi->mapField($mapping);
     }
     return $cmi;
 }

 /**
  * @param ColumnInfoInterface         $columnInfo
  * @param ODMMongoDBClassMetadataInfo $metadata
  *
  * @return array
  */
 private function getODMTransformerInfo(ColumnInfoInterface $columnInfo, ODMMongoDBClassMetadataInfo $metadata)
 {
     $fieldName = $columnInfo->getPropertyPath();
     if (in_array($metadata->getTypeOfField($fieldName), ['entity', 'entities'])) {
         $mapping = $metadata->getFieldMapping($fieldName);
         $target = $mapping['targetEntity'];
         if (!$this->doctrine->getRepository($target) instanceof ReferableEntityRepositoryInterface) {
             return;
         }
         return array($this->transformer, array('class' => $target, 'multiple' => 'entities' === $metadata->getTypeOfField($fieldName)));
     }
     if (in_array($metadata->getTypeOfField($fieldName), ['one', 'many'])) {
         $mapping = $metadata->getFieldMapping($fieldName);
         $target = $mapping['targetDocument'];
         // TODO Remove this hack
         switch ($target) {
             case 'Pim\\Bundle\\CatalogBundle\\Model\\ProductPrice':
             case 'Pim\\Bundle\\CatalogBundle\\Model\\Metric':
                 return;
         }
         if (!$this->doctrine->getRepository($target) instanceof ReferableEntityRepositoryInterface) {
             return;
         }
         return array($this->transformer, array('class' => $mapping['targetDocument'], 'multiple' => 'many' === $metadata->getTypeOfField($fieldName)));
     }
 }

 /**
  * Returns an array of fields. Fields can be both column fields and
  * association fields.
  *
  * @param \Doctrine\ODM\MongoDB\Mapping\ClassMetadataInfo $metadata
  *
  * @return array
  */
 private function getFieldsFromMetadata(ClassMetadataInfo $metadata)
 {
     $fields = (array) $metadata->getFieldNames();
     // Remove the primary key field if it's not managed manually
     if ($metadata->isIdGeneratorAuto()) {
         $fields = array_diff($fields, array($metadata->identifier));
     }
     return $fields;
 }

 public function testOwningSideAndInverseSide()
 {
     $cm = new ClassMetadataInfo('Documents\\User');
     $cm->mapManyReference(array('fieldName' => 'articles', 'inversedBy' => 'user'));
     $this->assertTrue($cm->fieldMappings['articles']['isOwningSide']);
     $cm = new ClassMetadataInfo('Documents\\Article');
     $cm->mapOneReference(array('fieldName' => 'user', 'mappedBy' => 'articles'));
     $this->assertTrue($cm->fieldMappings['user']['isInverseSide']);
 }

 protected function setUp()
 {
     parent::setUp();
     $this->filesystem = new Filesystem();
     $this->documentName = ucfirst($this->getName());
     $this->tmpDir = sys_get_temp_dir() . '/ismaambrosi';
     $this->metadata = new ClassMetadataInfo($this->documentName);
     $this->metadata->mapField(array('name' => 'id', 'id' => true, 'strategy' => 'auto'));
     $this->metadata->mapField(array('fieldName' => 'name', 'type' => 'string'));
     $this->metadata->mapField(array('fieldName' => 'description', 'type' => 'string'));
 }

 function it_configures_the_mappings_of_a_model_that_overrides_an_original_model($configuration, ClassMetadataInfo $metadataInfo, MappingDriver $mappingDriver)
 {
     $originalQux1 = __NAMESPACE__ . '\\OriginalQux1';
     $originalQux2 = __NAMESPACE__ . '\\OriginalQux2';
     $overrideQux1 = __NAMESPACE__ . '\\OverrideQux1';
     $overrideQux2 = __NAMESPACE__ . '\\OverrideQux2';
     $mappingDriver->getAllClassNames()->willReturn([$originalQux1]);
     $configuration->getMetadataDriverImpl()->willReturn($mappingDriver);
     $metadataInfo->getName()->willReturn($overrideQux1);
     $mappingDriver->loadMetadataForClass($originalQux1, Argument::any())->shouldBeCalled();
     $overrides = [['original' => $originalQux1, 'override' => $overrideQux1], ['original' => $originalQux2, 'override' => $overrideQux2]];
     $this->configure($metadataInfo, $overrides, $configuration);
 }

 /**
  * Set the association mappings of a metadata.
  *
  * @param ClassMetadataInfo $metadata
  * @param Configuration     $configuration
  */
 protected function setAssociationMappings(ClassMetadataInfo $metadata, Configuration $configuration)
 {
     $supportedClasses = $configuration->getMetadataDriverImpl()->getAllClassNames();
     foreach (class_parents($metadata->getName()) as $parent) {
         if (in_array($parent, $supportedClasses)) {
             $parentMetadata = new MongoClassMetadata($parent);
             $configuration->getMetadataDriverImpl()->loadMetadataForClass($parent, $parentMetadata);
             foreach ($parentMetadata->associationMappings as $key => $value) {
                 if ($this->hasRelation($value['association'])) {
                     $metadata->associationMappings[$key] = $value;
                 }
             }
         }
     }
 }

 /**
  * @param ClassMetadataInfo $metadata
  * @param $configuration
  */
 private function setAssociationMappings(ClassMetadataInfo $metadata, $configuration)
 {
     foreach (class_parents($metadata->getName()) as $parent) {
         $parentMetadata = new ClassMetadata($parent);
         if (in_array($parent, $configuration->getMetadataDriverImpl()->getAllClassNames())) {
             $configuration->getMetadataDriverImpl()->loadMetadataForClass($parent, $parentMetadata);
             if ($parentMetadata->isMappedSuperclass) {
                 foreach ($parentMetadata->associationMappings as $key => $value) {
                     if ($this->hasRelation($value['association'])) {
                         $metadata->associationMappings[$key] = $value;
                     }
                 }
             }
         }
     }
 }

 public function generateBookDocumentFixture()
 {
     $metadata = new ClassMetadataInfo($this->namespace . '\\DocumentGeneratorBook');
     $metadata->namespace = $this->namespace;
     $metadata->customRepositoryClassName = $this->namespace . '\\DocumentGeneratorBookRepository';
     $metadata->collection = 'book';
     $metadata->mapField(array('fieldName' => 'name', 'type' => 'string'));
     $metadata->mapField(array('fieldName' => 'status', 'type' => 'string'));
     $metadata->mapField(array('fieldName' => 'id', 'type' => 'integer', 'id' => true));
     $metadata->mapOneReference(array('fieldName' => 'author', 'targetDocument' => 'Doctrine\\ODM\\MongoDB\\Tests\\Tools\\DocumentGeneratorAuthor'));
     $metadata->mapManyReference(array('fieldName' => 'comments', 'targetDocument' => 'Doctrine\\ODM\\MongoDB\\Tests\\Tools\\DocumentGeneratorComment'));
     $metadata->addLifecycleCallback('loading', 'postLoad');
     $metadata->addLifecycleCallback('willBeRemoved', 'preRemove');
     $metadata->setIdGeneratorType(ClassMetadataInfo::GENERATOR_TYPE_AUTO);
     $this->generator->writeDocumentClass($metadata, $this->tmpDir);
     return $metadata;
 }

 /**
  * @param  \Symfony\Component\HttpKernel\Bundle\BundleInterface $bundle
  * @param  string                                               $document
  * @param  array                                                $fields
  * @param  Boolean                                              $withRepository
  * @throws \RuntimeException
  */
 public function generate(BundleInterface $bundle, $document, array $fields, $withRepository)
 {
     $config = $this->documentManager->getConfiguration();
     $config->addDocumentNamespace($bundle->getName(), $bundle->getNamespace() . '\\Document');
     $documentClass = $config->getDocumentNamespace($bundle->getName()) . '\\' . $document;
     $documentPath = $bundle->getPath() . '/Document/' . str_replace('\\', '/', $document) . '.php';
     if (file_exists($documentPath)) {
         throw new \RuntimeException(sprintf('Document "%s" already exists.', $documentClass));
     }
     $class = new ClassMetadataInfo($documentClass);
     if ($withRepository) {
         $class->setCustomRepositoryClass($documentClass . 'Repository');
     }
     $class->mapField(array('fieldName' => 'id', 'type' => 'integer', 'id' => true));
     $class->setIdGeneratorType(ClassMetadataInfo::GENERATOR_TYPE_AUTO);
     foreach ($fields as $field) {
         $class->mapField($field);
     }
     $documentGenerator = $this->getDocumentGenerator();
     $documentCode = $documentGenerator->generateDocumentClass($class);
     $this->filesystem->mkdir(dirname($documentPath));
     file_put_contents($documentPath, rtrim($documentCode) . PHP_EOL, LOCK_EX);
     if ($withRepository) {
         $path = $bundle->getPath() . str_repeat('/..', substr_count(get_class($bundle), '\\'));
         $this->getRepositoryGenerator()->writeDocumentRepositoryClass($class->customRepositoryClassName, $path);
     }
 }

 /**
  * @param ClassMetadataInfo $metadata
  * @param $configuration
  */
 private function setAssociationMappings(ClassMetadataInfo $metadata, $configuration)
 {
     foreach (class_parents($metadata->getName()) as $parent) {
         if (false === in_array($parent, $configuration->getMetadataDriverImpl()->getAllClassNames())) {
             continue;
         }
         $parentMetadata = new ClassMetadata($parent, $configuration->getNamingStrategy());
         // Wakeup Reflection
         $parentMetadata->wakeupReflection($this->getReflectionService());
         // Load Metadata
         $configuration->getMetadataDriverImpl()->loadMetadataForClass($parent, $parentMetadata);
         if (false === $this->isResource($parentMetadata)) {
             continue;
         }
         if ($parentMetadata->isMappedSuperclass) {
             foreach ($parentMetadata->associationMappings as $key => $value) {
                 if ($this->hasRelation($value['association'])) {
                     $metadata->associationMappings[$key] = $value;
                 }
             }
         }
     }
 }

 /**
  * @param ClassMetadataInfo $class
  * @param ODM\ShardKey      $shardKey
  *
  * @throws MappingException
  */
 private function setShardKey(ClassMetadataInfo $class, ODM\ShardKey $shardKey)
 {
     $options = array();
     $allowed = array('unique', 'numInitialChunks');
     foreach ($allowed as $name) {
         if (isset($shardKey->{$name})) {
             $options[$name] = $shardKey->{$name};
         }
     }
     $class->setShardKey($shardKey->keys, $options);
 }

    /**
     * {@inheritdoc}
     */
    public function loadMetadataForClass($className, ClassMetadataInfo $class)
    {
        $element = $this->getElement($className);
        if ( ! $element) {
            return;
        }
        $element['type'] = isset($element['type']) ? $element['type'] : 'document';

        if (isset($element['db'])) {
            $class->setDatabase($element['db']);
        }
        if (isset($element['collection'])) {
            $class->setCollection($element['collection']);
        }
        if ($element['type'] == 'document') {
            if (isset($element['repositoryClass'])) {
                $class->setCustomRepositoryClass($element['repositoryClass']);
            }
        } elseif ($element['type'] === 'mappedSuperclass') {
            $class->isMappedSuperclass = true;
        } elseif ($element['type'] === 'embeddedDocument') {
            $class->isEmbeddedDocument = true;
        }
        if (isset($element['indexes'])) {
            foreach($element['indexes'] as $index) {
                $class->addIndex($index['keys'], isset($index['options']) ? $index['options'] : array());
            }
        }
        if (isset($element['inheritanceType'])) {
            $class->setInheritanceType(constant('Doctrine\ODM\MongoDB\Mapping\ClassMetadata::INHERITANCE_TYPE_' . strtoupper($element['inheritanceType'])));
        }
        if (isset($element['discriminatorField'])) {
            $discrField = $element['discriminatorField'];
            $class->setDiscriminatorField(array(
                'name' => $discrField['name'],
                'fieldName' => $discrField['fieldName']
            ));
        }
        if (isset($element['discriminatorMap'])) {
            $class->setDiscriminatorMap($element['discriminatorMap']);
        }
        if (isset($element['changeTrackingPolicy'])) {
            $class->setChangeTrackingPolicy(constant('Doctrine\ODM\MongoDB\Mapping\ClassMetadata::CHANGETRACKING_'
                    . strtoupper($element['changeTrackingPolicy'])));
        }
        if (isset($element['fields'])) {
            foreach ($element['fields'] as $fieldName => $mapping) {
                if (is_string($mapping)) {
                    $type = $mapping;
                    $mapping = array();
                    $mapping['type'] = $type;
                }
                if ( ! isset($mapping['fieldName'])) {
                    $mapping['fieldName'] = $fieldName;
                }
                if (isset($mapping['type']) && $mapping['type'] === 'collection') {
                    $mapping['strategy'] = isset($mapping['strategy']) ? $mapping['strategy'] : 'pushAll';
                }
                $this->addFieldMapping($class, $mapping);
            }
        }
        if (isset($element['embedOne'])) {
            foreach ($element['embedOne'] as $fieldName => $embed) {
                $this->addMappingFromEmbed($class, $fieldName, $embed, 'one');
            }
        }
        if (isset($element['embedMany'])) {
            foreach ($element['embedMany'] as $fieldName => $embed) {
                $this->addMappingFromEmbed($class, $fieldName, $embed, 'many');
            }
        }
        if (isset($element['referenceOne'])) {
            foreach ($element['referenceOne'] as $fieldName => $reference) {
                $this->addMappingFromReference($class, $fieldName, $reference, 'one');
            }
        }
        if (isset($element['referenceMany'])) {
            foreach ($element['referenceMany'] as $fieldName => $reference) {
                $this->addMappingFromReference($class, $fieldName, $reference, 'many');
            }
        }
        if (isset($element['lifecycleCallbacks'])) {
            foreach ($element['lifecycleCallbacks'] as $type => $methods) {
                foreach ($methods as $method) {
                    $class->addLifecycleCallback($method, constant('Doctrine\ODM\MongoDB\Events::' . $type));
                }
            }
        }
    }

 private function addFieldMapping(ClassMetadataInfo $class, $mapping)
 {
     if (isset($mapping['name'])) {
         $name = $mapping['name'];
     } elseif (isset($mapping['fieldName'])) {
         $name = $mapping['fieldName'];
     } else {
         throw new \InvalidArgumentException('Cannot infer a MongoDB name from the mapping');
     }
     $class->mapField($mapping);
     if (!(isset($mapping['index']) || isset($mapping['unique']) || isset($mapping['sparse']))) {
         return;
     }
     // Multiple index specifications in one field mapping is ambiguous
     if ((isset($mapping['index']) && is_array($mapping['index'])) + (isset($mapping['unique']) && is_array($mapping['unique'])) + (isset($mapping['sparse']) && is_array($mapping['sparse'])) > 1) {
         throw new \InvalidArgumentException('Multiple index specifications found among index, unique, and/or sparse fields');
     }
     // Index this field if either "index", "unique", or "sparse" are set
     $keys = array($name => 'asc');
     /* The "order" option is only used in the index specification and should
      * not be passed along as an index option.
      */
     if (isset($mapping['index']['order'])) {
         $keys[$name] = $mapping['index']['order'];
         unset($mapping['index']['order']);
     } elseif (isset($mapping['unique']['order'])) {
         $keys[$name] = $mapping['unique']['order'];
         unset($mapping['unique']['order']);
     } elseif (isset($mapping['sparse']['order'])) {
         $keys[$name] = $mapping['sparse']['order'];
         unset($mapping['sparse']['order']);
     }
     /* Initialize $options from any array value among index, unique, and
      * sparse. Any boolean values for unique or sparse should be merged into
      * the options afterwards to ensure consistent parsing.
      */
     $options = array();
     $unique = null;
     $sparse = null;
     if (isset($mapping['index']) && is_array($mapping['index'])) {
         $options = $mapping['index'];
     }
     if (isset($mapping['unique'])) {
         if (is_array($mapping['unique'])) {
             $options = $mapping['unique'] + array('unique' => true);
         } else {
             $unique = (bool) $mapping['unique'];
         }
     }
     if (isset($mapping['sparse'])) {
         if (is_array($mapping['sparse'])) {
             $options = $mapping['sparse'] + array('sparse' => true);
         } else {
             $sparse = (bool) $mapping['sparse'];
         }
     }
     if (isset($unique)) {
         $options['unique'] = $unique;
     }
     if (isset($sparse)) {
         $options['sparse'] = $sparse;
     }
     $class->addIndex($keys, $options);
 }

 private function addIndex(ClassMetadataInfo $class, \SimpleXmlElement $xmlIndex)
 {
     $attributes = $xmlIndex->attributes();
     $keys = array();
     foreach ($xmlIndex->{'key'} as $key) {
         $keys[(string) $key['name']] = isset($key['order']) ? (string) $key['order'] : 'asc';
     }
     $options = array();
     if (isset($attributes['background'])) {
         $options['background'] = 'true' === (string) $attributes['background'];
     }
     if (isset($attributes['drop-dups'])) {
         $options['dropDups'] = 'true' === (string) $attributes['drop-dups'];
     }
     if (isset($attributes['name'])) {
         $options['name'] = (string) $attributes['name'];
     }
     if (isset($attributes['safe'])) {
         $options['safe'] = 'true' === (string) $attributes['safe'];
     }
     if (isset($attributes['sparse'])) {
         $options['sparse'] = 'true' === (string) $attributes['sparse'];
     }
     if (isset($attributes['unique'])) {
         $options['unique'] = 'true' === (string) $attributes['unique'];
     }
     if (isset($xmlIndex->{'option'})) {
         foreach ($xmlIndex->{'option'} as $option) {
             $value = (string) $option['value'];
             if ($value === 'true') {
                 $value = true;
             } elseif ($value === 'false') {
                 $value = false;
             } elseif (is_numeric($value)) {
                 $value = preg_match('/^[-]?\\d+$/', $value) ? (int) $value : (double) $value;
             }
             $options[(string) $option['name']] = $value;
         }
     }
     $class->addIndex($keys, $options);
 }