Copied!

Converts between objects and arrays by mapping properties.

The normalization process looks for all the object's properties (public and private).
The result is a map from property names 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
property with the corresponding name exists. If found, the property gets the value.

Cloneable Instantiable
Constants
public Symfony\Component\Serializer\Normalizer\AbstractNormalizer ::ALLOW_EXTRA_ATTRIBUTES = 'allow_extra_attributes'
 

If ATTRIBUTES are specified, and the source has fields that are not part of that list,
either ignore those attributes (true) or throw an ExtraAttributesException (false).

public Symfony\Component\Serializer\Normalizer\AbstractNormalizer ::ATTRIBUTES = 'attributes'
 

Limit (de)normalize to the specified names.

For nested structures, this list needs to reflect the object tree.

public Symfony\Component\Serializer\Normalizer\AbstractNormalizer ::CALLBACKS = 'callbacks'
 

Hashmap of field name => callable to (de)normalize this field.

The callable is called if the field is encountered with the arguments:

  • mixed $attributeValue value of this field
  • object|string $object the whole object being normalized or the object's class being denormalized
  • string $attributeName name of the attribute being (de)normalized
  • string $format the requested format
  • array $context the serialization context
public Symfony\Component\Serializer\Normalizer\AbstractNormalizer ::CIRCULAR_REFERENCE_HANDLER = 'circular_reference_handler'
 

Handler to call when a circular reference has been detected.

If you specify no handler, a CircularReferenceException is thrown.

The method will be called with ($object, $format, $context) and its
return value is returned as the result of the normalize call.

public Symfony\Component\Serializer\Normalizer\AbstractNormalizer ::CIRCULAR_REFERENCE_LIMIT = 'circular_reference_limit'
 

How many loops of circular reference to allow while normalizing.

The default value of 1 means that when we encounter the same object a
second time, we consider that a circular reference.

You can raise this value for special cases, e.g. in combination with the
max depth setting of the object normalizer.

public Symfony\Component\Serializer\Normalizer\DenormalizerInterface ::COLLECT_DENORMALIZATION_ERRORS = 'collect_denormalization_errors'
public Symfony\Component\Serializer\Normalizer\AbstractObjectNormalizer ::DEEP_OBJECT_TO_POPULATE = 'deep_object_to_populate'
 

Flag to tell the denormalizer to also populate existing objects on
attributes of the main object.

Setting this to true is only useful if you also specify the root object
in OBJECT_TO_POPULATE.

public Symfony\Component\Serializer\Normalizer\AbstractNormalizer ::DEFAULT_CONSTRUCTOR_ARGUMENTS = 'default_constructor_arguments'
 

Hashmap of default values for constructor arguments.

The names need to match the parameter names in the constructor arguments.

public Symfony\Component\Serializer\Normalizer\AbstractObjectNormalizer ::DEPTH_KEY_PATTERN = 'depth_%s::%s'
 

How to track the current depth in the context.

public Symfony\Component\Serializer\Normalizer\AbstractObjectNormalizer ::DISABLE_TYPE_ENFORCEMENT = 'disable_type_enforcement'
 

While denormalizing, we can verify that types match.

You can disable this by setting this flag to true.

public Symfony\Component\Serializer\Normalizer\AbstractObjectNormalizer ::ENABLE_MAX_DEPTH = 'enable_max_depth'
 

Set to true to respect the max depth metadata on fields.

public Symfony\Component\Serializer\Normalizer\AbstractObjectNormalizer ::EXCLUDE_FROM_CACHE_KEY = 'exclude_from_cache_key'
 

Specify which context key are not relevant to determine which attributes
of an object to (de)normalize.

public Symfony\Component\Serializer\Normalizer\AbstractNormalizer ::GROUPS = 'groups'
 

Only (de)normalize attributes that are in the specified groups.

public Symfony\Component\Serializer\Normalizer\AbstractNormalizer ::IGNORED_ATTRIBUTES = 'ignored_attributes'
 

Skip the specified attributes when normalizing an object tree.

This list is applied to each element of nested structures.

Note: The behaviour for nested structures is different from ATTRIBUTES
for historical reason. Aligning the behaviour would be a BC break.

public Symfony\Component\Serializer\Normalizer\AbstractObjectNormalizer ::MAX_DEPTH_HANDLER = 'max_depth_handler'
 

Callback to allow to set a value for an attribute when the max depth has
been reached.

If no callback is given, the attribute is skipped. If a callable is
given, its return value is used (even if null).

The arguments are:

  • mixed $attributeValue value of this field
  • object $object the whole object being normalized
  • string $attributeName name of the attribute being normalized
  • string $format the requested format
  • array $context the serialization context
public Symfony\Component\Serializer\Normalizer\AbstractNormalizer ::OBJECT_TO_POPULATE = 'object_to_populate'
 

Instead of creating a new instance of an object, update the specified object.

If you have a nested structure, child objects will be overwritten with
new instances unless you set DEEP_OBJECT_TO_POPULATE to true.

