vendor/symfony/var-exporter/Internal/Hydrator.php line 40

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\VarExporter\Internal;
  14. use Symfony\Component\VarExporter\Exception\ClassNotFoundException;
  16. /**
  17.  * @author Nicolas Grekas <p@tchwork.com>
  18.  *
  19.  * @internal
  20.  */
  21. class Hydrator
  22. {
  23.     public static $hydrators = [];
  25.     public $registry;
  26.     public $values;
  27.     public $properties;
  28.     public $value;
  29.     public $wakeups;
  31.     public function __construct(?Registry $registry, ?Values $values, array $properties, $value, array $wakeups)
  32.     {
  33.         $this->registry = $registry;
  34.         $this->values = $values;
  35.         $this->properties = $properties;
  36.         $this->value = $value;
  37.         $this->wakeups = $wakeups;
  38.     }
  40.     public static function hydrate($objects, $values, $properties, $value, $wakeups)
  41.     {
  42.         foreach ($properties as $class => $vars) {
  43.             (self::$hydrators[$class] ?? self::getHydrator($class))($vars, $objects);
  44.         }
  45.         foreach ($wakeups as $k => $v) {
  46.             if (\is_array($v)) {
  47.                 $objects[-$k]->__unserialize($v);
  48.             } else {
  49.                 $objects[$v]->__wakeup();
  50.             }
  51.         }
  53.         return $value;
  54.     }
  56.     public static function getHydrator($class)
  57.     {
  58.         switch ($class) {
  59.             case 'stdClass':
  60.                 return self::$hydrators[$class] = static function ($properties, $objects) {
  61.                     foreach ($properties as $name => $values) {
  62.                         foreach ($values as $i => $v) {
  63.                             $objects[$i]->$name = $v;
  64.                         }
  65.                     }
  66.                 };
  68.             case 'ErrorException':
  69.                 return self::$hydrators[$class] = (self::$hydrators['stdClass'] ?? self::getHydrator('stdClass'))->bindTo(null, new class() extends \ErrorException {
  70.                 });
  72.             case 'TypeError':
  73.                 return self::$hydrators[$class] = (self::$hydrators['stdClass'] ?? self::getHydrator('stdClass'))->bindTo(null, new class() extends \Error {
  74.                 });
  76.             case 'SplObjectStorage':
  77.                 return self::$hydrators[$class] = static function ($properties, $objects) {
  78.                     foreach ($properties as $name => $values) {
  79.                         if ("\0" === $name) {
  80.                             foreach ($values as $i => $v) {
  81.                                 for ($j = 0; $j < \count($v); ++$j) {
  82.                                     $objects[$i]->attach($v[$j], $v[++$j]);
  83.                                 }
  84.                             }
  85.                             continue;
  86.                         }
  87.                         foreach ($values as $i => $v) {
  88.                             $objects[$i]->$name = $v;
  89.                         }
  90.                     }
  91.                 };
  92.         }
  94.         if (!class_exists($class) && !interface_exists($class, false) && !trait_exists($class, false)) {
  95.             throw new ClassNotFoundException($class);
  96.         }
  97.         $classReflector = new \ReflectionClass($class);
  99.         switch ($class) {
  100.             case 'ArrayIterator':
  101.             case 'ArrayObject':
  102.                 $constructor = \Closure::fromCallable([$classReflector->getConstructor(), 'invokeArgs']);
  104.                 return self::$hydrators[$class] = static function ($properties, $objects) use ($constructor) {
  105.                     foreach ($properties as $name => $values) {
  106.                         if ("\0" !== $name) {
  107.                             foreach ($values as $i => $v) {
  108.                                 $objects[$i]->$name = $v;
  109.                             }
  110.                         }
  111.                     }
  112.                     foreach ($properties["\0"] ?? [] as $i => $v) {
  113.                         $constructor($objects[$i], $v);
  114.                     }
  115.                 };
  116.         }
  118.         if (!$classReflector->isInternal()) {
  119.             return self::$hydrators[$class] = (self::$hydrators['stdClass'] ?? self::getHydrator('stdClass'))->bindTo(null, $class);
  120.         }
  122.         if ($classReflector->name !== $class) {
  123.             return self::$hydrators[$classReflector->name] ?? self::getHydrator($classReflector->name);
  124.         }
  126.         $propertySetters = [];
  127.         foreach ($classReflector->getProperties() as $propertyReflector) {
  128.             if (!$propertyReflector->isStatic()) {
  129.                 $propertyReflector->setAccessible(true);
  130.                 $propertySetters[$propertyReflector->name] = \Closure::fromCallable([$propertyReflector, 'setValue']);
  131.             }
  132.         }
  134.         if (!$propertySetters) {
  135.             return self::$hydrators[$class] = self::$hydrators['stdClass'] ?? self::getHydrator('stdClass');
  136.         }
  138.         return self::$hydrators[$class] = static function ($properties, $objects) use ($propertySetters) {
  139.             foreach ($properties as $name => $values) {
  140.                 if ($setValue = $propertySetters[$name] ?? null) {
  141.                     foreach ($values as $i => $v) {
  142.                         $setValue($objects[$i], $v);
  143.                     }
  144.                     continue;
  145.                 }
  146.                 foreach ($values as $i => $v) {
  147.                     $objects[$i]->$name = $v;
  148.                 }
  149.             }
  150.         };
  151.     }
  152. }