class Serializer

Same name in this branch
  1. 8.x drupal/core/vendor/symfony/serializer/Symfony/Component/Serializer/Serializer.php \Symfony\Component\Serializer\Serializer
  2. 8.x drupal/core/modules/rest/lib/Drupal/rest/Plugin/views/style/Serializer.php \Drupal\rest\Plugin\views\style\Serializer

Serializer serializes and deserializes data

objects are turned into arrays by normalizers arrays are turned into various output formats by encoders

$serializer->serialize($obj, 'xml') $serializer->decode($data, 'xml') $serializer->denormalize($data, 'Class', 'xml')

@author Jordi Boggiano <j.boggiano@seld.be> @author Johannes M. Schmitt <schmittjoh@gmail.com> @author Lukas Kahwe Smith <smith@pooteeweet.org>

Hierarchy

Expanded class hierarchy of Serializer

6 files declare their use of Serializer
CustomNormalizerTest.php in drupal/core/vendor/symfony/serializer/Symfony/Component/Serializer/Tests/Normalizer/CustomNormalizerTest.php
EntitySerializationTest.php in drupal/core/modules/serialization/lib/Drupal/serialization/Tests/EntitySerializationTest.php
Contains \Drupal\serialization\Tests\EntitySerializationTest.
JsonEncoderTest.php in drupal/core/vendor/symfony/serializer/Symfony/Component/Serializer/Tests/Encoder/JsonEncoderTest.php
NormalizerTestBase.php in drupal/core/modules/hal/lib/Drupal/hal/Tests/NormalizerTestBase.php
Contains \Drupal\hal\Tests\NormalizerTestBase.
SerializerTest.php in drupal/core/vendor/symfony/serializer/Symfony/Component/Serializer/Tests/SerializerTest.php

... See full list

1 string reference to 'Serializer'
serialization.services.yml in drupal/core/modules/serialization/serialization.services.yml
drupal/core/modules/serialization/serialization.services.yml
1 service uses Serializer
serializer in drupal/core/modules/serialization/serialization.services.yml
Symfony\Component\Serializer\Serializer

File

drupal/core/vendor/symfony/serializer/Symfony/Component/Serializer/Serializer.php, line 38

Namespace

Symfony\Component\Serializer
View source
class Serializer implements SerializerInterface, NormalizerInterface, DenormalizerInterface, EncoderInterface, DecoderInterface {
  protected $encoder;
  protected $decoder;
  protected $normalizers = array();
  protected $normalizerCache = array();
  protected $denormalizerCache = array();
  public function __construct(array $normalizers = array(), array $encoders = array()) {
    foreach ($normalizers as $normalizer) {
      if ($normalizer instanceof SerializerAwareInterface) {
        $normalizer
          ->setSerializer($this);
      }
    }
    $this->normalizers = $normalizers;
    $decoders = array();
    $realEncoders = array();
    foreach ($encoders as $encoder) {
      if ($encoder instanceof SerializerAwareInterface) {
        $encoder
          ->setSerializer($this);
      }
      if ($encoder instanceof DecoderInterface) {
        $decoders[] = $encoder;
      }
      if ($encoder instanceof EncoderInterface) {
        $realEncoders[] = $encoder;
      }
    }
    $this->encoder = new ChainEncoder($realEncoders);
    $this->decoder = new ChainDecoder($decoders);
  }

  /**
   * {@inheritdoc}
   */
  public final function serialize($data, $format, array $context = array()) {
    if (!$this
      ->supportsEncoding($format)) {
      throw new UnexpectedValueException(sprintf('Serialization for the format %s is not supported', $format));
    }
    if ($this->encoder
      ->needsNormalization($format)) {
      $data = $this
        ->normalize($data, $format, $context);
    }
    return $this
      ->encode($data, $format, $context);
  }

  /**
   * {@inheritdoc}
   */
  public final function deserialize($data, $type, $format, array $context = array()) {
    if (!$this
      ->supportsDecoding($format)) {
      throw new UnexpectedValueException(sprintf('Deserialization for the format %s is not supported', $format));
    }
    $data = $this
      ->decode($data, $format, $context);
    return $this
      ->denormalize($data, $type, $format, $context);
  }

  /**
   * {@inheritdoc}
   */
  public function normalize($data, $format = null, array $context = array()) {
    if (null === $data || is_scalar($data)) {
      return $data;
    }
    if (is_object($data) && $this
      ->supportsNormalization($data, $format)) {
      return $this
        ->normalizeObject($data, $format, $context);
    }
    if ($data instanceof \Traversable) {
      $normalized = array();
      foreach ($data as $key => $val) {
        $normalized[$key] = $this
          ->normalize($val, $format, $context);
      }
      return $normalized;
    }
    if (is_object($data)) {
      return $this
        ->normalizeObject($data, $format, $context);
    }
    if (is_array($data)) {
      foreach ($data as $key => $val) {
        $data[$key] = $this
          ->normalize($val, $format, $context);
      }
      return $data;
    }
    throw new UnexpectedValueException(sprintf('An unexpected value could not be normalized: %s', var_export($data, true)));
  }

  /**
   * {@inheritdoc}
   */
  public function denormalize($data, $type, $format = null, array $context = array()) {
    return $this
      ->denormalizeObject($data, $type, $format, $context);
  }

  /**
   * {@inheritdoc}
   */
  public function supportsNormalization($data, $format = null) {
    try {
      $this
        ->getNormalizer($data, $format);
    } catch (RuntimeException $e) {
      return false;
    }
    return true;
  }