public Symfony\Component\Serializer\Normalizer\AbstractObjectNormalizer ::PRESERVE_EMPTY_OBJECTS = 'preserve_empty_objects'
 

Flag to control whether an empty object should be kept as an object (in
JSON: {}) or converted to a list (in JSON: []).

public Symfony\Component\Serializer\Normalizer\AbstractObjectNormalizer ::SKIP_NULL_VALUES = 'skip_null_values'
 

Flag to control whether fields with the value null should be output
when normalizing or omitted.

public Symfony\Component\Serializer\Normalizer\AbstractObjectNormalizer ::SKIP_UNINITIALIZED_VALUES = 'skip_uninitialized_values'
 

Flag to control whether uninitialized PHP>=7.4 typed class properties
should be excluded when normalizing.

Methods
public Symfony\Component\Serializer\Normalizer\AbstractObjectNormalizer :: __construct ( ? Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactoryInterface $classMetadataFactory = NULL , ? Symfony\Component\Serializer\NameConverter\NameConverterInterface $nameConverter = NULL , ? Symfony\Component\PropertyInfo\PropertyTypeExtractorInterface $propertyTypeExtractor = NULL , ? Symfony\Component\Serializer\Mapping\ClassDiscriminatorResolverInterface $classDiscriminatorResolver = NULL , ? callable $objectClassResolver = NULL , array $defaultContext = [ ] )
public Symfony\Component\Serializer\Normalizer\AbstractObjectNormalizer :: denormalize ( ? mixed $data , string $type , ? string $format = NULL , array $context = [ ] )
 

Denormalizes data back into an object of the given class.

  • param mixed $data Data to restore
  • param string $type The expected class to instantiate
  • param string $format Format the given data was extracted from
  • param array $context Options available to the denormalizer
  • return mixed
  • throws BadMethodCallException Occurs when the normalizer is not called in an expected context
  • throws InvalidArgumentException Occurs when the arguments are not coherent or not supported
  • throws UnexpectedValueException Occurs when the item cannot be hydrated with the given data
  • throws ExtraAttributesException Occurs when the item doesn't have attribute to receive given data
  • throws LogicException Occurs when the normalizer is not supposed to denormalize
  • throws RuntimeException Occurs if the class cannot be instantiated
  • throws ExceptionInterface Occurs for all the other cases of errors
public hasCacheableSupportsMethod () : bool
 
public Symfony\Component\Serializer\Normalizer\AbstractObjectNormalizer :: normalize ( ? mixed $object , ? string $format = NULL , array $context = [ ] )
 

Normalizes an object into a set of arrays/scalars.

  • param mixed $object Object to normalize
  • param string $format Format the normalization result will be encoded as
  • param array $context Context options for the normalizer
  • return array | string | int | float | bool | ArrayObject | null \ArrayObject is used to make sure an empty object is encoded as an object not an array
  • throws InvalidArgumentException Occurs when the object given is not a supported type for the normalizer
  • throws CircularReferenceException Occurs when the normalizer detects a circular reference when no circular
    reference handler can fix it
  • throws LogicException Occurs when the normalizer is not called in an expected context
  • throws ExceptionInterface Occurs for all the other cases of errors
public Symfony\Component\Serializer\Normalizer\AbstractNormalizer :: setSerializer ( Symfony\Component\Serializer\SerializerInterface $serializer )
public supportsDenormalization ( ? mixed $data , string $type , ? string $format = NULL ) : bool
 

Checks whether the given class is supported for denormalization by this normalizer.

  • param mixed $data Data to denormalize from
  • param string $type The class to which the data should be denormalized
  • param string $format The format being deserialized from
  • param array $context Options available to the denormalizer
  • return bool
  • param array $context
  • param array $context
public supportsNormalization ( ? mixed $data , ? string $format = NULL ) : bool
 

Checks whether the given class is supported for normalization by this normalizer.

  • param mixed $data Data to normalize
  • param string $format The format being (de-)serialized from or into
  • param array $context Context options for the normalizer
  • return bool
  • param array $context
  • param array $context
Constants
protected Symfony\Component\Serializer\Normalizer\AbstractNormalizer ::CIRCULAR_REFERENCE_LIMIT_COUNTERS = 'circular_reference_limit_counters'
 
  • internal
Properties
protected Symfony\Component\Serializer\Normalizer\AbstractObjectNormalizer :: $classDiscriminatorResolver
 
  • var ClassDiscriminatorResolverInterface | null
protected Symfony\Component\Serializer\Normalizer\AbstractNormalizer :: $classMetadataFactory
 
  • var ClassMetadataFactoryInterface | null
protected Symfony\Component\Serializer\Normalizer\AbstractNormalizer :: $defaultContext
protected Symfony\Component\Serializer\Normalizer\AbstractNormalizer :: $nameConverter
 
  • var NameConverterInterface | null
