vendor/doctrine/common/lib/Doctrine/Common/Proxy/ProxyGenerator.php line 291

Open in your IDE?
  1. <?php
  2. namespace Doctrine\Common\Proxy;
  4. use Doctrine\Common\Proxy\Exception\InvalidArgumentException;
  5. use Doctrine\Common\Proxy\Exception\UnexpectedValueException;
  6. use Doctrine\Common\Util\ClassUtils;
  7. use Doctrine\Persistence\Mapping\ClassMetadata;
  8. use function array_map;
  9. use function method_exists;
  11. /**
  12.  * This factory is used to generate proxy classes.
  13.  * It builds proxies from given parameters, a template and class metadata.
  14.  *
  15.  * @author Marco Pivetta <ocramius@gmail.com>
  16.  * @since  2.4
  17.  */
  18. class ProxyGenerator
  19. {
  20.     /**
  21.      * Used to match very simple id methods that don't need
  22.      * to be decorated since the identifier is known.
  23.      */
  24.     const PATTERN_MATCH_ID_METHOD = '((public\s+)?(function\s+%s\s*\(\)\s*)\s*(?::\s*\??\s*\\\\?[a-z_\x7f-\xff][\w\x7f-\xff]*(?:\\\\[a-z_\x7f-\xff][\w\x7f-\xff]*)*\s*)?{\s*return\s*\$this->%s;\s*})i';
  26.     /**
  27.      * The namespace that contains all proxy classes.
  28.      *
  29.      * @var string
  30.      */
  31.     private $proxyNamespace;
  33.     /**
  34.      * The directory that contains all proxy classes.
  35.      *
  36.      * @var string
  37.      */
  38.     private $proxyDirectory;
  40.     /**
  41.      * Map of callables used to fill in placeholders set in the template.
  42.      *
  43.      * @var string[]|callable[]
  44.      */
  45.     protected $placeholders = [
  46.         'baseProxyInterface'   => Proxy::class,
  47.         'additionalProperties' => '',
  48.     ];
  50.     /**
  51.      * Template used as a blueprint to generate proxies.
  52.      *
  53.      * @var string
  54.      */
  55.     protected $proxyClassTemplate = '<?php
  57. namespace <namespace>;
  59. /**
  60.  * DO NOT EDIT THIS FILE - IT WAS CREATED BY DOCTRINE\'S PROXY GENERATOR
  61.  */
  62. class <proxyShortClassName> extends \<className> implements \<baseProxyInterface>
  63. {
  64.     /**
  65.      * @var \Closure the callback responsible for loading properties in the proxy object. This callback is called with
  66.      *      three parameters, being respectively the proxy object to be initialized, the method that triggered the
  67.      *      initialization process and an array of ordered parameters that were passed to that method.
  68.      *
  69.      * @see \Doctrine\Common\Proxy\Proxy::__setInitializer
  70.      */
  71.     public $__initializer__;
  73.     /**
  74.      * @var \Closure the callback responsible of loading properties that need to be copied in the cloned object
  75.      *
  76.      * @see \Doctrine\Common\Proxy\Proxy::__setCloner
  77.      */
  78.     public $__cloner__;
  80.     /**
  81.      * @var boolean flag indicating if this object was already initialized
  82.      *
  83.      * @see \Doctrine\Persistence\Proxy::__isInitialized
  84.      */
  85.     public $__isInitialized__ = false;
  87.     /**
  88.      * @var array<string, null> properties to be lazy loaded, indexed by property name
  89.      */
  90.     public static $lazyPropertiesNames = <lazyPropertiesNames>;
  92.     /**
  93.      * @var array<string, mixed> default values of properties to be lazy loaded, with keys being the property names
  94.      *
  95.      * @see \Doctrine\Common\Proxy\Proxy::__getLazyProperties
  96.      */
  97.     public static $lazyPropertiesDefaults = <lazyPropertiesDefaults>;
  99. <additionalProperties>
  101. <constructorImpl>
  103. <magicGet>
  105. <magicSet>
  107. <magicIsset>
  109. <sleepImpl>
  111. <wakeupImpl>
  113. <cloneImpl>
  115.     /**
  116.      * Forces initialization of the proxy
  117.      */
  118.     public function __load()
  119.     {
  120.         $this->__initializer__ && $this->__initializer__->__invoke($this, \'__load\', []);
  121.     }
  123.     /**
  124.      * {@inheritDoc}
  125.      * @internal generated method: use only when explicitly handling proxy specific loading logic
  126.      */
  127.     public function __isInitialized()
  128.     {
  129.         return $this->__isInitialized__;
  130.     }
  132.     /**
  133.      * {@inheritDoc}
  134.      * @internal generated method: use only when explicitly handling proxy specific loading logic
  135.      */
  136.     public function __setInitialized($initialized)
  137.     {
  138.         $this->__isInitialized__ = $initialized;
  139.     }
  141.     /**
  142.      * {@inheritDoc}
  143.      * @internal generated method: use only when explicitly handling proxy specific loading logic
  144.      */
  145.     public function __setInitializer(\Closure $initializer = null)
  146.     {
  147.         $this->__initializer__ = $initializer;
  148.     }
  150.     /**
  151.      * {@inheritDoc}
  152.      * @internal generated method: use only when explicitly handling proxy specific loading logic
  153.      */
  154.     public function __getInitializer()
  155.     {
  156.         return $this->__initializer__;
  157.     }
  159.     /**
  160.      * {@inheritDoc}
  161.      * @internal generated method: use only when explicitly handling proxy specific loading logic
  162.      */
  163.     public function __setCloner(\Closure $cloner = null)
  164.     {
  165.         $this->__cloner__ = $cloner;
  166.     }
  168.     /**
  169.      * {@inheritDoc}
  170.      * @internal generated method: use only when explicitly handling proxy specific cloning logic
  171.      */
  172.     public function __getCloner()
  173.     {
  174.         return $this->__cloner__;
  175.     }
  177.     /**
  178.      * {@inheritDoc}
  179.      * @internal generated method: use only when explicitly handling proxy specific loading logic
  180.      * @deprecated no longer in use - generated code now relies on internal components rather than generated public API
  181.      * @static
  182.      */
  183.     public function __getLazyProperties()
  184.     {
  185.         return self::$lazyPropertiesDefaults;
  186.     }
  188.     <methods>
  189. }
  190. ';
  192.     /**
  193.      * Initializes a new instance of the <tt>ProxyFactory</tt> class that is
  194.      * connected to the given <tt>EntityManager</tt>.
  195.      *
  196.      * @param string $proxyDirectory The directory to use for the proxy classes. It must exist.
  197.      * @param string $proxyNamespace The namespace to use for the proxy classes.
  198.      *
  199.      * @throws InvalidArgumentException
  200.      */
  201.     public function __construct($proxyDirectory, $proxyNamespace)
  202.     {
  203.         if ( ! $proxyDirectory) {
  204.             throw InvalidArgumentException::proxyDirectoryRequired();
  205.         }
  207.         if ( ! $proxyNamespace) {
  208.             throw InvalidArgumentException::proxyNamespaceRequired();
  209.         }
  211.         $this->proxyDirectory = $proxyDirectory;
  212.         $this->proxyNamespace = $proxyNamespace;
  213.     }
  215.     /**
  216.      * Sets a placeholder to be replaced in the template.
  217.      *
  218.      * @param string          $name
  219.      * @param string|callable $placeholder
  220.      *
  221.      * @throws InvalidArgumentException
  222.      */
  223.     public function setPlaceholder($name, $placeholder)
  224.     {
  225.         if ( ! is_string($placeholder) && ! is_callable($placeholder)) {
  226.             throw InvalidArgumentException::invalidPlaceholder($name);
  227.         }
  229.         $this->placeholders[$name] = $placeholder;
  230.     }
  232.     /**
  233.      * Sets the base template used to create proxy classes.
  234.      *
  235.      * @param string $proxyClassTemplate
  236.      */
  237.     public function setProxyClassTemplate($proxyClassTemplate)
  238.     {
  239.         $this->proxyClassTemplate = (string) $proxyClassTemplate;
  240.     }
  242.     /**
  243.      * Generates a proxy class file.
  244.      *
  245.      * @param \Doctrine\Persistence\Mapping\ClassMetadata $class    Metadata for the original class.
  246.      * @param string|bool                                 $fileName Filename (full path) for the generated class. If none is given, eval() is used.
  247.      *
  248.      * @throws InvalidArgumentException
  249.      * @throws UnexpectedValueException
  250.      */
  251.     public function generateProxyClass(ClassMetadata $class, $fileName = false)
  252.     {
  253.         $this->verifyClassCanBeProxied($class);
  255.         preg_match_all('(<([a-zA-Z]+)>)', $this->proxyClassTemplate, $placeholderMatches);
  257.         $placeholderMatches = array_combine($placeholderMatches[0], $placeholderMatches[1]);
  258.         $placeholders       = [];
  260.         foreach ($placeholderMatches as $placeholder => $name) {
  261.             $placeholders[$placeholder] = isset($this->placeholders[$name])
  262.                 ? $this->placeholders[$name]
  263.                 : [$this, 'generate' . $name];
  264.         }
  266.         foreach ($placeholders as & $placeholder) {
  267.             if (is_callable($placeholder)) {
  268.                 $placeholder = call_user_func($placeholder, $class);
  269.             }
  270.         }
  272.         $proxyCode = strtr($this->proxyClassTemplate, $placeholders);
  274.         if ( ! $fileName) {
  275.             $proxyClassName = $this->generateNamespace($class) . '\\' . $this->generateProxyShortClassName($class);
  277.             if ( ! class_exists($proxyClassName)) {
  278.                 eval(substr($proxyCode, 5));
  279.             }
  281.             return;
  282.         }
  284.         $parentDirectory = dirname($fileName);
  286.         if ( ! is_dir($parentDirectory) && (false === @mkdir($parentDirectory, 0775, true))) {
  287.             throw UnexpectedValueException::proxyDirectoryNotWritable($this->proxyDirectory);
  288.         }
  290.         if ( ! is_writable($parentDirectory)) {
  291.             throw UnexpectedValueException::proxyDirectoryNotWritable($this->proxyDirectory);
  292.         }
  294.         $tmpFileName = $fileName . '.' . uniqid('', true);
  296.         file_put_contents($tmpFileName, $proxyCode);
  297.         @chmod($tmpFileName, 0664);
  298.         rename($tmpFileName, $fileName);
  299.     }
  301.     /**
  302.      * @param ClassMetadata $class
  303.      *
  304.      * @throws InvalidArgumentException
  305.      */
  306.     private function verifyClassCanBeProxied(ClassMetadata $class)
  307.     {
  308.         if ($class->getReflectionClass()->isFinal()) {
  309.             throw InvalidArgumentException::classMustNotBeFinal($class->getName());
  310.         }
  312.         if ($class->getReflectionClass()->isAbstract()) {
  313.             throw InvalidArgumentException::classMustNotBeAbstract($class->getName());
  314.         }
  315.     }
  317.     /**
  318.      * Generates the proxy short class name to be used in the template.
  319.      *
  320.      * @param \Doctrine\Persistence\Mapping\ClassMetadata $class
  321.      *
  322.      * @return string
  323.      */
  324.     private function generateProxyShortClassName(ClassMetadata $class)
  325.     {
  326.         $proxyClassName = ClassUtils::generateProxyClassName($class->getName(), $this->proxyNamespace);
  327.         $parts          = explode('\\', strrev($proxyClassName), 2);
  329.         return strrev($parts[0]);
  330.     }
  332.     /**
  333.      * Generates the proxy namespace.
  334.      *
  335.      * @param \Doctrine\Persistence\Mapping\ClassMetadata $class
  336.      *
  337.      * @return string
  338.      */
  339.     private function generateNamespace(ClassMetadata $class)
  340.     {
  341.         $proxyClassName = ClassUtils::generateProxyClassName($class->getName(), $this->proxyNamespace);
  342.         $parts          = explode('\\', strrev($proxyClassName), 2);
  344.         return strrev($parts[1]);
  345.     }
  347.     /**
  348.      * Generates the original class name.
  349.      *
  350.      * @param \Doctrine\Persistence\Mapping\ClassMetadata $class
  351.      *
  352.      * @return string
  353.      */
  354.     private function generateClassName(ClassMetadata $class)
  355.     {
  356.         return ltrim($class->getName(), '\\');
  357.     }
  359.     /**
  360.      * Generates the array representation of lazy loaded public properties and their default values.
  361.      *
  362.      * @param \Doctrine\Persistence\Mapping\ClassMetadata $class
  363.      *
  364.      * @return string
  365.      */
  366.     private function generateLazyPropertiesNames(ClassMetadata $class)
  367.     {
  368.         $lazyPublicProperties = $this->getLazyLoadedPublicPropertiesNames($class);
  369.         $values               = [];
  371.         foreach ($lazyPublicProperties as $name) {
  372.             $values[$name] = null;
  373.         }
  375.         return var_export($values, true);
  376.     }
  378.     /**
  379.      * Generates the array representation of lazy loaded public properties names.
  380.      *
  381.      * @param \Doctrine\Persistence\Mapping\ClassMetadata $class
  382.      *
  383.      * @return string
  384.      */
  385.     private function generateLazyPropertiesDefaults(ClassMetadata $class)
  386.     {
  387.         return var_export($this->getLazyLoadedPublicProperties($class), true);
  388.     }
  390.     /**
  391.      * Generates the constructor code (un-setting public lazy loaded properties, setting identifier field values).
  392.      *
  393.      * @param \Doctrine\Persistence\Mapping\ClassMetadata $class
  394.      *
  395.      * @return string
  396.      */
  397.     private function generateConstructorImpl(ClassMetadata $class)
  398.     {
  399.         $constructorImpl = <<<'EOT'
  400.     public function __construct(?\Closure $initializer = null, ?\Closure $cloner = null)
  401.     {
  403. EOT;
  405.         $toUnset = array_map(static function (string $name) : string {
  406.             return '$this->' . $name;
  407.         }, $this->getLazyLoadedPublicPropertiesNames($class));
  409.         $constructorImpl .= ($toUnset === [] ? '' : '        unset(' . implode(', ', $toUnset) . ");\n")
  410.             . <<<'EOT'
  412.         $this->__initializer__ = $initializer;
  413.         $this->__cloner__      = $cloner;
  414.     }
  415. EOT;
  417.         return $constructorImpl;
  418.     }
  420.     /**
  421.      * Generates the magic getter invoked when lazy loaded public properties are requested.
  422.      *
  423.      * @param \Doctrine\Persistence\Mapping\ClassMetadata $class
  424.      *
  425.      * @return string
  426.      */
  427.     private function generateMagicGet(ClassMetadata $class)
  428.     {
  429.         $lazyPublicProperties = $this->getLazyLoadedPublicPropertiesNames($class);
  430.         $reflectionClass      = $class->getReflectionClass();
  431.         $hasParentGet         = false;
  432.         $returnReference      = '';
  433.         $inheritDoc           = '';
  434.         $name                 = '$name';
  435.         $parametersString     = '$name';
  436.         $returnTypeHint       = null;
  438.         if ($reflectionClass->hasMethod('__get')) {
  439.             $hasParentGet     = true;
  440.             $inheritDoc       = '{@inheritDoc}';
  441.             $methodReflection = $reflectionClass->getMethod('__get');
  443.             if ($methodReflection->returnsReference()) {
  444.                 $returnReference = '& ';
  445.             }
  447.             $methodParameters = $methodReflection->getParameters();
  448.             $name             = '$' . $methodParameters[0]->getName();
  450.             $parametersString = $this->buildParametersString($methodReflection->getParameters(), ['name']);
  451.             $returnTypeHint   = $this->getMethodReturnType($methodReflection);
  452.         }
  454.         if (empty($lazyPublicProperties) && ! $hasParentGet) {
  455.             return '';
  456.         }
  458.         $magicGet = <<<EOT
  459.     /**
  460.      * $inheritDoc
  461.      * @param string \$name
  462.      */
  463.     public function {$returnReference}__get($parametersString)$returnTypeHint
  464.     {
  466. EOT;
  468.         if ( ! empty($lazyPublicProperties)) {
  469.             $magicGet .= <<<'EOT'
  470.         if (\array_key_exists($name, self::$lazyPropertiesNames)) {
  471.             $this->__initializer__ && $this->__initializer__->__invoke($this, '__get', [$name]);
  472. EOT;
  474.             if ($returnTypeHint === ': void') {
  475.                 $magicGet .= "\n            return;";
  476.             } else {
  477.                 $magicGet .= "\n            return \$this->\$name;";
  478.             }
  480.             $magicGet .= <<<'EOT'
  482.         }
  485. EOT;
  486.         }
  488.         if ($hasParentGet) {
  489.             $magicGet .= <<<'EOT'
  490.         $this->__initializer__ && $this->__initializer__->__invoke($this, '__get', [$name]);
  491. EOT;
  493.             if ($returnTypeHint === ': void') {
  494.                 $magicGet .= <<<'EOT'
  496.         parent::__get($name);
  497.         return;
  498. EOT;
  499.             } else {
  500.                 $magicGet .= <<<'EOT'
  502.         return parent::__get($name);
  503. EOT;
  504.             }
  505.         } else {
  506.             $magicGet .= sprintf(<<<EOT
  507.         trigger_error(sprintf('Undefined property: %%s::$%%s', __CLASS__, %s), E_USER_NOTICE);
  509. EOT
  510.                 , $name);
  511.         }
  513.         return $magicGet . "\n    }";
  514.     }
  516.     /**
  517.      * Generates the magic setter (currently unused).
  518.      *
  519.      * @param \Doctrine\Persistence\Mapping\ClassMetadata $class
  520.      *
  521.      * @return string
  522.      */
  523.     private function generateMagicSet(ClassMetadata $class)
  524.     {
  525.         $lazyPublicProperties = $this->getLazyLoadedPublicPropertiesNames($class);
  526.         $hasParentSet         = $class->getReflectionClass()->hasMethod('__set');
  527.         $parametersString     = '$name, $value';
  528.         $returnTypeHint       = null;
  530.         if ($hasParentSet) {
  531.             $methodReflection = $class->getReflectionClass()->getMethod('__set');
  532.             $parametersString = $this->buildParametersString($methodReflection->getParameters(), ['name', 'value']);
  533.             $returnTypeHint   = $this->getMethodReturnType($methodReflection);
  534.         }
  536.         if (empty($lazyPublicProperties) && ! $hasParentSet) {
  537.             return '';
  538.         }
  540.         $inheritDoc = $hasParentSet ? '{@inheritDoc}' : '';
  541.         $magicSet   = sprintf(<<<'EOT'
  542.     /**
  543.      * %s
  544.      * @param string $name
  545.      * @param mixed  $value
  546.      */
  547.     public function __set(%s)%s
  548.     {
  550. EOT
  551.             , $inheritDoc, $parametersString, $returnTypeHint);
  553.         if ( ! empty($lazyPublicProperties)) {
  554.             $magicSet .= <<<'EOT'
  555.         if (\array_key_exists($name, self::$lazyPropertiesNames)) {
  556.             $this->__initializer__ && $this->__initializer__->__invoke($this, '__set', [$name, $value]);
  558.             $this->$name = $value;
  560.             return;
  561.         }
  564. EOT;
  565.         }
  567.         if ($hasParentSet) {
  568.             $magicSet .= <<<'EOT'
  569.         $this->__initializer__ && $this->__initializer__->__invoke($this, '__set', [$name, $value]);
  571.         return parent::__set($name, $value);
  572. EOT;
  573.         } else {
  574.             $magicSet .= "        \$this->\$name = \$value;";
  575.         }
  577.         return $magicSet . "\n    }";
  578.     }
  580.     /**
  581.      * Generates the magic issetter invoked when lazy loaded public properties are checked against isset().
  582.      *
  583.      * @param \Doctrine\Persistence\Mapping\ClassMetadata $class
  584.      *
  585.      * @return string
  586.      */
  587.     private function generateMagicIsset(ClassMetadata $class)
  588.     {
  589.         $lazyPublicProperties = $this->getLazyLoadedPublicPropertiesNames($class);
  590.         $hasParentIsset       = $class->getReflectionClass()->hasMethod('__isset');
  591.         $parametersString     = '$name';
  592.         $returnTypeHint       = null;
  594.         if ($hasParentIsset) {
  595.             $methodReflection = $class->getReflectionClass()->getMethod('__isset');
  596.             $parametersString = $this->buildParametersString($methodReflection->getParameters(), ['name']);
  597.             $returnTypeHint   = $this->getMethodReturnType($methodReflection);
  598.         }
  600.         if (empty($lazyPublicProperties) && ! $hasParentIsset) {
  601.             return '';
  602.         }
  604.         $inheritDoc = $hasParentIsset ? '{@inheritDoc}' : '';
  605.         $magicIsset = <<<EOT
  606.     /**
  607.      * $inheritDoc
  608.      * @param  string \$name
  609.      * @return boolean
  610.      */
  611.     public function __isset($parametersString)$returnTypeHint
  612.     {
  614. EOT;
  616.         if ( ! empty($lazyPublicProperties)) {
  617.             $magicIsset .= <<<'EOT'
  618.         if (\array_key_exists($name, self::$lazyPropertiesNames)) {
  619.             $this->__initializer__ && $this->__initializer__->__invoke($this, '__isset', [$name]);
  621.             return isset($this->$name);
  622.         }
  625. EOT;
  626.         }
  628.         if ($hasParentIsset) {
  629.             $magicIsset .= <<<'EOT'
  630.         $this->__initializer__ && $this->__initializer__->__invoke($this, '__isset', [$name]);
  632.         return parent::__isset($name);
  633. EOT;
  634.         } else {
  635.             $magicIsset .= "        return false;";
  636.         }
  638.         return $magicIsset . "\n    }";
  639.     }
  641.     /**
  642.      * Generates implementation for the `__sleep` method of proxies.
  643.      *
  644.      * @param \Doctrine\Persistence\Mapping\ClassMetadata $class
  645.      *
  646.      * @return string
  647.      */
  648.     private function generateSleepImpl(ClassMetadata $class)
  649.     {
  650.         $hasParentSleep = $class->getReflectionClass()->hasMethod('__sleep');
  651.         $inheritDoc     = $hasParentSleep ? '{@inheritDoc}' : '';
  652.         $sleepImpl      = <<<EOT
  653.     /**
  654.      * $inheritDoc
  655.      * @return array
  656.      */
  657.     public function __sleep()
  658.     {
  660. EOT;
  662.         if ($hasParentSleep) {
  663.             return $sleepImpl . <<<'EOT'
  664.         $properties = array_merge(['__isInitialized__'], parent::__sleep());
  666.         if ($this->__isInitialized__) {
  667.             $properties = array_diff($properties, array_keys(self::$lazyPropertiesNames));
  668.         }
  670.         return $properties;
  671.     }
  672. EOT;
  673.         }
  675.         $allProperties = ['__isInitialized__'];
  677.         /* @var $prop \ReflectionProperty */
  678.         foreach ($class->getReflectionClass()->getProperties() as $prop) {
  679.             if ($prop->isStatic()) {
  680.                 continue;
  681.             }
  683.             $allProperties[] = $prop->isPrivate()
  684.                 ? "\0" . $prop->getDeclaringClass()->getName() . "\0" . $prop->getName()
  685.                 : $prop->getName();
  686.         }
  688.         $lazyPublicProperties = $this->getLazyLoadedPublicPropertiesNames($class);
  689.         $protectedProperties  = array_diff($allProperties, $lazyPublicProperties);
  691.         foreach ($allProperties as &$property) {
  692.             $property = var_export($property, true);
  693.         }
  695.         foreach ($protectedProperties as &$property) {
  696.             $property = var_export($property, true);
  697.         }
  699.         $allProperties       = implode(', ', $allProperties);
  700.         $protectedProperties = implode(', ', $protectedProperties);
  702.         return $sleepImpl . <<<EOT
  703.         if (\$this->__isInitialized__) {
  704.             return [$allProperties];
  705.         }
  707.         return [$protectedProperties];
  708.     }
  709. EOT;
  710.     }
  712.     /**
  713.      * Generates implementation for the `__wakeup` method of proxies.
  714.      *
  715.      * @param \Doctrine\Persistence\Mapping\ClassMetadata $class
  716.      *
  717.      * @return string
  718.      */
  719.     private function generateWakeupImpl(ClassMetadata $class)
  720.     {
  721.         $unsetPublicProperties = [];
  722.         $hasWakeup             = $class->getReflectionClass()->hasMethod('__wakeup');
  724.         foreach ($this->getLazyLoadedPublicPropertiesNames($class) as $lazyPublicProperty) {
  725.             $unsetPublicProperties[] = '$this->' . $lazyPublicProperty;
  726.         }
  728.         $shortName  = $this->generateProxyShortClassName($class);
  729.         $inheritDoc = $hasWakeup ? '{@inheritDoc}' : '';
  730.         $wakeupImpl = <<<EOT
  731.     /**
  732.      * $inheritDoc
  733.      */
  734.     public function __wakeup()
  735.     {
  736.         if ( ! \$this->__isInitialized__) {
  737.             \$this->__initializer__ = function ($shortName \$proxy) {
  738.                 \$proxy->__setInitializer(null);
  739.                 \$proxy->__setCloner(null);
  741.                 \$existingProperties = get_object_vars(\$proxy);
  743.                 foreach (\$proxy::\$lazyPropertiesDefaults as \$property => \$defaultValue) {
  744.                     if ( ! array_key_exists(\$property, \$existingProperties)) {
  745.                         \$proxy->\$property = \$defaultValue;
  746.                     }
  747.                 }
  748.             };
  750. EOT;
  752.         if ( ! empty($unsetPublicProperties)) {
  753.             $wakeupImpl .= "\n            unset(" . implode(', ', $unsetPublicProperties) . ");";
  754.         }
  756.         $wakeupImpl .= "\n        }";
  758.         if ($hasWakeup) {
  759.             $wakeupImpl .= "\n        parent::__wakeup();";
  760.         }
  762.         $wakeupImpl .= "\n    }";
  764.         return $wakeupImpl;
  765.     }
  767.     /**
  768.      * Generates implementation for the `__clone` method of proxies.
  769.      *
  770.      * @param \Doctrine\Persistence\Mapping\ClassMetadata $class
  771.      *
  772.      * @return string
  773.      */
  774.     private function generateCloneImpl(ClassMetadata $class)
  775.     {
  776.         $hasParentClone  = $class->getReflectionClass()->hasMethod('__clone');
  777.         $inheritDoc      = $hasParentClone ? '{@inheritDoc}' : '';
  778.         $callParentClone = $hasParentClone ? "\n        parent::__clone();\n" : '';
  780.         return <<<EOT
  781.     /**
  782.      * $inheritDoc
  783.      */
  784.     public function __clone()
  785.     {
  786.         \$this->__cloner__ && \$this->__cloner__->__invoke(\$this, '__clone', []);
  787. $callParentClone    }
  788. EOT;
  789.     }
  791.     /**
  792.      * Generates decorated methods by picking those available in the parent class.
  793.      *
  794.      * @param \Doctrine\Persistence\Mapping\ClassMetadata $class
  795.      *
  796.      * @return string
  797.      */
  798.     private function generateMethods(ClassMetadata $class)
  799.     {
  800.         $methods           = '';
  801.         $methodNames       = [];
  802.         $reflectionMethods = $class->getReflectionClass()->getMethods(\ReflectionMethod::IS_PUBLIC);
  803.         $skippedMethods    = [
  804.             '__sleep'   => true,
  805.             '__clone'   => true,
  806.             '__wakeup'  => true,
  807.             '__get'     => true,
  808.             '__set'     => true,
  809.             '__isset'   => true,
  810.         ];
  812.         foreach ($reflectionMethods as $method) {
  813.             $name = $method->getName();
  815.             if ($method->isConstructor() ||
  816.                 isset($skippedMethods[strtolower($name)]) ||
  817.                 isset($methodNames[$name]) ||
  818.                 $method->isFinal() ||
  819.                 $method->isStatic() ||
  820.                 ( ! $method->isPublic())
  821.             ) {
  822.                 continue;
  823.             }
  825.             $methodNames[$name] = true;
  826.             $methods           .= "\n    /**\n"
  827.                 . "     * {@inheritDoc}\n"
  828.                 . "     */\n"
  829.                 . '    public function ';
  831.             if ($method->returnsReference()) {
  832.                 $methods .= '&';
  833.             }
  835.             $methods .= $name . '(' . $this->buildParametersString($method->getParameters()) . ')';
  836.             $methods .= $this->getMethodReturnType($method);
  837.             $methods .= "\n" . '    {' . "\n";
  839.             if ($this->isShortIdentifierGetter($method, $class)) {
  840.                 $identifier = lcfirst(substr($name, 3));
  841.                 $fieldType  = $class->getTypeOfField($identifier);
  842.                 $cast       = in_array($fieldType, ['integer', 'smallint']) ? '(int) ' : '';
  844.                 $methods .= '        if ($this->__isInitialized__ === false) {' . "\n";
  845.                 $methods .= '            ';
  846.                 $methods .= $this->shouldProxiedMethodReturn($method) ? 'return ' : '';
  847.                 $methods .= $cast . ' parent::' . $method->getName() . "();\n";
  848.                 $methods .= '        }' . "\n\n";
  849.             }
  851.             $invokeParamsString = implode(', ', $this->getParameterNamesForInvoke($method->getParameters()));
  852.             $callParamsString   = implode(', ', $this->getParameterNamesForParentCall($method->getParameters()));
  854.             $methods .= "\n        \$this->__initializer__ "
  855.                 . "&& \$this->__initializer__->__invoke(\$this, " . var_export($name, true)
  856.                 . ", [" . $invokeParamsString . "]);"
  857.                 . "\n\n        "
  858.                 . ($this->shouldProxiedMethodReturn($method) ? 'return ' : '')
  859.                 . "parent::" . $name . '(' . $callParamsString . ');'
  860.                 . "\n" . '    }' . "\n";
  861.         }
  863.         return $methods;
  864.     }
  866.     /**
  867.      * Generates the Proxy file name.
  868.      *
  869.      * @param string $className
  870.      * @param string $baseDirectory Optional base directory for proxy file name generation.
  871.      *                              If not specified, the directory configured on the Configuration of the
  872.      *                              EntityManager will be used by this factory.
  873.      *
  874.      * @return string
  875.      */
  876.     public function getProxyFileName($className, $baseDirectory = null)
  877.     {
  878.         $baseDirectory = $baseDirectory ?: $this->proxyDirectory;
  880.         return rtrim($baseDirectory, DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR . Proxy::MARKER
  881.             . str_replace('\\', '', $className) . '.php';
  882.     }
  884.     /**
  885.      * Checks if the method is a short identifier getter.
  886.      *
  887.      * What does this mean? For proxy objects the identifier is already known,
  888.      * however accessing the getter for this identifier usually triggers the
  889.      * lazy loading, leading to a query that may not be necessary if only the
  890.      * ID is interesting for the userland code (for example in views that
  891.      * generate links to the entity, but do not display anything else).
  892.      *
  893.      * @param \ReflectionMethod                           $method
  894.      * @param \Doctrine\Persistence\Mapping\ClassMetadata $class
  895.      *
  896.      * @return boolean
  897.      */
  898.     private function isShortIdentifierGetter($method, ClassMetadata $class)
  899.     {
  900.         $identifier = lcfirst(substr($method->getName(), 3));
  901.         $startLine  = $method->getStartLine();
  902.         $endLine    = $method->getEndLine();
  903.         $cheapCheck = (
  904.             $method->getNumberOfParameters() == 0
  905.             && substr($method->getName(), 0, 3) == 'get'
  906.             && in_array($identifier, $class->getIdentifier(), true)
  907.             && $class->hasField($identifier)
  908.             && (($endLine - $startLine) <= 4)
  909.         );
  911.         if ($cheapCheck) {
  912.             $code = file($method->getFileName());
  913.             $code = trim(implode(' ', array_slice($code, $startLine - 1, $endLine - $startLine + 1)));
  915.             $pattern = sprintf(self::PATTERN_MATCH_ID_METHOD, $method->getName(), $identifier);
  917.             if (preg_match($pattern, $code)) {
  918.                 return true;
  919.             }
  920.         }
  922.         return false;
  923.     }
  925.     /**
  926.      * Generates the list of public properties to be lazy loaded.
  927.      *
  928.      * @param \Doctrine\Persistence\Mapping\ClassMetadata $class
  929.      *
  930.      * @return array<int, string>
  931.      */
  932.     private function getLazyLoadedPublicPropertiesNames(ClassMetadata $class) : array
  933.     {
  934.         $properties = [];
  936.         foreach ($class->getReflectionClass()->getProperties(\ReflectionProperty::IS_PUBLIC) as $property) {
  937.             $name = $property->getName();
  939.             if (($class->hasField($name) || $class->hasAssociation($name)) && ! $class->isIdentifier($name)) {
  940.                 $properties[] = $name;
  941.             }
  942.         }
  944.         return $properties;
  945.     }
  947.     /**
  948.      * Generates the list of default values of public properties.
  949.      *
  950.      * @param \Doctrine\Persistence\Mapping\ClassMetadata $class
  951.      *
  952.      * @return mixed[]
  953.      */
  954.     private function getLazyLoadedPublicProperties(ClassMetadata $class)
  955.     {
  956.         $defaultProperties          = $class->getReflectionClass()->getDefaultProperties();
  957.         $lazyLoadedPublicProperties = $this->getLazyLoadedPublicPropertiesNames($class);
  958.         $defaultValues              = [];
  960.         foreach ($class->getReflectionClass()->getProperties(\ReflectionProperty::IS_PUBLIC) as $property) {
  961.             $name = $property->getName();
  963.             if ( ! in_array($name, $lazyLoadedPublicProperties, true)) {
  964.                 continue;
  965.             }
  967.             if (array_key_exists($name, $defaultProperties)) {
  968.                 $defaultValues[$name] = $defaultProperties[$name];
  969.             } elseif (method_exists($property, 'getType')) {
  970.                 $propertyType = $property->getType();
  971.                 if (null !== $propertyType && $propertyType->allowsNull()) {
  972.                     $defaultValues[$name] = null;
  973.                 }
  974.             }
  975.         }
  977.         return $defaultValues;
  978.     }
  980.     /**
  981.      * @param \ReflectionParameter[] $parameters
  982.      * @param string[]               $renameParameters
  983.      *
  984.      * @return string
  985.      */
  986.     private function buildParametersString(array $parameters, array $renameParameters = [])
  987.     {
  988.         $parameterDefinitions = [];
  990.         /* @var $param \ReflectionParameter */
  991.         $i = -1;
  992.         foreach ($parameters as $param) {
  993.             $i++;
  994.             $parameterDefinition = '';
  996.             if ($parameterType = $this->getParameterType($param)) {
  997.                 $parameterDefinition .= $parameterType . ' ';
  998.             }
  1000.             if ($param->isPassedByReference()) {
  1001.                 $parameterDefinition .= '&';
  1002.             }
  1004.             if ($param->isVariadic()) {
  1005.                 $parameterDefinition .= '...';
  1006.             }
  1008.             $parameterDefinition .= '$' . ($renameParameters ? $renameParameters[$i] : $param->getName());
  1010.             if ($param->isDefaultValueAvailable()) {
  1011.                 $parameterDefinition .= ' = ' . var_export($param->getDefaultValue(), true);
  1012.             }
  1014.             $parameterDefinitions[] = $parameterDefinition;
  1015.         }
  1017.         return implode(', ', $parameterDefinitions);
  1018.     }
  1020.     /**
  1021.      * @param \ReflectionParameter $parameter
  1022.      *
  1023.      * @return string|null
  1024.      */
  1025.     private function getParameterType(\ReflectionParameter $parameter)
  1026.     {
  1027.         if ( ! $parameter->hasType()) {
  1028.             return null;
  1029.         }
  1031.         return $this->formatType($parameter->getType(), $parameter->getDeclaringFunction(), $parameter);
  1032.     }
  1034.     /**
  1035.      * @param \ReflectionParameter[] $parameters
  1036.      *
  1037.      * @return string[]
  1038.      */
  1039.     private function getParameterNamesForInvoke(array $parameters)
  1040.     {
  1041.         return array_map(
  1042.             function (\ReflectionParameter $parameter) {
  1043.                 return '$' . $parameter->getName();
  1044.             },
  1045.             $parameters
  1046.         );
  1047.     }
  1049.     /**
  1050.      * @param \ReflectionParameter[] $parameters
  1051.      *
  1052.      * @return string[]
  1053.      */
  1054.     private function getParameterNamesForParentCall(array $parameters)
  1055.     {
  1056.         return array_map(
  1057.             function (\ReflectionParameter $parameter) {
  1058.                 $name = '';
  1060.                 if ($parameter->isVariadic()) {
  1061.                     $name .= '...';
  1062.                 }
  1064.                 $name .= '$' . $parameter->getName();
  1066.                 return $name;
  1067.             },
  1068.             $parameters
  1069.         );
  1070.     }
  1072.     /**
  1073.      * @param \ReflectionMethod $method
  1074.      *
  1075.      * @return string
  1076.      */
  1077.     private function getMethodReturnType(\ReflectionMethod $method)
  1078.     {
  1079.         if ( ! $method->hasReturnType()) {
  1080.             return '';
  1081.         }
  1083.         return ': ' . $this->formatType($method->getReturnType(), $method);
  1084.     }
  1086.     /**
  1087.      * @param \ReflectionMethod $method
  1088.      *
  1089.      * @return bool
  1090.      */
  1091.     private function shouldProxiedMethodReturn(\ReflectionMethod $method)
  1092.     {
  1093.         if ( ! $method->hasReturnType()) {
  1094.             return true;
  1095.         }
  1097.         return 'void' !== strtolower($this->formatType($method->getReturnType(), $method));
  1098.     }
  1100.     /**
  1101.      * @param \ReflectionType $type
  1102.      * @param \ReflectionMethod $method
  1103.      * @param \ReflectionParameter|null $parameter
  1104.      *
  1105.      * @return string
  1106.      */
  1107.     private function formatType(
  1108.         \ReflectionType $type,
  1109.         \ReflectionMethod $method,
  1110.         \ReflectionParameter $parameter = null
  1111.     ) {
  1112.         $name      = $type->getName();
  1113.         $nameLower = strtolower($name);
  1115.         if ('self' === $nameLower) {
  1116.             $name = $method->getDeclaringClass()->getName();
  1117.         }
  1119.         if ('parent' === $nameLower) {
  1120.             $name = $method->getDeclaringClass()->getParentClass()->getName();
  1121.         }
  1123.         if ( ! $type->isBuiltin() && ! class_exists($name) && ! interface_exists($name)) {
  1124.             if (null !== $parameter) {
  1125.                 throw UnexpectedValueException::invalidParameterTypeHint(
  1126.                     $method->getDeclaringClass()->getName(),
  1127.                     $method->getName(),
  1128.                     $parameter->getName()
  1129.                 );
  1130.             }
  1132.             throw UnexpectedValueException::invalidReturnTypeHint(
  1133.                 $method->getDeclaringClass()->getName(),
  1134.                 $method->getName()
  1135.             );
  1136.         }
  1138.         if ( ! $type->isBuiltin()) {
  1139.             $name = '\\' . $name;
  1140.         }
  1142.         if ($type->allowsNull()
  1143.             && (null === $parameter || ! $parameter->isDefaultValueAvailable() || null !== $parameter->getDefaultValue())
  1144.         ) {
  1145.             $name = '?' . $name;
  1146.         }
  1148.         return $name;
  1149.     }
  1150. }
  1152. interface_exists(ClassMetadata::class);