Deprecated: Constant E_STRICT is deprecated in /home/pastorz/old-espace-client/vendor/symfony/error-handler/ErrorHandler.php on line 58

Deprecated: Constant E_STRICT is deprecated in /home/pastorz/old-espace-client/vendor/symfony/error-handler/ErrorHandler.php on line 76
Symfony Profiler

vendor/doctrine/orm/lib/Doctrine/ORM/Proxy/ProxyFactory.php line 123

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. namespace Doctrine\ORM\Proxy;
  7. use Closure;
  8. use Doctrine\Common\Proxy\AbstractProxyFactory;
  9. use Doctrine\Common\Proxy\Proxy as CommonProxy;
  10. use Doctrine\Common\Proxy\ProxyDefinition;
  11. use Doctrine\Common\Proxy\ProxyGenerator;
  12. use Doctrine\Common\Util\ClassUtils;
  13. use Doctrine\ORM\EntityManagerInterface;
  14. use Doctrine\ORM\EntityNotFoundException;
  15. use Doctrine\ORM\Persisters\Entity\EntityPersister;
  16. use Doctrine\ORM\Proxy\Proxy as LegacyProxy;
  17. use Doctrine\ORM\UnitOfWork;
  18. use Doctrine\ORM\Utility\IdentifierFlattener;
  19. use Doctrine\Persistence\Mapping\ClassMetadata;
  20. use ReflectionProperty;
  21. use Symfony\Component\VarExporter\ProxyHelper;
  22. use Symfony\Component\VarExporter\VarExporter;
  23. use Throwable;
  25. use function array_flip;
  26. use function str_replace;
  27. use function strpos;
  28. use function substr;
  29. use function uksort;
  31. /**
  32.  * This factory is used to create proxy objects for entities at runtime.
  33.  */
  34. class ProxyFactory extends AbstractProxyFactory
  35. {
  36.     private const PROXY_CLASS_TEMPLATE = <<<'EOPHP'
  37. <?php
  39. namespace <namespace>;
  41. /**
  42.  * DO NOT EDIT THIS FILE - IT WAS CREATED BY DOCTRINE'S PROXY GENERATOR
  43.  */
  44. class <proxyShortClassName> extends \<className> implements \<baseProxyInterface>
  45. {
  46.     <useLazyGhostTrait>
  48.     public function __construct(?\Closure $initializer = null, ?\Closure $cloner = null)
  49.     {
  50.         if ($cloner !== null) {
  51.             return;
  52.         }
  54.         self::createLazyGhost($initializer, <skippedProperties>, $this);
  55.     }
  57.     public function __isInitialized(): bool
  58.     {
  59.         return isset($this->lazyObjectState) && $this->isLazyObjectInitialized();
  60.     }
  62.     public function __serialize(): array
  63.     {
  64.         <serializeImpl>
  65.     }
  66. }
  68. EOPHP;
  70.     /** @var EntityManagerInterface The EntityManager this factory is bound to. */
  71.     private $em;
  73.     /** @var UnitOfWork The UnitOfWork this factory uses to retrieve persisters */
  74.     private $uow;
  76.     /** @var string */
  77.     private $proxyNs;
  79.     /**
  80.      * The IdentifierFlattener used for manipulating identifiers
  81.      *
  82.      * @var IdentifierFlattener
  83.      */
  84.     private $identifierFlattener;
  86.     /** @var ProxyDefinition[] */
  87.     private $definitions = [];
  89.     /**
  90.      * Initializes a new instance of the <tt>ProxyFactory</tt> class that is
  91.      * connected to the given <tt>EntityManager</tt>.
  92.      *
  93.      * @param EntityManagerInterface    $em           The EntityManager the new factory works for.
  94.      * @param string                    $proxyDir     The directory to use for the proxy classes. It must exist.
  95.      * @param string                    $proxyNs      The namespace to use for the proxy classes.
  96.      * @param bool|self::AUTOGENERATE_* $autoGenerate The strategy for automatically generating proxy classes.
  97.      */
  98.     public function __construct(EntityManagerInterface $em, $proxyDir, $proxyNs, $autoGenerate = self::AUTOGENERATE_NEVER)
  99.     {
  100.         $proxyGenerator = new ProxyGenerator($proxyDir, $proxyNs);
  102.         if ($em->getConfiguration()->isLazyGhostObjectEnabled()) {
  103.             $proxyGenerator->setPlaceholder('baseProxyInterface', InternalProxy::class);
  104.             $proxyGenerator->setPlaceholder('useLazyGhostTrait', Closure::fromCallable([$this, 'generateUseLazyGhostTrait']));
  105.             $proxyGenerator->setPlaceholder('skippedProperties', Closure::fromCallable([$this, 'generateSkippedProperties']));
  106.             $proxyGenerator->setPlaceholder('serializeImpl', Closure::fromCallable([$this, 'generateSerializeImpl']));
  107.             $proxyGenerator->setProxyClassTemplate(self::PROXY_CLASS_TEMPLATE);
  108.         } else {
  109.             $proxyGenerator->setPlaceholder('baseProxyInterface', LegacyProxy::class);
  110.         }
  112.         parent::__construct($proxyGenerator, $em->getMetadataFactory(), $autoGenerate);
  114.         $this->em                  = $em;
  115.         $this->uow                 = $em->getUnitOfWork();
  116.         $this->proxyNs             = $proxyNs;
  117.         $this->identifierFlattener = new IdentifierFlattener($this->uow, $em->getMetadataFactory());
  118.     }
  120.     /**
  121.      * {@inheritDoc}
  122.      */
  123.     public function getProxy($className, array $identifier)
  124.     {
  125.         $proxy = parent::getProxy($className, $identifier);
  127.         if (! $this->em->getConfiguration()->isLazyGhostObjectEnabled()) {
  128.             return $proxy;
  129.         }
  131.         $initializer = $this->definitions[$className]->initializer;
  133.         $proxy->__construct(static function (InternalProxy $object) use ($initializer, $proxy): void {
  134.             $initializer($object, $proxy);
  135.         });
  137.         return $proxy;
  138.     }
  140.     /**
  141.      * {@inheritDoc}
  142.      */
  143.     protected function skipClass(ClassMetadata $metadata)
  144.     {
  145.         return $metadata->isMappedSuperclass
  146.             || $metadata->isEmbeddedClass
  147.             || $metadata->getReflectionClass()->isAbstract();
  148.     }
  150.     /**
  151.      * {@inheritDoc}
  152.      */
  153.     protected function createProxyDefinition($className)
  154.     {
  155.         $classMetadata   = $this->em->getClassMetadata($className);
  156.         $entityPersister = $this->uow->getEntityPersister($className);
  158.         if ($this->em->getConfiguration()->isLazyGhostObjectEnabled()) {
  159.             $initializer = $this->createLazyInitializer($classMetadata, $entityPersister);
  160.             $cloner      = static function (): void {
  161.             };
  162.         } else {
  163.             $initializer = $this->createInitializer($classMetadata, $entityPersister);
  164.             $cloner      = $this->createCloner($classMetadata, $entityPersister);
  165.         }
  167.         return $this->definitions[$className] = new ProxyDefinition(
  168.             ClassUtils::generateProxyClassName($className, $this->proxyNs),
  169.             $classMetadata->getIdentifierFieldNames(),
  170.             $classMetadata->getReflectionProperties(),
  171.             $initializer,
  172.             $cloner
  173.         );
  174.     }
  176.     /**
  177.      * Creates a closure capable of initializing a proxy
  178.      *
  179.      * @psalm-return Closure(CommonProxy):void
  180.      *
  181.      * @throws EntityNotFoundException
  182.      */
  183.     private function createInitializer(ClassMetadata $classMetadata, EntityPersister $entityPersister): Closure
  184.     {
  185.         $wakeupProxy = $classMetadata->getReflectionClass()->hasMethod('__wakeup');
  187.         return function (CommonProxy $proxy) use ($entityPersister, $classMetadata, $wakeupProxy): void {
  188.             $initializer = $proxy->__getInitializer();
  189.             $cloner      = $proxy->__getCloner();
  191.             $proxy->__setInitializer(null);
  192.             $proxy->__setCloner(null);
  194.             if ($proxy->__isInitialized()) {
  195.                 return;
  196.             }
  198.             $properties = $proxy->__getLazyProperties();
  200.             foreach ($properties as $propertyName => $property) {
  201.                 if (! isset($proxy->$propertyName)) {
  202.                     $proxy->$propertyName = $properties[$propertyName];
  203.                 }
  204.             }
  206.             $proxy->__setInitialized(true);
  208.             if ($wakeupProxy) {
  209.                 $proxy->__wakeup();
  210.             }
  212.             $identifier = $classMetadata->getIdentifierValues($proxy);
  214.             try {
  215.                 $entity = $entityPersister->loadById($identifier, $proxy);
  216.             } catch (Throwable $exception) {
  217.                 $proxy->__setInitializer($initializer);
  218.                 $proxy->__setCloner($cloner);
  219.                 $proxy->__setInitialized(false);
  221.                 throw $exception;
  222.             }
  224.             if ($entity === null) {
  225.                 $proxy->__setInitializer($initializer);
  226.                 $proxy->__setCloner($cloner);
  227.                 $proxy->__setInitialized(false);
  229.                 throw EntityNotFoundException::fromClassNameAndIdentifier(
  230.                     $classMetadata->getName(),
  231.                     $this->identifierFlattener->flattenIdentifier($classMetadata, $identifier)
  232.                 );
  233.             }
  234.         };
  235.     }
  237.     /**
  238.      * Creates a closure capable of initializing a proxy
  239.      *
  240.      * @return Closure(InternalProxy, InternalProxy):void
  241.      *
  242.      * @throws EntityNotFoundException
  243.      */
  244.     private function createLazyInitializer(ClassMetadata $classMetadata, EntityPersister $entityPersister): Closure
  245.     {
  246.         return function (InternalProxy $proxy, InternalProxy $original) use ($entityPersister, $classMetadata): void {
  247.             $identifier = $classMetadata->getIdentifierValues($original);
  248.             $entity     = $entityPersister->loadById($identifier, $original);
  250.             if ($entity === null) {
  251.                 throw EntityNotFoundException::fromClassNameAndIdentifier(
  252.                     $classMetadata->getName(),
  253.                     $this->identifierFlattener->flattenIdentifier($classMetadata, $identifier)
  254.                 );
  255.             }
  257.             if ($proxy === $original) {
  258.                 return;
  259.             }
  261.             $class = $entityPersister->getClassMetadata();
  263.             foreach ($class->getReflectionProperties() as $property) {
  264.                 if (! $class->hasField($property->name) && ! $class->hasAssociation($property->name)) {
  265.                     continue;
  266.                 }
  268.                 $property->setAccessible(true);
  269.                 $property->setValue($proxy, $property->getValue($entity));
  270.             }
  271.         };
  272.     }
  274.     /**
  275.      * Creates a closure capable of finalizing state a cloned proxy
  276.      *
  277.      * @psalm-return Closure(CommonProxy):void
  278.      *
  279.      * @throws EntityNotFoundException
  280.      */
  281.     private function createCloner(ClassMetadata $classMetadata, EntityPersister $entityPersister): Closure
  282.     {
  283.         return function (CommonProxy $proxy) use ($entityPersister, $classMetadata): void {
  284.             if ($proxy->__isInitialized()) {
  285.                 return;
  286.             }
  288.             $proxy->__setInitialized(true);
  289.             $proxy->__setInitializer(null);
  291.             $class      = $entityPersister->getClassMetadata();
  292.             $identifier = $classMetadata->getIdentifierValues($proxy);
  293.             $original   = $entityPersister->loadById($identifier);
  295.             if ($original === null) {
  296.                 throw EntityNotFoundException::fromClassNameAndIdentifier(
  297.                     $classMetadata->getName(),
  298.                     $this->identifierFlattener->flattenIdentifier($classMetadata, $identifier)
  299.                 );
  300.             }
  302.             foreach ($class->getReflectionProperties() as $property) {
  303.                 if (! $class->hasField($property->name) && ! $class->hasAssociation($property->name)) {
  304.                     continue;
  305.                 }
  307.                 $property->setAccessible(true);
  308.                 $property->setValue($proxy, $property->getValue($original));
  309.             }
  310.         };
  311.     }
  313.     private function generateUseLazyGhostTrait(ClassMetadata $class): string
  314.     {
  315.         $code = ProxyHelper::generateLazyGhost($class->getReflectionClass());
  316.         $code = substr($code, 7 + (int) strpos($code, "\n{"));
  317.         $code = substr($code, 0, (int) strpos($code, "\n}"));
  318.         $code = str_replace('LazyGhostTrait;', str_replace("\n    ", "\n", 'LazyGhostTrait {
  319.             initializeLazyObject as __load;
  320.             setLazyObjectAsInitialized as public __setInitialized;
  321.             isLazyObjectInitialized as private;
  322.             createLazyGhost as private;
  323.             resetLazyObject as private;
  324.         }'), $code);
  326.         return $code;
  327.     }
  329.     private function generateSkippedProperties(ClassMetadata $class): string
  330.     {
  331.         $skippedProperties = [];
  332.         $identifiers       = array_flip($class->getIdentifierFieldNames());
  333.         $filter            = ReflectionProperty::IS_PUBLIC | ReflectionProperty::IS_PROTECTED | ReflectionProperty::IS_PRIVATE;
  334.         $reflector         = $class->getReflectionClass();
  336.         while ($reflector) {
  337.             foreach ($reflector->getProperties($filter) as $property) {
  338.                 $name = $property->name;
  340.                 if ($property->isStatic() || (($class->hasField($name) || $class->hasAssociation($name)) && ! isset($identifiers[$name]))) {
  341.                     continue;
  342.                 }
  344.                 $prefix = $property->isPrivate() ? "\0" . $property->class . "\0" : ($property->isProtected() ? "\0*\0" : '');
  346.                 $skippedProperties[$prefix . $name] = true;
  347.             }
  349.             $filter    = ReflectionProperty::IS_PRIVATE;
  350.             $reflector = $reflector->getParentClass();
  351.         }
  353.         uksort($skippedProperties, 'strnatcmp');
  355.         $code = VarExporter::export($skippedProperties);
  356.         $code = str_replace(VarExporter::export($class->getName()), 'parent::class', $code);
  357.         $code = str_replace("\n", "\n        ", $code);
  359.         return $code;
  360.     }
  362.     private function generateSerializeImpl(ClassMetadata $class): string
  363.     {
  364.         $reflector  = $class->getReflectionClass();
  365.         $properties = $reflector->hasMethod('__serialize') ? 'parent::__serialize()' : '(array) $this';
  367.         $code = '$properties = ' . $properties . ';
  368.         unset($properties["\0" . self::class . "\0lazyObjectState"], $properties[\'__isCloning\']);
  370.         ';
  372.         if ($reflector->hasMethod('__serialize') || ! $reflector->hasMethod('__sleep')) {
  373.             return $code . 'return $properties;';
  374.         }
  376.         return $code . '$data = [];
  378.         foreach (parent::__sleep() as $name) {
  379.             $value = $properties[$k = $name] ?? $properties[$k = "\0*\0$name"] ?? $properties[$k = "\0' . $reflector->name . '\0$name"] ?? $k = null;
  381.             if (null === $k) {
  382.                 trigger_error(sprintf(\'serialize(): "%s" returned as member variable from __sleep() but does not exist\', $name), \E_USER_NOTICE);
  383.             } else {
  384.                 $data[$k] = $value;
  385.             }
  386.         }
  388.         return $data;';
  389.     }
  390. }