protected Symfony\Component\Serializer\Normalizer\AbstractNormalizer :: $serializer
 
  • var SerializerInterface
Methods
protected final Symfony\Component\Serializer\Normalizer\AbstractNormalizer :: applyCallbacks ( ? mixed $value , object | string $object , string $attribute , ? string $format , array $context ) : ? mixed
protected Symfony\Component\Serializer\Normalizer\AbstractObjectNormalizer :: createChildContext ( array $parentContext , string $attribute , ? string $format ) : array
 

Overwritten to update the cache key for the child.

We must not mix up the attribute cache between parent and children.

  • internal
  • internal
protected Symfony\Component\Serializer\Normalizer\AbstractObjectNormalizer :: denormalizeParameter ( ReflectionClass $class , ReflectionParameter $parameter , string $parameterName , ? mixed $parameterData , array $context , ? string $format = NULL ) : ? mixed
 
  • internal
protected extractAttributes ( object $object , ? string $format = NULL , array $context = [ ] ) : array
 

Extracts attributes to normalize from the class of the given object, format and context.

  • return string []
protected Symfony\Component\Serializer\Normalizer\AbstractNormalizer :: extractObjectToPopulate ( string $class , array $context , ? string $key = NULL ) : ? object
 

Extract the object_to_populate field from the context if it exists
and is an instance of the provided $class.

  • param string $class The class the object should be
  • param string | null $key They in which to look for the object to populate.
    Keeps backwards compatibility with AbstractNormalizer.
protected Symfony\Component\Serializer\Normalizer\AbstractNormalizer :: getAllowedAttributes ( object | string $classOrObject , array $context , bool $attributesAsString = false )
 

Gets attributes to normalize using groups.

  • param bool $attributesAsString If false, return an array of {@link AttributeMetadataInterface}
  • throws LogicException if the 'allow_extra_attributes' context variable is false and no class metadata factory is provided
  • return string []| AttributeMetadataInterface []| bool
protected Symfony\Component\Serializer\Normalizer\AbstractObjectNormalizer :: getAttributes ( object $object , ? string $format , array $context ) : array
 

Gets and caches attributes for the given object, format and context.

  • return string []
protected getAttributeValue ( object $object , string $attribute , ? string $format = NULL , array $context = [ ] ) : ? mixed
 

Gets the attribute value.

  • return mixed
protected Symfony\Component\Serializer\Normalizer\AbstractNormalizer :: getConstructor ( array $data , string $class , array $context , ReflectionClass $reflectionClass , array | bool $allowedAttributes ) : ? ReflectionMethod
 

Returns the method to use to construct an object. This method must be either
the object constructor or static.

protected Symfony\Component\Serializer\Normalizer\AbstractNormalizer :: getGroups ( array $context ) : array
protected Symfony\Component\Serializer\Normalizer\AbstractNormalizer :: handleCircularReference ( object $object , ? string $format = NULL , array $context = [ ] ) : ? mixed
 

Handles a circular reference.

If a circular reference handler is set, it will be called. Otherwise, a
{@class CircularReferenceException} will be thrown.

  • final
  • throws CircularReferenceException
protected Symfony\Component\Serializer\Normalizer\AbstractObjectNormalizer :: instantiateObject ( array $data , string $class , array $context , ReflectionClass $reflectionClass , array | bool $allowedAttributes , ? string $format = NULL )
 

Instantiates an object using constructor parameters when needed.

This method also allows to denormalize data into an existing object if
it is present in the context with the object_to_populate. This object
is removed from the context before being returned to avoid side effects
when recursively normalizing an object graph.

  • return object
  • throws RuntimeException
  • throws MissingConstructorArgumentsException
protected isAllowedAttribute ( object | string $classOrObject , string $attribute , ? string $format = NULL , array $context = [ ] ) : bool
 

Is this attribute allowed?

  • return bool
protected Symfony\Component\Serializer\Normalizer\AbstractNormalizer :: isCircularReference ( object $object , array $context ) : bool
 

Detects if the configured circular reference limit is reached.

  • throws CircularReferenceException
protected Symfony\Component\Serializer\Normalizer\AbstractNormalizer :: prepareForDenormalization ( ? mixed $data ) : array
 

Normalizes the given data to an array. It's particularly useful during
the denormalization process.

protected setAttributeValue ( object $object , string $attribute , ? mixed $value , ? string $format = NULL , array $context = [ ] )
 

Sets attribute value.

protected final Symfony\Component\Serializer\Normalizer\AbstractNormalizer :: validateCallbackContext ( array $context , string $contextType = '' ) : void
 

Validate callbacks set in context.

  • param string $contextType Used to specify which context is invalid in exceptions
  • throws InvalidArgumentException
Methods
private getReflectionProperty ( object | string $classOrObject , string $attribute ) : ReflectionProperty
 
  • throws ReflectionException
private supports ( string $class ) : bool
 

Checks if the given class has any non-static property.

© 2022 Bruce Wells
Search Namespaces \ Classes
Configuration