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\Persistence\Mapping\ClassMetadata;
  5. use Doctrine\Common\Proxy\Exception\InvalidArgumentException;
  6. use Doctrine\Common\Proxy\Exception\UnexpectedValueException;
  7. use Doctrine\Common\Util\ClassUtils;
  9. /**
  10.  * This factory is used to generate proxy classes.
  11.  * It builds proxies from given parameters, a template and class metadata.
  12.  *
  13.  * @author Marco Pivetta <ocramius@gmail.com>
  14.  * @since  2.4
  15.  *
  16.  * @deprecated The Doctrine\Common\Proxy component is deprecated, please use ocramius/proxy-manager instead.
  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\Common\Persistence\Proxy::__isInitialized
  84.      */
  85.     public $__isInitialized__ = false;
  87.     /**
  88.      * @var array properties to be lazy loaded, with keys being the property
  89.      *            names and values being their default values
  90.      *
  91.      * @see \Doctrine\Common\Proxy\Proxy::__getLazyProperties
  92.      */
  93.     public static $lazyPropertiesDefaults = [<lazyPropertiesDefaults>];
  95. <additionalProperties>
  97. <constructorImpl>
  99. <magicGet>
  101. <magicSet>
  103. <magicIsset>
  105. <sleepImpl>
  107. <wakeupImpl>
  109. <cloneImpl>
  111.     /**
  112.      * Forces initialization of the proxy
  113.      */
  114.     public function __load()
  115.     {
  116.         $this->__initializer__ && $this->__initializer__->__invoke($this, \'__load\', []);
  117.     }
  119.     /**
  120.      * {@inheritDoc}
  121.      * @internal generated method: use only when explicitly handling proxy specific loading logic
  122.      */
  123.     public function __isInitialized()
  124.     {
  125.         return $this->__isInitialized__;
  126.     }
  128.     /**
  129.      * {@inheritDoc}
  130.      * @internal generated method: use only when explicitly handling proxy specific loading logic
  131.      */
  132.     public function __setInitialized($initialized)
  133.     {
  134.         $this->__isInitialized__ = $initialized;
  135.     }
  137.     /**
  138.      * {@inheritDoc}
  139.      * @internal generated method: use only when explicitly handling proxy specific loading logic
  140.      */
  141.     public function __setInitializer(\Closure $initializer = null)
  142.     {
  143.         $this->__initializer__ = $initializer;
  144.     }
  146.     /**
  147.      * {@inheritDoc}
  148.      * @internal generated method: use only when explicitly handling proxy specific loading logic
  149.      */
  150.     public function __getInitializer()
  151.     {
  152.         return $this->__initializer__;
  153.     }
  155.     /**
  156.      * {@inheritDoc}
  157.      * @internal generated method: use only when explicitly handling proxy specific loading logic
  158.      */
  159.     public function __setCloner(\Closure $cloner = null)
  160.     {
  161.         $this->__cloner__ = $cloner;
  162.     }
  164.     /**
  165.      * {@inheritDoc}
  166.      * @internal generated method: use only when explicitly handling proxy specific cloning logic
  167.      */
  168.     public function __getCloner()
  169.     {
  170.         return $this->__cloner__;
  171.     }
  173.     /**
  174.      * {@inheritDoc}
  175.      * @internal generated method: use only when explicitly handling proxy specific loading logic
  176.      * @static
  177.      */
  178.     public function __getLazyProperties()
  179.     {
  180.         return self::$lazyPropertiesDefaults;
  181.     }
  183.     <methods>
  184. }
  185. ';
  187.     /**
  188.      * Initializes a new instance of the <tt>ProxyFactory</tt> class that is
  189.      * connected to the given <tt>EntityManager</tt>.
  190.      *
  191.      * @param string $proxyDirectory The directory to use for the proxy classes. It must exist.
  192.      * @param string $proxyNamespace The namespace to use for the proxy classes.
  193.      *
  194.      * @throws InvalidArgumentException
  195.      */
  196.     public function __construct($proxyDirectory, $proxyNamespace)
  197.     {
  198.         if ( ! $proxyDirectory) {
  199.             throw InvalidArgumentException::proxyDirectoryRequired();
  200.         }
  202.         if ( ! $proxyNamespace) {
  203.             throw InvalidArgumentException::proxyNamespaceRequired();
  204.         }
  206.         $this->proxyDirectory = $proxyDirectory;
  207.         $this->proxyNamespace = $proxyNamespace;
  208.     }
  210.     /**
  211.      * Sets a placeholder to be replaced in the template.
  212.      *
  213.      * @param string          $name
  214.      * @param string|callable $placeholder
  215.      *
  216.      * @throws InvalidArgumentException
  217.      */
  218.     public function setPlaceholder($name, $placeholder)
  219.     {
  220.         if ( ! is_string($placeholder) && ! is_callable($placeholder)) {
  221.             throw InvalidArgumentException::invalidPlaceholder($name);
  222.         }
  224.         $this->placeholders[$name] = $placeholder;
  225.     }
  227.     /**
  228.      * Sets the base template used to create proxy classes.
  229.      *
  230.      * @param string $proxyClassTemplate
  231.      */
  232.     public function setProxyClassTemplate($proxyClassTemplate)
  233.     {
  234.         $this->proxyClassTemplate = (string) $proxyClassTemplate;
  235.     }
  237.     /**
  238.      * Generates a proxy class file.
  239.      *
  240.      * @param \Doctrine\Common\Persistence\Mapping\ClassMetadata $class    Metadata for the original class.
  241.      * @param string|bool                                        $fileName Filename (full path) for the generated class. If none is given, eval() is used.
  242.      *
  243.      * @throws InvalidArgumentException
  244.      * @throws UnexpectedValueException
  245.      */
  246.     public function generateProxyClass(ClassMetadata $class, $fileName = false)
  247.     {
  248.         $this->verifyClassCanBeProxied($class);
  250.         preg_match_all('(<([a-zA-Z]+)>)', $this->proxyClassTemplate, $placeholderMatches);
  252.         $placeholderMatches = array_combine($placeholderMatches[0], $placeholderMatches[1]);
  253.         $placeholders       = [];
  255.         foreach ($placeholderMatches as $placeholder => $name) {
  256.             $placeholders[$placeholder] = isset($this->placeholders[$name])
  257.                 ? $this->placeholders[$name]
  258.                 : [$this, 'generate' . $name];
  259.         }
  261.         foreach ($placeholders as & $placeholder) {
  262.             if (is_callable($placeholder)) {
  263.                 $placeholder = call_user_func($placeholder, $class);
  264.             }
  265.         }
  267.         $proxyCode = strtr($this->proxyClassTemplate, $placeholders);
  269.         if ( ! $fileName) {
  270.             $proxyClassName = $this->generateNamespace($class) . '\\' . $this->generateProxyShortClassName($class);
  272.             if ( ! class_exists($proxyClassName)) {
  273.                 eval(substr($proxyCode, 5));
  274.             }
  276.             return;
  277.         }
  279.         $parentDirectory = dirname($fileName);
  281.         if ( ! is_dir($parentDirectory) && (false === @mkdir($parentDirectory, 0775, true))) {
  282.             throw UnexpectedValueException::proxyDirectoryNotWritable($this->proxyDirectory);
  283.         }
  285.         if ( ! is_writable($parentDirectory)) {
  286.             throw UnexpectedValueException::proxyDirectoryNotWritable($this->proxyDirectory);
  287.         }
  289.         $tmpFileName = $fileName . '.' . uniqid('', true);
  291.         file_put_contents($tmpFileName, $proxyCode);
  292.         @chmod($tmpFileName, 0664);
  293.         rename($tmpFileName, $fileName);
  294.     }
  296.     /**
  297.      * @param ClassMetadata $class
  298.      *
  299.      * @throws InvalidArgumentException
  300.      */
  301.     private function verifyClassCanBeProxied(ClassMetadata $class)
  302.     {
  303.         if ($class->getReflectionClass()->isFinal()) {
  304.             throw InvalidArgumentException::classMustNotBeFinal($class->getName());
  305.         }
  307.         if ($class->getReflectionClass()->isAbstract()) {
  308.             throw InvalidArgumentException::classMustNotBeAbstract($class->getName());
  309.         }
  310.     }
  312.     /**
  313.      * Generates the proxy short class name to be used in the template.
  314.      *
  315.      * @param \Doctrine\Common\Persistence\Mapping\ClassMetadata $class
  316.      *
  317.      * @return string
  318.      */
  319.     private function generateProxyShortClassName(ClassMetadata $class)
  320.     {
  321.         $proxyClassName = ClassUtils::generateProxyClassName($class->getName(), $this->proxyNamespace);
  322.         $parts          = explode('\\', strrev($proxyClassName), 2);
  324.         return strrev($parts[0]);
  325.     }
  327.     /**
  328.      * Generates the proxy namespace.
  329.      *
  330.      * @param \Doctrine\Common\Persistence\Mapping\ClassMetadata $class
  331.      *
  332.      * @return string
  333.      */
  334.     private function generateNamespace(ClassMetadata $class)
  335.     {
  336.         $proxyClassName = ClassUtils::generateProxyClassName($class->getName(), $this->proxyNamespace);
  337.         $parts          = explode('\\', strrev($proxyClassName), 2);
  339.         return strrev($parts[1]);
  340.     }
  342.     /**
  343.      * Generates the original class name.
  344.      *
  345.      * @param \Doctrine\Common\Persistence\Mapping\ClassMetadata $class
  346.      *
  347.      * @return string
  348.      */
  349.     private function generateClassName(ClassMetadata $class)
  350.     {
  351.         return ltrim($class->getName(), '\\');
  352.     }
  354.     /**
  355.      * Generates the array representation of lazy loaded public properties and their default values.
  356.      *
  357.      * @param \Doctrine\Common\Persistence\Mapping\ClassMetadata $class
  358.      *
  359.      * @return string
  360.      */
  361.     private function generateLazyPropertiesDefaults(ClassMetadata $class)
  362.     {
  363.         $lazyPublicProperties = $this->getLazyLoadedPublicProperties($class);
  364.         $values               = [];
  366.         foreach ($lazyPublicProperties as $key => $value) {
  367.             $values[] = var_export($key, true) . ' => ' . var_export($value, true);
  368.         }
  370.         return implode(', ', $values);
  371.     }
  373.     /**
  374.      * Generates the constructor code (un-setting public lazy loaded properties, setting identifier field values).
  375.      *
  376.      * @param \Doctrine\Common\Persistence\Mapping\ClassMetadata $class
  377.      *
  378.      * @return string
  379.      */
  380.     private function generateConstructorImpl(ClassMetadata $class)
  381.     {
  382.         $constructorImpl = <<<'EOT'
  383.     /**
  384.      * @param \Closure $initializer
  385.      * @param \Closure $cloner
  386.      */
  387.     public function __construct($initializer = null, $cloner = null)
  388.     {
  390. EOT;
  391.         $toUnset         = [];
  393.         foreach ($this->getLazyLoadedPublicProperties($class) as $lazyPublicProperty => $unused) {
  394.             $toUnset[] = '$this->' . $lazyPublicProperty;
  395.         }
  397.         $constructorImpl .= (empty($toUnset) ? '' : '        unset(' . implode(', ', $toUnset) . ");\n")
  398.             . <<<'EOT'
  400.         $this->__initializer__ = $initializer;
  401.         $this->__cloner__      = $cloner;
  402.     }
  403. EOT;
  405.         return $constructorImpl;
  406.     }
  408.     /**
  409.      * Generates the magic getter invoked when lazy loaded public properties are requested.
  410.      *
  411.      * @param \Doctrine\Common\Persistence\Mapping\ClassMetadata $class
  412.      *
  413.      * @return string
  414.      */
  415.     private function generateMagicGet(ClassMetadata $class)
  416.     {
  417.         $lazyPublicProperties = array_keys($this->getLazyLoadedPublicProperties($class));
  418.         $reflectionClass      = $class->getReflectionClass();
  419.         $hasParentGet         = false;
  420.         $returnReference      = '';
  421.         $inheritDoc           = '';
  423.         if ($reflectionClass->hasMethod('__get')) {
  424.             $hasParentGet = true;
  425.             $inheritDoc   = '{@inheritDoc}';
  427.             if ($reflectionClass->getMethod('__get')->returnsReference()) {
  428.                 $returnReference = '& ';
  429.             }
  430.         }
  432.         if (empty($lazyPublicProperties) && ! $hasParentGet) {
  433.             return '';
  434.         }
  436.         $magicGet = <<<EOT
  437.     /**
  438.      * $inheritDoc
  439.      * @param string \$name
  440.      */
  441.     public function {$returnReference}__get(\$name)
  442.     {
  444. EOT;
  446.         if ( ! empty($lazyPublicProperties)) {
  447.             $magicGet .= <<<'EOT'
  448.         if (array_key_exists($name, $this->__getLazyProperties())) {
  449.             $this->__initializer__ && $this->__initializer__->__invoke($this, '__get', [$name]);
  451.             return $this->$name;
  452.         }
  455. EOT;
  456.         }
  458.         if ($hasParentGet) {
  459.             $magicGet .= <<<'EOT'
  460.         $this->__initializer__ && $this->__initializer__->__invoke($this, '__get', [$name]);
  462.         return parent::__get($name);
  464. EOT;
  465.         } else {
  466.             $magicGet .= <<<'EOT'
  467.         trigger_error(sprintf('Undefined property: %s::$%s', __CLASS__, $name), E_USER_NOTICE);
  469. EOT;
  470.         }
  472.         $magicGet .= "    }";
  474.         return $magicGet;
  475.     }
  477.     /**
  478.      * Generates the magic setter (currently unused).
  479.      *
  480.      * @param \Doctrine\Common\Persistence\Mapping\ClassMetadata $class
  481.      *
  482.      * @return string
  483.      */
  484.     private function generateMagicSet(ClassMetadata $class)
  485.     {
  486.         $lazyPublicProperties = $this->getLazyLoadedPublicProperties($class);
  487.         $hasParentSet         = $class->getReflectionClass()->hasMethod('__set');
  489.         if (empty($lazyPublicProperties) && ! $hasParentSet) {
  490.             return '';
  491.         }
  493.         $inheritDoc = $hasParentSet ? '{@inheritDoc}' : '';
  494.         $magicSet   = <<<EOT
  495.     /**
  496.      * $inheritDoc
  497.      * @param string \$name
  498.      * @param mixed  \$value
  499.      */
  500.     public function __set(\$name, \$value)
  501.     {
  503. EOT;
  505.         if ( ! empty($lazyPublicProperties)) {
  506.             $magicSet .= <<<'EOT'
  507.         if (array_key_exists($name, $this->__getLazyProperties())) {
  508.             $this->__initializer__ && $this->__initializer__->__invoke($this, '__set', [$name, $value]);
  510.             $this->$name = $value;
  512.             return;
  513.         }
  516. EOT;
  517.         }
  519.         if ($hasParentSet) {
  520.             $magicSet .= <<<'EOT'
  521.         $this->__initializer__ && $this->__initializer__->__invoke($this, '__set', [$name, $value]);
  523.         return parent::__set($name, $value);
  524. EOT;
  525.         } else {
  526.             $magicSet .= "        \$this->\$name = \$value;";
  527.         }
  529.         $magicSet .= "\n    }";
  531.         return $magicSet;
  532.     }
  534.     /**
  535.      * Generates the magic issetter invoked when lazy loaded public properties are checked against isset().
  536.      *
  537.      * @param \Doctrine\Common\Persistence\Mapping\ClassMetadata $class
  538.      *
  539.      * @return string
  540.      */
  541.     private function generateMagicIsset(ClassMetadata $class)
  542.     {
  543.         $lazyPublicProperties = array_keys($this->getLazyLoadedPublicProperties($class));
  544.         $hasParentIsset       = $class->getReflectionClass()->hasMethod('__isset');
  546.         if (empty($lazyPublicProperties) && ! $hasParentIsset) {
  547.             return '';
  548.         }
  550.         $inheritDoc = $hasParentIsset ? '{@inheritDoc}' : '';
  551.         $magicIsset = <<<EOT
  552.     /**
  553.      * $inheritDoc
  554.      * @param  string \$name
  555.      * @return boolean
  556.      */
  557.     public function __isset(\$name)
  558.     {
  560. EOT;
  562.         if ( ! empty($lazyPublicProperties)) {
  563.             $magicIsset .= <<<'EOT'
  564.         if (array_key_exists($name, $this->__getLazyProperties())) {
  565.             $this->__initializer__ && $this->__initializer__->__invoke($this, '__isset', [$name]);
  567.             return isset($this->$name);
  568.         }
  571. EOT;
  572.         }
  574.         if ($hasParentIsset) {
  575.             $magicIsset .= <<<'EOT'
  576.         $this->__initializer__ && $this->__initializer__->__invoke($this, '__isset', [$name]);
  578.         return parent::__isset($name);
  580. EOT;
  581.         } else {
  582.             $magicIsset .= "        return false;";
  583.         }
  585.         return $magicIsset . "\n    }";
  586.     }
  588.     /**
  589.      * Generates implementation for the `__sleep` method of proxies.
  590.      *
  591.      * @param \Doctrine\Common\Persistence\Mapping\ClassMetadata $class
  592.      *
  593.      * @return string
  594.      */
  595.     private function generateSleepImpl(ClassMetadata $class)
  596.     {
  597.         $hasParentSleep = $class->getReflectionClass()->hasMethod('__sleep');
  598.         $inheritDoc     = $hasParentSleep ? '{@inheritDoc}' : '';
  599.         $sleepImpl      = <<<EOT
  600.     /**
  601.      * $inheritDoc
  602.      * @return array
  603.      */
  604.     public function __sleep()
  605.     {
  607. EOT;
  609.         if ($hasParentSleep) {
  610.             return $sleepImpl . <<<'EOT'
  611.         $properties = array_merge(['__isInitialized__'], parent::__sleep());
  613.         if ($this->__isInitialized__) {
  614.             $properties = array_diff($properties, array_keys($this->__getLazyProperties()));
  615.         }
  617.         return $properties;
  618.     }
  619. EOT;
  620.         }
  622.         $allProperties = ['__isInitialized__'];
  624.         /* @var $prop \ReflectionProperty */
  625.         foreach ($class->getReflectionClass()->getProperties() as $prop) {
  626.             if ($prop->isStatic()) {
  627.                 continue;
  628.             }
  630.             $allProperties[] = $prop->isPrivate()
  631.                 ? "\0" . $prop->getDeclaringClass()->getName() . "\0" . $prop->getName()
  632.                 : $prop->getName();
  633.         }
  635.         $lazyPublicProperties = array_keys($this->getLazyLoadedPublicProperties($class));
  636.         $protectedProperties  = array_diff($allProperties, $lazyPublicProperties);
  638.         foreach ($allProperties as &$property) {
  639.             $property = var_export($property, true);
  640.         }
  642.         foreach ($protectedProperties as &$property) {
  643.             $property = var_export($property, true);
  644.         }
  646.         $allProperties       = implode(', ', $allProperties);
  647.         $protectedProperties = implode(', ', $protectedProperties);
  649.         return $sleepImpl . <<<EOT
  650.         if (\$this->__isInitialized__) {
  651.             return [$allProperties];
  652.         }
  654.         return [$protectedProperties];
  655.     }
  656. EOT;
  657.     }
  659.     /**
  660.      * Generates implementation for the `__wakeup` method of proxies.
  661.      *
  662.      * @param \Doctrine\Common\Persistence\Mapping\ClassMetadata $class
  663.      *
  664.      * @return string
  665.      */
  666.     private function generateWakeupImpl(ClassMetadata $class)
  667.     {
  668.         $unsetPublicProperties = [];
  669.         $hasWakeup             = $class->getReflectionClass()->hasMethod('__wakeup');
  671.         foreach (array_keys($this->getLazyLoadedPublicProperties($class)) as $lazyPublicProperty) {
  672.             $unsetPublicProperties[] = '$this->' . $lazyPublicProperty;
  673.         }
  675.         $shortName  = $this->generateProxyShortClassName($class);
  676.         $inheritDoc = $hasWakeup ? '{@inheritDoc}' : '';
  677.         $wakeupImpl = <<<EOT
  678.     /**
  679.      * $inheritDoc
  680.      */
  681.     public function __wakeup()
  682.     {
  683.         if ( ! \$this->__isInitialized__) {
  684.             \$this->__initializer__ = function ($shortName \$proxy) {
  685.                 \$proxy->__setInitializer(null);
  686.                 \$proxy->__setCloner(null);
  688.                 \$existingProperties = get_object_vars(\$proxy);
  690.                 foreach (\$proxy->__getLazyProperties() as \$property => \$defaultValue) {
  691.                     if ( ! array_key_exists(\$property, \$existingProperties)) {
  692.                         \$proxy->\$property = \$defaultValue;
  693.                     }
  694.                 }
  695.             };
  697. EOT;
  699.         if ( ! empty($unsetPublicProperties)) {
  700.             $wakeupImpl .= "\n            unset(" . implode(', ', $unsetPublicProperties) . ");";
  701.         }
  703.         $wakeupImpl .= "\n        }";
  705.         if ($hasWakeup) {
  706.             $wakeupImpl .= "\n        parent::__wakeup();";
  707.         }
  709.         $wakeupImpl .= "\n    }";
  711.         return $wakeupImpl;
  712.     }
  714.     /**
  715.      * Generates implementation for the `__clone` method of proxies.
  716.      *
  717.      * @param \Doctrine\Common\Persistence\Mapping\ClassMetadata $class
  718.      *
  719.      * @return string
  720.      */
  721.     private function generateCloneImpl(ClassMetadata $class)
  722.     {
  723.         $hasParentClone  = $class->getReflectionClass()->hasMethod('__clone');
  724.         $inheritDoc      = $hasParentClone ? '{@inheritDoc}' : '';
  725.         $callParentClone = $hasParentClone ? "\n        parent::__clone();\n" : '';
  727.         return <<<EOT
  728.     /**
  729.      * $inheritDoc
  730.      */
  731.     public function __clone()
  732.     {
  733.         \$this->__cloner__ && \$this->__cloner__->__invoke(\$this, '__clone', []);
  734. $callParentClone    }
  735. EOT;
  736.     }
  738.     /**
  739.      * Generates decorated methods by picking those available in the parent class.
  740.      *
  741.      * @param \Doctrine\Common\Persistence\Mapping\ClassMetadata $class
  742.      *
  743.      * @return string
  744.      */
  745.     private function generateMethods(ClassMetadata $class)
  746.     {
  747.         $methods           = '';
  748.         $methodNames       = [];
  749.         $reflectionMethods = $class->getReflectionClass()->getMethods(\ReflectionMethod::IS_PUBLIC);
  750.         $skippedMethods    = [
  751.             '__sleep'   => true,
  752.             '__clone'   => true,
  753.             '__wakeup'  => true,
  754.             '__get'     => true,
  755.             '__set'     => true,
  756.             '__isset'   => true,
  757.         ];
  759.         foreach ($reflectionMethods as $method) {
  760.             $name = $method->getName();
  762.             if ($method->isConstructor() ||
  763.                 isset($skippedMethods[strtolower($name)]) ||
  764.                 isset($methodNames[$name]) ||
  765.                 $method->isFinal() ||
  766.                 $method->isStatic() ||
  767.                 ( ! $method->isPublic())
  768.             ) {
  769.                 continue;
  770.             }
  772.             $methodNames[$name] = true;
  773.             $methods           .= "\n    /**\n"
  774.                 . "     * {@inheritDoc}\n"
  775.                 . "     */\n"
  776.                 . '    public function ';
  778.             if ($method->returnsReference()) {
  779.                 $methods .= '&';
  780.             }
  782.             $methods .= $name . '(' . $this->buildParametersString($method->getParameters()) . ')';
  783.             $methods .= $this->getMethodReturnType($method);
  784.             $methods .= "\n" . '    {' . "\n";
  786.             if ($this->isShortIdentifierGetter($method, $class)) {
  787.                 $identifier = lcfirst(substr($name, 3));
  788.                 $fieldType  = $class->getTypeOfField($identifier);
  789.                 $cast       = in_array($fieldType, ['integer', 'smallint']) ? '(int) ' : '';
  791.                 $methods .= '        if ($this->__isInitialized__ === false) {' . "\n";
  792.                 $methods .= '            ';
  793.                 $methods .= $this->shouldProxiedMethodReturn($method) ? 'return ' : '';
  794.                 $methods .= $cast . ' parent::' . $method->getName() . "();\n";
  795.                 $methods .= '        }' . "\n\n";
  796.             }
  798.             $invokeParamsString = implode(', ', $this->getParameterNamesForInvoke($method->getParameters()));
  799.             $callParamsString   = implode(', ', $this->getParameterNamesForParentCall($method->getParameters()));
  801.             $methods .= "\n        \$this->__initializer__ "
  802.                 . "&& \$this->__initializer__->__invoke(\$this, " . var_export($name, true)
  803.                 . ", [" . $invokeParamsString . "]);"
  804.                 . "\n\n        "
  805.                 . ($this->shouldProxiedMethodReturn($method) ? 'return ' : '')
  806.                 . "parent::" . $name . '(' . $callParamsString . ');'
  807.                 . "\n" . '    }' . "\n";
  808.         }
  810.         return $methods;
  811.     }
  813.     /**
  814.      * Generates the Proxy file name.
  815.      *
  816.      * @param string $className
  817.      * @param string $baseDirectory Optional base directory for proxy file name generation.
  818.      *                              If not specified, the directory configured on the Configuration of the
  819.      *                              EntityManager will be used by this factory.
  820.      *
  821.      * @return string
  822.      */
  823.     public function getProxyFileName($className, $baseDirectory = null)
  824.     {
  825.         $baseDirectory = $baseDirectory ?: $this->proxyDirectory;
  827.         return rtrim($baseDirectory, DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR . Proxy::MARKER
  828.             . str_replace('\\', '', $className) . '.php';
  829.     }
  831.     /**
  832.      * Checks if the method is a short identifier getter.
  833.      *
  834.      * What does this mean? For proxy objects the identifier is already known,
  835.      * however accessing the getter for this identifier usually triggers the
  836.      * lazy loading, leading to a query that may not be necessary if only the
  837.      * ID is interesting for the userland code (for example in views that
  838.      * generate links to the entity, but do not display anything else).
  839.      *
  840.      * @param \ReflectionMethod                                  $method
  841.      * @param \Doctrine\Common\Persistence\Mapping\ClassMetadata $class
  842.      *
  843.      * @return boolean
  844.      */
  845.     private function isShortIdentifierGetter($method, ClassMetadata $class)
  846.     {
  847.         $identifier = lcfirst(substr($method->getName(), 3));
  848.         $startLine  = $method->getStartLine();
  849.         $endLine    = $method->getEndLine();
  850.         $cheapCheck = (
  851.             $method->getNumberOfParameters() == 0
  852.             && substr($method->getName(), 0, 3) == 'get'
  853.             && in_array($identifier, $class->getIdentifier(), true)
  854.             && $class->hasField($identifier)
  855.             && (($endLine - $startLine) <= 4)
  856.         );
  858.         if ($cheapCheck) {
  859.             $code = file($method->getFileName());
  860.             $code = trim(implode(' ', array_slice($code, $startLine - 1, $endLine - $startLine + 1)));
  862.             $pattern = sprintf(self::PATTERN_MATCH_ID_METHOD, $method->getName(), $identifier);
  864.             if (preg_match($pattern, $code)) {
  865.                 return true;
  866.             }
  867.         }
  869.         return false;
  870.     }
  872.     /**
  873.      * Generates the list of public properties to be lazy loaded, with their default values.
  874.      *
  875.      * @param \Doctrine\Common\Persistence\Mapping\ClassMetadata $class
  876.      *
  877.      * @return mixed[]
  878.      */
  879.     private function getLazyLoadedPublicProperties(ClassMetadata $class)
  880.     {
  881.         $defaultProperties = $class->getReflectionClass()->getDefaultProperties();
  882.         $properties        = [];
  884.         foreach ($class->getReflectionClass()->getProperties(\ReflectionProperty::IS_PUBLIC) as $property) {
  885.             $name = $property->getName();
  887.             if (($class->hasField($name) || $class->hasAssociation($name)) && ! $class->isIdentifier($name)) {
  888.                 $properties[$name] = $defaultProperties[$name];
  889.             }
  890.         }
  892.         return $properties;
  893.     }
  895.     /**
  896.      * @param \ReflectionParameter[] $parameters
  897.      *
  898.      * @return string
  899.      */
  900.     private function buildParametersString(array $parameters)
  901.     {
  902.         $parameterDefinitions = [];
  904.         /* @var $param \ReflectionParameter */
  905.         foreach ($parameters as $param) {
  906.             $parameterDefinition = '';
  908.             if ($parameterType = $this->getParameterType($param)) {
  909.                 $parameterDefinition .= $parameterType . ' ';
  910.             }
  912.             if ($param->isPassedByReference()) {
  913.                 $parameterDefinition .= '&';
  914.             }
  916.             if ($param->isVariadic()) {
  917.                 $parameterDefinition .= '...';
  918.             }
  920.             $parameterDefinition .= '$' . $param->getName();
  922.             if ($param->isDefaultValueAvailable()) {
  923.                 $parameterDefinition .= ' = ' . var_export($param->getDefaultValue(), true);
  924.             }
  926.             $parameterDefinitions[] = $parameterDefinition;
  927.         }
  929.         return implode(', ', $parameterDefinitions);
  930.     }
  932.     /**
  933.      * @param \ReflectionParameter $parameter
  934.      *
  935.      * @return string|null
  936.      */
  937.     private function getParameterType(\ReflectionParameter $parameter)
  938.     {
  939.         if ( ! $parameter->hasType()) {
  940.             return null;
  941.         }
  943.         return $this->formatType($parameter->getType(), $parameter->getDeclaringFunction(), $parameter);
  944.     }
  946.     /**
  947.      * @param \ReflectionParameter[] $parameters
  948.      *
  949.      * @return string[]
  950.      */
  951.     private function getParameterNamesForInvoke(array $parameters)
  952.     {
  953.         return array_map(
  954.             function (\ReflectionParameter $parameter) {
  955.                 return '$' . $parameter->getName();
  956.             },
  957.             $parameters
  958.         );
  959.     }
  961.     /**
  962.      * @param \ReflectionParameter[] $parameters
  963.      *
  964.      * @return string[]
  965.      */
  966.     private function getParameterNamesForParentCall(array $parameters)
  967.     {
  968.         return array_map(
  969.             function (\ReflectionParameter $parameter) {
  970.                 $name = '';
  972.                 if ($parameter->isVariadic()) {
  973.                     $name .= '...';
  974.                 }
  976.                 $name .= '$' . $parameter->getName();
  978.                 return $name;
  979.             },
  980.             $parameters
  981.         );
  982.     }
  984.     /**
  985.      * @param \ReflectionMethod $method
  986.      *
  987.      * @return string
  988.      */
  989.     private function getMethodReturnType(\ReflectionMethod $method)
  990.     {
  991.         if ( ! $method->hasReturnType()) {
  992.             return '';
  993.         }
  995.         return ': ' . $this->formatType($method->getReturnType(), $method);
  996.     }
  998.     /**
  999.      * @param \ReflectionMethod $method
  1000.      *
  1001.      * @return bool
  1002.      */
  1003.     private function shouldProxiedMethodReturn(\ReflectionMethod $method)
  1004.     {
  1005.         if ( ! $method->hasReturnType()) {
  1006.             return true;
  1007.         }
  1009.         return 'void' !== strtolower($this->formatType($method->getReturnType(), $method));
  1010.     }
  1012.     /**
  1013.      * @param \ReflectionType $type
  1014.      * @param \ReflectionMethod $method
  1015.      * @param \ReflectionParameter|null $parameter
  1016.      *
  1017.      * @return string
  1018.      */
  1019.     private function formatType(
  1020.         \ReflectionType $type,
  1021.         \ReflectionMethod $method,
  1022.         \ReflectionParameter $parameter = null
  1023.     ) {
  1024.         $name      = $type->getName();
  1025.         $nameLower = strtolower($name);
  1027.         if ('self' === $nameLower) {
  1028.             $name = $method->getDeclaringClass()->getName();
  1029.         }
  1031.         if ('parent' === $nameLower) {
  1032.             $name = $method->getDeclaringClass()->getParentClass()->getName();
  1033.         }
  1035.         if ( ! $type->isBuiltin() && ! class_exists($name) && ! interface_exists($name)) {
  1036.             if (null !== $parameter) {
  1037.                 throw UnexpectedValueException::invalidParameterTypeHint(
  1038.                     $method->getDeclaringClass()->getName(),
  1039.                     $method->getName(),
  1040.                     $parameter->getName()
  1041.                 );
  1042.             }
  1044.             throw UnexpectedValueException::invalidReturnTypeHint(
  1045.                 $method->getDeclaringClass()->getName(),
  1046.                 $method->getName()
  1047.             );
  1048.         }
  1050.         if ( ! $type->isBuiltin()) {
  1051.             $name = '\\' . $name;
  1052.         }
  1054.         if ($type->allowsNull()
  1055.             && (null === $parameter || ! $parameter->isDefaultValueAvailable() || null !== $parameter->getDefaultValue())
  1056.         ) {
  1057.             $name = '?' . $name;
  1058.         }
  1060.         return $name;
  1061.     }
  1062. }