Move normalizer cache to getNormalier()/getDenormalizer(), use those in normalizeObject()/denormalizeObject()

Berdir · fabpot · commit e7389aa24cb6 · 2014-03-27T08:44:58.000+01:00
diff --git a/src/Symfony/Component/Serializer/Serializer.php b/src/Symfony/Component/Serializer/Serializer.php
@@ -17,7 +17,6 @@
 use Symfony\Component\Serializer\Encoder\DecoderInterface;
 use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
 use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
-use Symfony\Component\Serializer\Exception\RuntimeException;
 use Symfony\Component\Serializer\Exception\LogicException;
 use Symfony\Component\Serializer\Exception\UnexpectedValueException;
 
@@ -144,55 +143,68 @@ public function denormalize($data, $type, $format = null, array $context = array
      */
     public function supportsNormalization($data, $format = null)
     {
-        try {
-            $this->getNormalizer($data, $format);
-        } catch (RuntimeException $e) {
-            return false;
-        }
-
-        return true;
+        return (bool) $this->getNormalizer($data, $format);
     }
 
     /**
      * {@inheritdoc}
      */
     public function supportsDenormalization($data, $type, $format = null)
     {
-        try {
-            $this->getDenormalizer($data, $type, $format = null);
-        } catch (RuntimeException $e) {
-            return false;
-        }
-
-        return true;
+        return (bool) $this->getDenormalizer($data, $type, $format);
     }
 
     /**
-     * {@inheritdoc}
+     * Returns a matching normalizer.
+     *
+     * @param object $data The object to get the serializer for
+     * @param string $format format name, present to give the option to normalizers to act differently based on formats
+     *
+     * @return NormalizerInterface|null
      */
-    private function getNormalizer($data, $format = null)
+    private function getNormalizer($data, $format)
     {
+
+        $class = get_class($data);
+        if (isset($this->normalizerCache[$class][$format])) {
+            return $this->normalizerCache[$class][$format];
+        }
+
         foreach ($this->normalizers as $normalizer) {
             if ($normalizer instanceof NormalizerInterface && $normalizer->supportsNormalization($data, $format)) {
+                $this->normalizerCache[$class][$format] = $normalizer;
+
                 return $normalizer;
             }
         }
 
-        throw new RuntimeException(sprintf('No normalizer found for format "%s".', $format));
+        return null;
     }
 
     /**
-     * {@inheritdoc}
+     * Returns a matching denormalizer.
+     *
+     * @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
+     *
+     * @return DenormalizerInterface|null
      */
-    private function getDenormalizer($data, $type, $format = null)
+    private function getDenormalizer($data, $class, $format)
     {
+        if (isset($this->denormalizerCache[$class][$format])) {
+            return $this->denormalizerCache[$class][$format];
+        }
+
         foreach ($this->normalizers as $normalizer) {
-            if ($normalizer instanceof DenormalizerInterface && $normalizer->supportsDenormalization($data, $type, $format)) {
+            if ($normalizer instanceof DenormalizerInterface && $normalizer->supportsDenormalization($data, $class, $format)) {
+                $this->denormalizerCache[$class][$format] = $normalizer;
+
                 return $normalizer;
             }
         }
 
-        throw new RuntimeException(sprintf('No denormalizer found for format "%s".', $format));
+        return null;
     }
 
     /**
@@ -223,27 +235,16 @@ final public function decode($data, $format, array $context = array())
      * @throws LogicException
      * @throws UnexpectedValueException
      */
-    private function normalizeObject($object, $format = null, array $context = array())
+    private function normalizeObject($object, $format, 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);
-            }
+        if ($normalizer = $this->getNormalizer($object, $format)) {
+            return $normalizer->normalize($object, $format, $context);
         }
-
-        throw new UnexpectedValueException(sprintf('Could not normalize object of type %s, no supporting normalizer found.', $class));
+        throw new UnexpectedValueException(sprintf('Could not normalize object of type %s, no supporting normalizer found.', get_class($object)));
     }
 
     /**
@@ -259,25 +260,15 @@ private function normalizeObject($object, $format = null, array $context = array
      * @throws LogicException
      * @throws UnexpectedValueException
      */
-    private function denormalizeObject($data, $class, $format = null, array $context = array())
+    private function denormalizeObject($data, $class, $format, 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);
-            }
+        if ($normalizer = $this->getDenormalizer($data, $class, $format)) {
+            return $normalizer->denormalize($data, $class, $format, $context);
         }
-
         throw new UnexpectedValueException(sprintf('Could not denormalize object of type %s, no supporting normalizer found.', $class));
     }
 
