public function deserialize($data, $type, $format) { $visitor = $this->getDeserializationVisitor($format); $visitor->setNavigator($navigator = new GraphNavigator(GraphNavigator::DIRECTION_DESERIALIZATION, $this->factory, $this->exclusionStrategy)); $navigator->accept($visitor->prepare($data), $type, $visitor); return $visitor->getResult(); }
public function deserialize($data, $type, $format) { $visitor = $this->getDeserializationVisitor($format); $visitor->setNavigator($navigator = new GraphNavigator(GraphNavigator::DIRECTION_DESERIALIZATION, $this->factory, $format, $this->handlerRegistry, $this->objectConstructor, $this->exclusionStrategy, $this->dispatcher)); $navigatorResult = $navigator->accept($visitor->prepare($data), $this->typeParser->parse($type), $visitor); // This is a special case if the root is handled by a callback on the object iself. if (null === ($visitorResult = $visitor->getResult()) && null !== $navigatorResult) { return $navigatorResult; } return $visitorResult; }
protected function loadMetadataFromFile(\ReflectionClass $class, $file) { $config = Yaml::parse(file_get_contents($file)); if (!isset($config[$name = $class->getName()])) { throw new RuntimeException(sprintf('Expected metadata for class %s to be defined in %s.', $class->getName(), $file)); } $config = $config[$name]; $metadata = new ClassMetadata($name); $metadata->fileResources[] = $file; $metadata->fileResources[] = $class->getFileName(); $exclusionPolicy = isset($config['exclusion_policy']) ? strtoupper($config['exclusion_policy']) : 'NONE'; $excludeAll = isset($config['exclude']) ? (bool) $config['exclude'] : false; $classAccessType = isset($config['access_type']) ? $config['access_type'] : PropertyMetadata::ACCESS_TYPE_PROPERTY; $propertiesMetadata = array(); if (isset($config['accessor_order'])) { $metadata->setAccessorOrder($config['accessor_order'], isset($config['custom_accessor_order']) ? $config['custom_accessor_order'] : array()); } if (isset($config['xml_root_name'])) { $metadata->xmlRootName = (string) $config['xml_root_name']; } if (array_key_exists('virtual_properties', $config)) { foreach ($config['virtual_properties'] as $methodName => $propertySettings) { if (!$class->hasMethod($methodName)) { throw new RuntimeException('The method ' . $methodName . ' not found in class ' . $class->name); } $virtualPropertyMetadata = new VirtualPropertyMetadata($name, $methodName); $propertiesMetadata[$methodName] = $virtualPropertyMetadata; $config['properties'][$methodName] = $propertySettings; } } if (!$excludeAll) { foreach ($class->getProperties() as $property) { if ($name !== $property->getDeclaringClass()->getName()) { continue; } $pName = $property->getName(); $propertiesMetadata[$pName] = new PropertyMetadata($name, $pName); } foreach ($propertiesMetadata as $pName => $pMetadata) { $isExclude = false; $isExpose = $pMetadata instanceof VirtualPropertyMetadata; if (isset($config['properties'][$pName])) { $pConfig = $config['properties'][$pName]; if (isset($pConfig['exclude'])) { $isExclude = (bool) $pConfig['exclude']; } if (isset($pConfig['expose'])) { $isExpose = (bool) $pConfig['expose']; } if (isset($pConfig['since_version'])) { $pMetadata->sinceVersion = (string) $pConfig['since_version']; } if (isset($pConfig['until_version'])) { $pMetadata->untilVersion = (string) $pConfig['until_version']; } if (isset($pConfig['serialized_name'])) { $pMetadata->serializedName = (string) $pConfig['serialized_name']; } if (isset($pConfig['type'])) { $pMetadata->setType((string) $pConfig['type']); } if (isset($pConfig['groups'])) { $pMetadata->groups = $pConfig['groups']; } if (isset($pConfig['xml_list'])) { $pMetadata->xmlCollection = true; $colConfig = $pConfig['xml_list']; if (isset($colConfig['inline'])) { $pMetadata->xmlCollectionInline = (bool) $colConfig['inline']; } if (isset($colConfig['entry_name'])) { $pMetadata->xmlEntryName = (string) $colConfig['entry_name']; } } if (isset($pConfig['xml_map'])) { $pMetadata->xmlCollection = true; $colConfig = $pConfig['xml_map']; if (isset($colConfig['inline'])) { $pMetadata->xmlCollectionInline = (bool) $colConfig['inline']; } if (isset($colConfig['entry_name'])) { $pMetadata->xmlEntryName = (string) $colConfig['entry_name']; } if (isset($colConfig['key_attribute_name'])) { $pMetadata->xmlKeyAttribute = $colConfig['key_attribute_name']; } } if (isset($pConfig['xml_attribute'])) { $pMetadata->xmlAttribute = (bool) $pConfig['xml_attribute']; } if (isset($pConfig['xml_attribute_map'])) { $pMetadata->xmlAttribute = (bool) $pConfig['xml_attribute_map']; } if (isset($pConfig['xml_value'])) { $pMetadata->xmlValue = (bool) $pConfig['xml_value']; } if (isset($pConfig['xml_key_value_pairs'])) { $pMetadata->xmlKeyValuePairs = (bool) $pConfig['xml_key_value_pairs']; } //we need read_only before setter and getter set, because that method depends on flag being set if (isset($pConfig['read_only'])) { $pMetadata->readOnly = (bool) $pConfig['read_only']; } $pMetadata->setAccessor(isset($pConfig['access_type']) ? $pConfig['access_type'] : $classAccessType, isset($pConfig['accessor']['getter']) ? $pConfig['accessor']['getter'] : null, isset($pConfig['accessor']['setter']) ? $pConfig['accessor']['setter'] : null); if (isset($pConfig['inline'])) { $pMetadata->inline = (bool) $pConfig['inline']; } } if (ExclusionPolicy::NONE === $exclusionPolicy && !$isExclude || ExclusionPolicy::ALL === $exclusionPolicy && $isExpose) { $metadata->addPropertyMetadata($pMetadata); } } } if (isset($config['handler_callbacks'])) { foreach ($config['handler_callbacks'] as $direction => $formats) { foreach ($formats as $format => $methodName) { $direction = GraphNavigator::parseDirection($direction); $metadata->addHandlerCallback($direction, $format, $methodName); } } } if (isset($config['callback_methods'])) { $cConfig = $config['callback_methods']; if (isset($cConfig['pre_serialize'])) { $metadata->preSerializeMethods = $this->getCallbackMetadata($class, $cConfig['pre_serialize']); } if (isset($cConfig['post_serialize'])) { $metadata->postSerializeMethods = $this->getCallbackMetadata($class, $cConfig['post_serialize']); } if (isset($cConfig['post_deserialize'])) { $metadata->postDeserializeMethods = $this->getCallbackMetadata($class, $cConfig['post_deserialize']); } } return $metadata; }
protected function loadMetadataFromFile(\ReflectionClass $class, $path) { $previous = libxml_use_internal_errors(true); $elem = simplexml_load_file($path); libxml_use_internal_errors($previous); if (false === $elem) { throw new XmlErrorException(libxml_get_last_error()); } $metadata = new ClassMetadata($name = $class->getName()); if (!($elems = $elem->xpath("./class[@name = '" . $name . "']"))) { throw new RuntimeException(sprintf('Could not find class %s inside XML element.', $name)); } $elem = reset($elems); $metadata->fileResources[] = $path; $metadata->fileResources[] = $class->getFileName(); $exclusionPolicy = strtoupper($elem->attributes()->{'exclusion-policy'}) ?: 'NONE'; $excludeAll = null !== ($exclude = $elem->attributes()->exclude) ? 'true' === strtolower($exclude) : false; $classAccessType = (string) ($elem->attributes()->{'access-type'} ?: PropertyMetadata::ACCESS_TYPE_PROPERTY); $propertiesMetadata = array(); $propertiesNodes = array(); if (null !== ($accessorOrder = $elem->attributes()->{'accessor-order'})) { $metadata->setAccessorOrder((string) $accessorOrder, preg_split('/\\s*,\\s*/', (string) $elem->attributes()->{'custom-accessor-order'})); } if (null !== ($xmlRootName = $elem->attributes()->{'xml-root-name'})) { $metadata->xmlRootName = (string) $xmlRootName; } foreach ($elem->xpath('./virtual-property') as $method) { if (!isset($method->attributes()->method)) { throw new RuntimeException('The method attribute must be set for all virtual-property elements.'); } $virtualPropertyMetadata = new VirtualPropertyMetadata($name, (string) $method->attributes()->method); $propertiesMetadata[] = $virtualPropertyMetadata; $propertiesNodes[] = $method; } if (!$excludeAll) { foreach ($class->getProperties() as $property) { if ($name !== $property->getDeclaringClass()->getName()) { continue; } $propertiesMetadata[] = new PropertyMetadata($name, $pName = $property->getName()); $pElems = $elem->xpath("./property[@name = '" . $pName . "']"); $propertiesNodes[] = $pElems ? reset($pElems) : null; } foreach ($propertiesMetadata as $propertyKey => $pMetadata) { $isExclude = false; $isExpose = $pMetadata instanceof VirtualPropertyMetadata; $pElem = $propertiesNodes[$propertyKey]; if (!empty($pElem)) { if (null !== ($exclude = $pElem->attributes()->exclude)) { $isExclude = 'true' === strtolower($exclude); } if (null !== ($expose = $pElem->attributes()->expose)) { $isExpose = 'true' === strtolower($expose); } if (null !== ($version = $pElem->attributes()->{'since-version'})) { $pMetadata->sinceVersion = (string) $version; } if (null !== ($version = $pElem->attributes()->{'until-version'})) { $pMetadata->untilVersion = (string) $version; } if (null !== ($serializedName = $pElem->attributes()->{'serialized-name'})) { $pMetadata->serializedName = (string) $serializedName; } if (null !== ($type = $pElem->attributes()->type)) { $pMetadata->setType((string) $type); } else { if (isset($pElem->type)) { $pMetadata->setType((string) $pElem->type); } } if (null !== ($groups = $pElem->attributes()->groups)) { $pMetadata->groups = preg_split('/\\s*,\\s*/', (string) $groups); } if (isset($pElem->{'xml-list'})) { $pMetadata->xmlCollection = true; $colConfig = $pElem->{'xml-list'}; if (isset($colConfig->attributes()->inline)) { $pMetadata->xmlCollectionInline = 'true' === (string) $colConfig->attributes()->inline; } if (isset($colConfig->attributes()->{'entry-name'})) { $pMetadata->xmlEntryName = (string) $colConfig->attributes()->{'entry-name'}; } } if (isset($pElem->{'xml-map'})) { $pMetadata->xmlCollection = true; $colConfig = $pElem->{'xml-map'}; if (isset($colConfig->attributes()->inline)) { $pMetadata->xmlCollectionInline = 'true' === (string) $colConfig->attributes()->inline; } if (isset($colConfig->attributes()->{'entry-name'})) { $pMetadata->xmlEntryName = (string) $colConfig->attributes()->{'entry-name'}; } if (isset($colConfig->attributes()->{'key-attribute-name'})) { $pMetadata->xmlKeyAttribute = (string) $colConfig->attributes()->{'key-attribute-name'}; } } if (isset($pElem->attributes()->{'xml-attribute'})) { $pMetadata->xmlAttribute = 'true' === (string) $pElem->attributes()->{'xml-attribute'}; } if (isset($pElem->attributes()->{'xml-attribute-map'})) { $pMetadata->xmlAttribute = 'true' === (string) $pElem->attributes()->{'xml-attribute-map'}; } if (isset($pElem->attributes()->{'xml-value'})) { $pMetadata->xmlValue = 'true' === (string) $pElem->attributes()->{'xml-value'}; } if (isset($pElem->attributes()->{'xml-key-value-pairs'})) { $pMetadata->xmlKeyValuePairs = 'true' === (string) $pElem->attributes()->{'xml-key-value-pairs'}; } //we need read-only before setter and getter set, because that method depends on flag being set if (null !== ($readOnly = $pElem->attributes()->{'read-only'})) { $pMetadata->readOnly = 'true' === strtolower($readOnly); } $getter = $pElem->attributes()->{'accessor-getter'}; $setter = $pElem->attributes()->{'accessor-setter'}; $pMetadata->setAccessor((string) ($pElem->attributes()->{'access-type'} ?: $classAccessType), $getter ? (string) $getter : null, $setter ? (string) $setter : null); if (null !== ($inline = $pElem->attributes()->inline)) { $pMetadata->inline = 'true' === strtolower($inline); } } if (ExclusionPolicy::NONE === (string) $exclusionPolicy && !$isExclude || ExclusionPolicy::ALL === (string) $exclusionPolicy && $isExpose) { $metadata->addPropertyMetadata($pMetadata); } } } foreach ($elem->xpath('./callback-method') as $method) { if (!isset($method->attributes()->type)) { throw new RuntimeException('The type attribute must be set for all callback-method elements.'); } if (!isset($method->attributes()->name)) { throw new RuntimeException('The name attribute must be set for all callback-method elements.'); } switch ((string) $method->attributes()->type) { case 'pre-serialize': $metadata->addPreSerializeMethod(new MethodMetadata($name, (string) $method->attributes()->name)); break; case 'post-serialize': $metadata->addPostSerializeMethod(new MethodMetadata($name, (string) $method->attributes()->name)); break; case 'post-deserialize': $metadata->addPostDeserializeMethod(new MethodMetadata($name, (string) $method->attributes()->name)); break; case 'handler': if (!isset($method->attributes()->format)) { throw new RuntimeException('The format attribute must be set for "handler" callback methods.'); } if (!isset($method->attributes()->direction)) { throw new RuntimeException('The direction attribute must be set for "handler" callback methods.'); } $direction = GraphNavigator::parseDirection((string) $method->attributes()->direction); $format = (string) $method->attributes()->format; $metadata->addHandlerCallback($direction, $format, (string) $method->attributes()->name); break; default: throw new RuntimeException(sprintf('The type "%s" is not supported.', $method->attributes()->name)); } } return $metadata; }
public function loadMetadataForClass(\ReflectionClass $class) { $classMetadata = new ClassMetadata($name = $class->getName()); $classMetadata->fileResources[] = $class->getFilename(); $propertiesMetadata = array(); $propertiesAnnotations = array(); $exclusionPolicy = 'NONE'; $excludeAll = false; $classAccessType = PropertyMetadata::ACCESS_TYPE_PROPERTY; foreach ($this->reader->getClassAnnotations($class) as $annot) { if ($annot instanceof ExclusionPolicy) { $exclusionPolicy = $annot->policy; } else { if ($annot instanceof XmlRoot) { $classMetadata->xmlRootName = $annot->name; } else { if ($annot instanceof Exclude) { $excludeAll = true; } else { if ($annot instanceof AccessType) { $classAccessType = $annot->type; } else { if ($annot instanceof AccessorOrder) { $classMetadata->setAccessorOrder($annot->order, $annot->custom); } } } } } } foreach ($class->getMethods() as $method) { if ($method->getDeclaringClass()->getName() !== $name) { continue; } $methodAnnotations = $this->reader->getMethodAnnotations($method); foreach ($methodAnnotations as $annot) { if ($annot instanceof PreSerialize) { $classMetadata->addPreSerializeMethod(new MethodMetadata($name, $method->getName())); continue 2; } else { if ($annot instanceof PostDeserialize) { $classMetadata->addPostDeserializeMethod(new MethodMetadata($name, $method->getName())); continue 2; } else { if ($annot instanceof PostSerialize) { $classMetadata->addPostSerializeMethod(new MethodMetadata($name, $method->getName())); continue 2; } else { if ($annot instanceof VirtualProperty) { $virtualPropertyMetadata = new VirtualPropertyMetadata($name, $method->getName()); $propertiesMetadata[] = $virtualPropertyMetadata; $propertiesAnnotations[] = $methodAnnotations; continue 2; } else { if ($annot instanceof HandlerCallback) { $classMetadata->addHandlerCallback(GraphNavigator::parseDirection($annot->direction), $annot->format, $method->name); continue 2; } } } } } } } if (!$excludeAll) { foreach ($class->getProperties() as $property) { if ($property->getDeclaringClass()->getName() !== $name) { continue; } $propertiesMetadata[] = new PropertyMetadata($name, $property->getName()); $propertiesAnnotations[] = $this->reader->getPropertyAnnotations($property); } foreach ($propertiesMetadata as $propertyKey => $propertyMetadata) { $isExclude = false; $isExpose = $propertyMetadata instanceof VirtualPropertyMetadata; $AccessType = $classAccessType; $accessor = array(null, null); $propertyAnnotations = $propertiesAnnotations[$propertyKey]; foreach ($propertyAnnotations as $annot) { if ($annot instanceof Since) { $propertyMetadata->sinceVersion = $annot->version; } else { if ($annot instanceof Until) { $propertyMetadata->untilVersion = $annot->version; } else { if ($annot instanceof SerializedName) { $propertyMetadata->serializedName = $annot->name; } else { if ($annot instanceof Expose) { $isExpose = true; } else { if ($annot instanceof Exclude) { $isExclude = true; } else { if ($annot instanceof Type) { $propertyMetadata->setType($annot->name); } else { if ($annot instanceof XmlList) { $propertyMetadata->xmlCollection = true; $propertyMetadata->xmlCollectionInline = $annot->inline; $propertyMetadata->xmlEntryName = $annot->entry; } else { if ($annot instanceof XmlMap) { $propertyMetadata->xmlCollection = true; $propertyMetadata->xmlCollectionInline = $annot->inline; $propertyMetadata->xmlEntryName = $annot->entry; $propertyMetadata->xmlKeyAttribute = $annot->keyAttribute; } else { if ($annot instanceof XmlKeyValuePairs) { $propertyMetadata->xmlKeyValuePairs = true; } else { if ($annot instanceof XmlAttribute) { $propertyMetadata->xmlAttribute = true; } else { if ($annot instanceof XmlValue) { $propertyMetadata->xmlValue = true; } else { if ($annot instanceof AccessType) { $AccessType = $annot->type; } else { if ($annot instanceof ReadOnly) { $propertyMetadata->readOnly = true; } else { if ($annot instanceof Accessor) { $accessor = array($annot->getter, $annot->setter); } else { if ($annot instanceof Groups) { $propertyMetadata->groups = $annot->groups; } else { if ($annot instanceof Inline) { $propertyMetadata->inline = true; } else { if ($annot instanceof XmlAttributeMap) { $propertyMetadata->xmlAttributeMap = true; } } } } } } } } } } } } } } } } } } $propertyMetadata->setAccessor($AccessType, $accessor[0], $accessor[1]); if (ExclusionPolicy::NONE === $exclusionPolicy && !$isExclude || ExclusionPolicy::ALL === $exclusionPolicy && $isExpose) { $classMetadata->addPropertyMetadata($propertyMetadata); } } } return $classMetadata; }