  /**
   * {@inheritdoc}
   */
  public function supportsDenormalization($data, $type, $format = null) {
    try {
      $this
        ->getDenormalizer($data, $type, $format = null);
    } catch (RuntimeException $e) {
      return false;
    }
    return true;
  }

  /**
   * {@inheritdoc}
   */
  private function getNormalizer($data, $format = null) {
    foreach ($this->normalizers as $normalizer) {
      if ($normalizer instanceof NormalizerInterface && $normalizer
        ->supportsNormalization($data, $format)) {
        return $normalizer;
      }
    }
    throw new RuntimeException(sprintf('No normalizer found for format "%s".', $format));
  }

  /**
   * {@inheritdoc}
   */
  private function getDenormalizer($data, $type, $format = null) {
    foreach ($this->normalizers as $normalizer) {
      if ($normalizer instanceof DenormalizerInterface && $normalizer
        ->supportsDenormalization($data, $type, $format)) {
        return $normalizer;
      }
    }
    throw new RuntimeException(sprintf('No denormalizer found for format "%s".', $format));
  }

  /**
   * {@inheritdoc}
   */
  public final function encode($data, $format, array $context = array()) {
    return $this->encoder
      ->encode($data, $format, $context);
  }

  /**
   * {@inheritdoc}
   */
  public final function decode($data, $format, array $context = array()) {
    return $this->decoder
      ->decode($data, $format, $context);
  }

  /**
   * Normalizes an object into a set of arrays/scalars
   *
   * @param object $object object to normalize
   * @param string $format format name, present to give the option to normalizers to act differently based on formats
   * @param array $context The context data for this particular normalization
   *
   * @return array|scalar
   *
   * @throws LogicException
   * @throws UnexpectedValueException
   */
  private function normalizeObject($object, $format = null, array $context = array()) {
    if (!$this->normalizers) {
      throw new LogicException('You must register at least one normalizer to be able to normalize objects.');
    }
    $class = get_class($object);
    if (isset($this->normalizerCache[$class][$format])) {
      return $this->normalizerCache[$class][$format]
        ->normalize($object, $format, $context);
    }
    foreach ($this->normalizers as $normalizer) {
      if ($normalizer instanceof NormalizerInterface && $normalizer
        ->supportsNormalization($object, $format)) {
        $this->normalizerCache[$class][$format] = $normalizer;
        return $normalizer
          ->normalize($object, $format, $context);
      }
    }
    throw new UnexpectedValueException(sprintf('Could not normalize object of type %s, no supporting normalizer found.', $class));
  }

  /**
   * Denormalizes data back into an object of the given class
   *
   * @param mixed  $data   data to restore
   * @param string $class  the expected class to instantiate
   * @param string $format format name, present to give the option to normalizers to act differently based on formats
   * @param array $context The context data for this particular denormalization
   *
   * @return object
   *
   * @throws LogicException
   * @throws UnexpectedValueException
   */
  private function denormalizeObject($data, $class, $format = null, array $context = array()) {
    if (!$this->normalizers) {
      throw new LogicException('You must register at least one normalizer to be able to denormalize objects.');
    }
    if (isset($this->denormalizerCache[$class][$format])) {
      return $this->denormalizerCache[$class][$format]
        ->denormalize($data, $class, $format, $context);
    }
    foreach ($this->normalizers as $normalizer) {
      if ($normalizer instanceof DenormalizerInterface && $normalizer
        ->supportsDenormalization($data, $class, $format)) {
        $this->denormalizerCache[$class][$format] = $normalizer;
        return $normalizer
          ->denormalize($data, $class, $format, $context);
      }
    }
    throw new UnexpectedValueException(sprintf('Could not denormalize object of type %s, no supporting normalizer found.', $class));
  }

  /**
   * {@inheritdoc}
   */
  public function supportsEncoding($format) {
    return $this->encoder
      ->supportsEncoding($format);
  }

  /**
   * {@inheritdoc}
   */
  public function supportsDecoding($format) {
    return $this->decoder
      ->supportsDecoding($format);
  }

}

Members

Namesort descending Modifiers Type Description Overrides
Serializer::$decoder protected property
Serializer::$denormalizerCache protected property
Serializer::$encoder protected property
Serializer::$normalizerCache protected property
Serializer::$normalizers protected property
Serializer::decode final public function Decodes a string into PHP data. Overrides DecoderInterface::decode
Serializer::denormalize public function Denormalizes data back into an object of the given class Overrides DenormalizerInterface::denormalize
Serializer::denormalizeObject private function Denormalizes data back into an object of the given class
Serializer::deserialize final public function Deserializes data into the given type. Overrides SerializerInterface::deserialize
Serializer::encode final public function Encodes data into the given format Overrides EncoderInterface::encode
Serializer::getDenormalizer private function
Serializer::getNormalizer private function
Serializer::normalize public function Normalizes an object into a set of arrays/scalars Overrides NormalizerInterface::normalize
Serializer::normalizeObject private function Normalizes an object into a set of arrays/scalars
Serializer::serialize final public function Serializes data in the appropriate format Overrides SerializerInterface::serialize
Serializer::supportsDecoding public function Checks whether the deserializer can decode from given format. Overrides DecoderInterface::supportsDecoding
Serializer::supportsDenormalization public function Checks whether the given class is supported for denormalization by this normalizer Overrides DenormalizerInterface::supportsDenormalization
Serializer::supportsEncoding public function Checks whether the serializer can encode to given format Overrides EncoderInterface::supportsEncoding
Serializer::supportsNormalization public function Checks whether the given class is supported for normalization by this normalizer Overrides NormalizerInterface::supportsNormalization
Serializer::__construct public function