protected static function doProcess($annotation, ClassMetadata $metadata)
 {
     if (is_string($annotation->custom)) {
         $annotation->custom = explode(',', $annotation->custom);
     }
     $metadata->setAccessorOrder($annotation->order, array_map('trim', (array) $annotation->custom));
 }
Esempio n. 2
0
 protected function setDiscriminator(DoctrineClassMetadata $doctrineMetadata, ClassMetadata $classMetadata)
 {
     /** @var \Doctrine\ORM\Mapping\ClassMetadata $doctrineMetadata */
     if (empty($classMetadata->discriminatorMap) && !$classMetadata->discriminatorDisabled && !empty($doctrineMetadata->discriminatorMap) && $doctrineMetadata->isRootEntity()) {
         $classMetadata->setDiscriminator($doctrineMetadata->discriminatorColumn['name'], $doctrineMetadata->discriminatorMap, []);
     }
 }
 /**
  * Get the object manager handling the specified class
  * Returns NULL if cannot be found
  *
  * @param ClassMetadata $metadata
  * @return null|ObjectManager
  */
 protected function getObjectManager(ClassMetadata $metadata)
 {
     foreach ($this->managerRegistryCollection as $managerRegistry) {
         if ($objectManager = $managerRegistry->getManagerForClass($metadata->getName())) {
             return $objectManager;
         }
     }
 }
 protected static function doProcess($annotation, ClassMetadata $metadata)
 {
     if (is_string($annotation->groups)) {
         $annotation->groups = explode(',', $annotation->groups);
     }
     if ($annotation->disabled) {
         $metadata->discriminatorDisabled = true;
     } else {
         $metadata->setDiscriminator($annotation->field, $annotation->map, array_map('trim', (array) $annotation->groups));
     }
 }
Esempio n. 5
0
 protected function getClassAnnotations(ClassMetadata $classMetadata)
 {
     $config = $this->getClassConfig($classMetadata->getName());
     $annotations = [];
     foreach ($config as $key => $value) {
         if (in_array($key, ['properties', 'virtual_properties'])) {
             continue;
         }
         $annotations = array_merge($annotations, $this->createAnnotationsForArray($value, $key));
     }
     return $annotations;
 }
Esempio n. 6
0
 protected function getClassAnnotations(ClassMetadata $classMetadata)
 {
     $element = $this->getClassElement($classMetadata->getName());
     if (!$element) {
         return [];
     }
     $exclude = ['property', 'virtual-property', 'pre-serialize', 'post-serialize', 'post-deserialize', 'discriminator'];
     $annotations = $this->loadComplex($element, ['name'], $exclude);
     foreach ($element->xpath('./discriminator') as $discriminatorElement) {
         $discriminator = new Annotations\Discriminator();
         foreach ($this->loadAnnotationProperties($discriminatorElement) as $attrName => $value) {
             $discriminator->{$attrName} = $value;
         }
         $map = [];
         foreach ($discriminatorElement->xpath('./map') as $item) {
             $v = (string) $item->attributes()->value;
             $map[$v] = (string) $item;
         }
         $discriminator->map = $map;
         $annotations[] = $discriminator;
     }
     return $annotations;
 }
Esempio n. 7
0
 public function testSetAccessorOrderAlphabetical()
 {
     $metadata = new ClassMetadata(new \ReflectionClass(PropertyMetadataOrder::class));
     $metadata->addAttributeMetadata(new PropertyMetadata(PropertyMetadataOrder::class, 'b'));
     $metadata->addAttributeMetadata(new PropertyMetadata(PropertyMetadataOrder::class, 'a'));
     $this->assertEquals(['b', 'a'], array_keys($metadata->getAttributesMetadata()));
     $metadata->setAccessorOrder(ClassMetadata::ACCESSOR_ORDER_ALPHABETICAL);
     $this->assertEquals(['a', 'b'], array_keys($metadata->getAttributesMetadata()));
 }
 public function construct(VisitorInterface $visitor, ClassMetadata $metadata, $data, Type $type, DeserializationContext $context)
 {
     return $this->getInstantiator()->instantiate($metadata->getName());
 }
Esempio n. 9
0
 /**
  * Get the array of properties that should be serialized in an object
  *
  * @param ClassMetadata $metadata
  *
  * @return PropertyMetadata[]
  */
 public function getNonSkippedProperties(ClassMetadata $metadata)
 {
     $this->assertInitialized();
     /** @var PropertyMetadata[] $properties */
     $properties = $metadata->getAttributesMetadata();
     return array_filter($properties, [$this, 'filterPropertyMetadata']);
 }
Esempio n. 10
0
 protected function getClassAnnotations(ClassMetadata $classMetadata)
 {
     return $this->reader->getClassAnnotations($classMetadata->getReflectionClass());
 }
 protected static function doProcess($annotation, ClassMetadata $metadata)
 {
     $metadata->registerNamespace($annotation->uri, $annotation->prefix);
 }
 /**
  * @param ClassMetadata $metadata
  * @param $properties
  */
 private function validateObjectProperties(ClassMetadata $metadata, $properties)
 {
     $has_xml_value = false;
     foreach ($properties as $property) {
         if ($property->xmlValue && !$has_xml_value) {
             $has_xml_value = true;
         } elseif ($property->xmlValue) {
             throw new RuntimeException(sprintf('Only one property can be target of @XmlValue attribute. Invalid usage detected in class %s', $metadata->getName()));
         }
     }
     if ($has_xml_value) {
         foreach ($properties as $property) {
             if (!$property->xmlValue && !$property->xmlAttribute) {
                 throw new RuntimeException(sprintf('If you make use of @XmlValue, all other properties in the class must have the @XmlAttribute annotation. Invalid usage detected in class %s.', $metadata->getName()));
             }
         }
     }
 }