344 lines
12 KiB
PHP
344 lines
12 KiB
PHP
<?php
|
|
/*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
* This software consists of voluntary contributions made by many individuals
|
|
* and is licensed under the LGPL. For more information, see
|
|
* <http://www.doctrine-project.org>.
|
|
*/
|
|
|
|
namespace Doctrine\ORM\Proxy;
|
|
|
|
use Doctrine\ORM\EntityManager,
|
|
Doctrine\ORM\Mapping\ClassMetadata,
|
|
Doctrine\ORM\Mapping\AssociationMapping;
|
|
|
|
/**
|
|
* This factory is used to create proxy objects for entities at runtime.
|
|
*
|
|
* @author Roman Borschel <roman@code-factory.org>
|
|
* @author Giorgio Sironi <piccoloprincipeazzurro@gmail.com>
|
|
* @since 2.0
|
|
*/
|
|
class ProxyFactory
|
|
{
|
|
/** The EntityManager this factory is bound to. */
|
|
private $_em;
|
|
/** Whether to automatically (re)generate proxy classes. */
|
|
private $_autoGenerate;
|
|
/** The namespace that contains all proxy classes. */
|
|
private $_proxyNamespace;
|
|
/** The directory that contains all proxy classes. */
|
|
private $_proxyDir;
|
|
|
|
/**
|
|
* Initializes a new instance of the <tt>ProxyFactory</tt> class that is
|
|
* connected to the given <tt>EntityManager</tt>.
|
|
*
|
|
* @param EntityManager $em The EntityManager the new factory works for.
|
|
* @param string $proxyDir The directory to use for the proxy classes. It must exist.
|
|
* @param string $proxyNs The namespace to use for the proxy classes.
|
|
* @param boolean $autoGenerate Whether to automatically generate proxy classes.
|
|
*/
|
|
public function __construct(EntityManager $em, $proxyDir, $proxyNs, $autoGenerate = false)
|
|
{
|
|
if ( ! $proxyDir) {
|
|
throw ProxyException::proxyDirectoryRequired();
|
|
}
|
|
if ( ! $proxyNs) {
|
|
throw ProxyException::proxyNamespaceRequired();
|
|
}
|
|
$this->_em = $em;
|
|
$this->_proxyDir = $proxyDir;
|
|
$this->_autoGenerate = $autoGenerate;
|
|
$this->_proxyNamespace = $proxyNs;
|
|
}
|
|
|
|
/**
|
|
* Gets a reference proxy instance for the entity of the given type and identified by
|
|
* the given identifier.
|
|
*
|
|
* @param string $className
|
|
* @param mixed $identifier
|
|
* @return object
|
|
*/
|
|
public function getProxy($className, $identifier)
|
|
{
|
|
$proxyClassName = str_replace('\\', '', $className) . 'Proxy';
|
|
$fqn = $this->_proxyNamespace . '\\' . $proxyClassName;
|
|
|
|
if (! class_exists($fqn, false)) {
|
|
$fileName = $this->_proxyDir . DIRECTORY_SEPARATOR . $proxyClassName . '.php';
|
|
if ($this->_autoGenerate) {
|
|
$this->_generateProxyClass($this->_em->getClassMetadata($className), $proxyClassName, $fileName, self::$_proxyClassTemplate);
|
|
}
|
|
require $fileName;
|
|
}
|
|
|
|
if ( ! $this->_em->getMetadataFactory()->hasMetadataFor($fqn)) {
|
|
$this->_em->getMetadataFactory()->setMetadataFor($fqn, $this->_em->getClassMetadata($className));
|
|
}
|
|
|
|
$entityPersister = $this->_em->getUnitOfWork()->getEntityPersister($className);
|
|
|
|
return new $fqn($entityPersister, $identifier);
|
|
}
|
|
|
|
/**
|
|
* Generates proxy classes for all given classes.
|
|
*
|
|
* @param array $classes The classes (ClassMetadata instances) for which to generate proxies.
|
|
* @param string $toDir The target directory of the proxy classes. If not specified, the
|
|
* directory configured on the Configuration of the EntityManager used
|
|
* by this factory is used.
|
|
*/
|
|
public function generateProxyClasses(array $classes, $toDir = null)
|
|
{
|
|
$proxyDir = $toDir ?: $this->_proxyDir;
|
|
$proxyDir = rtrim($proxyDir, DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR;
|
|
foreach ($classes as $class) {
|
|
/* @var $class ClassMetadata */
|
|
if ($class->isMappedSuperclass) {
|
|
continue;
|
|
}
|
|
|
|
$proxyClassName = str_replace('\\', '', $class->name) . 'Proxy';
|
|
$proxyFileName = $proxyDir . $proxyClassName . '.php';
|
|
$this->_generateProxyClass($class, $proxyClassName, $proxyFileName, self::$_proxyClassTemplate);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Generates a proxy class file.
|
|
*
|
|
* @param $class
|
|
* @param $originalClassName
|
|
* @param $proxyClassName
|
|
* @param $file The path of the file to write to.
|
|
*/
|
|
private function _generateProxyClass($class, $proxyClassName, $fileName, $file)
|
|
{
|
|
$methods = $this->_generateMethods($class);
|
|
$sleepImpl = $this->_generateSleep($class);
|
|
$cloneImpl = $class->reflClass->hasMethod('__clone') ? 'parent::__clone();' : ''; // hasMethod() checks case-insensitive
|
|
|
|
$placeholders = array(
|
|
'<namespace>',
|
|
'<proxyClassName>', '<className>',
|
|
'<methods>', '<sleepImpl>', '<cloneImpl>'
|
|
);
|
|
|
|
if(substr($class->name, 0, 1) == "\\") {
|
|
$className = substr($class->name, 1);
|
|
} else {
|
|
$className = $class->name;
|
|
}
|
|
|
|
$replacements = array(
|
|
$this->_proxyNamespace,
|
|
$proxyClassName, $className,
|
|
$methods, $sleepImpl, $cloneImpl
|
|
);
|
|
|
|
$file = str_replace($placeholders, $replacements, $file);
|
|
|
|
file_put_contents($fileName, $file, LOCK_EX);
|
|
}
|
|
|
|
/**
|
|
* Generates the methods of a proxy class.
|
|
*
|
|
* @param ClassMetadata $class
|
|
* @return string The code of the generated methods.
|
|
*/
|
|
private function _generateMethods(ClassMetadata $class)
|
|
{
|
|
$methods = '';
|
|
|
|
foreach ($class->reflClass->getMethods() as $method) {
|
|
/* @var $method ReflectionMethod */
|
|
if ($method->isConstructor() || in_array(strtolower($method->getName()), array("__sleep", "__clone"))) {
|
|
continue;
|
|
}
|
|
|
|
if ($method->isPublic() && ! $method->isFinal() && ! $method->isStatic()) {
|
|
$methods .= "\n" . ' public function ';
|
|
if ($method->returnsReference()) {
|
|
$methods .= '&';
|
|
}
|
|
$methods .= $method->getName() . '(';
|
|
$firstParam = true;
|
|
$parameterString = $argumentString = '';
|
|
|
|
foreach ($method->getParameters() as $param) {
|
|
if ($firstParam) {
|
|
$firstParam = false;
|
|
} else {
|
|
$parameterString .= ', ';
|
|
$argumentString .= ', ';
|
|
}
|
|
|
|
// We need to pick the type hint class too
|
|
if (($paramClass = $param->getClass()) !== null) {
|
|
$parameterString .= '\\' . $paramClass->getName() . ' ';
|
|
} else if ($param->isArray()) {
|
|
$parameterString .= 'array ';
|
|
}
|
|
|
|
if ($param->isPassedByReference()) {
|
|
$parameterString .= '&';
|
|
}
|
|
|
|
$parameterString .= '$' . $param->getName();
|
|
$argumentString .= '$' . $param->getName();
|
|
|
|
if ($param->isDefaultValueAvailable()) {
|
|
$parameterString .= ' = ' . var_export($param->getDefaultValue(), true);
|
|
}
|
|
}
|
|
|
|
$methods .= $parameterString . ')';
|
|
$methods .= "\n" . ' {' . "\n";
|
|
if ($this->isShortIdentifierGetter($method, $class)) {
|
|
$identifier = lcfirst(substr($method->getName(), 3));
|
|
|
|
$cast = in_array($class->fieldMappings[$identifier]['type'], array('integer', 'smallint')) ? '(int) ' : '';
|
|
|
|
$methods .= ' if ($this->__isInitialized__ === false) {' . "\n";
|
|
$methods .= ' return ' . $cast . '$this->_identifier["' . $identifier . '"];' . "\n";
|
|
$methods .= ' }' . "\n";
|
|
}
|
|
$methods .= ' $this->__load();' . "\n";
|
|
$methods .= ' return parent::' . $method->getName() . '(' . $argumentString . ');';
|
|
$methods .= "\n" . ' }' . "\n";
|
|
}
|
|
}
|
|
|
|
return $methods;
|
|
}
|
|
|
|
/**
|
|
* @param ReflectionMethod $method
|
|
* @param ClassMetadata $class
|
|
* @return bool
|
|
*/
|
|
private function isShortIdentifierGetter($method, $class)
|
|
{
|
|
$identifier = lcfirst(substr($method->getName(), 3));
|
|
return (
|
|
$method->getNumberOfParameters() == 0 &&
|
|
substr($method->getName(), 0, 3) == "get" &&
|
|
in_array($identifier, $class->identifier, true) &&
|
|
$class->hasField($identifier) &&
|
|
(($method->getEndLine() - $method->getStartLine()) <= 4)
|
|
&& in_array($class->fieldMappings[$identifier]['type'], array('integer', 'bigint', 'smallint', 'string'))
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Generates the code for the __sleep method for a proxy class.
|
|
*
|
|
* @param $class
|
|
* @return string
|
|
*/
|
|
private function _generateSleep(ClassMetadata $class)
|
|
{
|
|
$sleepImpl = '';
|
|
|
|
if ($class->reflClass->hasMethod('__sleep')) {
|
|
$sleepImpl .= "return array_merge(array('__isInitialized__'), parent::__sleep());";
|
|
} else {
|
|
$sleepImpl .= "return array('__isInitialized__', ";
|
|
$first = true;
|
|
|
|
foreach ($class->getReflectionProperties() as $name => $prop) {
|
|
if ($first) {
|
|
$first = false;
|
|
} else {
|
|
$sleepImpl .= ', ';
|
|
}
|
|
|
|
$sleepImpl .= "'" . $name . "'";
|
|
}
|
|
|
|
$sleepImpl .= ');';
|
|
}
|
|
|
|
return $sleepImpl;
|
|
}
|
|
|
|
/** Proxy class code template */
|
|
private static $_proxyClassTemplate =
|
|
'<?php
|
|
|
|
namespace <namespace>;
|
|
|
|
/**
|
|
* THIS CLASS WAS GENERATED BY THE DOCTRINE ORM. DO NOT EDIT THIS FILE.
|
|
*/
|
|
class <proxyClassName> extends \<className> implements \Doctrine\ORM\Proxy\Proxy
|
|
{
|
|
private $_entityPersister;
|
|
private $_identifier;
|
|
public $__isInitialized__ = false;
|
|
public function __construct($entityPersister, $identifier)
|
|
{
|
|
$this->_entityPersister = $entityPersister;
|
|
$this->_identifier = $identifier;
|
|
}
|
|
/** @private */
|
|
public function __load()
|
|
{
|
|
if (!$this->__isInitialized__ && $this->_entityPersister) {
|
|
$this->__isInitialized__ = true;
|
|
|
|
if (method_exists($this, "__wakeup")) {
|
|
// call this after __isInitialized__to avoid infinite recursion
|
|
// but before loading to emulate what ClassMetadata::newInstance()
|
|
// provides.
|
|
$this->__wakeup();
|
|
}
|
|
|
|
if ($this->_entityPersister->load($this->_identifier, $this) === null) {
|
|
throw new \Doctrine\ORM\EntityNotFoundException();
|
|
}
|
|
unset($this->_entityPersister, $this->_identifier);
|
|
}
|
|
}
|
|
|
|
<methods>
|
|
|
|
public function __sleep()
|
|
{
|
|
<sleepImpl>
|
|
}
|
|
|
|
public function __clone()
|
|
{
|
|
if (!$this->__isInitialized__ && $this->_entityPersister) {
|
|
$this->__isInitialized__ = true;
|
|
$class = $this->_entityPersister->getClassMetadata();
|
|
$original = $this->_entityPersister->load($this->_identifier);
|
|
if ($original === null) {
|
|
throw new \Doctrine\ORM\EntityNotFoundException();
|
|
}
|
|
foreach ($class->reflFields AS $field => $reflProperty) {
|
|
$reflProperty->setValue($this, $reflProperty->getValue($original));
|
|
}
|
|
unset($this->_entityPersister, $this->_identifier);
|
|
}
|
|
<cloneImpl>
|
|
}
|
|
}';
|
|
}
|