PHP ClassMetadata::getFieldNames方法代码示例

 public function guessColumnFormatters(\Faker\Generator $generator)
 {
     $formatters = array();
     $class = $this->class;
     $nameGuesser = new \Faker\Guesser\Name($generator);
     $columnTypeGuesser = new ColumnTypeGuesser($generator);
     foreach ($this->class->getFieldNames() as $fieldName) {
         if ($this->class->isIdentifier($fieldName) || !$this->class->hasField($fieldName)) {
             continue;
         }
         if ($formatter = $nameGuesser->guessFormat($fieldName)) {
             $formatters[$fieldName] = $formatter;
             continue;
         }
         if ($formatter = $columnTypeGuesser->guessFormat($fieldName, $this->class)) {
             $formatters[$fieldName] = $formatter;
             continue;
         }
     }
     foreach ($this->class->getAssociationNames() as $assocName) {
         if (!$this->class->isIdentifier($assocName) || !$this->class->isCollectionValuedAssociation($assocName)) {
             continue;
         }
         $relatedClass = $this->class->getAssociationTargetClass($assocName);
         $formatters[$assocName] = function ($inserted) use($relatedClass) {
             return isset($inserted[$relatedClass]) ? $inserted[$relatedClass][mt_rand(0, count($inserted[$relatedClass]) - 1)] : null;
         };
     }
     return $formatters;
 }

 protected function getEntityFields(ClassMetadata $metaData, array $data)
 {
     // change data keys to camelcase
     $result = array();
     foreach ($data as $key => $value) {
         // convert to camelcase if underscore is in name
         if (strpos($key, '_') !== false) {
             $key = implode('', array_map('ucfirst', explode('_', $key)));
         }
         $result[$key] = $value;
     }
     $data = $result;
     // get all fields
     $fieldNames = $metaData->getFieldNames();
     $fields = array();
     foreach ($fieldNames as $fieldName) {
         if (!isset($data[$fieldName])) {
             continue;
         }
         $type = $metaData->getTypeOfField($fieldName);
         $value = $this->getColumnTypeValue($type, $data[$fieldName]);
         $fields[$fieldName] = $value;
     }
     return $fields;
 }

 public function fieldList(ClassMetadata $metadata)
 {
     $return = [];
     foreach ($metadata->getFieldNames() as $field) {
         if ($this->isSerializableField($field, $metadata)) {
             $return[] = $field;
         }
     }
     return $return;
 }

 /**
  * Extract values from an object using a by-reference logic (this means that values are
  * directly fetched without using the public API of the entity, in this case, getters)
  *
  * @param  object $object
  * @return array
  */
 protected function extractByReference($object)
 {
     $fieldNames = array_merge($this->metadata->getFieldNames(), $this->metadata->getAssociationNames());
     $refl = $this->metadata->getReflectionClass();
     $data = array();
     foreach ($fieldNames as $fieldName) {
         $reflProperty = $refl->getProperty($fieldName);
         $reflProperty->setAccessible(true);
         $data[$fieldName] = $this->extractValue($fieldName, $reflProperty->getValue($object));
     }
     return $data;
 }

 /**
  * @param $entity
  * @param ClassMetadata $classMetadata
  * @return array
  */
 private function generateConstructor($entity, $classMetadata)
 {
     $fields = [];
     $fields[] = sprintf("\t\tfunction %s(data) {\n", $entity);
     $fields[] = "\t\t\tif (angular.isDefined(data)) {\n";
     foreach ($classMetadata->getFieldNames() as $item) {
         $item = $this->handleField($item, $classMetadata->getName(), true);
         if ($item !== null) {
             $fields[] = $item;
         }
     }
     $fields[] = "\t\t\t} else {\n";
     foreach ($classMetadata->getFieldNames() as $item) {
         $item = $this->handleField($item, $classMetadata->getName(), false);
         if ($item !== null) {
             $fields[] = $item;
         }
     }
     $fields[] = "\t\t\t}\n";
     $fields[] = "\t\t}\n\n";
     return $fields;
 }

 public function fieldList(ClassMetadata $metadata, $includeId = true)
 {
     $return = [];
     $serializerMetadata = $metadata->getSerializer();
     foreach ($metadata->getFieldNames() as $field) {
         if (isset($serializerMetadata['fields'][$field]['unserializeIgnore']) && $serializerMetadata['fields'][$field]['unserializeIgnore']) {
             continue;
         }
         $return[] = $field;
     }
     if (!$includeId) {
         unset($return[$metadata->getIdentifier()]);
     }
     return $return;
 }

 /**
  * Extract values from an object using a by-reference logic (this means that values are
  * directly fetched without using the public API of the entity, in this case, getters)
  *
  * @param  object $object
  * @return array
  */
 protected function extractByReference($object)
 {
     $fieldNames = array_merge($this->metadata->getFieldNames(), $this->metadata->getAssociationNames());
     $refl = $this->metadata->getReflectionClass();
     $filter = $object instanceof FilterProviderInterface ? $object->getFilter() : $this->filterComposite;
     $data = array();
     foreach ($fieldNames as $fieldName) {
         if ($filter && !$filter->filter($fieldName)) {
             continue;
         }
         $reflProperty = $refl->getProperty($fieldName);
         $reflProperty->setAccessible(true);
         $data[$fieldName] = $this->extractValue($fieldName, $reflProperty->getValue($object), $object);
     }
     return $data;
 }

 /**
  * Returns an array of fields. Fields can be both column fields and
  * association fields.
  *
  * @param ClassMetadata $metadata
  *
  * @return array $fields
  */
 private function getFieldsFromMetadata(ClassMetadata $metadata)
 {
     $fields = (array) $metadata->getFieldNames();
     if (!$this->isIdentifierNatural($metadata)) {
         $fields = array_diff($fields, $metadata->getIdentifier());
     }
     $fieldsMapping = array();
     foreach ($fields as $field) {
         $fieldsMapping[$field] = $metadata->getTypeOfField($field);
     }
     foreach ($metadata->associationMappings as $fieldName => $relation) {
         if ($relation['type'] !== ORMClassMetadataInfo::ONE_TO_MANY) {
             $fieldsMapping[$fieldName] = 'relation';
         }
     }
     return $fieldsMapping;
 }

 /**
  * Get the default hydrator
  *
  * @param ClassMetadata     $metadata
  * @param HydratorInterface $hydrator
  *
  * @return HydratorInterface
  */
 private function createEntityHydrator(ClassMetadata $metadata, HydratorInterface $hydrator = null)
 {
     $hydrator = $hydrator ?: new ClassMethods();
     foreach ($metadata->getFieldNames() as $field) {
         switch ($metadata->getTypeOfField($field)) {
             case Type::DATETIME:
                 $hydrator->addStrategy($field, new DateTimeStrategy());
                 break;
             case Type::SIMPLE_ARRAY:
                 $hydrator->addStrategy($field, new SimpleArrayStrategy());
                 break;
             case Type::BOOLEAN:
                 $hydrator->addStrategy($field, new BooleanStrategy());
                 break;
         }
     }
     return $hydrator;
 }

 /**
  * @param \Doctrine\Common\Persistence\Mapping\ClassMetadata $metadata
  * @param                                                    $model
  *
  * @return array
  */
 protected function processFieldNames(ClassMetadata $metadata, $model)
 {
     $data = array();
     foreach ($metadata->getFieldNames() as $fieldName) {
         if ($metadata->isIdentifier($fieldName) && $metadata->usesIdGenerator()) {
             continue;
         }
         $data[$fieldName] = $this->navigator->accept($this->getVisitor(), $this->readProperty($model, $fieldName));
     }
     return $data;
 }

 /**
  * Returns the entity embeddable fields
  *
  * @param ClassMetadata $metadata
  *
  * @return array
  */
 protected function getEntityEmbeddables(ClassMetadata $metadata)
 {
     $entityFields = $metadata->getFieldNames();
     $embeddables = [];
     foreach ($entityFields as $embeddableField) {
         if (false !== strpos($embeddableField, '.')) {
             list($embeddablePropertyName, ) = explode('.', $embeddableField);
             $embeddables[$embeddablePropertyName] = $embeddablePropertyName;
         }
     }
     return $embeddables;
 }

 protected function prepareMetadataFields(ClassMetadata $metadata)
 {
     $fields = [];
     foreach ($metadata->getFieldNames() as $fieldName) {
         $groups = [];
         list($realName, ) = explode('.', $fieldName);
         if (!in_array($realName, $this->hiddenFields)) {
             $groups = ['default', Inflector::tableize($metadata->getReflectionClass()->getShortName())];
         }
         $fields[$realName]['groups'] = $groups;
     }
     return $fields;
 }

 /**
  * @param Common\Persistence\Mapping\ClassMetadata $class
  *
  * @return array
  *
  * @throws ORM\Mapping\MappingException
  */
 private function buildPhoneFields(Common\Persistence\Mapping\ClassMetadata $class)
 {
     $phoneFields = [];
     foreach ($class->getFieldNames() as $fieldName) {
         $mapping = $class->getFieldMapping($fieldName);
         if ($mapping['type'] !== Types\Phone::PHONE) {
             continue;
         }
         $classReflection = $class->isInheritedField($fieldName) ? new \ReflectionClass($mapping['declared']) : $class->getReflectionClass();
         $phoneFields[$fieldName] = ['phoneFieldClass' => $classReflection->getName()];
     }
     return $phoneFields;
 }

 /**
  * @param \Faker\Generator $generator
  * @return array
  */
 public function guessColumnFormatters(\Faker\Generator $generator)
 {
     $formatters = array();
     $nameGuesser = new \Faker\Guesser\Name($generator);
     $columnTypeGuesser = new ColumnTypeGuesser($generator);
     foreach ($this->class->getFieldNames() as $fieldName) {
         if ($this->class->isIdentifier($fieldName) || !$this->class->hasField($fieldName)) {
             continue;
         }
         $size = isset($this->class->fieldMappings[$fieldName]['length']) ? $this->class->fieldMappings[$fieldName]['length'] : null;
         if ($formatter = $nameGuesser->guessFormat($fieldName, $size)) {
             $formatters[$fieldName] = $formatter;
             continue;
         }
         if ($formatter = $columnTypeGuesser->guessFormat($fieldName, $this->class)) {
             $formatters[$fieldName] = $formatter;
             continue;
         }
     }
     foreach ($this->class->getAssociationNames() as $assocName) {
         if ($this->class->isCollectionValuedAssociation($assocName)) {
             continue;
         }
         $relatedClass = $this->class->getAssociationTargetClass($assocName);
         $unique = $optional = false;
         if ($this->class instanceof \Doctrine\ORM\Mapping\ClassMetadata) {
             $mappings = $this->class->getAssociationMappings();
             foreach ($mappings as $mapping) {
                 if ($mapping['targetEntity'] == $relatedClass) {
                     if ($mapping['type'] == \Doctrine\ORM\Mapping\ClassMetadata::ONE_TO_ONE) {
                         $unique = true;
                         $optional = isset($mapping['joinColumns'][0]['nullable']) ? $mapping['joinColumns'][0]['nullable'] : false;
                         break;
                     }
                 }
             }
         } elseif ($this->class instanceof \Doctrine\ODM\MongoDB\Mapping\ClassMetadata) {
             $mappings = $this->class->associationMappings;
             foreach ($mappings as $mapping) {
                 if ($mapping['targetDocument'] == $relatedClass) {
                     if ($mapping['type'] == \Doctrine\ODM\MongoDB\Mapping\ClassMetadata::ONE && $mapping['association'] == \Doctrine\ODM\MongoDB\Mapping\ClassMetadata::REFERENCE_ONE) {
                         $unique = true;
                         $optional = isset($mapping['nullable']) ? $mapping['nullable'] : false;
                         break;
                     }
                 }
             }
         }
         $index = 0;
         $formatters[$assocName] = function ($inserted) use($relatedClass, &$index, $unique, $optional) {
             if (isset($inserted[$relatedClass])) {
                 if ($unique) {
                     $related = null;
                     if (isset($inserted[$relatedClass][$index]) || !$optional) {
                         $related = $inserted[$relatedClass][$index];
                     }
                     $index++;
                     return $related;
                 }
                 return $inserted[$relatedClass][mt_rand(0, count($inserted[$relatedClass]) - 1)];
             }
             return null;
         };
     }
     return $formatters;
 }