/**
  * {@inheritdoc}
  */
 public function loadMetadataForClass(\ReflectionClass $class)
 {
     $annotations = $this->reader->getClassAnnotations($class);
     if (0 == count($annotations)) {
         return null;
     }
     $classMetadata = new ClassMetadata($name = $class->getName());
     $classMetadata->fileResources[] = $class->getFilename();
     foreach ($annotations as $annotation) {
         if ($annotation instanceof Annotation\Relation) {
             $relationMetadata = new RelationMetadata($annotation->rel);
             if (null !== $annotation->excludeIf) {
                 $relationMetadata->setExcludeIf($annotation->excludeIf);
             }
             if ($annotation->href instanceof Annotation\Route) {
                 $relationMetadata->setRoute($annotation->href->value);
                 if (!empty($annotation->href->parameters)) {
                     $relationMetadata->setParams($annotation->href->parameters);
                 }
                 if (!empty($annotation->href->options)) {
                     $relationMetadata->setOptions($annotation->href->options);
                 }
             } else {
                 $relationMetadata->setUrl($annotation->href);
             }
             if (null !== $annotation->attributes) {
                 $relationMetadata->setAttributes($annotation->attributes);
             }
             if (null !== $annotation->embed && $annotation->embed instanceof Annotation\Content) {
                 if (!(empty($annotation->embed->provider) xor empty($annotation->embed->property))) {
                     throw new \RuntimeException('The @Content annotation needs either a provider or a property.');
                 }
                 $providerId = $providerMethod = $providerArguments = null;
                 if (!empty($annotation->embed->provider)) {
                     if (2 !== count($annotation->embed->provider)) {
                         throw new \RuntimeException('The @Content provider parameters should be an array of 2 values, a service id and a method.');
                     }
                     $providerId = $annotation->embed->provider[0];
                     $providerMethod = $annotation->embed->provider[1];
                     $providerArguments = $annotation->embed->providerArguments ?: array();
                 } else {
                     $providerId = 'fsc_hateoas.factory.identity';
                     $providerMethod = 'get';
                     $providerArguments = array($annotation->embed->property);
                 }
                 $relationContentMetadata = new RelationContentMetadata($providerId, $providerMethod);
                 $relationContentMetadata->setProviderArguments($providerArguments);
                 $relationMetadata->setContent($relationContentMetadata);
                 $relationContentMetadata->setSerializerType($annotation->embed->serializerType);
                 $relationContentMetadata->setSerializerXmlElementName($annotation->embed->serializerXmlElementName);
                 if (null !== $annotation->embed->serializerXmlElementNameRootMetadata) {
                     $relationContentMetadata->setSerializerXmlElementRootName($annotation->embed->serializerXmlElementNameRootMetadata);
                 }
             }
             $classMetadata->addRelation($relationMetadata);
         }
     }
     return $classMetadata;
 }
 public function add($rel, $href, array $embed = null, array $attributes = null, array $excludeIf = null)
 {
     $relationMetadata = new RelationMetadata($rel);
     if (is_array($href)) {
         if (!isset($href['route'])) {
             throw new \RuntimeException('href\'s "route" is required.');
         }
         $relationMetadata->setRoute($href['route']);
         if (isset($href['parameters'])) {
             $relationMetadata->setParams($href['parameters']);
         }
         if (isset($href['options'])) {
             $relationMetadata->setOptions($href['options']);
         }
     } else {
         $relationMetadata->setUrl($href);
     }
     if (null !== $embed) {
         if (!empty($embed['provider']) && !empty($embed['property'])) {
             throw new \RuntimeException('Content configuration can only have either a provider or a property.');
         }
         if (empty($embed['provider']) && empty($embed['property'])) {
             throw new \RuntimeException('Content configuration needs either a provider or a property.');
         }
         if (isset($embed['provider']) && 2 !== count($embed['provider'])) {
             throw new \RuntimeException('Content "provider" is required, and should be an array of 2 values. [service, method]');
         }
         if (!empty($embed['provider'])) {
             $providerId = $embed['provider'][0];
             $providerMethod = $embed['provider'][1];
         } else {
             $providerId = 'fsc_hateoas.factory.identity';
             $providerMethod = 'get';
         }
         $contentMetadata = new RelationContentMetadata($providerId, $providerMethod);
         if (isset($embed['providerArguments'])) {
             $contentMetadata->setProviderArguments($embed['providerArguments']);
         }
         if (isset($embed['property'])) {
             $contentMetadata->setProviderArguments(array($embed['property']));
         }
         if (isset($embed['serializerType'])) {
             $contentMetadata->setSerializerType($embed['serializerType']);
         }
         if (isset($embed['serializerXmlElementName'])) {
             $contentMetadata->setSerializerXmlElementName($embed['serializerXmlElementName']);
         }
         if (isset($embed['serializerXmlElementRootMetadata'])) {
             $contentMetadata->setSerializerXmlElementRootName($embed['serializerXmlElementRootMetadata']);
         }
         $relationMetadata->setContent($contentMetadata);
     }
     if (null !== $attributes) {
         $relationMetadata->setAttributes($attributes);
     }
     if (null !== $excludeIf) {
         $relationMetadata->setExcludeIf($excludeIf);
     }
     $this->relationsMetadata[] = $relationMetadata;
 }
 /**
  * {@inheritdoc}
  */
 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.', $name, $file));
     }
     $config = $config[$name];
     $classMetadata = new ClassMetadata($name);
     if (isset($config['relations'])) {
         foreach ($config['relations'] as $relation) {
             if (!isset($relation['href'])) {
                 throw new \RuntimeException('The "href" relation parameter is required.');
             }
             $relationMetadata = new RelationMetadata($relation['rel']);
             if (is_array($relation['href'])) {
                 $relationMetadata->setRoute($relation['href']['route']);
                 if (isset($relation['href']['parameters'])) {
                     $relationMetadata->setParams($relation['href']['parameters']);
                 }
                 if (isset($relation['href']['options'])) {
                     $relationMetadata->setOptions($relation['href']['options']);
                 }
             } else {
                 $relationMetadata->setUrl($relation['href']);
             }
             if (!empty($relation['attributes'])) {
                 $relationMetadata->setAttributes($relation['attributes']);
             }
             if (!empty($relation['exclude_if'])) {
                 $relationMetadata->setExcludeIf($relation['exclude_if']);
             }
             if (!empty($relation['content'])) {
                 $relationContent = $relation['content'];
                 if (!empty($relationContent['provider_id']) && !empty($relationContent['property'])) {
                     throw new \RuntimeException('The content configuration can only have either a provider or a property.');
                 }
                 if (!empty($relationContent['provider_id']) && empty($relationContent['provider_method'])) {
                     throw new \RuntimeException('The content configuration needs a "provider_method" when using "provider_id".');
                 }
                 $providerId = $providerMethod = $providerArguments = null;
                 if (!empty($relationContent['provider_id'])) {
                     $providerId = $relationContent['provider_id'];
                     $providerMethod = $relationContent['provider_method'];
                     $providerArguments = isset($relationContent['provider_arguments']) ? $relationContent['provider_arguments'] : array();
                 } elseif (!empty($relationContent['property'])) {
                     $providerId = 'fsc_hateoas.factory.identity';
                     $providerMethod = 'get';
                     $providerArguments = array($relationContent['property']);
                 }
                 $relationContentMetadata = new RelationContentMetadata($providerId, $providerMethod);
                 $relationContentMetadata->setProviderArguments($providerArguments);
                 $relationMetadata->setContent($relationContentMetadata);
                 if (isset($relationContent['serializer_type'])) {
                     $relationContentMetadata->setSerializerType($relationContent['serializer_type']);
                 }
                 if (isset($relationContent['serializer_xml_element_name'])) {
                     $relationContentMetadata->setSerializerXmlElementName($relationContent['serializer_xml_element_name']);
                 }
                 if (array_key_exists('serializer_xml_element_name_root_metadata', $relationContent)) {
                     $relationContentMetadata->setSerializerXmlElementRootName($relationContent['serializer_xml_element_name_root_metadata']);
                 }
             }
             $classMetadata->addRelation($relationMetadata);
         }
     }
     return $classMetadata;
 }