Converts between objects with getter and setter methods and arrays.
The normalization process looks at all public methods and calls the ones which have a name starting with get and take no parameters. The result is a map from property names (method name stripped of the get prefix and converted to lower case) to property values. Property values are normalized through the serializer.
The denormalization first looks at the constructor of the given class to see if any of the parameters have the same name as one of the properties. The constructor is then called with all parameters or an exception is thrown if any required parameters were not present as properties. Then the denormalizer walks through the given map of property names to property values to see if a setter method exists for any of the properties. If a setter exists it is called with the property value. No automatic denormalization of the value takes place.
@author Nils Adermann <naderman@naderman.de>
Expanded class hierarchy of GetSetMethodNormalizer
class GetSetMethodNormalizer extends SerializerAwareNormalizer implements NormalizerInterface, DenormalizerInterface {
protected $callbacks = array();
protected $ignoredAttributes = array();
protected $camelizedAttributes = array();
/**
* Set normalization callbacks
*
* @param array $callbacks help normalize the result
*
* @throws InvalidArgumentException if a non-callable callback is set
*/
public function setCallbacks(array $callbacks) {
foreach ($callbacks as $attribute => $callback) {
if (!is_callable($callback)) {
throw new InvalidArgumentException(sprintf('The given callback for attribute "%s" is not callable.', $attribute));
}
}
$this->callbacks = $callbacks;
}
/**
* Set ignored attributes for normalization
*
* @param array $ignoredAttributes
*/
public function setIgnoredAttributes(array $ignoredAttributes) {
$this->ignoredAttributes = $ignoredAttributes;
}
/**
* Set attributes to be camelized on denormalize
*
* @param array $camelizedAttributes
*/
public function setCamelizedAttributes(array $camelizedAttributes) {
$this->camelizedAttributes = $camelizedAttributes;
}
/**
* {@inheritdoc}
*/
public function normalize($object, $format = null, array $context = array()) {
$reflectionObject = new \ReflectionObject($object);
$reflectionMethods = $reflectionObject
->getMethods(\ReflectionMethod::IS_PUBLIC);
$attributes = array();
foreach ($reflectionMethods as $method) {
if ($this
->isGetMethod($method)) {
$attributeName = lcfirst(substr($method->name, 3));
if (in_array($attributeName, $this->ignoredAttributes)) {
continue;
}
$attributeValue = $method
->invoke($object);
if (array_key_exists($attributeName, $this->callbacks)) {
$attributeValue = call_user_func($this->callbacks[$attributeName], $attributeValue);
}
if (null !== $attributeValue && !is_scalar($attributeValue)) {
$attributeValue = $this->serializer
->normalize($attributeValue, $format);
}
$attributes[$attributeName] = $attributeValue;
}
}
return $attributes;
}
/**
* {@inheritdoc}
*/
public function denormalize($data, $class, $format = null, array $context = array()) {
$reflectionClass = new \ReflectionClass($class);
$constructor = $reflectionClass
->getConstructor();
if ($constructor) {
$constructorParameters = $constructor
->getParameters();
$params = array();
foreach ($constructorParameters as $constructorParameter) {
$paramName = lcfirst($this
->formatAttribute($constructorParameter->name));
if (isset($data[$paramName])) {
$params[] = $data[$paramName];
// don't run set for a parameter passed to the constructor
unset($data[$paramName]);
}
elseif (!$constructorParameter
->isOptional()) {
throw new RuntimeException('Cannot create an instance of ' . $class . ' from serialized data because its constructor requires ' . 'parameter "' . $constructorParameter->name . '" to be present.');
}
}
$object = $reflectionClass
->newInstanceArgs($params);
}
else {
$object = new $class();
}
foreach ($data as $attribute => $value) {
$setter = 'set' . $this
->formatAttribute($attribute);
if (method_exists($object, $setter)) {
$object
->{$setter}($value);
}
}
return $object;
}
/**
* Format attribute name to access parameters or methods
* As option, if attribute name is found on camelizedAttributes array
* returns attribute name in camelcase format
*
* @param string $attributeName
* @return string
*/
protected function formatAttribute($attributeName) {
if (in_array($attributeName, $this->camelizedAttributes)) {
return preg_replace_callback('/(^|_|\\.)+(.)/', function ($match) {
return ('.' === $match[1] ? '_' : '') . strtoupper($match[2]);
}, $attributeName);
}
return $attributeName;
}
/**
* {@inheritDoc}
*/
public function supportsNormalization($data, $format = null) {
return is_object($data) && $this
->supports(get_class($data));
}
/**
* {@inheritDoc}
*/
public function supportsDenormalization($data, $type, $format = null) {
return $this
->supports($type);
}
/**
* Checks if the given class has any get{Property} method.
*
* @param string $class
*
* @return Boolean
*/
private function supports($class) {
$class = new \ReflectionClass($class);
$methods = $class
->getMethods(\ReflectionMethod::IS_PUBLIC);
foreach ($methods as $method) {
if ($this
->isGetMethod($method)) {
return true;
}
}
return false;
}
/**
* Checks if a method's name is get.* and can be called without parameters.
*
* @param \ReflectionMethod $method the method to check
*
* @return Boolean whether the method is a getter.
*/
private function isGetMethod(\ReflectionMethod $method) {
return 0 === strpos($method->name, 'get') && 3 < strlen($method->name) && 0 === $method
->getNumberOfRequiredParameters();
}
}
Name | Modifiers | Type | Description | Overrides |
---|---|---|---|---|
GetSetMethodNormalizer:: |
protected | property | ||
GetSetMethodNormalizer:: |
protected | property | ||
GetSetMethodNormalizer:: |
protected | property | ||
GetSetMethodNormalizer:: |
public | function |
Denormalizes data back into an object of the given class Overrides DenormalizerInterface:: |
|
GetSetMethodNormalizer:: |
protected | function | Format attribute name to access parameters or methods As option, if attribute name is found on camelizedAttributes array returns attribute name in camelcase format | |
GetSetMethodNormalizer:: |
private | function | Checks if a method's name is get.* and can be called without parameters. | |
GetSetMethodNormalizer:: |
public | function |
Normalizes an object into a set of arrays/scalars Overrides NormalizerInterface:: |
|
GetSetMethodNormalizer:: |
public | function | Set normalization callbacks | |
GetSetMethodNormalizer:: |
public | function | Set attributes to be camelized on denormalize | |
GetSetMethodNormalizer:: |
public | function | Set ignored attributes for normalization | |
GetSetMethodNormalizer:: |
private | function | Checks if the given class has any get{Property} method. | |
GetSetMethodNormalizer:: |
public | function |
Checks whether the given class is supported for denormalization by this normalizer Overrides DenormalizerInterface:: |
|
GetSetMethodNormalizer:: |
public | function |
Checks whether the given class is supported for normalization by this normalizer Overrides NormalizerInterface:: |
|
SerializerAwareNormalizer:: |
protected | property | ||
SerializerAwareNormalizer:: |
public | function |
Sets the owning Serializer object Overrides SerializerAwareInterface:: |