Initial Commit
This commit is contained in:
David Stone
362
dependencies/symfony/var-exporter/Internal/Exporter.php
vendored
Normal file
362
dependencies/symfony/var-exporter/Internal/Exporter.php
vendored
Normal file
@ -0,0 +1,362 @@
|
||||
<?php
|
||||
|
||||
/*
|
||||
* This file is part of the Symfony package.
|
||||
*
|
||||
* (c) Fabien Potencier <fabien@symfony.com>
|
||||
*
|
||||
* For the full copyright and license information, please view the LICENSE
|
||||
* file that was distributed with this source code.
|
||||
*/
|
||||
namespace WP_Ultimo\Dependencies\Symfony\Component\VarExporter\Internal;
|
||||
|
||||
use WP_Ultimo\Dependencies\Symfony\Component\VarExporter\Exception\NotInstantiableTypeException;
|
||||
/**
|
||||
* @author Nicolas Grekas <p@tchwork.com>
|
||||
*
|
||||
* @internal
|
||||
*/
|
||||
class Exporter
|
||||
{
|
||||
/**
|
||||
* Prepares an array of values for VarExporter.
|
||||
*
|
||||
* For performance this method is public and has no type-hints.
|
||||
*
|
||||
* @param array &$values
|
||||
* @param \SplObjectStorage $objectsPool
|
||||
* @param array &$refsPool
|
||||
* @param int &$objectsCount
|
||||
* @param bool &$valuesAreStatic
|
||||
*
|
||||
* @return array
|
||||
*
|
||||
* @throws NotInstantiableTypeException When a value cannot be serialized
|
||||
*/
|
||||
public static function prepare($values, $objectsPool, &$refsPool, &$objectsCount, &$valuesAreStatic)
|
||||
{
|
||||
$refs = $values;
|
||||
foreach ($values as $k => $value) {
|
||||
if (\is_resource($value)) {
|
||||
throw new NotInstantiableTypeException(\get_resource_type($value) . ' resource');
|
||||
}
|
||||
$refs[$k] = $objectsPool;
|
||||
if ($isRef = !($valueIsStatic = $values[$k] !== $objectsPool)) {
|
||||
$values[$k] =& $value;
|
||||
// Break hard references to make $values completely
|
||||
unset($value);
|
||||
// independent from the original structure
|
||||
$refs[$k] = $value = $values[$k];
|
||||
if ($value instanceof Reference && 0 > $value->id) {
|
||||
$valuesAreStatic = \false;
|
||||
++$value->count;
|
||||
continue;
|
||||
}
|
||||
$refsPool[] = [&$refs[$k], $value, &$value];
|
||||
$refs[$k] = $values[$k] = new Reference(-\count($refsPool), $value);
|
||||
}
|
||||
if (\is_array($value)) {
|
||||
if ($value) {
|
||||
$value = self::prepare($value, $objectsPool, $refsPool, $objectsCount, $valueIsStatic);
|
||||
}
|
||||
goto handle_value;
|
||||
} elseif (!\is_object($value) || $value instanceof \UnitEnum) {
|
||||
goto handle_value;
|
||||
}
|
||||
$valueIsStatic = \false;
|
||||
if (isset($objectsPool[$value])) {
|
||||
++$objectsCount;
|
||||
$value = new Reference($objectsPool[$value][0]);
|
||||
goto handle_value;
|
||||
}
|
||||
$class = $value::class;
|
||||
$reflector = Registry::$reflectors[$class] ??= Registry::getClassReflector($class);
|
||||
$properties = [];
|
||||
if ($reflector->hasMethod('__serialize')) {
|
||||
if (!$reflector->getMethod('__serialize')->isPublic()) {
|
||||
throw new \Error(\sprintf('Call to %s method "%s::__serialize()".', $reflector->getMethod('__serialize')->isProtected() ? 'protected' : 'private', $class));
|
||||
}
|
||||
if (!\is_array($serializeProperties = $value->__serialize())) {
|
||||
throw new \TypeError($class . '::__serialize() must return an array');
|
||||
}
|
||||
if ($reflector->hasMethod('__unserialize')) {
|
||||
$properties = $serializeProperties;
|
||||
} else {
|
||||
foreach ($serializeProperties as $n => $v) {
|
||||
$c = \PHP_VERSION_ID >= 80100 && $reflector->hasProperty($n) && ($p = $reflector->getProperty($n))->isReadOnly() ? $p->class : 'stdClass';
|
||||
$properties[$c][$n] = $v;
|
||||
}
|
||||
}
|
||||
goto prepare_value;
|
||||
}
|
||||
$sleep = null;
|
||||
$proto = Registry::$prototypes[$class];
|
||||
if (($value instanceof \ArrayIterator || $value instanceof \ArrayObject) && null !== $proto) {
|
||||
// ArrayIterator and ArrayObject need special care because their "flags"
|
||||
// option changes the behavior of the (array) casting operator.
|
||||
[$arrayValue, $properties] = self::getArrayObjectProperties($value, $proto);
|
||||
// populates Registry::$prototypes[$class] with a new instance
|
||||
Registry::getClassReflector($class, Registry::$instantiableWithoutConstructor[$class], Registry::$cloneable[$class]);
|
||||
} elseif ($value instanceof \SplObjectStorage && Registry::$cloneable[$class] && null !== $proto) {
|
||||
// By implementing Serializable, SplObjectStorage breaks
|
||||
// internal references; let's deal with it on our own.
|
||||
foreach (clone $value as $v) {
|
||||
$properties[] = $v;
|
||||
$properties[] = $value[$v];
|
||||
}
|
||||
$properties = ['SplObjectStorage' => ["\x00" => $properties]];
|
||||
$arrayValue = (array) $value;
|
||||
} elseif ($value instanceof \Serializable || $value instanceof \__PHP_Incomplete_Class || \PHP_VERSION_ID < 80200 && $value instanceof \DatePeriod) {
|
||||
++$objectsCount;
|
||||
$objectsPool[$value] = [$id = \count($objectsPool), \serialize($value), [], 0];
|
||||
$value = new Reference($id);
|
||||
goto handle_value;
|
||||
} else {
|
||||
if (\method_exists($class, '__sleep')) {
|
||||
if (!\is_array($sleep = $value->__sleep())) {
|
||||
\trigger_error('serialize(): __sleep should return an array only containing the names of instance-variables to serialize', \E_USER_NOTICE);
|
||||
$value = null;
|
||||
goto handle_value;
|
||||
}
|
||||
$sleep = \array_flip($sleep);
|
||||
}
|
||||
$arrayValue = (array) $value;
|
||||
}
|
||||
$proto = (array) $proto;
|
||||
foreach ($arrayValue as $name => $v) {
|
||||
$i = 0;
|
||||
$n = (string) $name;
|
||||
if ('' === $n || "\x00" !== $n[0]) {
|
||||
$c = $reflector->hasProperty($n) && ($p = $reflector->getProperty($n))->isReadOnly() ? $p->class : 'stdClass';
|
||||
} elseif ('*' === $n[1]) {
|
||||
$n = \substr($n, 3);
|
||||
$c = $reflector->getProperty($n)->class;
|
||||
if ('Error' === $c) {
|
||||
$c = 'TypeError';
|
||||
} elseif ('Exception' === $c) {
|
||||
$c = 'ErrorException';
|
||||
}
|
||||
} else {
|
||||
$i = \strpos($n, "\x00", 2);
|
||||
$c = \substr($n, 1, $i - 1);
|
||||
$n = \substr($n, 1 + $i);
|
||||
}
|
||||
if (null !== $sleep) {
|
||||
if (!isset($sleep[$n]) || $i && $c !== $class) {
|
||||
unset($arrayValue[$name]);
|
||||
continue;
|
||||
}
|
||||
$sleep[$n] = \false;
|
||||
}
|
||||
if (!\array_key_exists($name, $proto) || $proto[$name] !== $v || "\x00Error\x00trace" === $name || "\x00Exception\x00trace" === $name) {
|
||||
$properties[$c][$n] = $v;
|
||||
}
|
||||
}
|
||||
if ($sleep) {
|
||||
foreach ($sleep as $n => $v) {
|
||||
if (\false !== $v) {
|
||||
\trigger_error(\sprintf('serialize(): "%s" returned as member variable from __sleep() but does not exist', $n), \E_USER_NOTICE);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (\method_exists($class, '__unserialize')) {
|
||||
$properties = $arrayValue;
|
||||
}
|
||||
prepare_value:
|
||||
$objectsPool[$value] = [$id = \count($objectsPool)];
|
||||
$properties = self::prepare($properties, $objectsPool, $refsPool, $objectsCount, $valueIsStatic);
|
||||
++$objectsCount;
|
||||
$objectsPool[$value] = [$id, $class, $properties, \method_exists($class, '__unserialize') ? -$objectsCount : (\method_exists($class, '__wakeup') ? $objectsCount : 0)];
|
||||
$value = new Reference($id);
|
||||
handle_value:
|
||||
if ($isRef) {
|
||||
unset($value);
|
||||
// Break the hard reference created above
|
||||
} elseif (!$valueIsStatic) {
|
||||
$values[$k] = $value;
|
||||
}
|
||||
$valuesAreStatic = $valueIsStatic && $valuesAreStatic;
|
||||
}
|
||||
return $values;
|
||||
}
|
||||
public static function export($value, $indent = '')
|
||||
{
|
||||
switch (\true) {
|
||||
case \is_int($value) || \is_float($value):
|
||||
return \var_export($value, \true);
|
||||
case [] === $value:
|
||||
return '[]';
|
||||
case \false === $value:
|
||||
return 'false';
|
||||
case \true === $value:
|
||||
return 'true';
|
||||
case null === $value:
|
||||
return 'null';
|
||||
case '' === $value:
|
||||
return "''";
|
||||
case $value instanceof \UnitEnum:
|
||||
return '\\' . \ltrim(\var_export($value, \true), '\\');
|
||||
}
|
||||
if ($value instanceof Reference) {
|
||||
if (0 <= $value->id) {
|
||||
return '$o[' . $value->id . ']';
|
||||
}
|
||||
if (!$value->count) {
|
||||
return self::export($value->value, $indent);
|
||||
}
|
||||
$value = -$value->id;
|
||||
return '&$r[' . $value . ']';
|
||||
}
|
||||
$subIndent = $indent . ' ';
|
||||
if (\is_string($value)) {
|
||||
$code = \sprintf("'%s'", \addcslashes($value, "'\\"));
|
||||
$code = \preg_replace_callback("/((?:[\\0\\r\\n]|||||||||)++)(.)/", function ($m) use($subIndent) {
|
||||
$m[1] = \sprintf('\'."%s".\'', \str_replace(["\x00", "\r", "\n", "", "", "", "", "", "", "", "", "", '\\n\\'], ['\\0', '\\r', '\\n', '\\u{202A}', '\\u{202B}', '\\u{202D}', '\\u{202E}', '\\u{2066}', '\\u{2067}', '\\u{2068}', '\\u{202C}', '\\u{2069}', '\\n"' . "\n" . $subIndent . '."\\'], $m[1]));
|
||||
if ("'" === $m[2]) {
|
||||
return \substr($m[1], 0, -2);
|
||||
}
|
||||
if (\str_ends_with($m[1], 'n".\'')) {
|
||||
return \substr_replace($m[1], "\n" . $subIndent . ".'" . $m[2], -2);
|
||||
}
|
||||
return $m[1] . $m[2];
|
||||
}, $code, -1, $count);
|
||||
if ($count && \str_starts_with($code, "''.")) {
|
||||
$code = \substr($code, 3);
|
||||
}
|
||||
return $code;
|
||||
}
|
||||
if (\is_array($value)) {
|
||||
$j = -1;
|
||||
$code = '';
|
||||
foreach ($value as $k => $v) {
|
||||
$code .= $subIndent;
|
||||
if (!\is_int($k) || 1 !== $k - $j) {
|
||||
$code .= self::export($k, $subIndent) . ' => ';
|
||||
}
|
||||
if (\is_int($k) && $k > $j) {
|
||||
$j = $k;
|
||||
}
|
||||
$code .= self::export($v, $subIndent) . ",\n";
|
||||
}
|
||||
return "[\n" . $code . $indent . ']';
|
||||
}
|
||||
if ($value instanceof Values) {
|
||||
$code = $subIndent . "\$r = [],\n";
|
||||
foreach ($value->values as $k => $v) {
|
||||
$code .= $subIndent . '$r[' . $k . '] = ' . self::export($v, $subIndent) . ",\n";
|
||||
}
|
||||
return "[\n" . $code . $indent . ']';
|
||||
}
|
||||
if ($value instanceof Registry) {
|
||||
return self::exportRegistry($value, $indent, $subIndent);
|
||||
}
|
||||
if ($value instanceof Hydrator) {
|
||||
return self::exportHydrator($value, $indent, $subIndent);
|
||||
}
|
||||
throw new \UnexpectedValueException(\sprintf('Cannot export value of type "%s".', \get_debug_type($value)));
|
||||
}
|
||||
private static function exportRegistry(Registry $value, string $indent, string $subIndent) : string
|
||||
{
|
||||
$code = '';
|
||||
$serializables = [];
|
||||
$seen = [];
|
||||
$prototypesAccess = 0;
|
||||
$factoriesAccess = 0;
|
||||
$r = '\\' . Registry::class;
|
||||
$j = -1;
|
||||
foreach ($value->classes as $k => $class) {
|
||||
if (':' === ($class[1] ?? null)) {
|
||||
$serializables[$k] = $class;
|
||||
continue;
|
||||
}
|
||||
if (!Registry::$instantiableWithoutConstructor[$class]) {
|
||||
if (\is_subclass_of($class, 'Serializable') && !\method_exists($class, '__unserialize')) {
|
||||
$serializables[$k] = 'C:' . \strlen($class) . ':"' . $class . '":0:{}';
|
||||
} else {
|
||||
$serializables[$k] = 'O:' . \strlen($class) . ':"' . $class . '":0:{}';
|
||||
}
|
||||
if (\is_subclass_of($class, 'Throwable')) {
|
||||
$eol = \is_subclass_of($class, 'Error') ? "\x00Error\x00" : "\x00Exception\x00";
|
||||
$serializables[$k] = \substr_replace($serializables[$k], '1:{s:' . (5 + \strlen($eol)) . ':"' . $eol . 'trace";a:0:{}}', -4);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
$code .= $subIndent . (1 !== $k - $j ? $k . ' => ' : '');
|
||||
$j = $k;
|
||||
$eol = ",\n";
|
||||
$c = '[' . self::export($class) . ']';
|
||||
if ($seen[$class] ?? \false) {
|
||||
if (Registry::$cloneable[$class]) {
|
||||
++$prototypesAccess;
|
||||
$code .= 'clone $p' . $c;
|
||||
} else {
|
||||
++$factoriesAccess;
|
||||
$code .= '$f' . $c . '()';
|
||||
}
|
||||
} else {
|
||||
$seen[$class] = \true;
|
||||
if (Registry::$cloneable[$class]) {
|
||||
$code .= 'clone (' . ($prototypesAccess++ ? '$p' : '($p = &' . $r . '::$prototypes)') . $c . ' ?? ' . $r . '::p';
|
||||
} else {
|
||||
$code .= '(' . ($factoriesAccess++ ? '$f' : '($f = &' . $r . '::$factories)') . $c . ' ?? ' . $r . '::f';
|
||||
$eol = '()' . $eol;
|
||||
}
|
||||
$code .= '(' . \substr($c, 1, -1) . '))';
|
||||
}
|
||||
$code .= $eol;
|
||||
}
|
||||
if (1 === $prototypesAccess) {
|
||||
$code = \str_replace('($p = &' . $r . '::$prototypes)', $r . '::$prototypes', $code);
|
||||
}
|
||||
if (1 === $factoriesAccess) {
|
||||
$code = \str_replace('($f = &' . $r . '::$factories)', $r . '::$factories', $code);
|
||||
}
|
||||
if ('' !== $code) {
|
||||
$code = "\n" . $code . $indent;
|
||||
}
|
||||
if ($serializables) {
|
||||
$code = $r . '::unserialize([' . $code . '], ' . self::export($serializables, $indent) . ')';
|
||||
} else {
|
||||
$code = '[' . $code . ']';
|
||||
}
|
||||
return '$o = ' . $code;
|
||||
}
|
||||
private static function exportHydrator(Hydrator $value, string $indent, string $subIndent) : string
|
||||
{
|
||||
$code = '';
|
||||
foreach ($value->properties as $class => $properties) {
|
||||
$code .= $subIndent . ' ' . self::export($class) . ' => ' . self::export($properties, $subIndent . ' ') . ",\n";
|
||||
}
|
||||
$code = [self::export($value->registry, $subIndent), self::export($value->values, $subIndent), '' !== $code ? "[\n" . $code . $subIndent . ']' : '[]', self::export($value->value, $subIndent), self::export($value->wakeups, $subIndent)];
|
||||
return '\\' . $value::class . "::hydrate(\n" . $subIndent . \implode(",\n" . $subIndent, $code) . "\n" . $indent . ')';
|
||||
}
|
||||
/**
|
||||
* @param \ArrayIterator|\ArrayObject $value
|
||||
* @param \ArrayIterator|\ArrayObject $proto
|
||||
*/
|
||||
private static function getArrayObjectProperties($value, $proto) : array
|
||||
{
|
||||
$reflector = $value instanceof \ArrayIterator ? 'ArrayIterator' : 'ArrayObject';
|
||||
$reflector = Registry::$reflectors[$reflector] ??= Registry::getClassReflector($reflector);
|
||||
$properties = [$arrayValue = (array) $value, $reflector->getMethod('getFlags')->invoke($value), $value instanceof \ArrayObject ? $reflector->getMethod('getIteratorClass')->invoke($value) : 'ArrayIterator'];
|
||||
$reflector = $reflector->getMethod('setFlags');
|
||||
$reflector->invoke($proto, \ArrayObject::STD_PROP_LIST);
|
||||
if ($properties[1] & \ArrayObject::STD_PROP_LIST) {
|
||||
$reflector->invoke($value, 0);
|
||||
$properties[0] = (array) $value;
|
||||
} else {
|
||||
$reflector->invoke($value, \ArrayObject::STD_PROP_LIST);
|
||||
$arrayValue = (array) $value;
|
||||
}
|
||||
$reflector->invoke($value, $properties[1]);
|
||||
if ([[], 0, 'ArrayIterator'] === $properties) {
|
||||
$properties = [];
|
||||
} else {
|
||||
if ('ArrayIterator' === $properties[2]) {
|
||||
unset($properties[2]);
|
||||
}
|
||||
$properties = [$reflector->class => ["\x00" => $properties]];
|
||||
}
|
||||
return [$arrayValue, $properties];
|
||||
}
|
||||
}
|
||||
260
dependencies/symfony/var-exporter/Internal/Hydrator.php
vendored
Normal file
260
dependencies/symfony/var-exporter/Internal/Hydrator.php
vendored
Normal file
@ -0,0 +1,260 @@
|
||||
<?php
|
||||
|
||||
/*
|
||||
* This file is part of the Symfony package.
|
||||
*
|
||||
* (c) Fabien Potencier <fabien@symfony.com>
|
||||
*
|
||||
* For the full copyright and license information, please view the LICENSE
|
||||
* file that was distributed with this source code.
|
||||
*/
|
||||
namespace WP_Ultimo\Dependencies\Symfony\Component\VarExporter\Internal;
|
||||
|
||||
use WP_Ultimo\Dependencies\Symfony\Component\VarExporter\Exception\ClassNotFoundException;
|
||||
/**
|
||||
* @author Nicolas Grekas <p@tchwork.com>
|
||||
*
|
||||
* @internal
|
||||
*/
|
||||
class Hydrator
|
||||
{
|
||||
public static $hydrators = [];
|
||||
public static $simpleHydrators = [];
|
||||
public static $propertyScopes = [];
|
||||
public $registry;
|
||||
public $values;
|
||||
public $properties;
|
||||
public $value;
|
||||
public $wakeups;
|
||||
public function __construct(?Registry $registry, ?Values $values, array $properties, $value, array $wakeups)
|
||||
{
|
||||
$this->registry = $registry;
|
||||
$this->values = $values;
|
||||
$this->properties = $properties;
|
||||
$this->value = $value;
|
||||
$this->wakeups = $wakeups;
|
||||
}
|
||||
public static function hydrate($objects, $values, $properties, $value, $wakeups)
|
||||
{
|
||||
foreach ($properties as $class => $vars) {
|
||||
(self::$hydrators[$class] ??= self::getHydrator($class))($vars, $objects);
|
||||
}
|
||||
foreach ($wakeups as $k => $v) {
|
||||
if (\is_array($v)) {
|
||||
$objects[-$k]->__unserialize($v);
|
||||
} else {
|
||||
$objects[$v]->__wakeup();
|
||||
}
|
||||
}
|
||||
return $value;
|
||||
}
|
||||
public static function getHydrator($class)
|
||||
{
|
||||
$baseHydrator = self::$hydrators['stdClass'] ??= static function ($properties, $objects) {
|
||||
foreach ($properties as $name => $values) {
|
||||
foreach ($values as $i => $v) {
|
||||
$objects[$i]->{$name} = $v;
|
||||
}
|
||||
}
|
||||
};
|
||||
switch ($class) {
|
||||
case 'stdClass':
|
||||
return $baseHydrator;
|
||||
case 'ErrorException':
|
||||
return $baseHydrator->bindTo(null, new class extends \ErrorException
|
||||
{
|
||||
});
|
||||
case 'TypeError':
|
||||
return $baseHydrator->bindTo(null, new class extends \Error
|
||||
{
|
||||
});
|
||||
case 'SplObjectStorage':
|
||||
return static function ($properties, $objects) {
|
||||
foreach ($properties as $name => $values) {
|
||||
if ("\x00" === $name) {
|
||||
foreach ($values as $i => $v) {
|
||||
for ($j = 0; $j < \count($v); ++$j) {
|
||||
$objects[$i]->attach($v[$j], $v[++$j]);
|
||||
}
|
||||
}
|
||||
continue;
|
||||
}
|
||||
foreach ($values as $i => $v) {
|
||||
$objects[$i]->{$name} = $v;
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
if (!\class_exists($class) && !\interface_exists($class, \false) && !\trait_exists($class, \false)) {
|
||||
throw new ClassNotFoundException($class);
|
||||
}
|
||||
$classReflector = new \ReflectionClass($class);
|
||||
switch ($class) {
|
||||
case 'ArrayIterator':
|
||||
case 'ArrayObject':
|
||||
$constructor = $classReflector->getConstructor()->invokeArgs(...);
|
||||
return static function ($properties, $objects) use($constructor) {
|
||||
foreach ($properties as $name => $values) {
|
||||
if ("\x00" !== $name) {
|
||||
foreach ($values as $i => $v) {
|
||||
$objects[$i]->{$name} = $v;
|
||||
}
|
||||
}
|
||||
}
|
||||
foreach ($properties["\x00"] ?? [] as $i => $v) {
|
||||
$constructor($objects[$i], $v);
|
||||
}
|
||||
};
|
||||
}
|
||||
if (!$classReflector->isInternal()) {
|
||||
return $baseHydrator->bindTo(null, $class);
|
||||
}
|
||||
if ($classReflector->name !== $class) {
|
||||
return self::$hydrators[$classReflector->name] ??= self::getHydrator($classReflector->name);
|
||||
}
|
||||
$propertySetters = [];
|
||||
foreach ($classReflector->getProperties() as $propertyReflector) {
|
||||
if (!$propertyReflector->isStatic()) {
|
||||
$propertySetters[$propertyReflector->name] = $propertyReflector->setValue(...);
|
||||
}
|
||||
}
|
||||
if (!$propertySetters) {
|
||||
return $baseHydrator;
|
||||
}
|
||||
return static function ($properties, $objects) use($propertySetters) {
|
||||
foreach ($properties as $name => $values) {
|
||||
if ($setValue = $propertySetters[$name] ?? null) {
|
||||
foreach ($values as $i => $v) {
|
||||
$setValue($objects[$i], $v);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
foreach ($values as $i => $v) {
|
||||
$objects[$i]->{$name} = $v;
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
public static function getSimpleHydrator($class)
|
||||
{
|
||||
$baseHydrator = self::$simpleHydrators['stdClass'] ??= (function ($properties, $object) {
|
||||
$readonly = (array) $this;
|
||||
foreach ($properties as $name => &$value) {
|
||||
$object->{$name} = $value;
|
||||
if (!($readonly[$name] ?? \false)) {
|
||||
$object->{$name} =& $value;
|
||||
}
|
||||
}
|
||||
})->bindTo(new \stdClass());
|
||||
switch ($class) {
|
||||
case 'stdClass':
|
||||
return $baseHydrator;
|
||||
case 'ErrorException':
|
||||
return $baseHydrator->bindTo(new \stdClass(), new class extends \ErrorException
|
||||
{
|
||||
});
|
||||
case 'TypeError':
|
||||
return $baseHydrator->bindTo(new \stdClass(), new class extends \Error
|
||||
{
|
||||
});
|
||||
case 'SplObjectStorage':
|
||||
return static function ($properties, $object) {
|
||||
foreach ($properties as $name => &$value) {
|
||||
if ("\x00" !== $name) {
|
||||
$object->{$name} = $value;
|
||||
$object->{$name} =& $value;
|
||||
continue;
|
||||
}
|
||||
for ($i = 0; $i < \count($value); ++$i) {
|
||||
$object->attach($value[$i], $value[++$i]);
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
if (!\class_exists($class) && !\interface_exists($class, \false) && !\trait_exists($class, \false)) {
|
||||
throw new ClassNotFoundException($class);
|
||||
}
|
||||
$classReflector = new \ReflectionClass($class);
|
||||
switch ($class) {
|
||||
case 'ArrayIterator':
|
||||
case 'ArrayObject':
|
||||
$constructor = $classReflector->getConstructor()->invokeArgs(...);
|
||||
return static function ($properties, $object) use($constructor) {
|
||||
foreach ($properties as $name => &$value) {
|
||||
if ("\x00" === $name) {
|
||||
$constructor($object, $value);
|
||||
} else {
|
||||
$object->{$name} = $value;
|
||||
$object->{$name} =& $value;
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
if (!$classReflector->isInternal()) {
|
||||
$readonly = new \stdClass();
|
||||
foreach ($classReflector->getProperties(\ReflectionProperty::IS_READONLY) as $propertyReflector) {
|
||||
if ($class === $propertyReflector->class) {
|
||||
$readonly->{$propertyReflector->name} = \true;
|
||||
}
|
||||
}
|
||||
return $baseHydrator->bindTo($readonly, $class);
|
||||
}
|
||||
if ($classReflector->name !== $class) {
|
||||
return self::$simpleHydrators[$classReflector->name] ??= self::getSimpleHydrator($classReflector->name);
|
||||
}
|
||||
$propertySetters = [];
|
||||
foreach ($classReflector->getProperties() as $propertyReflector) {
|
||||
if (!$propertyReflector->isStatic()) {
|
||||
$propertySetters[$propertyReflector->name] = $propertyReflector->setValue(...);
|
||||
}
|
||||
}
|
||||
if (!$propertySetters) {
|
||||
return $baseHydrator;
|
||||
}
|
||||
return static function ($properties, $object) use($propertySetters) {
|
||||
foreach ($properties as $name => &$value) {
|
||||
if ($setValue = $propertySetters[$name] ?? null) {
|
||||
$setValue($object, $value);
|
||||
} else {
|
||||
$object->{$name} = $value;
|
||||
$object->{$name} =& $value;
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
/**
|
||||
* @return array
|
||||
*/
|
||||
public static function getPropertyScopes($class)
|
||||
{
|
||||
$propertyScopes = [];
|
||||
$r = new \ReflectionClass($class);
|
||||
foreach ($r->getProperties() as $property) {
|
||||
$flags = $property->getModifiers();
|
||||
if (\ReflectionProperty::IS_STATIC & $flags) {
|
||||
continue;
|
||||
}
|
||||
$name = $property->name;
|
||||
if (\ReflectionProperty::IS_PRIVATE & $flags) {
|
||||
$propertyScopes["\x00{$class}\x00{$name}"] = $propertyScopes[$name] = [$class, $name, $flags & \ReflectionProperty::IS_READONLY ? $class : null];
|
||||
continue;
|
||||
}
|
||||
$propertyScopes[$name] = [$class, $name, $flags & \ReflectionProperty::IS_READONLY ? $property->class : null];
|
||||
if (\ReflectionProperty::IS_PROTECTED & $flags) {
|
||||
$propertyScopes["\x00*\x00{$name}"] = $propertyScopes[$name];
|
||||
}
|
||||
}
|
||||
while ($r = $r->getParentClass()) {
|
||||
$class = $r->name;
|
||||
foreach ($r->getProperties(\ReflectionProperty::IS_PRIVATE) as $property) {
|
||||
if (!$property->isStatic()) {
|
||||
$name = $property->name;
|
||||
$readonlyScope = $property->isReadOnly() ? $class : null;
|
||||
$propertyScopes["\x00{$class}\x00{$name}"] = [$class, $name, $readonlyScope];
|
||||
$propertyScopes[$name] ??= [$class, $name, $readonlyScope];
|
||||
}
|
||||
}
|
||||
}
|
||||
return $propertyScopes;
|
||||
}
|
||||
}
|
||||
119
dependencies/symfony/var-exporter/Internal/LazyObjectRegistry.php
vendored
Normal file
119
dependencies/symfony/var-exporter/Internal/LazyObjectRegistry.php
vendored
Normal file
@ -0,0 +1,119 @@
|
||||
<?php
|
||||
|
||||
/*
|
||||
* This file is part of the Symfony package.
|
||||
*
|
||||
* (c) Fabien Potencier <fabien@symfony.com>
|
||||
*
|
||||
* For the full copyright and license information, please view the LICENSE
|
||||
* file that was distributed with this source code.
|
||||
*/
|
||||
namespace WP_Ultimo\Dependencies\Symfony\Component\VarExporter\Internal;
|
||||
|
||||
/**
|
||||
* Stores the state of lazy objects and caches related reflection information.
|
||||
*
|
||||
* As a micro-optimization, this class uses no type declarations.
|
||||
*
|
||||
* @internal
|
||||
*/
|
||||
class LazyObjectRegistry
|
||||
{
|
||||
/**
|
||||
* @var array<class-string, \ReflectionClass>
|
||||
*/
|
||||
public static $classReflectors = [];
|
||||
/**
|
||||
* @var array<class-string, array<string, mixed>>
|
||||
*/
|
||||
public static $defaultProperties = [];
|
||||
/**
|
||||
* @var array<class-string, list<\Closure>>
|
||||
*/
|
||||
public static $classResetters = [];
|
||||
/**
|
||||
* @var array<class-string, array{get: \Closure, set: \Closure, isset: \Closure, unset: \Closure}>
|
||||
*/
|
||||
public static $classAccessors = [];
|
||||
/**
|
||||
* @var array<class-string, array{set: bool, isset: bool, unset: bool, clone: bool, serialize: bool, unserialize: bool, sleep: bool, wakeup: bool, destruct: bool, get: int}>
|
||||
*/
|
||||
public static $parentMethods = [];
|
||||
public static ?\Closure $noInitializerState = null;
|
||||
public static function getClassResetters($class)
|
||||
{
|
||||
$classProperties = [];
|
||||
if ((self::$classReflectors[$class] ??= new \ReflectionClass($class))->isInternal()) {
|
||||
$propertyScopes = [];
|
||||
} else {
|
||||
$propertyScopes = Hydrator::$propertyScopes[$class] ??= Hydrator::getPropertyScopes($class);
|
||||
}
|
||||
foreach ($propertyScopes as $key => [$scope, $name, $readonlyScope]) {
|
||||
$propertyScopes[$k = "\x00{$scope}\x00{$name}"] ?? $propertyScopes[$k = "\x00*\x00{$name}"] ?? ($k = $name);
|
||||
if ($k === $key && "\x00{$class}\x00lazyObjectState" !== $k) {
|
||||
$classProperties[$readonlyScope ?? $scope][$name] = $key;
|
||||
}
|
||||
}
|
||||
$resetters = [];
|
||||
foreach ($classProperties as $scope => $properties) {
|
||||
$resetters[] = \Closure::bind(static function ($instance, $skippedProperties, $onlyProperties = null) use($properties) {
|
||||
foreach ($properties as $name => $key) {
|
||||
if (!\array_key_exists($key, $skippedProperties) && (null === $onlyProperties || \array_key_exists($key, $onlyProperties))) {
|
||||
unset($instance->{$name});
|
||||
}
|
||||
}
|
||||
}, null, $scope);
|
||||
}
|
||||
$resetters[] = static function ($instance, $skippedProperties, $onlyProperties = null) {
|
||||
foreach ((array) $instance as $name => $value) {
|
||||
if ("\x00" !== ($name[0] ?? '') && !\array_key_exists($name, $skippedProperties) && (null === $onlyProperties || \array_key_exists($name, $onlyProperties))) {
|
||||
unset($instance->{$name});
|
||||
}
|
||||
}
|
||||
};
|
||||
return $resetters;
|
||||
}
|
||||
public static function getClassAccessors($class)
|
||||
{
|
||||
return \Closure::bind(static fn() => ['get' => static function &($instance, $name, $readonly) {
|
||||
if (!$readonly) {
|
||||
return $instance->{$name};
|
||||
}
|
||||
$value = $instance->{$name};
|
||||
return $value;
|
||||
}, 'set' => static function ($instance, $name, $value) {
|
||||
$instance->{$name} = $value;
|
||||
}, 'isset' => static fn($instance, $name) => isset($instance->{$name}), 'unset' => static function ($instance, $name) {
|
||||
unset($instance->{$name});
|
||||
}], null, \Closure::class === $class ? null : $class)();
|
||||
}
|
||||
public static function getParentMethods($class)
|
||||
{
|
||||
$parent = \get_parent_class($class);
|
||||
$methods = [];
|
||||
foreach (['set', 'isset', 'unset', 'clone', 'serialize', 'unserialize', 'sleep', 'wakeup', 'destruct', 'get'] as $method) {
|
||||
if (!$parent || !\method_exists($parent, '__' . $method)) {
|
||||
$methods[$method] = \false;
|
||||
} else {
|
||||
$m = new \ReflectionMethod($parent, '__' . $method);
|
||||
$methods[$method] = !$m->isAbstract() && !$m->isPrivate();
|
||||
}
|
||||
}
|
||||
$methods['get'] = $methods['get'] ? $m->returnsReference() ? 2 : 1 : 0;
|
||||
return $methods;
|
||||
}
|
||||
public static function getScope($propertyScopes, $class, $property, $readonlyScope = null)
|
||||
{
|
||||
if (null === $readonlyScope && !isset($propertyScopes[$k = "\x00{$class}\x00{$property}"]) && !isset($propertyScopes[$k = "\x00*\x00{$property}"])) {
|
||||
return null;
|
||||
}
|
||||
$frame = \debug_backtrace(\DEBUG_BACKTRACE_PROVIDE_OBJECT | \DEBUG_BACKTRACE_IGNORE_ARGS, 3)[2];
|
||||
if (\ReflectionProperty::class === ($scope = $frame['class'] ?? \Closure::class)) {
|
||||
$scope = $frame['object']->class;
|
||||
}
|
||||
if (null === $readonlyScope && '*' === $k[1] && ($class === $scope || \is_subclass_of($class, $scope) && !isset($propertyScopes["\x00{$scope}\x00{$property}"]))) {
|
||||
return null;
|
||||
}
|
||||
return $scope;
|
||||
}
|
||||
}
|
||||
107
dependencies/symfony/var-exporter/Internal/LazyObjectState.php
vendored
Normal file
107
dependencies/symfony/var-exporter/Internal/LazyObjectState.php
vendored
Normal file
@ -0,0 +1,107 @@
|
||||
<?php
|
||||
|
||||
/*
|
||||
* This file is part of the Symfony package.
|
||||
*
|
||||
* (c) Fabien Potencier <fabien@symfony.com>
|
||||
*
|
||||
* For the full copyright and license information, please view the LICENSE
|
||||
* file that was distributed with this source code.
|
||||
*/
|
||||
namespace WP_Ultimo\Dependencies\Symfony\Component\VarExporter\Internal;
|
||||
|
||||
use WP_Ultimo\Dependencies\Symfony\Component\VarExporter\Hydrator as PublicHydrator;
|
||||
/**
|
||||
* Keeps the state of lazy objects.
|
||||
*
|
||||
* As a micro-optimization, this class uses no type declarations.
|
||||
*
|
||||
* @internal
|
||||
*/
|
||||
class LazyObjectState
|
||||
{
|
||||
public const STATUS_UNINITIALIZED_FULL = 1;
|
||||
public const STATUS_UNINITIALIZED_PARTIAL = 2;
|
||||
public const STATUS_INITIALIZED_FULL = 3;
|
||||
public const STATUS_INITIALIZED_PARTIAL = 4;
|
||||
/**
|
||||
* @var array<string, true>
|
||||
*/
|
||||
public readonly array $skippedProperties;
|
||||
/**
|
||||
* @var self::STATUS_*
|
||||
*/
|
||||
public int $status = 0;
|
||||
public object $realInstance;
|
||||
public function __construct(public readonly \Closure|array $initializer, $skippedProperties = [])
|
||||
{
|
||||
$this->skippedProperties = $skippedProperties;
|
||||
$this->status = \is_array($initializer) ? self::STATUS_UNINITIALIZED_PARTIAL : self::STATUS_UNINITIALIZED_FULL;
|
||||
}
|
||||
public function initialize($instance, $propertyName, $propertyScope)
|
||||
{
|
||||
if (self::STATUS_INITIALIZED_FULL === $this->status) {
|
||||
return self::STATUS_INITIALIZED_FULL;
|
||||
}
|
||||
if (\is_array($this->initializer)) {
|
||||
$class = $instance::class;
|
||||
$propertyScope ??= $class;
|
||||
$propertyScopes = Hydrator::$propertyScopes[$class];
|
||||
$propertyScopes[$k = "\x00{$propertyScope}\x00{$propertyName}"] ?? $propertyScopes[$k = "\x00*\x00{$propertyName}"] ?? ($k = $propertyName);
|
||||
if ($initializer = $this->initializer[$k] ?? null) {
|
||||
$value = $initializer(...[$instance, $propertyName, $propertyScope, LazyObjectRegistry::$defaultProperties[$class][$k] ?? null]);
|
||||
$accessor = LazyObjectRegistry::$classAccessors[$propertyScope] ??= LazyObjectRegistry::getClassAccessors($propertyScope);
|
||||
$accessor['set']($instance, $propertyName, $value);
|
||||
return $this->status = self::STATUS_INITIALIZED_PARTIAL;
|
||||
}
|
||||
$status = self::STATUS_UNINITIALIZED_PARTIAL;
|
||||
if ($initializer = $this->initializer["\x00"] ?? null) {
|
||||
if (!\is_array($values = $initializer($instance, LazyObjectRegistry::$defaultProperties[$class]))) {
|
||||
throw new \TypeError(\sprintf('The lazy-initializer defined for instance of "%s" must return an array, got "%s".', $class, \get_debug_type($values)));
|
||||
}
|
||||
$properties = (array) $instance;
|
||||
foreach ($values as $key => $value) {
|
||||
if ($k === $key) {
|
||||
$status = self::STATUS_INITIALIZED_PARTIAL;
|
||||
}
|
||||
if (!\array_key_exists($key, $properties) && ([$scope, $name, $readonlyScope] = $propertyScopes[$key] ?? null)) {
|
||||
$scope = $readonlyScope ?? ('*' !== $scope ? $scope : $class);
|
||||
$accessor = LazyObjectRegistry::$classAccessors[$scope] ??= LazyObjectRegistry::getClassAccessors($scope);
|
||||
$accessor['set']($instance, $name, $value);
|
||||
}
|
||||
}
|
||||
}
|
||||
return $status;
|
||||
}
|
||||
$this->status = self::STATUS_INITIALIZED_FULL;
|
||||
try {
|
||||
if ($defaultProperties = \array_diff_key(LazyObjectRegistry::$defaultProperties[$instance::class], $this->skippedProperties)) {
|
||||
PublicHydrator::hydrate($instance, $defaultProperties);
|
||||
}
|
||||
($this->initializer)($instance);
|
||||
} catch (\Throwable $e) {
|
||||
$this->status = self::STATUS_UNINITIALIZED_FULL;
|
||||
$this->reset($instance);
|
||||
throw $e;
|
||||
}
|
||||
return self::STATUS_INITIALIZED_FULL;
|
||||
}
|
||||
public function reset($instance) : void
|
||||
{
|
||||
$class = $instance::class;
|
||||
$propertyScopes = Hydrator::$propertyScopes[$class] ??= Hydrator::getPropertyScopes($class);
|
||||
$skippedProperties = $this->skippedProperties;
|
||||
$properties = (array) $instance;
|
||||
$onlyProperties = \is_array($this->initializer) ? $this->initializer : null;
|
||||
foreach ($propertyScopes as $key => [$scope, $name, $readonlyScope]) {
|
||||
$propertyScopes[$k = "\x00{$scope}\x00{$name}"] ?? $propertyScopes[$k = "\x00*\x00{$name}"] ?? ($k = $name);
|
||||
if ($k === $key && (null !== $readonlyScope || !\array_key_exists($k, $properties))) {
|
||||
$skippedProperties[$k] = \true;
|
||||
}
|
||||
}
|
||||
foreach (LazyObjectRegistry::$classResetters[$class] as $reset) {
|
||||
$reset($instance, $skippedProperties, $onlyProperties);
|
||||
}
|
||||
$this->status = self::STATUS_INITIALIZED_FULL === $this->status ? self::STATUS_UNINITIALIZED_FULL : self::STATUS_UNINITIALIZED_PARTIAL;
|
||||
}
|
||||
}
|
||||
29
dependencies/symfony/var-exporter/Internal/LazyObjectTrait.php
vendored
Normal file
29
dependencies/symfony/var-exporter/Internal/LazyObjectTrait.php
vendored
Normal file
@ -0,0 +1,29 @@
|
||||
<?php
|
||||
|
||||
/*
|
||||
* This file is part of the Symfony package.
|
||||
*
|
||||
* (c) Fabien Potencier <fabien@symfony.com>
|
||||
*
|
||||
* For the full copyright and license information, please view the LICENSE
|
||||
* file that was distributed with this source code.
|
||||
*/
|
||||
namespace WP_Ultimo\Dependencies\Symfony\Component\VarExporter\Internal;
|
||||
|
||||
if (\PHP_VERSION_ID >= 80300) {
|
||||
/**
|
||||
* @internal
|
||||
*/
|
||||
trait LazyObjectTrait
|
||||
{
|
||||
private readonly LazyObjectState $lazyObjectState;
|
||||
}
|
||||
} else {
|
||||
/**
|
||||
* @internal
|
||||
*/
|
||||
trait LazyObjectTrait
|
||||
{
|
||||
private LazyObjectState $lazyObjectState;
|
||||
}
|
||||
}
|
||||
28
dependencies/symfony/var-exporter/Internal/Reference.php
vendored
Normal file
28
dependencies/symfony/var-exporter/Internal/Reference.php
vendored
Normal file
@ -0,0 +1,28 @@
|
||||
<?php
|
||||
|
||||
/*
|
||||
* This file is part of the Symfony package.
|
||||
*
|
||||
* (c) Fabien Potencier <fabien@symfony.com>
|
||||
*
|
||||
* For the full copyright and license information, please view the LICENSE
|
||||
* file that was distributed with this source code.
|
||||
*/
|
||||
namespace WP_Ultimo\Dependencies\Symfony\Component\VarExporter\Internal;
|
||||
|
||||
/**
|
||||
* @author Nicolas Grekas <p@tchwork.com>
|
||||
*
|
||||
* @internal
|
||||
*/
|
||||
class Reference
|
||||
{
|
||||
public $id;
|
||||
public $value;
|
||||
public $count = 0;
|
||||
public function __construct(int $id, $value = null)
|
||||
{
|
||||
$this->id = $id;
|
||||
$this->value = $value;
|
||||
}
|
||||
}
|
||||
120
dependencies/symfony/var-exporter/Internal/Registry.php
vendored
Normal file
120
dependencies/symfony/var-exporter/Internal/Registry.php
vendored
Normal file
@ -0,0 +1,120 @@
|
||||
<?php
|
||||
|
||||
/*
|
||||
* This file is part of the Symfony package.
|
||||
*
|
||||
* (c) Fabien Potencier <fabien@symfony.com>
|
||||
*
|
||||
* For the full copyright and license information, please view the LICENSE
|
||||
* file that was distributed with this source code.
|
||||
*/
|
||||
namespace WP_Ultimo\Dependencies\Symfony\Component\VarExporter\Internal;
|
||||
|
||||
use WP_Ultimo\Dependencies\Symfony\Component\VarExporter\Exception\ClassNotFoundException;
|
||||
use WP_Ultimo\Dependencies\Symfony\Component\VarExporter\Exception\NotInstantiableTypeException;
|
||||
/**
|
||||
* @author Nicolas Grekas <p@tchwork.com>
|
||||
*
|
||||
* @internal
|
||||
*/
|
||||
class Registry
|
||||
{
|
||||
public static $reflectors = [];
|
||||
public static $prototypes = [];
|
||||
public static $factories = [];
|
||||
public static $cloneable = [];
|
||||
public static $instantiableWithoutConstructor = [];
|
||||
public $classes = [];
|
||||
public function __construct(array $classes)
|
||||
{
|
||||
$this->classes = $classes;
|
||||
}
|
||||
public static function unserialize($objects, $serializables)
|
||||
{
|
||||
$unserializeCallback = \ini_set('unserialize_callback_func', __CLASS__ . '::getClassReflector');
|
||||
try {
|
||||
foreach ($serializables as $k => $v) {
|
||||
$objects[$k] = \unserialize($v);
|
||||
}
|
||||
} finally {
|
||||
\ini_set('unserialize_callback_func', $unserializeCallback);
|
||||
}
|
||||
return $objects;
|
||||
}
|
||||
public static function p($class)
|
||||
{
|
||||
self::getClassReflector($class, \true, \true);
|
||||
return self::$prototypes[$class];
|
||||
}
|
||||
public static function f($class)
|
||||
{
|
||||
$reflector = self::$reflectors[$class] ??= self::getClassReflector($class, \true, \false);
|
||||
return self::$factories[$class] = [$reflector, 'newInstanceWithoutConstructor'](...);
|
||||
}
|
||||
public static function getClassReflector($class, $instantiableWithoutConstructor = \false, $cloneable = null)
|
||||
{
|
||||
if (!($isClass = \class_exists($class)) && !\interface_exists($class, \false) && !\trait_exists($class, \false)) {
|
||||
throw new ClassNotFoundException($class);
|
||||
}
|
||||
$reflector = new \ReflectionClass($class);
|
||||
if ($instantiableWithoutConstructor) {
|
||||
$proto = $reflector->newInstanceWithoutConstructor();
|
||||
} elseif (!$isClass || $reflector->isAbstract()) {
|
||||
throw new NotInstantiableTypeException($class);
|
||||
} elseif ($reflector->name !== $class) {
|
||||
$reflector = self::$reflectors[$name = $reflector->name] ??= self::getClassReflector($name, \false, $cloneable);
|
||||
self::$cloneable[$class] = self::$cloneable[$name];
|
||||
self::$instantiableWithoutConstructor[$class] = self::$instantiableWithoutConstructor[$name];
|
||||
self::$prototypes[$class] = self::$prototypes[$name];
|
||||
return $reflector;
|
||||
} else {
|
||||
try {
|
||||
$proto = $reflector->newInstanceWithoutConstructor();
|
||||
$instantiableWithoutConstructor = \true;
|
||||
} catch (\ReflectionException) {
|
||||
$proto = $reflector->implementsInterface('Serializable') && !\method_exists($class, '__unserialize') ? 'C:' : 'O:';
|
||||
if ('C:' === $proto && !$reflector->getMethod('unserialize')->isInternal()) {
|
||||
$proto = null;
|
||||
} else {
|
||||
try {
|
||||
$proto = @\unserialize($proto . \strlen($class) . ':"' . $class . '":0:{}');
|
||||
} catch (\Exception $e) {
|
||||
if (__FILE__ !== $e->getFile()) {
|
||||
throw $e;
|
||||
}
|
||||
throw new NotInstantiableTypeException($class, $e);
|
||||
}
|
||||
if (\false === $proto) {
|
||||
throw new NotInstantiableTypeException($class);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (null !== $proto && !$proto instanceof \Throwable && !$proto instanceof \Serializable && !\method_exists($class, '__sleep') && !\method_exists($class, '__serialize')) {
|
||||
try {
|
||||
\serialize($proto);
|
||||
} catch (\Exception $e) {
|
||||
throw new NotInstantiableTypeException($class, $e);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (null === $cloneable) {
|
||||
if (($proto instanceof \Reflector || $proto instanceof \ReflectionGenerator || $proto instanceof \ReflectionType || $proto instanceof \IteratorIterator || $proto instanceof \RecursiveIteratorIterator) && (!$proto instanceof \Serializable && !\method_exists($proto, '__wakeup') && !\method_exists($class, '__unserialize'))) {
|
||||
throw new NotInstantiableTypeException($class);
|
||||
}
|
||||
$cloneable = $reflector->isCloneable() && !$reflector->hasMethod('__clone');
|
||||
}
|
||||
self::$cloneable[$class] = $cloneable;
|
||||
self::$instantiableWithoutConstructor[$class] = $instantiableWithoutConstructor;
|
||||
self::$prototypes[$class] = $proto;
|
||||
if ($proto instanceof \Throwable) {
|
||||
static $setTrace;
|
||||
if (null === $setTrace) {
|
||||
$setTrace = [new \ReflectionProperty(\Error::class, 'trace'), new \ReflectionProperty(\Exception::class, 'trace')];
|
||||
$setTrace[0] = $setTrace[0]->setValue(...);
|
||||
$setTrace[1] = $setTrace[1]->setValue(...);
|
||||
}
|
||||
$setTrace[$proto instanceof \Exception]($proto, []);
|
||||
}
|
||||
return $reflector;
|
||||
}
|
||||
}
|
||||
25
dependencies/symfony/var-exporter/Internal/Values.php
vendored
Normal file
25
dependencies/symfony/var-exporter/Internal/Values.php
vendored
Normal file
@ -0,0 +1,25 @@
|
||||
<?php
|
||||
|
||||
/*
|
||||
* This file is part of the Symfony package.
|
||||
*
|
||||
* (c) Fabien Potencier <fabien@symfony.com>
|
||||
*
|
||||
* For the full copyright and license information, please view the LICENSE
|
||||
* file that was distributed with this source code.
|
||||
*/
|
||||
namespace WP_Ultimo\Dependencies\Symfony\Component\VarExporter\Internal;
|
||||
|
||||
/**
|
||||
* @author Nicolas Grekas <p@tchwork.com>
|
||||
*
|
||||
* @internal
|
||||
*/
|
||||
class Values
|
||||
{
|
||||
public $values;
|
||||
public function __construct(array $values)
|
||||
{
|
||||
$this->values = $values;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user