.gitignore 0000666 00000000224 13052402471 0006534 0 ustar 00 build/
logs/
reports/
dist/
tests/Doctrine/Tests/Common/Proxy/generated/
vendor/
.idea
composer.lock
doctrine-common-*.tar
doctrine-common-*.tar.gz
.gitmodules 0000666 00000000223 13052402471 0006720 0 ustar 00 [submodule "lib/vendor/doctrine-build-common"]
path = lib/vendor/doctrine-build-common
url = git://github.com/doctrine/doctrine-build-common.git
LICENSE 0000666 00000002051 13052402471 0005551 0 ustar 00 Copyright (c) 2006-2012 Doctrine Project
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
README.md 0000666 00000000764 13052402471 0006034 0 ustar 00 # Doctrine Common
[![Build Status](https://secure.travis-ci.org/doctrine/common.png)](http://travis-ci.org/doctrine/common)
The Doctrine Common project is a library that provides extensions to core PHP functionality.
## More resources:
* [Website](http://www.doctrine-project.org)
* [Documentation](http://docs.doctrine-project.org/projects/doctrine-common/en/latest/)
* [Issue Tracker](http://www.doctrine-project.org/jira/browse/DCOM)
* [Downloads](http://github.com/doctrine/common/downloads)
UPGRADE_TO_2_1 0000666 00000004121 13052402471 0006621 0 ustar 00 This document details all the possible changes that you should investigate when updating
your project from Doctrine Common 2.0.x to 2.1
## AnnotationReader changes
The annotation reader was heavily refactored between 2.0 and 2.1-RC1. In theory the operation of the new reader should be backwards compatible, but it has to be setup differently to work that way:
$reader = new \Doctrine\Common\Annotations\AnnotationReader();
$reader->setDefaultAnnotationNamespace('Doctrine\ORM\Mapping\\');
// new code necessary starting here
$reader->setIgnoreNotImportedAnnotations(true);
$reader->setEnableParsePhpImports(false);
$reader = new \Doctrine\Common\Annotations\CachedReader(
new \Doctrine\Common\Annotations\IndexedReader($reader), new ArrayCache()
);
## Annotation Base class or @Annotation
Beginning after 2.1-RC2 you have to either extend ``Doctrine\Common\Annotations\Annotation`` or add @Annotation to your annotations class-level docblock, otherwise the class will simply be ignored.
## Removed methods on AnnotationReader
* AnnotationReader::setAutoloadAnnotations()
* AnnotationReader::getAutoloadAnnotations()
* AnnotationReader::isAutoloadAnnotations()
## AnnotationRegistry
Autoloading through the PHP autoloader is removed from the 2.1 AnnotationReader. Instead you have to use the global AnnotationRegistry for loading purposes:
\Doctrine\Common\Annotations\AnnotationRegistry::registerFile($fileWithAnnotations);
\Doctrine\Common\Annotations\AnnotationRegistry::registerAutoloadNamespace($namespace, $dirs = null);
\Doctrine\Common\Annotations\AnnotationRegistry::registerAutoloadNamespaces($namespaces);
\Doctrine\Common\Annotations\AnnotationRegistry::registerLoader($callable);
The $callable for registering a loader accepts a class as first and only parameter and must try to silently autoload it. On success true has to be returned.
The registerAutoloadNamespace function registers a PSR-0 compatible silent autoloader for all classes with the given namespace in the given directories.
If null is passed as directory the include path will be used.
UPGRADE_TO_2_2 0000666 00000004573 13052402471 0006635 0 ustar 00 This document details all the possible changes that you should investigate when
updating your project from Doctrine Common 2.1 to 2.2:
## Annotation Changes
- AnnotationReader::setIgnoreNotImportedAnnotations has been removed, you need to
add ignore annotation names which are supposed to be ignored via
AnnotationReader::addGlobalIgnoredName
- AnnotationReader::setAutoloadAnnotations was deprecated by the AnnotationRegistry
in 2.1 and has been removed in 2.2
- AnnotationReader::setEnableParsePhpImports was added to ease transition to the new
annotation mechanism in 2.1 and is removed in 2.2
- AnnotationReader::isParsePhpImportsEnabled is removed (see above)
- AnnotationReader::setDefaultAnnotationNamespace was deprecated in favor of explicit
configuration in 2.1 and will be removed in 2.2 (for isolated projects where you
have full-control over _all_ available annotations, we offer a dedicated reader
class ``SimpleAnnotationReader``)
- AnnotationReader::setAnnotationCreationFunction was deprecated in 2.1 and will be
removed in 2.2. We only offer two creation mechanisms which cannot be changed
anymore to allow the same reader instance to work with all annotations regardless
of which library they are coming from.
- AnnotationReader::setAnnotationNamespaceAlias was deprecated in 2.1 and will be
removed in 2.2 (see setDefaultAnnotationNamespace)
- If you use a class as annotation which has not the @Annotation marker in it's
class block, we will now throw an exception instead of silently ignoring it. You
can however still achieve the previous behavior using the @IgnoreAnnotation, or
AnnotationReader::addGlobalIgnoredName (the exception message will contain detailed
instructions when you run into this problem).
## Cache Changes
- Renamed old AbstractCache to CacheProvider
- Dropped the support to the following functions of all cache providers:
- CacheProvider::deleteByWildcard
- CacheProvider::deleteByRegEx
- CacheProvider::deleteByPrefix
- CacheProvider::deleteBySuffix
- CacheProvider::deleteAll will not remove ALL entries, it will only mark them as invalid
- CacheProvider::flushAll will remove ALL entries, namespaced or not
- Added support to MemcachedCache
- Added support to WincacheCache
## ClassLoader Changes
- ClassLoader::fileExistsInIncludePath() no longer exists. Use the native stream_resolve_include_path() PHP function composer.json 0000666 00000002413 13052402471 0007270 0 ustar 00 {
"name": "doctrine/common",
"type": "library",
"description": "Common Library for Doctrine projects",
"keywords": ["collections", "spl", "eventmanager", "annotations", "persistence"],
"homepage": "http://www.doctrine-project.org",
"license": "MIT",
"authors": [
{"name": "Guilherme Blanco", "email": "guilhermeblanco@gmail.com"},
{"name": "Roman Borschel", "email": "roman@code-factory.org"},
{"name": "Benjamin Eberlei", "email": "kontakt@beberlei.de"},
{"name": "Jonathan Wage", "email": "jonwage@gmail.com"},
{"name": "Johannes Schmitt", "email": "schmittjoh@gmail.com"}
],
"require": {
"php": ">=5.3.2",
"doctrine/inflector": "1.*",
"doctrine/cache": "1.*",
"doctrine/collections": "1.*",
"doctrine/lexer": "1.*",
"doctrine/annotations": "1.*"
},
"minimum-stability": "dev",
"require-dev": {
"phpunit/phpunit": "~3.7"
},
"autoload": {
"psr-0": { "Doctrine\\Common\\": "lib/" }
},
"extra": {
"branch-alias": {
"dev-master": "2.4.x-dev"
}
},
"archive": {
"exclude": ["!vendor", "tests", "*phpunit.xml", ".travis.yml", "build.xml", "build.properties", "composer.phar"]
}
}
lib/Doctrine/Common/ClassLoader.php 0000666 00000022422 13052402471 0013222 0 ustar 00 .
*/
namespace Doctrine\Common;
/**
* A ClassLoader is an autoloader for class files that can be
* installed on the SPL autoload stack. It is a class loader that either loads only classes
* of a specific namespace or all namespaces and it is suitable for working together
* with other autoloaders in the SPL autoload stack.
*
* If no include path is configured through the constructor or {@link setIncludePath}, a ClassLoader
* relies on the PHP include_path
.
*
* @author Roman Borschel
* @since 2.0
*/
class ClassLoader
{
/**
* PHP file extension.
*
* @var string
*/
protected $fileExtension = '.php';
/**
* Current namespace.
*
* @var string|null
*/
protected $namespace;
/**
* Current include path.
*
* @var string|null
*/
protected $includePath;
/**
* PHP namespace separator.
*
* @var string
*/
protected $namespaceSeparator = '\\';
/**
* Creates a new ClassLoader that loads classes of the
* specified namespace from the specified include path.
*
* If no include path is given, the ClassLoader relies on the PHP include_path.
* If neither a namespace nor an include path is given, the ClassLoader will
* be responsible for loading all classes, thereby relying on the PHP include_path.
*
* @param string|null $ns The namespace of the classes to load.
* @param string|null $includePath The base include path to use.
*/
public function __construct($ns = null, $includePath = null)
{
$this->namespace = $ns;
$this->includePath = $includePath;
}
/**
* Sets the namespace separator used by classes in the namespace of this ClassLoader.
*
* @param string $sep The separator to use.
*
* @return void
*/
public function setNamespaceSeparator($sep)
{
$this->namespaceSeparator = $sep;
}
/**
* Gets the namespace separator used by classes in the namespace of this ClassLoader.
*
* @return string
*/
public function getNamespaceSeparator()
{
return $this->namespaceSeparator;
}
/**
* Sets the base include path for all class files in the namespace of this ClassLoader.
*
* @param string|null $includePath
*
* @return void
*/
public function setIncludePath($includePath)
{
$this->includePath = $includePath;
}
/**
* Gets the base include path for all class files in the namespace of this ClassLoader.
*
* @return string|null
*/
public function getIncludePath()
{
return $this->includePath;
}
/**
* Sets the file extension of class files in the namespace of this ClassLoader.
*
* @param string $fileExtension
*
* @return void
*/
public function setFileExtension($fileExtension)
{
$this->fileExtension = $fileExtension;
}
/**
* Gets the file extension of class files in the namespace of this ClassLoader.
*
* @return string
*/
public function getFileExtension()
{
return $this->fileExtension;
}
/**
* Registers this ClassLoader on the SPL autoload stack.
*
* @return void
*/
public function register()
{
spl_autoload_register(array($this, 'loadClass'));
}
/**
* Removes this ClassLoader from the SPL autoload stack.
*
* @return void
*/
public function unregister()
{
spl_autoload_unregister(array($this, 'loadClass'));
}
/**
* Loads the given class or interface.
*
* @param string $className The name of the class to load.
*
* @return boolean TRUE if the class has been successfully loaded, FALSE otherwise.
*/
public function loadClass($className)
{
if ($this->namespace !== null && strpos($className, $this->namespace.$this->namespaceSeparator) !== 0) {
return false;
}
require ($this->includePath !== null ? $this->includePath . DIRECTORY_SEPARATOR : '')
. str_replace($this->namespaceSeparator, DIRECTORY_SEPARATOR, $className)
. $this->fileExtension;
return true;
}
/**
* Asks this ClassLoader whether it can potentially load the class (file) with
* the given name.
*
* @param string $className The fully-qualified name of the class.
*
* @return boolean TRUE if this ClassLoader can load the class, FALSE otherwise.
*/
public function canLoadClass($className)
{
if ($this->namespace !== null && strpos($className, $this->namespace.$this->namespaceSeparator) !== 0) {
return false;
}
$file = str_replace($this->namespaceSeparator, DIRECTORY_SEPARATOR, $className) . $this->fileExtension;
if ($this->includePath !== null) {
return is_file($this->includePath . DIRECTORY_SEPARATOR . $file);
}
return (false !== stream_resolve_include_path($file));
}
/**
* Checks whether a class with a given name exists. A class "exists" if it is either
* already defined in the current request or if there is an autoloader on the SPL
* autoload stack that is a) responsible for the class in question and b) is able to
* load a class file in which the class definition resides.
*
* If the class is not already defined, each autoloader in the SPL autoload stack
* is asked whether it is able to tell if the class exists. If the autoloader is
* a ClassLoader, {@link canLoadClass} is used, otherwise the autoload
* function of the autoloader is invoked and expected to return a value that
* evaluates to TRUE if the class (file) exists. As soon as one autoloader reports
* that the class exists, TRUE is returned.
*
* Note that, depending on what kinds of autoloaders are installed on the SPL
* autoload stack, the class (file) might already be loaded as a result of checking
* for its existence. This is not the case with a ClassLoader, who separates
* these responsibilities.
*
* @param string $className The fully-qualified name of the class.
*
* @return boolean TRUE if the class exists as per the definition given above, FALSE otherwise.
*/
public static function classExists($className)
{
if (class_exists($className, false) || interface_exists($className, false)) {
return true;
}
foreach (spl_autoload_functions() as $loader) {
if (is_array($loader)) { // array(???, ???)
if (is_object($loader[0])) {
if ($loader[0] instanceof ClassLoader) { // array($obj, 'methodName')
if ($loader[0]->canLoadClass($className)) {
return true;
}
} else if ($loader[0]->{$loader[1]}($className)) {
return true;
}
} else if ($loader[0]::$loader[1]($className)) { // array('ClassName', 'methodName')
return true;
}
} else if ($loader instanceof \Closure) { // function($className) {..}
if ($loader($className)) {
return true;
}
} else if (is_string($loader) && $loader($className)) { // "MyClass::loadClass"
return true;
}
if (class_exists($className, false) || interface_exists($className, false)) {
return true;
}
}
return false;
}
/**
* Gets the ClassLoader from the SPL autoload stack that is responsible
* for (and is able to load) the class with the given name.
*
* @param string $className The name of the class.
*
* @return ClassLoader The ClassLoader for the class or NULL if no such ClassLoader exists.
*/
public static function getClassLoader($className)
{
foreach (spl_autoload_functions() as $loader) {
if (is_array($loader)
&& $loader[0] instanceof ClassLoader
&& $loader[0]->canLoadClass($className)
) {
return $loader[0];
}
}
return null;
}
}
lib/Doctrine/Common/CommonException.php 0000666 00000002172 13052402471 0014135 0 ustar 00 .
*/
namespace Doctrine\Common;
/**
* Base exception class for package Doctrine\Common.
*
* @author heinrich
*/
class CommonException extends \Exception
{
}
lib/Doctrine/Common/Comparable.php 0000666 00000003436 13052402471 0013077 0 ustar 00 .
*/
namespace Doctrine\Common;
/**
* Comparable interface that allows to compare two value objects to each other for similarity.
*
* @link www.doctrine-project.org
* @since 2.2
* @author Benjamin Eberlei
* @author Guilherme Blanco
*/
interface Comparable
{
/**
* Compares the current object to the passed $other.
*
* Returns 0 if they are semantically equal, 1 if the other object
* is less than the current one, or -1 if its more than the current one.
*
* This method should not check for identity using ===, only for semantical equality for example
* when two different DateTime instances point to the exact same Date + TZ.
*
* @param mixed $other
*
* @return int
*/
public function compareTo($other);
}
lib/Doctrine/Common/EventArgs.php 0000666 00000004666 13052402471 0012736 0 ustar 00 .
*/
namespace Doctrine\Common;
/**
* EventArgs is the base class for classes containing event data.
*
* This class contains no event data. It is used by events that do not pass state
* information to an event handler when an event is raised. The single empty EventArgs
* instance can be obtained through {@link getEmptyInstance}.
*
* @link www.doctrine-project.org
* @since 2.0
* @author Guilherme Blanco
* @author Jonathan Wage
* @author Roman Borschel
*/
class EventArgs
{
/**
* Single instance of EventArgs.
*
* @var EventArgs
*/
private static $_emptyEventArgsInstance;
/**
* Gets the single, empty and immutable EventArgs instance.
*
* This instance will be used when events are dispatched without any parameter,
* like this: EventManager::dispatchEvent('eventname');
*
* The benefit from this is that only one empty instance is instantiated and shared
* (otherwise there would be instances for every dispatched in the abovementioned form).
*
* @see EventManager::dispatchEvent
*
* @link http://msdn.microsoft.com/en-us/library/system.eventargs.aspx
*
* @return EventArgs
*/
public static function getEmptyInstance()
{
if ( ! self::$_emptyEventArgsInstance) {
self::$_emptyEventArgsInstance = new EventArgs;
}
return self::$_emptyEventArgsInstance;
}
}
lib/Doctrine/Common/EventManager.php 0000666 00000012305 13052402471 0013401 0 ustar 00 .
*/
namespace Doctrine\Common;
/**
* The EventManager is the central point of Doctrine's event listener system.
* Listeners are registered on the manager and events are dispatched through the
* manager.
*
* @link www.doctrine-project.org
* @since 2.0
* @author Guilherme Blanco
* @author Jonathan Wage
* @author Roman Borschel
*/
class EventManager
{
/**
* Map of registered listeners.
* =>
*
* @var array
*/
private $_listeners = array();
/**
* Dispatches an event to all registered listeners.
*
* @param string $eventName The name of the event to dispatch. The name of the event is
* the name of the method that is invoked on listeners.
* @param EventArgs|null $eventArgs The event arguments to pass to the event handlers/listeners.
* If not supplied, the single empty EventArgs instance is used.
*
* @return boolean
*/
public function dispatchEvent($eventName, EventArgs $eventArgs = null)
{
if (isset($this->_listeners[$eventName])) {
$eventArgs = $eventArgs === null ? EventArgs::getEmptyInstance() : $eventArgs;
foreach ($this->_listeners[$eventName] as $listener) {
$listener->$eventName($eventArgs);
}
}
}
/**
* Gets the listeners of a specific event or all listeners.
*
* @param string|null $event The name of the event.
*
* @return array The event listeners for the specified event, or all event listeners.
*/
public function getListeners($event = null)
{
return $event ? $this->_listeners[$event] : $this->_listeners;
}
/**
* Checks whether an event has any registered listeners.
*
* @param string $event
*
* @return boolean TRUE if the specified event has any listeners, FALSE otherwise.
*/
public function hasListeners($event)
{
return isset($this->_listeners[$event]) && $this->_listeners[$event];
}
/**
* Adds an event listener that listens on the specified events.
*
* @param string|array $events The event(s) to listen on.
* @param object $listener The listener object.
*
* @return void
*/
public function addEventListener($events, $listener)
{
// Picks the hash code related to that listener
$hash = spl_object_hash($listener);
foreach ((array) $events as $event) {
// Overrides listener if a previous one was associated already
// Prevents duplicate listeners on same event (same instance only)
$this->_listeners[$event][$hash] = $listener;
}
}
/**
* Removes an event listener from the specified events.
*
* @param string|array $events
* @param object $listener
*
* @return void
*/
public function removeEventListener($events, $listener)
{
// Picks the hash code related to that listener
$hash = spl_object_hash($listener);
foreach ((array) $events as $event) {
// Check if actually have this listener associated
if (isset($this->_listeners[$event][$hash])) {
unset($this->_listeners[$event][$hash]);
}
}
}
/**
* Adds an EventSubscriber. The subscriber is asked for all the events it is
* interested in and added as a listener for these events.
*
* @param \Doctrine\Common\EventSubscriber $subscriber The subscriber.
*
* @return void
*/
public function addEventSubscriber(EventSubscriber $subscriber)
{
$this->addEventListener($subscriber->getSubscribedEvents(), $subscriber);
}
/**
* Removes an EventSubscriber. The subscriber is asked for all the events it is
* interested in and removed as a listener for these events.
*
* @param \Doctrine\Common\EventSubscriber $subscriber The subscriber.
*
* @return void
*/
public function removeEventSubscriber(EventSubscriber $subscriber)
{
$this->removeEventListener($subscriber->getSubscribedEvents(), $subscriber);
}
}
lib/Doctrine/Common/EventSubscriber.php 0000666 00000003201 13052402471 0014125 0 ustar 00 .
*/
namespace Doctrine\Common;
/**
* An EventSubscriber knows himself what events he is interested in.
* If an EventSubscriber is added to an EventManager, the manager invokes
* {@link getSubscribedEvents} and registers the subscriber as a listener for all
* returned events.
*
* @link www.doctrine-project.org
* @since 2.0
* @author Guilherme Blanco
* @author Jonathan Wage
* @author Roman Borschel
*/
interface EventSubscriber
{
/**
* Returns an array of events this subscriber wants to listen to.
*
* @return array
*/
public function getSubscribedEvents();
}
lib/Doctrine/Common/Lexer.php 0000666 00000002664 13052402471 0012113 0 ustar 00 .
*/
namespace Doctrine\Common;
use Doctrine\Common\Lexer\AbstractLexer;
/**
* Base class for writing simple lexers, i.e. for creating small DSLs.
*
* Lexer moved into its own Component Doctrine\Common\Lexer. This class
* only stays for being BC.
*
* @since 2.0
* @author Guilherme Blanco
* @author Jonathan Wage
* @author Roman Borschel
*/
abstract class Lexer extends AbstractLexer
{
}
lib/Doctrine/Common/NotifyPropertyChanged.php 0000666 00000003136 13052402471 0015316 0 ustar 00 .
*/
namespace Doctrine\Common;
/**
* Contract for classes that provide the service of notifying listeners of
* changes to their properties.
*
* @link www.doctrine-project.org
* @since 2.0
* @author Guilherme Blanco
* @author Jonathan Wage
* @author Roman Borschel
*/
interface NotifyPropertyChanged
{
/**
* Adds a listener that wants to be notified about property changes.
*
* @param PropertyChangedListener $listener
*
* @return void
*/
public function addPropertyChangedListener(PropertyChangedListener $listener);
}
lib/Doctrine/Common/Persistence/AbstractManagerRegistry.php 0000666 00000015006 13052402471 0020101 0 ustar 00 .
*/
namespace Doctrine\Common\Persistence;
use Doctrine\Common\Persistence\ManagerRegistry;
/**
* Abstract implementation of the ManagerRegistry contract.
*
* @link www.doctrine-project.org
* @since 2.2
* @author Fabien Potencier
* @author Benjamin Eberlei
* @author Lukas Kahwe Smith
*/
abstract class AbstractManagerRegistry implements ManagerRegistry
{
/**
* @var string
*/
private $name;
/**
* @var array
*/
private $connections;
/**
* @var array
*/
private $managers;
/**
* @var string
*/
private $defaultConnection;
/**
* @var string
*/
private $defaultManager;
/**
* @var string
*/
private $proxyInterfaceName;
/**
* Constructor.
*
* @param string $name
* @param array $connections
* @param array $managers
* @param string $defaultConnection
* @param string $defaultManager
* @param string $proxyInterfaceName
*/
public function __construct($name, array $connections, array $managers, $defaultConnection, $defaultManager, $proxyInterfaceName)
{
$this->name = $name;
$this->connections = $connections;
$this->managers = $managers;
$this->defaultConnection = $defaultConnection;
$this->defaultManager = $defaultManager;
$this->proxyInterfaceName = $proxyInterfaceName;
}
/**
* Fetches/creates the given services.
*
* A service in this context is connection or a manager instance.
*
* @param string $name The name of the service.
*
* @return object The instance of the given service.
*/
abstract protected function getService($name);
/**
* Resets the given services.
*
* A service in this context is connection or a manager instance.
*
* @param string $name The name of the service.
*
* @return void
*/
abstract protected function resetService($name);
/**
* Gets the name of the registry.
*
* @return string
*/
public function getName()
{
return $this->name;
}
/**
* {@inheritdoc}
*/
public function getConnection($name = null)
{
if (null === $name) {
$name = $this->defaultConnection;
}
if (!isset($this->connections[$name])) {
throw new \InvalidArgumentException(sprintf('Doctrine %s Connection named "%s" does not exist.', $this->name, $name));
}
return $this->getService($this->connections[$name]);
}
/**
* {@inheritdoc}
*/
public function getConnectionNames()
{
return $this->connections;
}
/**
* {@inheritdoc}
*/
public function getConnections()
{
$connections = array();
foreach ($this->connections as $name => $id) {
$connections[$name] = $this->getService($id);
}
return $connections;
}
/**
* {@inheritdoc}
*/
public function getDefaultConnectionName()
{
return $this->defaultConnection;
}
/**
* {@inheritdoc}
*/
public function getDefaultManagerName()
{
return $this->defaultManager;
}
/**
* {@inheritdoc}
*
* @throws \InvalidArgumentException
*/
public function getManager($name = null)
{
if (null === $name) {
$name = $this->defaultManager;
}
if (!isset($this->managers[$name])) {
throw new \InvalidArgumentException(sprintf('Doctrine %s Manager named "%s" does not exist.', $this->name, $name));
}
return $this->getService($this->managers[$name]);
}
/**
* {@inheritdoc}
*/
public function getManagerForClass($class)
{
// Check for namespace alias
if (strpos($class, ':') !== false) {
list($namespaceAlias, $simpleClassName) = explode(':', $class);
$class = $this->getAliasNamespace($namespaceAlias) . '\\' . $simpleClassName;
}
$proxyClass = new \ReflectionClass($class);
if ($proxyClass->implementsInterface($this->proxyInterfaceName)) {
$class = $proxyClass->getParentClass()->getName();
}
foreach ($this->managers as $id) {
$manager = $this->getService($id);
if (!$manager->getMetadataFactory()->isTransient($class)) {
return $manager;
}
}
}
/**
* {@inheritdoc}
*/
public function getManagerNames()
{
return $this->managers;
}
/**
* {@inheritdoc}
*/
public function getManagers()
{
$dms = array();
foreach ($this->managers as $name => $id) {
$dms[$name] = $this->getService($id);
}
return $dms;
}
/**
* {@inheritdoc}
*/
public function getRepository($persistentObjectName, $persistentManagerName = null)
{
return $this->getManager($persistentManagerName)->getRepository($persistentObjectName);
}
/**
* {@inheritdoc}
*/
public function resetManager($name = null)
{
if (null === $name) {
$name = $this->defaultManager;
}
if (!isset($this->managers[$name])) {
throw new \InvalidArgumentException(sprintf('Doctrine %s Manager named "%s" does not exist.', $this->name, $name));
}
// force the creation of a new document manager
// if the current one is closed
$this->resetService($this->managers[$name]);
}
}
lib/Doctrine/Common/Persistence/ConnectionRegistry.php 0000666 00000004026 13052402471 0017142 0 ustar 00 .
*/
namespace Doctrine\Common\Persistence;
/**
* Contract covering connection for a Doctrine persistence layer ManagerRegistry class to implement.
*
* @link www.doctrine-project.org
* @since 2.2
* @author Fabien Potencier
* @author Benjamin Eberlei
* @author Lukas Kahwe Smith
*/
interface ConnectionRegistry
{
/**
* Gets the default connection name.
*
* @return string The default connection name.
*/
public function getDefaultConnectionName();
/**
* Gets the named connection.
*
* @param string $name The connection name (null for the default one).
*
* @return object
*/
public function getConnection($name = null);
/**
* Gets an array of all registered connections.
*
* @return array An array of Connection instances.
*/
public function getConnections();
/**
* Gets all connection names.
*
* @return array An array of connection names.
*/
public function getConnectionNames();
}
lib/Doctrine/Common/Persistence/Event/LifecycleEventArgs.php 0000666 00000004477 13052402471 0020123 0 ustar 00 .
*/
namespace Doctrine\Common\Persistence\Event;
use Doctrine\Common\EventArgs;
use Doctrine\Common\Persistence\ObjectManager;
/**
* Lifecycle Events are triggered by the UnitOfWork during lifecycle transitions
* of entities.
*
* @link www.doctrine-project.org
* @since 2.2
* @author Roman Borschel
* @author Benjamin Eberlei
*/
class LifecycleEventArgs extends EventArgs
{
/**
* @var ObjectManager
*/
private $objectManager;
/**
* @var object
*/
private $object;
/**
* Constructor.
*
* @param object $object
* @param ObjectManager $objectManager
*/
public function __construct($object, ObjectManager $objectManager)
{
$this->object = $object;
$this->objectManager = $objectManager;
}
/**
* Retrieves the associated entity.
*
* @deprecated
*
* @return object
*/
public function getEntity()
{
return $this->object;
}
/**
* Retrieves the associated object.
*
* @return object
*/
public function getObject()
{
return $this->object;
}
/**
* Retrieves the associated ObjectManager.
*
* @return ObjectManager
*/
public function getObjectManager()
{
return $this->objectManager;
}
}
lib/Doctrine/Common/Persistence/Event/LoadClassMetadataEventArgs.php 0000666 00000004235 13052402471 0021522 0 ustar 00 .
*/
namespace Doctrine\Common\Persistence\Event;
use Doctrine\Common\EventArgs;
use Doctrine\Common\Persistence\ObjectManager;
use Doctrine\Common\Persistence\Mapping\ClassMetadata;
/**
* Class that holds event arguments for a loadMetadata event.
*
* @author Jonathan H. Wage
* @since 2.2
*/
class LoadClassMetadataEventArgs extends EventArgs
{
/**
* @var ClassMetadata
*/
private $classMetadata;
/**
* @var ObjectManager
*/
private $objectManager;
/**
* Constructor.
*
* @param ClassMetadata $classMetadata
* @param ObjectManager $objectManager
*/
public function __construct(ClassMetadata $classMetadata, ObjectManager $objectManager)
{
$this->classMetadata = $classMetadata;
$this->objectManager = $objectManager;
}
/**
* Retrieves the associated ClassMetadata.
*
* @return ClassMetadata
*/
public function getClassMetadata()
{
return $this->classMetadata;
}
/**
* Retrieves the associated ObjectManager.
*
* @return ObjectManager
*/
public function getObjectManager()
{
return $this->objectManager;
}
}
lib/Doctrine/Common/Persistence/Event/ManagerEventArgs.php 0000666 00000003457 13052402471 0017573 0 ustar 00 .
*/
namespace Doctrine\Common\Persistence\Event;
use Doctrine\Common\EventArgs;
use Doctrine\Common\Persistence\ObjectManager;
/**
* Provides event arguments for the preFlush event.
*
* @link www.doctrine-project.org
* @since 2.2
* @author Roman Borschel
* @author Benjamin Eberlei
*/
class ManagerEventArgs extends EventArgs
{
/**
* @var ObjectManager
*/
private $objectManager;
/**
* Constructor.
*
* @param ObjectManager $objectManager
*/
public function __construct(ObjectManager $objectManager)
{
$this->objectManager = $objectManager;
}
/**
* Retrieves the associated ObjectManager.
*
* @return ObjectManager
*/
public function getObjectManager()
{
return $this->objectManager;
}
}
lib/Doctrine/Common/Persistence/Event/OnClearEventArgs.php 0000666 00000004734 13052402471 0017543 0 ustar 00 .
*/
namespace Doctrine\Common\Persistence\Event;
use Doctrine\Common\EventArgs;
use Doctrine\Common\Persistence\ObjectManager;
/**
* Provides event arguments for the onClear event.
*
* @link www.doctrine-project.org
* @since 2.2
* @author Roman Borschel
* @author Benjamin Eberlei
*/
class OnClearEventArgs extends EventArgs
{
/**
* @var \Doctrine\Common\Persistence\ObjectManager
*/
private $objectManager;
/**
* @var string|null
*/
private $entityClass;
/**
* Constructor.
*
* @param ObjectManager $objectManager The object manager.
* @param string|null $entityClass The optional entity class.
*/
public function __construct($objectManager, $entityClass = null)
{
$this->objectManager = $objectManager;
$this->entityClass = $entityClass;
}
/**
* Retrieves the associated ObjectManager.
*
* @return \Doctrine\Common\Persistence\ObjectManager
*/
public function getObjectManager()
{
return $this->objectManager;
}
/**
* Returns the name of the entity class that is cleared, or null if all are cleared.
*
* @return string|null
*/
public function getEntityClass()
{
return $this->entityClass;
}
/**
* Returns whether this event clears all entities.
*
* @return bool
*/
public function clearsAllEntities()
{
return ($this->entityClass === null);
}
}
lib/Doctrine/Common/Persistence/Event/PreUpdateEventArgs.php 0000666 00000007120 13052402471 0020101 0 ustar 00 .
*/
namespace Doctrine\Common\Persistence\Event;
use Doctrine\Common\EventArgs;
use Doctrine\Common\Persistence\ObjectManager;
/**
* Class that holds event arguments for a preUpdate event.
*
* @author Guilherme Blanco
* @author Roman Borschel
* @author Benjamin Eberlei
* @since 2.2
*/
class PreUpdateEventArgs extends LifecycleEventArgs
{
/**
* @var array
*/
private $entityChangeSet;
/**
* Constructor.
*
* @param object $entity
* @param ObjectManager $objectManager
* @param array $changeSet
*/
public function __construct($entity, ObjectManager $objectManager, array &$changeSet)
{
parent::__construct($entity, $objectManager);
$this->entityChangeSet = &$changeSet;
}
/**
* Retrieves the entity changeset.
*
* @return array
*/
public function getEntityChangeSet()
{
return $this->entityChangeSet;
}
/**
* Checks if field has a changeset.
*
* @param string $field
*
* @return boolean
*/
public function hasChangedField($field)
{
return isset($this->entityChangeSet[$field]);
}
/**
* Gets the old value of the changeset of the changed field.
*
* @param string $field
*
* @return mixed
*/
public function getOldValue($field)
{
$this->assertValidField($field);
return $this->entityChangeSet[$field][0];
}
/**
* Gets the new value of the changeset of the changed field.
*
* @param string $field
*
* @return mixed
*/
public function getNewValue($field)
{
$this->assertValidField($field);
return $this->entityChangeSet[$field][1];
}
/**
* Sets the new value of this field.
*
* @param string $field
* @param mixed $value
*
* @return void
*/
public function setNewValue($field, $value)
{
$this->assertValidField($field);
$this->entityChangeSet[$field][1] = $value;
}
/**
* Asserts the field exists in changeset.
*
* @param string $field
*
* @return void
*
* @throws \InvalidArgumentException
*/
private function assertValidField($field)
{
if ( ! isset($this->entityChangeSet[$field])) {
throw new \InvalidArgumentException(sprintf(
'Field "%s" is not a valid field of the entity "%s" in PreUpdateEventArgs.',
$field,
get_class($this->getEntity())
));
}
}
}
lib/Doctrine/Common/Persistence/ManagerRegistry.php 0000666 00000007543 13052402471 0016424 0 ustar 00 .
*/
namespace Doctrine\Common\Persistence;
/**
* Contract covering object managers for a Doctrine persistence layer ManagerRegistry class to implement.
*
* @link www.doctrine-project.org
* @since 2.2
* @author Fabien Potencier
* @author Benjamin Eberlei
* @author Lukas Kahwe Smith
*/
interface ManagerRegistry extends ConnectionRegistry
{
/**
* Gets the default object manager name.
*
* @return string The default object manager name.
*/
public function getDefaultManagerName();
/**
* Gets a named object manager.
*
* @param string $name The object manager name (null for the default one).
*
* @return \Doctrine\Common\Persistence\ObjectManager
*/
public function getManager($name = null);
/**
* Gets an array of all registered object managers.
*
* @return \Doctrine\Common\Persistence\ObjectManager[] An array of ObjectManager instances
*/
public function getManagers();
/**
* Resets a named object manager.
*
* This method is useful when an object manager has been closed
* because of a rollbacked transaction AND when you think that
* it makes sense to get a new one to replace the closed one.
*
* Be warned that you will get a brand new object manager as
* the existing one is not useable anymore. This means that any
* other object with a dependency on this object manager will
* hold an obsolete reference. You can inject the registry instead
* to avoid this problem.
*
* @param string|null $name The object manager name (null for the default one).
*
* @return \Doctrine\Common\Persistence\ObjectManager
*/
public function resetManager($name = null);
/**
* Resolves a registered namespace alias to the full namespace.
*
* This method looks for the alias in all registered object managers.
*
* @param string $alias The alias.
*
* @return string The full namespace.
*/
public function getAliasNamespace($alias);
/**
* Gets all connection names.
*
* @return array An array of connection names.
*/
public function getManagerNames();
/**
* Gets the ObjectRepository for an persistent object.
*
* @param string $persistentObject The name of the persistent object.
* @param string $persistentManagerName The object manager name (null for the default one).
*
* @return \Doctrine\Common\Persistence\ObjectRepository
*/
public function getRepository($persistentObject, $persistentManagerName = null);
/**
* Gets the object manager associated with a given class.
*
* @param string $class A persistent object class name.
*
* @return \Doctrine\Common\Persistence\ObjectManager|null
*/
public function getManagerForClass($class);
}
lib/Doctrine/Common/Persistence/Mapping/AbstractClassMetadataFactory.php 0000666 00000030176 13052402471 0022434 0 ustar 00 .
*/
namespace Doctrine\Common\Persistence\Mapping;
use Doctrine\Common\Cache\Cache;
use Doctrine\Common\Util\ClassUtils;
/**
* The ClassMetadataFactory is used to create ClassMetadata objects that contain all the
* metadata mapping informations of a class which describes how a class should be mapped
* to a relational database.
*
* This class was abstracted from the ORM ClassMetadataFactory.
*
* @since 2.2
* @author Benjamin Eberlei
* @author Guilherme Blanco
* @author Jonathan Wage
* @author Roman Borschel
*/
abstract class AbstractClassMetadataFactory implements ClassMetadataFactory
{
/**
* Salt used by specific Object Manager implementation.
*
* @var string
*/
protected $cacheSalt = '$CLASSMETADATA';
/**
* @var \Doctrine\Common\Cache\Cache|null
*/
private $cacheDriver;
/**
* @var array
*/
private $loadedMetadata = array();
/**
* @var bool
*/
protected $initialized = false;
/**
* @var ReflectionService|null
*/
private $reflectionService = null;
/**
* Sets the cache driver used by the factory to cache ClassMetadata instances.
*
* @param \Doctrine\Common\Cache\Cache $cacheDriver
*
* @return void
*/
public function setCacheDriver(Cache $cacheDriver = null)
{
$this->cacheDriver = $cacheDriver;
}
/**
* Gets the cache driver used by the factory to cache ClassMetadata instances.
*
* @return \Doctrine\Common\Cache\Cache|null
*/
public function getCacheDriver()
{
return $this->cacheDriver;
}
/**
* Returns an array of all the loaded metadata currently in memory.
*
* @return array
*/
public function getLoadedMetadata()
{
return $this->loadedMetadata;
}
/**
* Forces the factory to load the metadata of all classes known to the underlying
* mapping driver.
*
* @return array The ClassMetadata instances of all mapped classes.
*/
public function getAllMetadata()
{
if ( ! $this->initialized) {
$this->initialize();
}
$driver = $this->getDriver();
$metadata = array();
foreach ($driver->getAllClassNames() as $className) {
$metadata[] = $this->getMetadataFor($className);
}
return $metadata;
}
/**
* Lazy initialization of this stuff, especially the metadata driver,
* since these are not needed at all when a metadata cache is active.
*
* @return void
*/
abstract protected function initialize();
/**
* Gets the fully qualified class-name from the namespace alias.
*
* @param string $namespaceAlias
* @param string $simpleClassName
*
* @return string
*/
abstract protected function getFqcnFromAlias($namespaceAlias, $simpleClassName);
/**
* Returns the mapping driver implementation.
*
* @return \Doctrine\Common\Persistence\Mapping\Driver\MappingDriver
*/
abstract protected function getDriver();
/**
* Wakes up reflection after ClassMetadata gets unserialized from cache.
*
* @param ClassMetadata $class
* @param ReflectionService $reflService
*
* @return void
*/
abstract protected function wakeupReflection(ClassMetadata $class, ReflectionService $reflService);
/**
* Initializes Reflection after ClassMetadata was constructed.
*
* @param ClassMetadata $class
* @param ReflectionService $reflService
*
* @return void
*/
abstract protected function initializeReflection(ClassMetadata $class, ReflectionService $reflService);
/**
* Checks whether the class metadata is an entity.
*
* This method should return false for mapped superclasses or embedded classes.
*
* @param ClassMetadata $class
*
* @return boolean
*/
abstract protected function isEntity(ClassMetadata $class);
/**
* Gets the class metadata descriptor for a class.
*
* @param string $className The name of the class.
*
* @return \Doctrine\Common\Persistence\Mapping\ClassMetadata
*/
public function getMetadataFor($className)
{
if (isset($this->loadedMetadata[$className])) {
return $this->loadedMetadata[$className];
}
$realClassName = $className;
// Check for namespace alias
if (strpos($className, ':') !== false) {
list($namespaceAlias, $simpleClassName) = explode(':', $className);
$realClassName = $this->getFqcnFromAlias($namespaceAlias, $simpleClassName);
} else {
$realClassName = ClassUtils::getRealClass($realClassName);
}
if (isset($this->loadedMetadata[$realClassName])) {
// We do not have the alias name in the map, include it
$this->loadedMetadata[$className] = $this->loadedMetadata[$realClassName];
return $this->loadedMetadata[$realClassName];
}
if ($this->cacheDriver) {
if (($cached = $this->cacheDriver->fetch($realClassName . $this->cacheSalt)) !== false) {
$this->loadedMetadata[$realClassName] = $cached;
$this->wakeupReflection($cached, $this->getReflectionService());
} else {
foreach ($this->loadMetadata($realClassName) as $loadedClassName) {
$this->cacheDriver->save(
$loadedClassName . $this->cacheSalt, $this->loadedMetadata[$loadedClassName], null
);
}
}
} else {
$this->loadMetadata($realClassName);
}
if ($className != $realClassName) {
// We do not have the alias name in the map, include it
$this->loadedMetadata[$className] = $this->loadedMetadata[$realClassName];
}
return $this->loadedMetadata[$className];
}
/**
* Checks whether the factory has the metadata for a class loaded already.
*
* @param string $className
*
* @return boolean TRUE if the metadata of the class in question is already loaded, FALSE otherwise.
*/
public function hasMetadataFor($className)
{
return isset($this->loadedMetadata[$className]);
}
/**
* Sets the metadata descriptor for a specific class.
*
* NOTE: This is only useful in very special cases, like when generating proxy classes.
*
* @param string $className
* @param ClassMetadata $class
*
* @return void
*/
public function setMetadataFor($className, $class)
{
$this->loadedMetadata[$className] = $class;
}
/**
* Gets an array of parent classes for the given entity class.
*
* @param string $name
*
* @return array
*/
protected function getParentClasses($name)
{
// Collect parent classes, ignoring transient (not-mapped) classes.
$parentClasses = array();
foreach (array_reverse($this->getReflectionService()->getParentClasses($name)) as $parentClass) {
if ( ! $this->getDriver()->isTransient($parentClass)) {
$parentClasses[] = $parentClass;
}
}
return $parentClasses;
}
/**
* Loads the metadata of the class in question and all it's ancestors whose metadata
* is still not loaded.
*
* Important: The class $name does not necesarily exist at this point here.
* Scenarios in a code-generation setup might have access to XML/YAML
* Mapping files without the actual PHP code existing here. That is why the
* {@see Doctrine\Common\Persistence\Mapping\ReflectionService} interface
* should be used for reflection.
*
* @param string $name The name of the class for which the metadata should get loaded.
*
* @return array
*/
protected function loadMetadata($name)
{
if ( ! $this->initialized) {
$this->initialize();
}
$loaded = array();
$parentClasses = $this->getParentClasses($name);
$parentClasses[] = $name;
// Move down the hierarchy of parent classes, starting from the topmost class
$parent = null;
$rootEntityFound = false;
$visited = array();
$reflService = $this->getReflectionService();
foreach ($parentClasses as $className) {
if (isset($this->loadedMetadata[$className])) {
$parent = $this->loadedMetadata[$className];
if ($this->isEntity($parent)) {
$rootEntityFound = true;
array_unshift($visited, $className);
}
continue;
}
$class = $this->newClassMetadataInstance($className);
$this->initializeReflection($class, $reflService);
$this->doLoadMetadata($class, $parent, $rootEntityFound, $visited);
$this->loadedMetadata[$className] = $class;
$parent = $class;
if ($this->isEntity($class)) {
$rootEntityFound = true;
array_unshift($visited, $className);
}
$this->wakeupReflection($class, $reflService);
$loaded[] = $className;
}
return $loaded;
}
/**
* Actually loads the metadata from the underlying metadata.
*
* @param ClassMetadata $class
* @param ClassMetadata|null $parent
* @param bool $rootEntityFound
* @param array $nonSuperclassParents All parent class names
* that are not marked as mapped superclasses.
*
* @return void
*/
abstract protected function doLoadMetadata($class, $parent, $rootEntityFound, array $nonSuperclassParents);
/**
* Creates a new ClassMetadata instance for the given class name.
*
* @param string $className
*
* @return ClassMetadata
*/
abstract protected function newClassMetadataInstance($className);
/**
* {@inheritDoc}
*/
public function isTransient($class)
{
if ( ! $this->initialized) {
$this->initialize();
}
// Check for namespace alias
if (strpos($class, ':') !== false) {
list($namespaceAlias, $simpleClassName) = explode(':', $class);
$class = $this->getFqcnFromAlias($namespaceAlias, $simpleClassName);
}
return $this->getDriver()->isTransient($class);
}
/**
* Sets the reflectionService.
*
* @param ReflectionService $reflectionService
*
* @return void
*/
public function setReflectionService(ReflectionService $reflectionService)
{
$this->reflectionService = $reflectionService;
}
/**
* Gets the reflection service associated with this metadata factory.
*
* @return ReflectionService
*/
public function getReflectionService()
{
if ($this->reflectionService === null) {
$this->reflectionService = new RuntimeReflectionService();
}
return $this->reflectionService;
}
}
lib/Doctrine/Common/Persistence/Mapping/ClassMetadata.php 0000666 00000011343 13052402471 0017413 0 ustar 00 .
*/
namespace Doctrine\Common\Persistence\Mapping;
/**
* Contract for a Doctrine persistence layer ClassMetadata class to implement.
*
* @link www.doctrine-project.org
* @since 2.1
* @author Benjamin Eberlei
* @author Jonathan Wage
*/
interface ClassMetadata
{
/**
* Gets the fully-qualified class name of this persistent class.
*
* @return string
*/
public function getName();
/**
* Gets the mapped identifier field name.
*
* The returned structure is an array of the identifier field names.
*
* @return array
*/
public function getIdentifier();
/**
* Gets the ReflectionClass instance for this mapped class.
*
* @return \ReflectionClass
*/
public function getReflectionClass();
/**
* Checks if the given field name is a mapped identifier for this class.
*
* @param string $fieldName
*
* @return boolean
*/
public function isIdentifier($fieldName);
/**
* Checks if the given field is a mapped property for this class.
*
* @param string $fieldName
*
* @return boolean
*/
public function hasField($fieldName);
/**
* Checks if the given field is a mapped association for this class.
*
* @param string $fieldName
*
* @return boolean
*/
public function hasAssociation($fieldName);
/**
* Checks if the given field is a mapped single valued association for this class.
*
* @param string $fieldName
*
* @return boolean
*/
public function isSingleValuedAssociation($fieldName);
/**
* Checks if the given field is a mapped collection valued association for this class.
*
* @param string $fieldName
*
* @return boolean
*/
public function isCollectionValuedAssociation($fieldName);
/**
* A numerically indexed list of field names of this persistent class.
*
* This array includes identifier fields if present on this class.
*
* @return array
*/
public function getFieldNames();
/**
* Returns an array of identifier field names numerically indexed.
*
* @return array
*/
public function getIdentifierFieldNames();
/**
* Returns a numerically indexed list of association names of this persistent class.
*
* This array includes identifier associations if present on this class.
*
* @return array
*/
public function getAssociationNames();
/**
* Returns a type name of this field.
*
* This type names can be implementation specific but should at least include the php types:
* integer, string, boolean, float/double, datetime.
*
* @param string $fieldName
*
* @return string
*/
public function getTypeOfField($fieldName);
/**
* Returns the target class name of the given association.
*
* @param string $assocName
*
* @return string
*/
public function getAssociationTargetClass($assocName);
/**
* Checks if the association is the inverse side of a bidirectional association.
*
* @param string $assocName
*
* @return boolean
*/
public function isAssociationInverseSide($assocName);
/**
* Returns the target field of the owning side of the association.
*
* @param string $assocName
*
* @return string
*/
public function getAssociationMappedByTargetField($assocName);
/**
* Returns the identifier of this object as an array with field name as key.
*
* Has to return an empty array if no identifier isset.
*
* @param object $object
*
* @return array
*/
public function getIdentifierValues($object);
}
lib/Doctrine/Common/Persistence/Mapping/ClassMetadataFactory.php 0000666 00000005027 13052402471 0020745 0 ustar 00 .
*/
namespace Doctrine\Common\Persistence\Mapping;
/**
* Contract for a Doctrine persistence layer ClassMetadata class to implement.
*
* @link www.doctrine-project.org
* @since 2.1
* @author Benjamin Eberlei
* @author Jonathan Wage
*/
interface ClassMetadataFactory
{
/**
* Forces the factory to load the metadata of all classes known to the underlying
* mapping driver.
*
* @return array The ClassMetadata instances of all mapped classes.
*/
public function getAllMetadata();
/**
* Gets the class metadata descriptor for a class.
*
* @param string $className The name of the class.
*
* @return ClassMetadata
*/
public function getMetadataFor($className);
/**
* Checks whether the factory has the metadata for a class loaded already.
*
* @param string $className
*
* @return boolean TRUE if the metadata of the class in question is already loaded, FALSE otherwise.
*/
public function hasMetadataFor($className);
/**
* Sets the metadata descriptor for a specific class.
*
* @param string $className
*
* @param ClassMetadata $class
*/
public function setMetadataFor($className, $class);
/**
* Returns whether the class with the specified name should have its metadata loaded.
* This is only the case if it is either mapped directly or as a MappedSuperclass.
*
* @param string $className
*
* @return boolean
*/
public function isTransient($className);
}
lib/Doctrine/Common/Persistence/Mapping/Driver/AnnotationDriver.php 0000666 00000016017 13052402471 0021431 0 ustar 00 .
*/
namespace Doctrine\Common\Persistence\Mapping\Driver;
use Doctrine\Common\Annotations\AnnotationReader;
use Doctrine\Common\Annotations\AnnotationRegistry;
use Doctrine\Common\Persistence\Mapping\MappingException;
/**
* The AnnotationDriver reads the mapping metadata from docblock annotations.
*
* @since 2.2
* @author Benjamin Eberlei
* @author Guilherme Blanco
* @author Jonathan H. Wage
* @author Roman Borschel
*/
abstract class AnnotationDriver implements MappingDriver
{
/**
* The AnnotationReader.
*
* @var AnnotationReader
*/
protected $reader;
/**
* The paths where to look for mapping files.
*
* @var array
*/
protected $paths = array();
/**
* The paths excluded from path where to look for mapping files.
*
* @var array
*/
protected $excludePaths = array();
/**
* The file extension of mapping documents.
*
* @var string
*/
protected $fileExtension = '.php';
/**
* Cache for AnnotationDriver#getAllClassNames().
*
* @var array|null
*/
protected $classNames;
/**
* Name of the entity annotations as keys.
*
* @var array
*/
protected $entityAnnotationClasses = array();
/**
* Initializes a new AnnotationDriver that uses the given AnnotationReader for reading
* docblock annotations.
*
* @param AnnotationReader $reader The AnnotationReader to use, duck-typed.
* @param string|array|null $paths One or multiple paths where mapping classes can be found.
*/
public function __construct($reader, $paths = null)
{
$this->reader = $reader;
if ($paths) {
$this->addPaths((array) $paths);
}
}
/**
* Appends lookup paths to metadata driver.
*
* @param array $paths
*
* @return void
*/
public function addPaths(array $paths)
{
$this->paths = array_unique(array_merge($this->paths, $paths));
}
/**
* Retrieves the defined metadata lookup paths.
*
* @return array
*/
public function getPaths()
{
return $this->paths;
}
/**
* Append exclude lookup paths to metadata driver.
*
* @param array $paths
*/
public function addExcludePaths(array $paths)
{
$this->excludePaths = array_unique(array_merge($this->excludePaths, $paths));
}
/**
* Retrieve the defined metadata lookup exclude paths.
*
* @return array
*/
public function getExcludePaths()
{
return $this->excludePaths;
}
/**
* Retrieve the current annotation reader
*
* @return AnnotationReader
*/
public function getReader()
{
return $this->reader;
}
/**
* Gets the file extension used to look for mapping files under.
*
* @return string
*/
public function getFileExtension()
{
return $this->fileExtension;
}
/**
* Sets the file extension used to look for mapping files under.
*
* @param string $fileExtension The file extension to set.
*
* @return void
*/
public function setFileExtension($fileExtension)
{
$this->fileExtension = $fileExtension;
}
/**
* Returns whether the class with the specified name is transient. Only non-transient
* classes, that is entities and mapped superclasses, should have their metadata loaded.
*
* A class is non-transient if it is annotated with an annotation
* from the {@see AnnotationDriver::entityAnnotationClasses}.
*
* @param string $className
*
* @return boolean
*/
public function isTransient($className)
{
$classAnnotations = $this->reader->getClassAnnotations(new \ReflectionClass($className));
foreach ($classAnnotations as $annot) {
if (isset($this->entityAnnotationClasses[get_class($annot)])) {
return false;
}
}
return true;
}
/**
* {@inheritDoc}
*/
public function getAllClassNames()
{
if ($this->classNames !== null) {
return $this->classNames;
}
if (!$this->paths) {
throw MappingException::pathRequired();
}
$classes = array();
$includedFiles = array();
foreach ($this->paths as $path) {
if ( ! is_dir($path)) {
throw MappingException::fileMappingDriversRequireConfiguredDirectoryPath($path);
}
$iterator = new \RegexIterator(
new \RecursiveIteratorIterator(
new \RecursiveDirectoryIterator($path, \FilesystemIterator::SKIP_DOTS),
\RecursiveIteratorIterator::LEAVES_ONLY
),
'/^.+' . preg_quote($this->fileExtension) . '$/i',
\RecursiveRegexIterator::GET_MATCH
);
foreach ($iterator as $file) {
$sourceFile = $file[0];
if ( ! preg_match('(^phar:)i', $sourceFile)) {
$sourceFile = realpath($sourceFile);
}
foreach ($this->excludePaths as $excludePath) {
$exclude = str_replace('\\', '/', realpath($excludePath));
$current = str_replace('\\', '/', $sourceFile);
if (strpos($current, $exclude) !== false) {
continue 2;
}
}
require_once $sourceFile;
$includedFiles[] = $sourceFile;
}
}
$declared = get_declared_classes();
foreach ($declared as $className) {
$rc = new \ReflectionClass($className);
$sourceFile = $rc->getFileName();
if (in_array($sourceFile, $includedFiles) && ! $this->isTransient($className)) {
$classes[] = $className;
}
}
$this->classNames = $classes;
return $classes;
}
}
lib/Doctrine/Common/Persistence/Mapping/Driver/DefaultFileLocator.php 0000666 00000012030 13052402471 0021642 0 ustar 00 .
*/
namespace Doctrine\Common\Persistence\Mapping\Driver;
use Doctrine\Common\Persistence\Mapping\MappingException;
/**
* Locates the file that contains the metadata information for a given class name.
*
* This behavior is independent of the actual content of the file. It just detects
* the file which is responsible for the given class name.
*
* @author Benjamin Eberlei
* @author Johannes M. Schmitt
*/
class DefaultFileLocator implements FileLocator
{
/**
* The paths where to look for mapping files.
*
* @var array
*/
protected $paths = array();
/**
* The file extension of mapping documents.
*
* @var string|null
*/
protected $fileExtension;
/**
* Initializes a new FileDriver that looks in the given path(s) for mapping
* documents and operates in the specified operating mode.
*
* @param string|array $paths One or multiple paths where mapping documents can be found.
* @param string|null $fileExtension The file extension of mapping documents.
*/
public function __construct($paths, $fileExtension = null)
{
$this->addPaths((array) $paths);
$this->fileExtension = $fileExtension;
}
/**
* Appends lookup paths to metadata driver.
*
* @param array $paths
*
* @return void
*/
public function addPaths(array $paths)
{
$this->paths = array_unique(array_merge($this->paths, $paths));
}
/**
* Retrieves the defined metadata lookup paths.
*
* @return array
*/
public function getPaths()
{
return $this->paths;
}
/**
* Gets the file extension used to look for mapping files under.
*
* @return string|null
*/
public function getFileExtension()
{
return $this->fileExtension;
}
/**
* Sets the file extension used to look for mapping files under.
*
* @param string|null $fileExtension The file extension to set.
*
* @return void
*/
public function setFileExtension($fileExtension)
{
$this->fileExtension = $fileExtension;
}
/**
* {@inheritDoc}
*/
public function findMappingFile($className)
{
$fileName = str_replace('\\', '.', $className) . $this->fileExtension;
// Check whether file exists
foreach ($this->paths as $path) {
if (is_file($path . DIRECTORY_SEPARATOR . $fileName)) {
return $path . DIRECTORY_SEPARATOR . $fileName;
}
}
throw MappingException::mappingFileNotFound($className, $fileName);
}
/**
* {@inheritDoc}
*/
public function getAllClassNames($globalBasename)
{
$classes = array();
if ($this->paths) {
foreach ($this->paths as $path) {
if ( ! is_dir($path)) {
throw MappingException::fileMappingDriversRequireConfiguredDirectoryPath($path);
}
$iterator = new \RecursiveIteratorIterator(
new \RecursiveDirectoryIterator($path),
\RecursiveIteratorIterator::LEAVES_ONLY
);
foreach ($iterator as $file) {
$fileName = $file->getBasename($this->fileExtension);
if ($fileName == $file->getBasename() || $fileName == $globalBasename) {
continue;
}
// NOTE: All files found here means classes are not transient!
$classes[] = str_replace('.', '\\', $fileName);
}
}
}
return $classes;
}
/**
* {@inheritDoc}
*/
public function fileExists($className)
{
$fileName = str_replace('\\', '.', $className) . $this->fileExtension;
// Check whether file exists
foreach ((array) $this->paths as $path) {
if (is_file($path . DIRECTORY_SEPARATOR . $fileName)) {
return true;
}
}
return false;
}
}
lib/Doctrine/Common/Persistence/Mapping/Driver/FileDriver.php 0000666 00000014423 13052402471 0020175 0 ustar 00 .
*/
namespace Doctrine\Common\Persistence\Mapping\Driver;
use Doctrine\Common\Persistence\Mapping\MappingException;
/**
* Base driver for file-based metadata drivers.
*
* A file driver operates in a mode where it loads the mapping files of individual
* classes on demand. This requires the user to adhere to the convention of 1 mapping
* file per class and the file names of the mapping files must correspond to the full
* class name, including namespace, with the namespace delimiters '\', replaced by dots '.'.
*
* @link www.doctrine-project.org
* @since 2.2
* @author Benjamin Eberlei
* @author Guilherme Blanco
* @author Jonathan H. Wage
* @author Roman Borschel
*/
abstract class FileDriver implements MappingDriver
{
/**
* @var FileLocator
*/
protected $locator;
/**
* @var array|null
*/
protected $classCache;
/**
* @var string|null
*/
protected $globalBasename;
/**
* Initializes a new FileDriver that looks in the given path(s) for mapping
* documents and operates in the specified operating mode.
*
* @param string|array|FileLocator $locator A FileLocator or one/multiple paths
* where mapping documents can be found.
* @param string|null $fileExtension
*/
public function __construct($locator, $fileExtension = null)
{
if ($locator instanceof FileLocator) {
$this->locator = $locator;
} else {
$this->locator = new DefaultFileLocator((array)$locator, $fileExtension);
}
}
/**
* Sets the global basename.
*
* @param string $file
*
* @return void
*/
public function setGlobalBasename($file)
{
$this->globalBasename = $file;
}
/**
* Retrieves the global basename.
*
* @return string|null
*/
public function getGlobalBasename()
{
return $this->globalBasename;
}
/**
* Gets the element of schema meta data for the class from the mapping file.
* This will lazily load the mapping file if it is not loaded yet.
*
* @param string $className
*
* @return array The element of schema meta data.
*
* @throws MappingException
*/
public function getElement($className)
{
if ($this->classCache === null) {
$this->initialize();
}
if (isset($this->classCache[$className])) {
return $this->classCache[$className];
}
$result = $this->loadMappingFile($this->locator->findMappingFile($className));
if (!isset($result[$className])) {
throw MappingException::invalidMappingFile($className, str_replace('\\', '.', $className) . $this->locator->getFileExtension());
}
return $result[$className];
}
/**
* {@inheritDoc}
*/
public function isTransient($className)
{
if ($this->classCache === null) {
$this->initialize();
}
if (isset($this->classCache[$className])) {
return false;
}
return !$this->locator->fileExists($className);
}
/**
* {@inheritDoc}
*/
public function getAllClassNames()
{
if ($this->classCache === null) {
$this->initialize();
}
$classNames = (array)$this->locator->getAllClassNames($this->globalBasename);
if ($this->classCache) {
$classNames = array_merge(array_keys($this->classCache), $classNames);
}
return $classNames;
}
/**
* Loads a mapping file with the given name and returns a map
* from class/entity names to their corresponding file driver elements.
*
* @param string $file The mapping file to load.
*
* @return array
*/
abstract protected function loadMappingFile($file);
/**
* Initializes the class cache from all the global files.
*
* Using this feature adds a substantial performance hit to file drivers as
* more metadata has to be loaded into memory than might actually be
* necessary. This may not be relevant to scenarios where caching of
* metadata is in place, however hits very hard in scenarios where no
* caching is used.
*
* @return void
*/
protected function initialize()
{
$this->classCache = array();
if (null !== $this->globalBasename) {
foreach ($this->locator->getPaths() as $path) {
$file = $path.'/'.$this->globalBasename.$this->locator->getFileExtension();
if (is_file($file)) {
$this->classCache = array_merge(
$this->classCache,
$this->loadMappingFile($file)
);
}
}
}
}
/**
* Retrieves the locator used to discover mapping files by className.
*
* @return FileLocator
*/
public function getLocator()
{
return $this->locator;
}
/**
* Sets the locator used to discover mapping files by className.
*
* @param FileLocator $locator
*/
public function setLocator(FileLocator $locator)
{
$this->locator = $locator;
}
}
lib/Doctrine/Common/Persistence/Mapping/Driver/FileLocator.php 0000666 00000004446 13052402471 0020351 0 ustar 00 .
*/
namespace Doctrine\Common\Persistence\Mapping\Driver;
/**
* Locates the file that contains the metadata information for a given class name.
*
* This behavior is independent of the actual content of the file. It just detects
* the file which is responsible for the given class name.
*
* @author Benjamin Eberlei
* @author Johannes M. Schmitt
*/
interface FileLocator
{
/**
* Locates mapping file for the given class name.
*
* @param string $className
*
* @return string
*/
public function findMappingFile($className);
/**
* Gets all class names that are found with this file locator.
*
* @param string $globalBasename Passed to allow excluding the basename.
*
* @return array
*/
public function getAllClassNames($globalBasename);
/**
* Checks if a file can be found for this class name.
*
* @param string $className
*
* @return bool
*/
public function fileExists($className);
/**
* Gets all the paths that this file locator looks for mapping files.
*
* @return array
*/
public function getPaths();
/**
* Gets the file extension that mapping files are suffixed with.
*
* @return string
*/
public function getFileExtension();
}
lib/Doctrine/Common/Persistence/Mapping/Driver/MappingDriver.php 0000666 00000003763 13052402471 0020716 0 ustar 00 .
*/
namespace Doctrine\Common\Persistence\Mapping\Driver;
use Doctrine\Common\Persistence\Mapping\ClassMetadata;
/**
* Contract for metadata drivers.
*
* @since 2.2
* @author Jonathan H. Wage
*/
interface MappingDriver
{
/**
* Loads the metadata for the specified class into the provided container.
*
* @param string $className
* @param ClassMetadata $metadata
*
* @return void
*/
public function loadMetadataForClass($className, ClassMetadata $metadata);
/**
* Gets the names of all mapped classes known to this driver.
*
* @return array The names of all mapped classes known to this driver.
*/
public function getAllClassNames();
/**
* Returns whether the class with the specified name should have its metadata loaded.
* This is only the case if it is either mapped as an Entity or a MappedSuperclass.
*
* @param string $className
*
* @return boolean
*/
public function isTransient($className);
}
lib/Doctrine/Common/Persistence/Mapping/Driver/MappingDriverChain.php 0000666 00000011106 13052402471 0021647 0 ustar 00 .
*/
namespace Doctrine\Common\Persistence\Mapping\Driver;
use Doctrine\Common\Persistence\Mapping\Driver\MappingDriver;
use Doctrine\Common\Persistence\Mapping\ClassMetadata;
use Doctrine\Common\Persistence\Mapping\MappingException;
/**
* The DriverChain allows you to add multiple other mapping drivers for
* certain namespaces.
*
* @since 2.2
* @author Benjamin Eberlei
* @author Guilherme Blanco
* @author Jonathan H. Wage
* @author Roman Borschel
*/
class MappingDriverChain implements MappingDriver
{
/**
* The default driver.
*
* @var MappingDriver|null
*/
private $defaultDriver = null;
/**
* @var array
*/
private $drivers = array();
/**
* Gets the default driver.
*
* @return MappingDriver|null
*/
public function getDefaultDriver()
{
return $this->defaultDriver;
}
/**
* Set the default driver.
*
* @param MappingDriver $driver
*
* @return void
*/
public function setDefaultDriver(MappingDriver $driver)
{
$this->defaultDriver = $driver;
}
/**
* Adds a nested driver.
*
* @param MappingDriver $nestedDriver
* @param string $namespace
*
* @return void
*/
public function addDriver(MappingDriver $nestedDriver, $namespace)
{
$this->drivers[$namespace] = $nestedDriver;
}
/**
* Gets the array of nested drivers.
*
* @return array $drivers
*/
public function getDrivers()
{
return $this->drivers;
}
/**
* {@inheritDoc}
*/
public function loadMetadataForClass($className, ClassMetadata $metadata)
{
/* @var $driver MappingDriver */
foreach ($this->drivers as $namespace => $driver) {
if (strpos($className, $namespace) === 0) {
$driver->loadMetadataForClass($className, $metadata);
return;
}
}
if (null !== $this->defaultDriver) {
$this->defaultDriver->loadMetadataForClass($className, $metadata);
return;
}
throw MappingException::classNotFoundInNamespaces($className, array_keys($this->drivers));
}
/**
* {@inheritDoc}
*/
public function getAllClassNames()
{
$classNames = array();
$driverClasses = array();
/* @var $driver MappingDriver */
foreach ($this->drivers AS $namespace => $driver) {
$oid = spl_object_hash($driver);
if (!isset($driverClasses[$oid])) {
$driverClasses[$oid] = $driver->getAllClassNames();
}
foreach ($driverClasses[$oid] AS $className) {
if (strpos($className, $namespace) === 0) {
$classNames[$className] = true;
}
}
}
if (null !== $this->defaultDriver) {
foreach ($this->defaultDriver->getAllClassNames() as $className) {
$classNames[$className] = true;
}
}
return array_keys($classNames);
}
/**
* {@inheritDoc}
*/
public function isTransient($className)
{
/* @var $driver MappingDriver */
foreach ($this->drivers AS $namespace => $driver) {
if (strpos($className, $namespace) === 0) {
return $driver->isTransient($className);
}
}
if ($this->defaultDriver !== null) {
return $this->defaultDriver->isTransient($className);
}
return true;
}
}
lib/Doctrine/Common/Persistence/Mapping/Driver/PHPDriver.php 0000666 00000004275 13052402471 0017751 0 ustar 00 .
*/
namespace Doctrine\Common\Persistence\Mapping\Driver;
use Doctrine\Common\Persistence\Mapping\ClassMetadata;
/**
* The PHPDriver includes php files which just populate ClassMetadataInfo
* instances with plain PHP code.
*
* @link www.doctrine-project.org
* @since 2.0
* @author Benjamin Eberlei
* @author Guilherme Blanco
* @author Jonathan H. Wage
* @author Roman Borschel
*/
class PHPDriver extends FileDriver
{
/**
* {@inheritDoc}
*/
protected $metadata;
/**
* {@inheritDoc}
*/
public function __construct($locator, $fileExtension = null)
{
$fileExtension = ".php";
parent::__construct($locator, $fileExtension);
}
/**
* {@inheritDoc}
*/
public function loadMetadataForClass($className, ClassMetadata $metadata)
{
$this->metadata = $metadata;
$this->loadMappingFile($this->locator->findMappingFile($className));
}
/**
* {@inheritDoc}
*/
protected function loadMappingFile($file)
{
$metadata = $this->metadata;
include $file;
return array($metadata->getName() => $metadata);
}
}
lib/Doctrine/Common/Persistence/Mapping/Driver/StaticPHPDriver.php 0000666 00000010020 13052402471 0021102 0 ustar 00 .
*/
namespace Doctrine\Common\Persistence\Mapping\Driver;
use Doctrine\Common\Persistence\Mapping\ClassMetadata;
use Doctrine\Common\Persistence\Mapping\MappingException;
/**
* The StaticPHPDriver calls a static loadMetadata() method on your entity
* classes where you can manually populate the ClassMetadata instance.
*
* @link www.doctrine-project.org
* @since 2.2
* @author Benjamin Eberlei
* @author Guilherme Blanco
* @author Jonathan H. Wage
* @author Roman Borschel
*/
class StaticPHPDriver implements MappingDriver
{
/**
* Paths of entity directories.
*
* @var array
*/
private $paths = array();
/**
* Map of all class names.
*
* @var array
*/
private $classNames;
/**
* Constructor.
*
* @param array|string $paths
*/
public function __construct($paths)
{
$this->addPaths((array) $paths);
}
/**
* Adds paths.
*
* @param array $paths
*
* @return void
*/
public function addPaths(array $paths)
{
$this->paths = array_unique(array_merge($this->paths, $paths));
}
/**
* {@inheritdoc}
*/
public function loadMetadataForClass($className, ClassMetadata $metadata)
{
$className::loadMetadata($metadata);
}
/**
* {@inheritDoc}
* @todo Same code exists in AnnotationDriver, should we re-use it somehow or not worry about it?
*/
public function getAllClassNames()
{
if ($this->classNames !== null) {
return $this->classNames;
}
if (!$this->paths) {
throw MappingException::pathRequired();
}
$classes = array();
$includedFiles = array();
foreach ($this->paths as $path) {
if (!is_dir($path)) {
throw MappingException::fileMappingDriversRequireConfiguredDirectoryPath($path);
}
$iterator = new \RecursiveIteratorIterator(
new \RecursiveDirectoryIterator($path),
\RecursiveIteratorIterator::LEAVES_ONLY
);
foreach ($iterator as $file) {
if ($file->getBasename('.php') == $file->getBasename()) {
continue;
}
$sourceFile = realpath($file->getPathName());
require_once $sourceFile;
$includedFiles[] = $sourceFile;
}
}
$declared = get_declared_classes();
foreach ($declared as $className) {
$rc = new \ReflectionClass($className);
$sourceFile = $rc->getFileName();
if (in_array($sourceFile, $includedFiles) && !$this->isTransient($className)) {
$classes[] = $className;
}
}
$this->classNames = $classes;
return $classes;
}
/**
* {@inheritdoc}
*/
public function isTransient($className)
{
return ! method_exists($className, 'loadMetadata');
}
}
lib/Doctrine/Common/Persistence/Mapping/Driver/SymfonyFileLocator.php 0000666 00000014355 13052402471 0021736 0 ustar 00 .
*/
namespace Doctrine\Common\Persistence\Mapping\Driver;
use Doctrine\Common\Persistence\Mapping\MappingException;
/**
* The Symfony File Locator makes a simplifying assumptions compared
* to the DefaultFileLocator. By assuming paths only contain entities of a certain
* namespace the mapping files consists of the short classname only.
*
* @author Fabien Potencier
* @author Benjamin Eberlei
* @license MIT
*/
class SymfonyFileLocator implements FileLocator
{
/**
* The paths where to look for mapping files.
*
* @var array
*/
protected $paths = array();
/**
* A map of mapping directory path to namespace prefix used to expand class shortnames.
*
* @var array
*/
protected $prefixes = array();
/**
* File extension that is searched for.
*
* @var string|null
*/
protected $fileExtension;
/**
* Constructor.
*
* @param array $prefixes
* @param string|null $fileExtension
*/
public function __construct(array $prefixes, $fileExtension = null)
{
$this->addNamespacePrefixes($prefixes);
$this->fileExtension = $fileExtension;
}
/**
* Adds Namespace Prefixes.
*
* @param array $prefixes
*
* @return void
*/
public function addNamespacePrefixes(array $prefixes)
{
$this->prefixes = array_merge($this->prefixes, $prefixes);
$this->paths = array_merge($this->paths, array_keys($prefixes));
}
/**
* Gets Namespace Prefixes.
*
* @return array
*/
public function getNamespacePrefixes()
{
return $this->prefixes;
}
/**
* {@inheritDoc}
*/
public function getPaths()
{
return $this->paths;
}
/**
* {@inheritDoc}
*/
public function getFileExtension()
{
return $this->fileExtension;
}
/**
* Sets the file extension used to look for mapping files under.
*
* @param string $fileExtension The file extension to set.
*
* @return void
*/
public function setFileExtension($fileExtension)
{
$this->fileExtension = $fileExtension;
}
/**
* {@inheritDoc}
*/
public function fileExists($className)
{
$defaultFileName = str_replace('\\', '.', $className).$this->fileExtension;
foreach ($this->paths as $path) {
if (!isset($this->prefixes[$path])) {
// global namespace class
if (is_file($path.DIRECTORY_SEPARATOR.$defaultFileName)) {
return true;
}
continue;
}
$prefix = $this->prefixes[$path];
if (0 !== strpos($className, $prefix.'\\')) {
continue;
}
$filename = $path.'/'.strtr(substr($className, strlen($prefix)+1), '\\', '.').$this->fileExtension;
return is_file($filename);
}
return false;
}
/**
* {@inheritDoc}
*/
public function getAllClassNames($globalBasename = null)
{
$classes = array();
if ($this->paths) {
foreach ((array) $this->paths as $path) {
if (!is_dir($path)) {
throw MappingException::fileMappingDriversRequireConfiguredDirectoryPath($path);
}
$iterator = new \RecursiveIteratorIterator(
new \RecursiveDirectoryIterator($path),
\RecursiveIteratorIterator::LEAVES_ONLY
);
foreach ($iterator as $file) {
$fileName = $file->getBasename($this->fileExtension);
if ($fileName == $file->getBasename() || $fileName == $globalBasename) {
continue;
}
// NOTE: All files found here means classes are not transient!
if (isset($this->prefixes[$path])) {
$classes[] = $this->prefixes[$path].'\\'.str_replace('.', '\\', $fileName);
} else {
$classes[] = str_replace('.', '\\', $fileName);
}
}
}
}
return $classes;
}
/**
* {@inheritDoc}
*/
public function findMappingFile($className)
{
$defaultFileName = str_replace('\\', '.', $className).$this->fileExtension;
foreach ($this->paths as $path) {
if (!isset($this->prefixes[$path])) {
if (is_file($path.DIRECTORY_SEPARATOR.$defaultFileName)) {
return $path.DIRECTORY_SEPARATOR.$defaultFileName;
}
continue;
}
$prefix = $this->prefixes[$path];
if (0 !== strpos($className, $prefix.'\\')) {
continue;
}
$filename = $path.'/'.strtr(substr($className, strlen($prefix)+1), '\\', '.').$this->fileExtension;
if (is_file($filename)) {
return $filename;
}
throw MappingException::mappingFileNotFound($className, $filename);
}
throw MappingException::mappingFileNotFound($className, substr($className, strrpos($className, '\\') + 1).$this->fileExtension);
}
}
lib/Doctrine/Common/Persistence/Mapping/MappingException.php 0000666 00000006026 13052402471 0020161 0 ustar 00 .
*/
namespace Doctrine\Common\Persistence\Mapping;
/**
* A MappingException indicates that something is wrong with the mapping setup.
*
* @since 2.2
*/
class MappingException extends \Exception
{
/**
* @param string $className
* @param array $namespaces
*
* @return MappingException
*/
public static function classNotFoundInNamespaces($className, $namespaces)
{
return new self("The class '" . $className . "' was not found in the ".
"chain configured namespaces " . implode(", ", $namespaces));
}
/**
* @return MappingException
*/
public static function pathRequired()
{
return new self("Specifying the paths to your entities is required ".
"in the AnnotationDriver to retrieve all class names.");
}
/**
* @param string|null $path
*
* @return MappingException
*/
public static function fileMappingDriversRequireConfiguredDirectoryPath($path = null)
{
if ( ! empty($path)) {
$path = '[' . $path . ']';
}
return new self(
'File mapping drivers must have a valid directory path, ' .
'however the given path ' . $path . ' seems to be incorrect!'
);
}
/**
* @param string $entityName
* @param string $fileName
*
* @return MappingException
*/
public static function mappingFileNotFound($entityName, $fileName)
{
return new self("No mapping file found named '$fileName' for class '$entityName'.");
}
/**
* @param string $entityName
* @param string $fileName
*
* @return MappingException
*/
public static function invalidMappingFile($entityName, $fileName)
{
return new self("Invalid mapping file '$fileName' for class '$entityName'.");
}
/**
* @param string $className
*
* @return \Doctrine\Common\Persistence\Mapping\MappingException
*/
public static function nonExistingClass($className)
{
return new self("Class '$className' does not exist");
}
}
lib/Doctrine/Common/Persistence/Mapping/ReflectionService.php 0000666 00000004743 13052402471 0020326 0 ustar 00 .
*/
namespace Doctrine\Common\Persistence\Mapping;
/**
* Very simple reflection service abstraction.
*
* This is required inside metadata layers that may require either
* static or runtime reflection.
*
* @author Benjamin Eberlei
*/
interface ReflectionService
{
/**
* Returns an array of the parent classes (not interfaces) for the given class.
*
* @param string $class
*
* @throws \Doctrine\Common\Persistence\Mapping\MappingException
*
* @return array
*/
public function getParentClasses($class);
/**
* Returns the shortname of a class.
*
* @param string $class
*
* @return string
*/
public function getClassShortName($class);
/**
* @param string $class
*
* @return string
*/
public function getClassNamespace($class);
/**
* Returns a reflection class instance or null.
*
* @param string $class
*
* @return \ReflectionClass|null
*/
public function getClass($class);
/**
* Returns an accessible property (setAccessible(true)) or null.
*
* @param string $class
* @param string $property
*
* @return \ReflectionProperty|null
*/
public function getAccessibleProperty($class, $property);
/**
* Checks if the class have a public method with the given name.
*
* @param mixed $class
* @param mixed $method
*
* @return bool
*/
public function hasPublicMethod($class, $method);
}
lib/Doctrine/Common/Persistence/Mapping/RuntimeReflectionService.php 0000666 00000005562 13052402471 0021672 0 ustar 00 .
*/
namespace Doctrine\Common\Persistence\Mapping;
use ReflectionClass;
use ReflectionProperty;
use ReflectionMethod;
use ReflectionException;
use Doctrine\Common\Reflection\RuntimePublicReflectionProperty;
use Doctrine\Common\Persistence\Mapping\MappingException;
/**
* PHP Runtime Reflection Service.
*
* @author Benjamin Eberlei
*/
class RuntimeReflectionService implements ReflectionService
{
/**
* {@inheritDoc}
*/
public function getParentClasses($class)
{
if ( ! class_exists($class)) {
throw MappingException::nonExistingClass($class);
}
return class_parents($class);
}
/**
* {@inheritDoc}
*/
public function getClassShortName($class)
{
$reflectionClass = new ReflectionClass($class);
return $reflectionClass->getShortName();
}
/**
* {@inheritDoc}
*/
public function getClassNamespace($class)
{
$reflectionClass = new ReflectionClass($class);
return $reflectionClass->getNamespaceName();
}
/**
* {@inheritDoc}
*/
public function getClass($class)
{
return new ReflectionClass($class);
}
/**
* {@inheritDoc}
*/
public function getAccessibleProperty($class, $property)
{
$reflectionProperty = new ReflectionProperty($class, $property);
if ($reflectionProperty->isPublic()) {
$reflectionProperty = new RuntimePublicReflectionProperty($class, $property);
}
$reflectionProperty->setAccessible(true);
return $reflectionProperty;
}
/**
* {@inheritDoc}
*/
public function hasPublicMethod($class, $method)
{
try {
$reflectionMethod = new ReflectionMethod($class, $method);
} catch (ReflectionException $e) {
return false;
}
return $reflectionMethod->isPublic();
}
}
lib/Doctrine/Common/Persistence/Mapping/StaticReflectionService.php 0000666 00000004312 13052402471 0021466 0 ustar 00 .
*/
namespace Doctrine\Common\Persistence\Mapping;
/**
* PHP Runtime Reflection Service.
*
* @author Benjamin Eberlei
*/
class StaticReflectionService implements ReflectionService
{
/**
* {@inheritDoc}
*/
public function getParentClasses($class)
{
return array();
}
/**
* {@inheritDoc}
*/
public function getClassShortName($className)
{
if (strpos($className, '\\') !== false) {
$className = substr($className, strrpos($className, "\\")+1);
}
return $className;
}
/**
* {@inheritDoc}
*/
public function getClassNamespace($className)
{
$namespace = '';
if (strpos($className, '\\') !== false) {
$namespace = strrev(substr( strrev($className), strpos(strrev($className), '\\')+1 ));
}
return $namespace;
}
/**
* {@inheritDoc}
*/
public function getClass($class)
{
return null;
}
/**
* {@inheritDoc}
*/
public function getAccessibleProperty($class, $property)
{
return null;
}
/**
* {@inheritDoc}
*/
public function hasPublicMethod($class, $method)
{
return true;
}
}
lib/Doctrine/Common/Persistence/ObjectManager.php 0000666 00000012456 13052402471 0016021 0 ustar 00 .
*/
namespace Doctrine\Common\Persistence;
/**
* Contract for a Doctrine persistence layer ObjectManager class to implement.
*
* @link www.doctrine-project.org
* @since 2.1
* @author Benjamin Eberlei
* @author Jonathan Wage
*/
interface ObjectManager
{
/**
* Finds an object by its identifier.
*
* This is just a convenient shortcut for getRepository($className)->find($id).
*
* @param string $className The class name of the object to find.
* @param mixed $id The identity of the object to find.
*
* @return object The found object.
*/
public function find($className, $id);
/**
* Tells the ObjectManager to make an instance managed and persistent.
*
* The object will be entered into the database as a result of the flush operation.
*
* NOTE: The persist operation always considers objects that are not yet known to
* this ObjectManager as NEW. Do not pass detached objects to the persist operation.
*
* @param object $object The instance to make managed and persistent.
*
* @return void
*/
public function persist($object);
/**
* Removes an object instance.
*
* A removed object will be removed from the database as a result of the flush operation.
*
* @param object $object The object instance to remove.
*
* @return void
*/
public function remove($object);
/**
* Merges the state of a detached object into the persistence context
* of this ObjectManager and returns the managed copy of the object.
* The object passed to merge will not become associated/managed with this ObjectManager.
*
* @param object $object
*
* @return object
*/
public function merge($object);
/**
* Clears the ObjectManager. All objects that are currently managed
* by this ObjectManager become detached.
*
* @param string|null $objectName if given, only objects of this type will get detached.
*
* @return void
*/
public function clear($objectName = null);
/**
* Detaches an object from the ObjectManager, causing a managed object to
* become detached. Unflushed changes made to the object if any
* (including removal of the object), will not be synchronized to the database.
* Objects which previously referenced the detached object will continue to
* reference it.
*
* @param object $object The object to detach.
*
* @return void
*/
public function detach($object);
/**
* Refreshes the persistent state of an object from the database,
* overriding any local changes that have not yet been persisted.
*
* @param object $object The object to refresh.
*
* @return void
*/
public function refresh($object);
/**
* Flushes all changes to objects that have been queued up to now to the database.
* This effectively synchronizes the in-memory state of managed objects with the
* database.
*
* @return void
*/
public function flush();
/**
* Gets the repository for a class.
*
* @param string $className
*
* @return \Doctrine\Common\Persistence\ObjectRepository
*/
public function getRepository($className);
/**
* Returns the ClassMetadata descriptor for a class.
*
* The class name must be the fully-qualified class name without a leading backslash
* (as it is returned by get_class($obj)).
*
* @param string $className
*
* @return \Doctrine\Common\Persistence\Mapping\ClassMetadata
*/
public function getClassMetadata($className);
/**
* Gets the metadata factory used to gather the metadata of classes.
*
* @return \Doctrine\Common\Persistence\Mapping\ClassMetadataFactory
*/
public function getMetadataFactory();
/**
* Helper method to initialize a lazy loading proxy or persistent collection.
*
* This method is a no-op for other objects.
*
* @param object $obj
*
* @return void
*/
public function initializeObject($obj);
/**
* Checks if the object is part of the current UnitOfWork and therefore managed.
*
* @param object $object
*
* @return bool
*/
public function contains($object);
}
lib/Doctrine/Common/Persistence/ObjectManagerAware.php 0000666 00000004163 13052402471 0016775 0 ustar 00 .
*/
namespace Doctrine\Common\Persistence;
use Doctrine\Common\Persistence\Mapping\ClassMetadata;
/**
* Makes a Persistent Objects aware of its own object-manager.
*
* Using this interface the managing object manager and class metadata instances
* are injected into the persistent object after construction. This allows
* you to implement ActiveRecord functionality on top of the persistence-ignorance
* that Doctrine propagates.
*
* Word of Warning: This is a very powerful hook to change how you can work with your domain models.
* Using this hook will break the Single Responsibility Principle inside your Domain Objects
* and increase the coupling of database and objects.
*
* Every ObjectManager has to implement this functionality itself.
*
* @author Benjamin Eberlei
*/
interface ObjectManagerAware
{
/**
* Injects responsible ObjectManager and the ClassMetadata into this persistent object.
*
* @param ObjectManager $objectManager
* @param ClassMetadata $classMetadata
*
* @return void
*/
public function injectObjectManager(ObjectManager $objectManager, ClassMetadata $classMetadata);
}
lib/Doctrine/Common/Persistence/ObjectManagerDecorator.php 0000666 00000006177 13052402471 0017667 0 ustar 00 .
*/
namespace Doctrine\Common\Persistence;
/**
* Base class to simplify ObjectManager decorators
*
* @license http://opensource.org/licenses/MIT MIT
* @link www.doctrine-project.org
* @since 2.4
* @author Lars Strojny
*/
abstract class ObjectManagerDecorator implements ObjectManager
{
/**
* @var ObjectManager
*/
protected $wrapped;
/**
* {@inheritdoc}
*/
public function find($className, $id)
{
return $this->wrapped->find($className, $id);
}
/**
* {@inheritdoc}
*/
public function persist($object)
{
return $this->wrapped->persist($object);
}
/**
* {@inheritdoc}
*/
public function remove($object)
{
return $this->wrapped->remove($object);
}
/**
* {@inheritdoc}
*/
public function merge($object)
{
return $this->wrapped->merge($object);
}
/**
* {@inheritdoc}
*/
public function clear($objectName = null)
{
return $this->wrapped->clear($objectName);
}
/**
* {@inheritdoc}
*/
public function detach($object)
{
return $this->wrapped->detach($object);
}
/**
* {@inheritdoc}
*/
public function refresh($object)
{
return $this->wrapped->refresh($object);
}
/**
* {@inheritdoc}
*/
public function flush()
{
return $this->wrapped->flush();
}
/**
* {@inheritdoc}
*/
public function getRepository($className)
{
return $this->wrapped->getRepository($className);
}
/**
* {@inheritdoc}
*/
public function getClassMetadata($className)
{
return $this->wrapped->getClassMetadata($className);
}
/**
* {@inheritdoc}
*/
public function getMetadataFactory()
{
return $this->wrapped->getMetadataFactory();
}
/**
* {@inheritdoc}
*/
public function initializeObject($obj)
{
return $this->wrapped->initializeObject($obj);
}
/**
* {@inheritdoc}
*/
public function contains($object)
{
return $this->wrapped->contains($object);
}
}
lib/Doctrine/Common/Persistence/ObjectRepository.php 0000666 00000005030 13052402471 0016614 0 ustar 00 .
*/
namespace Doctrine\Common\Persistence;
/**
* Contract for a Doctrine persistence layer ObjectRepository class to implement.
*
* @link www.doctrine-project.org
* @since 2.1
* @author Benjamin Eberlei
* @author Jonathan Wage
*/
interface ObjectRepository
{
/**
* Finds an object by its primary key / identifier.
*
* @param mixed $id The identifier.
*
* @return object The object.
*/
public function find($id);
/**
* Finds all objects in the repository.
*
* @return array The objects.
*/
public function findAll();
/**
* Finds objects by a set of criteria.
*
* Optionally sorting and limiting details can be passed. An implementation may throw
* an UnexpectedValueException if certain values of the sorting or limiting details are
* not supported.
*
* @param array $criteria
* @param array|null $orderBy
* @param int|null $limit
* @param int|null $offset
*
* @return array The objects.
*
* @throws \UnexpectedValueException
*/
public function findBy(array $criteria, array $orderBy = null, $limit = null, $offset = null);
/**
* Finds a single object by a set of criteria.
*
* @param array $criteria The criteria.
*
* @return object The object.
*/
public function findOneBy(array $criteria);
/**
* Returns the class name of the object managed by the repository.
*
* @return string
*/
public function getClassName();
}
lib/Doctrine/Common/Persistence/PersistentObject.php 0000666 00000020770 13052402471 0016605 0 ustar 00 .
*/
namespace Doctrine\Common\Persistence;
use Doctrine\Common\Persistence\Mapping\ClassMetadata;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
/**
* PersistentObject base class that implements getter/setter methods for all mapped fields and associations
* by overriding __call.
*
* This class is a forward compatible implementation of the PersistentObject trait.
*
* Limitations:
*
* 1. All persistent objects have to be associated with a single ObjectManager, multiple
* ObjectManagers are not supported. You can set the ObjectManager with `PersistentObject#setObjectManager()`.
* 2. Setters and getters only work if a ClassMetadata instance was injected into the PersistentObject.
* This is either done on `postLoad` of an object or by accessing the global object manager.
* 3. There are no hooks for setters/getters. Just implement the method yourself instead of relying on __call().
* 4. Slower than handcoded implementations: An average of 7 method calls per access to a field and 11 for an association.
* 5. Only the inverse side associations get autoset on the owning side as well. Setting objects on the owning side
* will not set the inverse side associations.
*
* @example
*
* PersistentObject::setObjectManager($em);
*
* class Foo extends PersistentObject
* {
* private $id;
* }
*
* $foo = new Foo();
* $foo->getId(); // method exists through __call
*
* @author Benjamin Eberlei
*/
abstract class PersistentObject implements ObjectManagerAware
{
/**
* @var ObjectManager|null
*/
private static $objectManager = null;
/**
* @var ClassMetadata|null
*/
private $cm = null;
/**
* Sets the object manager responsible for all persistent object base classes.
*
* @param ObjectManager|null $objectManager
*
* @return void
*/
static public function setObjectManager(ObjectManager $objectManager = null)
{
self::$objectManager = $objectManager;
}
/**
* @return ObjectManager|null
*/
static public function getObjectManager()
{
return self::$objectManager;
}
/**
* Injects the Doctrine Object Manager.
*
* @param ObjectManager $objectManager
* @param ClassMetadata $classMetadata
*
* @return void
*
* @throws \RuntimeException
*/
public function injectObjectManager(ObjectManager $objectManager, ClassMetadata $classMetadata)
{
if ($objectManager !== self::$objectManager) {
throw new \RuntimeException("Trying to use PersistentObject with different ObjectManager instances. " .
"Was PersistentObject::setObjectManager() called?");
}
$this->cm = $classMetadata;
}
/**
* Sets a persistent fields value.
*
* @param string $field
* @param array $args
*
* @return void
*
* @throws \BadMethodCallException When no persistent field exists by that name.
* @throws \InvalidArgumentException When the wrong target object type is passed to an association.
*/
private function set($field, $args)
{
$this->initializeDoctrine();
if ($this->cm->hasField($field) && !$this->cm->isIdentifier($field)) {
$this->$field = $args[0];
} else if ($this->cm->hasAssociation($field) && $this->cm->isSingleValuedAssociation($field)) {
$targetClass = $this->cm->getAssociationTargetClass($field);
if (!($args[0] instanceof $targetClass) && $args[0] !== null) {
throw new \InvalidArgumentException("Expected persistent object of type '".$targetClass."'");
}
$this->$field = $args[0];
$this->completeOwningSide($field, $targetClass, $args[0]);
} else {
throw new \BadMethodCallException("no field with name '".$field."' exists on '".$this->cm->getName()."'");
}
}
/**
* Gets a persistent field value.
*
* @param string $field
*
* @return mixed
*
* @throws \BadMethodCallException When no persistent field exists by that name.
*/
private function get($field)
{
$this->initializeDoctrine();
if ( $this->cm->hasField($field) || $this->cm->hasAssociation($field) ) {
return $this->$field;
} else {
throw new \BadMethodCallException("no field with name '".$field."' exists on '".$this->cm->getName()."'");
}
}
/**
* If this is an inverse side association, completes the owning side.
*
* @param string $field
* @param ClassMetadata $targetClass
* @param object $targetObject
*
* @return void
*/
private function completeOwningSide($field, $targetClass, $targetObject)
{
// add this object on the owning side as well, for obvious infinite recursion
// reasons this is only done when called on the inverse side.
if ($this->cm->isAssociationInverseSide($field)) {
$mappedByField = $this->cm->getAssociationMappedByTargetField($field);
$targetMetadata = self::$objectManager->getClassMetadata($targetClass);
$setter = ($targetMetadata->isCollectionValuedAssociation($mappedByField) ? "add" : "set").$mappedByField;
$targetObject->$setter($this);
}
}
/**
* Adds an object to a collection.
*
* @param string $field
* @param array $args
*
* @return void
*
* @throws \BadMethodCallException
* @throws \InvalidArgumentException
*/
private function add($field, $args)
{
$this->initializeDoctrine();
if ($this->cm->hasAssociation($field) && $this->cm->isCollectionValuedAssociation($field)) {
$targetClass = $this->cm->getAssociationTargetClass($field);
if (!($args[0] instanceof $targetClass)) {
throw new \InvalidArgumentException("Expected persistent object of type '".$targetClass."'");
}
if (!($this->$field instanceof Collection)) {
$this->$field = new ArrayCollection($this->$field ?: array());
}
$this->$field->add($args[0]);
$this->completeOwningSide($field, $targetClass, $args[0]);
} else {
throw new \BadMethodCallException("There is no method add".$field."() on ".$this->cm->getName());
}
}
/**
* Initializes Doctrine Metadata for this class.
*
* @return void
*
* @throws \RuntimeException
*/
private function initializeDoctrine()
{
if ($this->cm !== null) {
return;
}
if (!self::$objectManager) {
throw new \RuntimeException("No runtime object manager set. Call PersistentObject#setObjectManager().");
}
$this->cm = self::$objectManager->getClassMetadata(get_class($this));
}
/**
* Magic methods.
*
* @param string $method
* @param array $args
*
* @return mixed
*
* @throws \BadMethodCallException
*/
public function __call($method, $args)
{
$command = substr($method, 0, 3);
$field = lcfirst(substr($method, 3));
if ($command == "set") {
$this->set($field, $args);
} else if ($command == "get") {
return $this->get($field);
} else if ($command == "add") {
$this->add($field, $args);
} else {
throw new \BadMethodCallException("There is no method ".$method." on ".$this->cm->getName());
}
}
}
lib/Doctrine/Common/Persistence/Proxy.php 0000666 00000003244 13052402471 0014434 0 ustar 00 .
*/
namespace Doctrine\Common\Persistence;
/**
* Interface for proxy classes.
*
* @author Roman Borschel
* @since 2.2
*/
interface Proxy
{
/**
* Marker for Proxy class names.
*
* @var string
*/
const MARKER = '__CG__';
/**
* Length of the proxy marker.
*
* @var integer
*/
const MARKER_LENGTH = 6;
/**
* Initializes this proxy if its not yet initialized.
*
* Acts as a no-op if already initialized.
*
* @return void
*/
public function __load();
/**
* Returns whether this proxy is initialized or not.
*
* @return bool
*/
public function __isInitialized();
}
lib/Doctrine/Common/PropertyChangedListener.php 0000666 00000003506 13052402471 0015634 0 ustar 00 .
*/
namespace Doctrine\Common;
/**
* Contract for classes that are potential listeners of a NotifyPropertyChanged
* implementor.
*
* @link www.doctrine-project.org
* @since 2.0
* @author Guilherme Blanco
* @author Jonathan Wage
* @author Roman Borschel
*/
interface PropertyChangedListener
{
/**
* Notifies the listener of a property change.
*
* @param object $sender The object on which the property changed.
* @param string $propertyName The name of the property that changed.
* @param mixed $oldValue The old value of the property that changed.
* @param mixed $newValue The new value of the property that changed.
*
* @return void
*/
function propertyChanged($sender, $propertyName, $oldValue, $newValue);
}
lib/Doctrine/Common/Proxy/AbstractProxyFactory.php 0000666 00000020061 13052402471 0016301 0 ustar 00 .
*/
namespace Doctrine\Common\Proxy;
use Doctrine\Common\Persistence\Mapping\ClassMetadataFactory;
use Doctrine\Common\Proxy\Exception\InvalidArgumentException;
use Doctrine\Common\Proxy\Exception\OutOfBoundsException;
use Doctrine\Common\Util\ClassUtils;
use Doctrine\Common\Persistence\Mapping\ClassMetadata;
/**
* Abstract factory for proxy objects.
*
* @author Benjamin Eberlei
*/
abstract class AbstractProxyFactory
{
/**
* Never autogenerate a proxy and rely that it was generated by some
* process before deployment.
*
* @var integer
*/
const AUTOGENERATE_NEVER = 0;
/**
* Always generates a new proxy in every request.
*
* This is only sane during development.
*
* @var integer
*/
const AUTOGENERATE_ALWAYS = 1;
/**
* Autogenerate the proxy class when the proxy file does not exist.
*
* This strategy causes a file exists call whenever any proxy is used the
* first time in a request.
*
* @var integer
*/
const AUTOGENERATE_FILE_NOT_EXISTS = 2;
/**
* Generate the proxy classes using eval().
*
* This strategy is only sane for development, and even then it gives me
* the creeps a little.
*
* @var integer
*/
const AUTOGENERATE_EVAL = 3;
/**
* @var \Doctrine\Common\Persistence\Mapping\ClassMetadataFactory
*/
private $metadataFactory;
/**
* @var \Doctrine\Common\Proxy\ProxyGenerator the proxy generator responsible for creating the proxy classes/files.
*/
private $proxyGenerator;
/**
* @var bool Whether to automatically (re)generate proxy classes.
*/
private $autoGenerate;
/**
* @var \Doctrine\Common\Proxy\ProxyDefinition[]
*/
private $definitions = array();
/**
* @param \Doctrine\Common\Proxy\ProxyGenerator $proxyGenerator
* @param \Doctrine\Common\Persistence\Mapping\ClassMetadataFactory $metadataFactory
* @param bool|int $autoGenerate
*/
public function __construct(ProxyGenerator $proxyGenerator, ClassMetadataFactory $metadataFactory, $autoGenerate)
{
$this->proxyGenerator = $proxyGenerator;
$this->metadataFactory = $metadataFactory;
$this->autoGenerate = (int)$autoGenerate;
}
/**
* Gets a reference proxy instance for the entity of the given type and identified by
* the given identifier.
*
* @param string $className
* @param array $identifier
*
* @return \Doctrine\Common\Proxy\Proxy
*
* @throws \Doctrine\Common\Proxy\Exception\OutOfBoundsException
*/
public function getProxy($className, array $identifier)
{
$definition = isset($this->definitions[$className])
? $this->definitions[$className]
: $this->getProxyDefinition($className);
$fqcn = $definition->proxyClassName;
$proxy = new $fqcn($definition->initializer, $definition->cloner);
foreach ($definition->identifierFields as $idField) {
if (! isset($identifier[$idField])) {
throw OutOfBoundsException::missingPrimaryKeyValue($className, $idField);
}
$definition->reflectionFields[$idField]->setValue($proxy, $identifier[$idField]);
}
return $proxy;
}
/**
* Generates proxy classes for all given classes.
*
* @param \Doctrine\Common\Persistence\Mapping\ClassMetadata[] $classes The classes (ClassMetadata instances)
* for which to generate proxies.
* @param string $proxyDir 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.
* @return int Number of generated proxies.
*/
public function generateProxyClasses(array $classes, $proxyDir = null)
{
$generated = 0;
foreach ($classes as $class) {
if ($this->skipClass($class)) {
continue;
}
$proxyFileName = $this->proxyGenerator->getProxyFileName($class->getName(), $proxyDir);
$this->proxyGenerator->generateProxyClass($class, $proxyFileName);
$generated += 1;
}
return $generated;
}
/**
* Reset initialization/cloning logic for an un-initialized proxy
*
* @param \Doctrine\Common\Proxy\Proxy $proxy
*
* @return \Doctrine\Common\Proxy\Proxy
*
* @throws \Doctrine\Common\Proxy\Exception\InvalidArgumentException
*/
public function resetUninitializedProxy(Proxy $proxy)
{
if ($proxy->__isInitialized()) {
throw InvalidArgumentException::unitializedProxyExpected($proxy);
}
$className = ClassUtils::getClass($proxy);
$definition = isset($this->definitions[$className])
? $this->definitions[$className]
: $this->getProxyDefinition($className);
$proxy->__setInitializer($definition->initializer);
$proxy->__setCloner($definition->cloner);
return $proxy;
}
/**
* Get a proxy definition for the given class name.
*
* @return ProxyDefinition
*/
private function getProxyDefinition($className)
{
$classMetadata = $this->metadataFactory->getMetadataFor($className);
$className = $classMetadata->getName(); // aliases and case sensitivity
$this->definitions[$className] = $this->createProxyDefinition($className);
$proxyClassName = $this->definitions[$className]->proxyClassName;
if ( ! class_exists($proxyClassName, false)) {
$fileName = $this->proxyGenerator->getProxyFileName($className);
switch ($this->autoGenerate) {
case self::AUTOGENERATE_NEVER:
require $fileName;
break;
case self::AUTOGENERATE_FILE_NOT_EXISTS:
if ( ! file_exists($fileName)) {
$this->proxyGenerator->generateProxyClass($classMetadata, $fileName);
}
require $fileName;
break;
case self::AUTOGENERATE_ALWAYS:
$this->proxyGenerator->generateProxyClass($classMetadata, $fileName);
require $fileName;
break;
case self::AUTOGENERATE_EVAL:
$this->proxyGenerator->generateProxyClass($classMetadata, false);
break;
}
}
return $this->definitions[$className];
}
/**
* Determine if this class should be skipped during proxy generation.
*
* @param \Doctrine\Common\Persistence\Mapping\ClassMetadata $metadata
* @return bool
*/
abstract protected function skipClass(ClassMetadata $metadata);
/**
* @return ProxyDefinition
*/
abstract protected function createProxyDefinition($className);
}
lib/Doctrine/Common/Proxy/Autoloader.php 0000666 00000006466 13052402471 0014260 0 ustar 00 .
*/
namespace Doctrine\Common\Proxy;
use Doctrine\Common\Proxy\Exception\InvalidArgumentException;
/**
* Special Autoloader for Proxy classes, which are not PSR-0 compliant.
*
* @author Benjamin Eberlei
*/
class Autoloader
{
/**
* Resolves proxy class name to a filename based on the following pattern.
*
* 1. Remove Proxy namespace from class name.
* 2. Remove namespace separators from remaining class name.
* 3. Return PHP filename from proxy-dir with the result from 2.
*
* @param string $proxyDir
* @param string $proxyNamespace
* @param string $className
*
* @return string
*
* @throws InvalidArgumentException
*/
public static function resolveFile($proxyDir, $proxyNamespace, $className)
{
if (0 !== strpos($className, $proxyNamespace)) {
throw InvalidArgumentException::notProxyClass($className, $proxyNamespace);
}
$className = str_replace('\\', '', substr($className, strlen($proxyNamespace) + 1));
return $proxyDir . DIRECTORY_SEPARATOR . $className . '.php';
}
/**
* Registers and returns autoloader callback for the given proxy dir and namespace.
*
* @param string $proxyDir
* @param string $proxyNamespace
* @param callable|null $notFoundCallback Invoked when the proxy file is not found.
*
* @return \Closure
*
* @throws InvalidArgumentException
*/
public static function register($proxyDir, $proxyNamespace, $notFoundCallback = null)
{
$proxyNamespace = ltrim($proxyNamespace, '\\');
if ( ! (null === $notFoundCallback || is_callable($notFoundCallback))) {
throw InvalidArgumentException::invalidClassNotFoundCallback($notFoundCallback);
}
$autoloader = function ($className) use ($proxyDir, $proxyNamespace, $notFoundCallback) {
if (0 === strpos($className, $proxyNamespace)) {
$file = Autoloader::resolveFile($proxyDir, $proxyNamespace, $className);
if ($notFoundCallback && ! file_exists($file)) {
call_user_func($notFoundCallback, $proxyDir, $proxyNamespace, $className);
}
require $file;
}
};
spl_autoload_register($autoloader);
return $autoloader;
}
}
lib/Doctrine/Common/Proxy/Exception/InvalidArgumentException.php 0000666 00000005466 13052402471 0021066 0 ustar 00 .
*/
namespace Doctrine\Common\Proxy\Exception;
use Doctrine\Common\Persistence\Proxy;
use InvalidArgumentException as BaseInvalidArgumentException;
/**
* Proxy Invalid Argument Exception.
*
* @link www.doctrine-project.org
* @since 2.4
* @author Marco Pivetta
*/
class InvalidArgumentException extends BaseInvalidArgumentException implements ProxyException
{
/**
* @return self
*/
public static function proxyDirectoryRequired()
{
return new self('You must configure a proxy directory. See docs for details');
}
/**
* @param string $className
* @param string $proxyNamespace
*
* @return self
*/
public static function notProxyClass($className, $proxyNamespace)
{
return new self(sprintf('The class "%s" is not part of the proxy namespace "%s"', $className, $proxyNamespace));
}
/**
* @param string $name
*
* @return self
*/
public static function invalidPlaceholder($name)
{
return new self(sprintf('Provided placeholder for "%s" must be either a string or a valid callable', $name));
}
/**
* @return self
*/
public static function proxyNamespaceRequired()
{
return new self('You must configure a proxy namespace');
}
/**
* @return self
*/
public static function unitializedProxyExpected(Proxy $proxy)
{
return new self(sprintf('Provided proxy of type "%s" must not be initialized.', get_class($proxy)));
}
/**
* @param mixed $callback
*
* @return self
*/
public static function invalidClassNotFoundCallback($callback)
{
$type = is_object($callback) ? get_class($callback) : gettype($callback);
return new self(sprintf('Invalid \$notFoundCallback given: must be a callable, "%s" given', $type));
}
}
lib/Doctrine/Common/Proxy/Exception/OutOfBoundsException.php 0000666 00000003160 13052402471 0020171 0 ustar 00 .
*/
namespace Doctrine\Common\Proxy\Exception;
use Doctrine\Common\Persistence\Proxy;
use OutOfBoundsException as BaseOutOfBoundsException;
/**
* Proxy Invalid Argument Exception.
*
* @link www.doctrine-project.org
* @author Fredrik Wendel
*/
class OutOfBoundsException extends BaseOutOfBoundsException implements ProxyException
{
/**
* @param string $className
* @param string $idField
*
* @return self
*/
public static function missingPrimaryKeyValue($className, $idField)
{
return new self(sprintf("Missing value for primary key %s on %s", $idField, $className));
}
}
lib/Doctrine/Common/Proxy/Exception/ProxyException.php 0000666 00000002304 13052402471 0017102 0 ustar 00 .
*/
namespace Doctrine\Common\Proxy\Exception;
/**
* Base exception interface for proxy exceptions.
*
* @link www.doctrine-project.org
* @since 2.4
* @author Marco Pivetta
*/
interface ProxyException
{
}
lib/Doctrine/Common/Proxy/Exception/UnexpectedValueException.php 0000666 00000004162 13052402471 0021066 0 ustar 00 .
*/
namespace Doctrine\Common\Proxy\Exception;
use UnexpectedValueException as BaseUnexpectedValueException;
/**
* Proxy Unexpected Value Exception.
*
* @link www.doctrine-project.org
* @since 2.4
* @author Marco Pivetta
*/
class UnexpectedValueException extends BaseUnexpectedValueException implements ProxyException
{
/**
* @return self
*/
public static function proxyDirectoryNotWritable($proxyDirectory)
{
return new self(sprintf('Your proxy directory "%s" must be writable', $proxyDirectory));
}
/**
* @param string $className
* @param string $methodName
* @param string $parameterName
* @param \Exception $previous
*
* @return self
*/
public static function invalidParameterTypeHint($className, $methodName, $parameterName, \Exception $previous)
{
return new self(
sprintf(
'The type hint of parameter "%s" in method "%s" in class "%s" is invalid.',
$parameterName,
$methodName,
$className
),
0,
$previous
);
}
}
lib/Doctrine/Common/Proxy/Proxy.php 0000666 00000005526 13052402471 0013276 0 ustar 00 .
*/
namespace Doctrine\Common\Proxy;
use Doctrine\Common\Persistence\Proxy as BaseProxy;
use Closure;
/**
* Interface for proxy classes.
*
* @author Roman Borschel
* @author Marco Pivetta
* @since 2.4
*/
interface Proxy extends BaseProxy
{
/**
* Marks the proxy as initialized or not.
*
* @param boolean $initialized
*
* @return void
*/
public function __setInitialized($initialized);
/**
* Sets the initializer callback to be used when initializing the proxy. That
* initializer should accept 3 parameters: $proxy, $method and $params. Those
* are respectively the proxy object that is being initialized, the method name
* that triggered initialization and the parameters passed to that method.
*
* @param Closure|null $initializer
*
* @return void
*/
public function __setInitializer(Closure $initializer = null);
/**
* Retrieves the initializer callback used to initialize the proxy.
*
* @see __setInitializer
*
* @return Closure|null
*/
public function __getInitializer();
/**
* Sets the callback to be used when cloning the proxy. That initializer should accept
* a single parameter, which is the cloned proxy instance itself.
*
* @param Closure|null $cloner
*
* @return void
*/
public function __setCloner(Closure $cloner = null);
/**
* Retrieves the callback to be used when cloning the proxy.
*
* @see __setCloner
*
* @return Closure|null
*/
public function __getCloner();
/**
* Retrieves the list of lazy loaded properties for a given proxy
*
* @return array Keys are the property names, and values are the default values
* for those properties.
*/
public function __getLazyProperties();
}
lib/Doctrine/Common/Proxy/ProxyDefinition.php 0000666 00000004033 13052402471 0015277 0 ustar 00 .
*/
namespace Doctrine\Common\Proxy;
/**
* Definition structure how to create a proxy.
*
* @author Benjamin Eberlei
*/
class ProxyDefinition
{
/**
* @var string
*/
public $proxyClassName;
/**
* @var array
*/
public $identifierFields;
/**
* @var \ReflectionProperty[]
*/
public $reflectionFields;
/**
* @var callable
*/
public $initializer;
/**
* @var callable
*/
public $cloner;
/**
* @param string $proxyClassName
* @param array $identifierFields
* @param array $reflectionFields
* @param callable $initializer
* @param callable $cloner
*/
public function __construct($proxyClassName, array $identifierFields, array $reflectionFields, $initializer, $cloner)
{
$this->proxyClassName = $proxyClassName;
$this->identifierFields = $identifierFields;
$this->reflectionFields = $reflectionFields;
$this->initializer = $initializer;
$this->cloner = $cloner;
}
}
lib/Doctrine/Common/Proxy/ProxyGenerator.php 0000666 00000070136 13052402471 0015144 0 ustar 00 .
*/
namespace Doctrine\Common\Proxy;
use Doctrine\Common\Persistence\Mapping\ClassMetadata;
use Doctrine\Common\Util\ClassUtils;
use Doctrine\Common\Proxy\Exception\InvalidArgumentException;
use Doctrine\Common\Proxy\Exception\UnexpectedValueException;
/**
* This factory is used to generate proxy classes.
* It builds proxies from given parameters, a template and class metadata.
*
* @author Marco Pivetta
* @since 2.4
*/
class ProxyGenerator
{
/**
* Used to match very simple id methods that don't need
* to be decorated since the identifier is known.
*/
const PATTERN_MATCH_ID_METHOD = '((public\s)?(function\s{1,}%s\s?\(\)\s{1,})\s{0,}{\s{0,}return\s{0,}\$this->%s;\s{0,}})i';
/**
* The namespace that contains all proxy classes.
*
* @var string
*/
private $proxyNamespace;
/**
* The directory that contains all proxy classes.
*
* @var string
*/
private $proxyDirectory;
/**
* Map of callables used to fill in placeholders set in the template.
*
* @var string[]|callable[]
*/
protected $placeholders = array(
'baseProxyInterface' => 'Doctrine\Common\Proxy\Proxy',
'additionalProperties' => '',
);
/**
* Template used as a blueprint to generate proxies.
*
* @var string
*/
protected $proxyClassTemplate = ';
/**
* DO NOT EDIT THIS FILE - IT WAS CREATED BY DOCTRINE\'S PROXY GENERATOR
*/
class extends \ implements \
{
/**
* @var \Closure the callback responsible for loading properties in the proxy object. This callback is called with
* three parameters, being respectively the proxy object to be initialized, the method that triggered the
* initialization process and an array of ordered parameters that were passed to that method.
*
* @see \Doctrine\Common\Persistence\Proxy::__setInitializer
*/
public $__initializer__;
/**
* @var \Closure the callback responsible of loading properties that need to be copied in the cloned object
*
* @see \Doctrine\Common\Persistence\Proxy::__setCloner
*/
public $__cloner__;
/**
* @var boolean flag indicating if this object was already initialized
*
* @see \Doctrine\Common\Persistence\Proxy::__isInitialized
*/
public $__isInitialized__ = false;
/**
* @var array properties to be lazy loaded, with keys being the property
* names and values being their default values
*
* @see \Doctrine\Common\Persistence\Proxy::__getLazyProperties
*/
public static $lazyPropertiesDefaults = array();
/**
* Forces initialization of the proxy
*/
public function __load()
{
$this->__initializer__ && $this->__initializer__->__invoke($this, \'__load\', array());
}
/**
* {@inheritDoc}
* @internal generated method: use only when explicitly handling proxy specific loading logic
*/
public function __isInitialized()
{
return $this->__isInitialized__;
}
/**
* {@inheritDoc}
* @internal generated method: use only when explicitly handling proxy specific loading logic
*/
public function __setInitialized($initialized)
{
$this->__isInitialized__ = $initialized;
}
/**
* {@inheritDoc}
* @internal generated method: use only when explicitly handling proxy specific loading logic
*/
public function __setInitializer(\Closure $initializer = null)
{
$this->__initializer__ = $initializer;
}
/**
* {@inheritDoc}
* @internal generated method: use only when explicitly handling proxy specific loading logic
*/
public function __getInitializer()
{
return $this->__initializer__;
}
/**
* {@inheritDoc}
* @internal generated method: use only when explicitly handling proxy specific loading logic
*/
public function __setCloner(\Closure $cloner = null)
{
$this->__cloner__ = $cloner;
}
/**
* {@inheritDoc}
* @internal generated method: use only when explicitly handling proxy specific cloning logic
*/
public function __getCloner()
{
return $this->__cloner__;
}
/**
* {@inheritDoc}
* @internal generated method: use only when explicitly handling proxy specific loading logic
* @static
*/
public function __getLazyProperties()
{
return self::$lazyPropertiesDefaults;
}
}
';
/**
* Initializes a new instance of the ProxyFactory class that is
* connected to the given EntityManager.
*
* @param string $proxyDirectory The directory to use for the proxy classes. It must exist.
* @param string $proxyNamespace The namespace to use for the proxy classes.
*
* @throws InvalidArgumentException
*/
public function __construct($proxyDirectory, $proxyNamespace)
{
if ( ! $proxyDirectory) {
throw InvalidArgumentException::proxyDirectoryRequired();
}
if ( ! $proxyNamespace) {
throw InvalidArgumentException::proxyNamespaceRequired();
}
$this->proxyDirectory = $proxyDirectory;
$this->proxyNamespace = $proxyNamespace;
}
/**
* Sets a placeholder to be replaced in the template.
*
* @param string $name
* @param string|callable $placeholder
*
* @throws InvalidArgumentException
*/
public function setPlaceholder($name, $placeholder)
{
if ( ! is_string($placeholder) && ! is_callable($placeholder)) {
throw InvalidArgumentException::invalidPlaceholder($name);
}
$this->placeholders[$name] = $placeholder;
}
/**
* Sets the base template used to create proxy classes.
*
* @param string $proxyClassTemplate
*/
public function setProxyClassTemplate($proxyClassTemplate)
{
$this->proxyClassTemplate = (string) $proxyClassTemplate;
}
/**
* Generates a proxy class file.
*
* @param \Doctrine\Common\Persistence\Mapping\ClassMetadata $class Metadata for the original class.
* @param string|bool $fileName Filename (full path) for the generated class. If none is given, eval() is used.
*
* @throws UnexpectedValueException
*/
public function generateProxyClass(ClassMetadata $class, $fileName = false)
{
preg_match_all('(<([a-zA-Z]+)>)', $this->proxyClassTemplate, $placeholderMatches);
$placeholderMatches = array_combine($placeholderMatches[0], $placeholderMatches[1]);
$placeholders = array();
foreach ($placeholderMatches as $placeholder => $name) {
$placeholders[$placeholder] = isset($this->placeholders[$name])
? $this->placeholders[$name]
: array($this, 'generate' . $name);
}
foreach ($placeholders as & $placeholder) {
if (is_callable($placeholder)) {
$placeholder = call_user_func($placeholder, $class);
}
}
$proxyCode = strtr($this->proxyClassTemplate, $placeholders);
if ( ! $fileName) {
$proxyClassName = $this->generateNamespace($class) . '\\' . $this->generateProxyShortClassName($class);
if ( ! class_exists($proxyClassName)) {
eval(substr($proxyCode, 5));
}
return;
}
$parentDirectory = dirname($fileName);
if ( ! is_dir($parentDirectory) && (false === @mkdir($parentDirectory, 0775, true))) {
throw UnexpectedValueException::proxyDirectoryNotWritable($this->proxyDirectory);
}
if ( ! is_writable($parentDirectory)) {
throw UnexpectedValueException::proxyDirectoryNotWritable($this->proxyDirectory);
}
$tmpFileName = $fileName . '.' . uniqid('', true);
file_put_contents($tmpFileName, $proxyCode);
rename($tmpFileName, $fileName);
}
/**
* Generates the proxy short class name to be used in the template.
*
* @param \Doctrine\Common\Persistence\Mapping\ClassMetadata $class
*
* @return string
*/
private function generateProxyShortClassName(ClassMetadata $class)
{
$proxyClassName = ClassUtils::generateProxyClassName($class->getName(), $this->proxyNamespace);
$parts = explode('\\', strrev($proxyClassName), 2);
return strrev($parts[0]);
}
/**
* Generates the proxy namespace.
*
* @param \Doctrine\Common\Persistence\Mapping\ClassMetadata $class
*
* @return string
*/
private function generateNamespace(ClassMetadata $class)
{
$proxyClassName = ClassUtils::generateProxyClassName($class->getName(), $this->proxyNamespace);
$parts = explode('\\', strrev($proxyClassName), 2);
return strrev($parts[1]);
}
/**
* Generates the original class name.
*
* @param \Doctrine\Common\Persistence\Mapping\ClassMetadata $class
*
* @return string
*/
private function generateClassName(ClassMetadata $class)
{
return ltrim($class->getName(), '\\');
}
/**
* Generates the array representation of lazy loaded public properties and their default values.
*
* @param \Doctrine\Common\Persistence\Mapping\ClassMetadata $class
*
* @return string
*/
private function generateLazyPropertiesDefaults(ClassMetadata $class)
{
$lazyPublicProperties = $this->getLazyLoadedPublicProperties($class);
$values = array();
foreach ($lazyPublicProperties as $key => $value) {
$values[] = var_export($key, true) . ' => ' . var_export($value, true);
}
return implode(', ', $values);
}
/**
* Generates the constructor code (un-setting public lazy loaded properties, setting identifier field values).
*
* @param \Doctrine\Common\Persistence\Mapping\ClassMetadata $class
*
* @return string
*/
private function generateConstructorImpl(ClassMetadata $class)
{
$constructorImpl = <<<'EOT'
/**
* @param \Closure $initializer
* @param \Closure $cloner
*/
public function __construct($initializer = null, $cloner = null)
{
EOT;
$toUnset = array();
foreach ($this->getLazyLoadedPublicProperties($class) as $lazyPublicProperty => $unused) {
$toUnset[] = '$this->' . $lazyPublicProperty;
}
$constructorImpl .= (empty($toUnset) ? '' : ' unset(' . implode(', ', $toUnset) . ");\n")
. <<<'EOT'
$this->__initializer__ = $initializer;
$this->__cloner__ = $cloner;
}
EOT;
return $constructorImpl;
}
/**
* Generates the magic getter invoked when lazy loaded public properties are requested.
*
* @param \Doctrine\Common\Persistence\Mapping\ClassMetadata $class
*
* @return string
*/
private function generateMagicGet(ClassMetadata $class)
{
$lazyPublicProperties = array_keys($this->getLazyLoadedPublicProperties($class));
$reflectionClass = $class->getReflectionClass();
$hasParentGet = false;
$returnReference = '';
$inheritDoc = '';
if ($reflectionClass->hasMethod('__get')) {
$hasParentGet = true;
$inheritDoc = '{@inheritDoc}';
if ($reflectionClass->getMethod('__get')->returnsReference()) {
$returnReference = '& ';
}
}
if (empty($lazyPublicProperties) && ! $hasParentGet) {
return '';
}
$magicGet = <<__getLazyProperties())) {
$this->__initializer__ && $this->__initializer__->__invoke($this, '__get', array($name));
return $this->$name;
}
EOT;
}
if ($hasParentGet) {
$magicGet .= <<<'EOT'
$this->__initializer__ && $this->__initializer__->__invoke($this, '__get', array($name));
return parent::__get($name);
EOT;
} else {
$magicGet .= <<<'EOT'
trigger_error(sprintf('Undefined property: %s::$%s', __CLASS__, $name), E_USER_NOTICE);
EOT;
}
$magicGet .= " }";
return $magicGet;
}
/**
* Generates the magic setter (currently unused).
*
* @param \Doctrine\Common\Persistence\Mapping\ClassMetadata $class
*
* @return string
*/
private function generateMagicSet(ClassMetadata $class)
{
$lazyPublicProperties = $this->getLazyLoadedPublicProperties($class);
$hasParentSet = $class->getReflectionClass()->hasMethod('__set');
if (empty($lazyPublicProperties) && ! $hasParentSet) {
return '';
}
$inheritDoc = $hasParentSet ? '{@inheritDoc}' : '';
$magicSet = <<__getLazyProperties())) {
$this->__initializer__ && $this->__initializer__->__invoke($this, '__set', array($name, $value));
$this->$name = $value;
return;
}
EOT;
}
if ($hasParentSet) {
$magicSet .= <<<'EOT'
$this->__initializer__ && $this->__initializer__->__invoke($this, '__set', array($name, $value));
return parent::__set($name, $value);
EOT;
} else {
$magicSet .= " \$this->\$name = \$value;";
}
$magicSet .= "\n }";
return $magicSet;
}
/**
* Generates the magic issetter invoked when lazy loaded public properties are checked against isset().
*
* @param \Doctrine\Common\Persistence\Mapping\ClassMetadata $class
*
* @return string
*/
private function generateMagicIsset(ClassMetadata $class)
{
$lazyPublicProperties = array_keys($this->getLazyLoadedPublicProperties($class));
$hasParentIsset = $class->getReflectionClass()->hasMethod('__isset');
if (empty($lazyPublicProperties) && ! $hasParentIsset) {
return '';
}
$inheritDoc = $hasParentIsset ? '{@inheritDoc}' : '';
$magicIsset = <<__getLazyProperties())) {
$this->__initializer__ && $this->__initializer__->__invoke($this, '__isset', array($name));
return isset($this->$name);
}
EOT;
}
if ($hasParentIsset) {
$magicIsset .= <<<'EOT'
$this->__initializer__ && $this->__initializer__->__invoke($this, '__isset', array($name));
return parent::__isset($name);
EOT;
} else {
$magicIsset .= " return false;";
}
return $magicIsset . "\n }";
}
/**
* Generates implementation for the `__sleep` method of proxies.
*
* @param \Doctrine\Common\Persistence\Mapping\ClassMetadata $class
*
* @return string
*/
private function generateSleepImpl(ClassMetadata $class)
{
$hasParentSleep = $class->getReflectionClass()->hasMethod('__sleep');
$inheritDoc = $hasParentSleep ? '{@inheritDoc}' : '';
$sleepImpl = <<__isInitialized__) {
$properties = array_diff($properties, array_keys($this->__getLazyProperties()));
}
return $properties;
}
EOT;
}
$allProperties = array('__isInitialized__');
/* @var $prop \ReflectionProperty */
foreach ($class->getReflectionClass()->getProperties() as $prop) {
if ($prop->isStatic()) {
continue;
}
$allProperties[] = $prop->isPrivate()
? "\0" . $prop->getDeclaringClass()->getName() . "\0" . $prop->getName()
: $prop->getName();
}
$lazyPublicProperties = array_keys($this->getLazyLoadedPublicProperties($class));
$protectedProperties = array_diff($allProperties, $lazyPublicProperties);
foreach ($allProperties as &$property) {
$property = var_export($property, true);
}
foreach ($protectedProperties as &$property) {
$property = var_export($property, true);
}
$allProperties = implode(', ', $allProperties);
$protectedProperties = implode(', ', $protectedProperties);
return $sleepImpl . <<__isInitialized__) {
return array($allProperties);
}
return array($protectedProperties);
}
EOT;
}
/**
* Generates implementation for the `__wakeup` method of proxies.
*
* @param \Doctrine\Common\Persistence\Mapping\ClassMetadata $class
*
* @return string
*/
private function generateWakeupImpl(ClassMetadata $class)
{
$unsetPublicProperties = array();
$hasWakeup = $class->getReflectionClass()->hasMethod('__wakeup');
foreach (array_keys($this->getLazyLoadedPublicProperties($class)) as $lazyPublicProperty) {
$unsetPublicProperties[] = '$this->' . $lazyPublicProperty;
}
$shortName = $this->generateProxyShortClassName($class);
$inheritDoc = $hasWakeup ? '{@inheritDoc}' : '';
$wakeupImpl = <<__isInitialized__) {
\$this->__initializer__ = function ($shortName \$proxy) {
\$proxy->__setInitializer(null);
\$proxy->__setCloner(null);
\$existingProperties = get_object_vars(\$proxy);
foreach (\$proxy->__getLazyProperties() as \$property => \$defaultValue) {
if ( ! array_key_exists(\$property, \$existingProperties)) {
\$proxy->\$property = \$defaultValue;
}
}
};
EOT;
if ( ! empty($unsetPublicProperties)) {
$wakeupImpl .= "\n unset(" . implode(', ', $unsetPublicProperties) . ");";
}
$wakeupImpl .= "\n }";
if ($hasWakeup) {
$wakeupImpl .= "\n parent::__wakeup();";
}
$wakeupImpl .= "\n }";
return $wakeupImpl;
}
/**
* Generates implementation for the `__clone` method of proxies.
*
* @param \Doctrine\Common\Persistence\Mapping\ClassMetadata $class
*
* @return string
*/
private function generateCloneImpl(ClassMetadata $class)
{
$hasParentClone = $class->getReflectionClass()->hasMethod('__clone');
$inheritDoc = $hasParentClone ? '{@inheritDoc}' : '';
$callParentClone = $hasParentClone ? "\n parent::__clone();\n" : '';
return <<__cloner__ && \$this->__cloner__->__invoke(\$this, '__clone', array());
$callParentClone }
EOT;
}
/**
* Generates decorated methods by picking those available in the parent class.
*
* @param \Doctrine\Common\Persistence\Mapping\ClassMetadata $class
*
* @return string
*/
private function generateMethods(ClassMetadata $class)
{
$methods = '';
$methodNames = array();
$reflectionMethods = $class->getReflectionClass()->getMethods(\ReflectionMethod::IS_PUBLIC);
$skippedMethods = array(
'__sleep' => true,
'__clone' => true,
'__wakeup' => true,
'__get' => true,
'__set' => true,
'__isset' => true,
);
foreach ($reflectionMethods as $method) {
$name = $method->getName();
if (
$method->isConstructor() ||
isset($skippedMethods[strtolower($name)]) ||
isset($methodNames[$name]) ||
$method->isFinal() ||
$method->isStatic() ||
( ! $method->isPublic())
) {
continue;
}
$methodNames[$name] = true;
$methods .= "\n /**\n"
. " * {@inheritDoc}\n"
. " */\n"
. ' public function ';
if ($method->returnsReference()) {
$methods .= '&';
}
$methods .= $name . '(';
$firstParam = true;
$parameterString = '';
$argumentString = '';
$parameters = array();
foreach ($method->getParameters() as $param) {
if ($firstParam) {
$firstParam = false;
} else {
$parameterString .= ', ';
$argumentString .= ', ';
}
try {
$paramClass = $param->getClass();
} catch (\ReflectionException $previous) {
throw UnexpectedValueException::invalidParameterTypeHint(
$class->getName(),
$method->getName(),
$param->getName(),
$previous
);
}
// We need to pick the type hint class too
if (null !== $paramClass) {
$parameterString .= '\\' . $paramClass->getName() . ' ';
} elseif ($param->isArray()) {
$parameterString .= 'array ';
} elseif (method_exists($param, 'isCallable') && $param->isCallable()) {
$parameterString .= 'callable ';
}
if ($param->isPassedByReference()) {
$parameterString .= '&';
}
$parameters[] = '$' . $param->getName();
$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($name, 3));
$fieldType = $class->getTypeOfField($identifier);
$cast = in_array($fieldType, array('integer', 'smallint')) ? '(int) ' : '';
$methods .= ' if ($this->__isInitialized__ === false) {' . "\n";
$methods .= ' return ' . $cast . ' parent::' . $method->getName() . "();\n";
$methods .= ' }' . "\n\n";
}
$methods .= "\n \$this->__initializer__ "
. "&& \$this->__initializer__->__invoke(\$this, " . var_export($name, true)
. ", array(" . implode(', ', $parameters) . "));"
. "\n\n return parent::" . $name . '(' . $argumentString . ');'
. "\n" . ' }' . "\n";
}
return $methods;
}
/**
* Generates the Proxy file name.
*
* @param string $className
* @param string $baseDirectory Optional base directory for proxy file name generation.
* If not specified, the directory configured on the Configuration of the
* EntityManager will be used by this factory.
*
* @return string
*/
public function getProxyFileName($className, $baseDirectory = null)
{
$baseDirectory = $baseDirectory ?: $this->proxyDirectory;
return rtrim($baseDirectory, DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR . Proxy::MARKER
. str_replace('\\', '', $className) . '.php';
}
/**
* Checks if the method is a short identifier getter.
*
* What does this mean? For proxy objects the identifier is already known,
* however accessing the getter for this identifier usually triggers the
* lazy loading, leading to a query that may not be necessary if only the
* ID is interesting for the userland code (for example in views that
* generate links to the entity, but do not display anything else).
*
* @param \ReflectionMethod $method
* @param \Doctrine\Common\Persistence\Mapping\ClassMetadata $class
*
* @return boolean
*/
private function isShortIdentifierGetter($method, ClassMetadata $class)
{
$identifier = lcfirst(substr($method->getName(), 3));
$startLine = $method->getStartLine();
$endLine = $method->getEndLine();
$cheapCheck = (
$method->getNumberOfParameters() == 0
&& substr($method->getName(), 0, 3) == 'get'
&& in_array($identifier, $class->getIdentifier(), true)
&& $class->hasField($identifier)
&& (($endLine - $startLine) <= 4)
);
if ($cheapCheck) {
$code = file($method->getDeclaringClass()->getFileName());
$code = trim(implode(' ', array_slice($code, $startLine - 1, $endLine - $startLine + 1)));
$pattern = sprintf(self::PATTERN_MATCH_ID_METHOD, $method->getName(), $identifier);
if (preg_match($pattern, $code)) {
return true;
}
}
return false;
}
/**
* Generates the list of public properties to be lazy loaded, with their default values.
*
* @param \Doctrine\Common\Persistence\Mapping\ClassMetadata $class
*
* @return mixed[]
*/
private function getLazyLoadedPublicProperties(ClassMetadata $class)
{
$defaultProperties = $class->getReflectionClass()->getDefaultProperties();
$properties = array();
foreach ($class->getReflectionClass()->getProperties(\ReflectionProperty::IS_PUBLIC) as $property) {
$name = $property->getName();
if (($class->hasField($name) || $class->hasAssociation($name)) && ! $class->isIdentifier($name)) {
$properties[$name] = $defaultProperties[$name];
}
}
return $properties;
}
}
lib/Doctrine/Common/Reflection/ClassFinderInterface.php 0000666 00000002534 13052402471 0017140 0 ustar 00 .
*/
namespace Doctrine\Common\Reflection;
/**
* Finds a class in a PSR-0 structure.
*
* @author Karoly Negyesi
*/
interface ClassFinderInterface
{
/**
* Finds a class.
*
* @param string $class The name of the class.
*
* @return string|null The name of the class or NULL if not found.
*/
public function findFile($class);
}
lib/Doctrine/Common/Reflection/Psr0FindFile.php 0000666 00000005034 13052402471 0015345 0 ustar 00 .
*/
namespace Doctrine\Common\Reflection;
/**
* Finds a class in a PSR-0 structure.
*
* @author Karoly Negyesi
*/
class Psr0FindFile implements ClassFinderInterface
{
/**
* The PSR-0 prefixes.
*
* @var array
*/
protected $prefixes;
/**
* @param array $prefixes An array of prefixes. Each key is a PHP namespace and each value is
* a list of directories.
*/
public function __construct($prefixes)
{
$this->prefixes = $prefixes;
}
/**
* {@inheritDoc}
*/
public function findFile($class)
{
$lastNsPos = strrpos($class, '\\');
if ('\\' == $class[0]) {
$class = substr($class, 1);
}
if (false !== $lastNsPos) {
// namespaced class name
$classPath = str_replace('\\', DIRECTORY_SEPARATOR, substr($class, 0, $lastNsPos)) . DIRECTORY_SEPARATOR;
$className = substr($class, $lastNsPos + 1);
} else {
// PEAR-like class name
$classPath = null;
$className = $class;
}
$classPath .= str_replace('_', DIRECTORY_SEPARATOR, $className) . '.php';
foreach ($this->prefixes as $prefix => $dirs) {
if (0 === strpos($class, $prefix)) {
foreach ($dirs as $dir) {
if (is_file($dir . DIRECTORY_SEPARATOR . $classPath)) {
return $dir . DIRECTORY_SEPARATOR . $classPath;
}
}
}
}
return null;
}
}
lib/Doctrine/Common/Reflection/ReflectionProviderInterface.php 0000666 00000003136 13052402471 0020547 0 ustar 00 .
*/
namespace Doctrine\Common\Reflection;
interface ReflectionProviderInterface
{
/**
* Gets the ReflectionClass equivalent for this class.
*
* @return \ReflectionClass
*/
public function getReflectionClass();
/**
* Gets the ReflectionMethod equivalent for this class.
*
* @param string $name
*
* @return \ReflectionMethod
*/
public function getReflectionMethod($name);
/**
* Gets the ReflectionProperty equivalent for this class.
*
* @param string $name
*
* @return \ReflectionProperty
*/
public function getReflectionProperty($name);
}
lib/Doctrine/Common/Reflection/RuntimePublicReflectionProperty.php 0000666 00000005177 13052402471 0021472 0 ustar 00 .
*/
namespace Doctrine\Common\Reflection;
use ReflectionProperty;
use Doctrine\Common\Proxy\Proxy;
/**
* PHP Runtime Reflection Public Property - special overrides for public properties.
*
* @author Marco Pivetta
* @since 2.4
*/
class RuntimePublicReflectionProperty extends ReflectionProperty
{
/**
* {@inheritDoc}
*
* Checks is the value actually exist before fetching it.
* This is to avoid calling `__get` on the provided $object if it
* is a {@see \Doctrine\Common\Proxy\Proxy}.
*/
public function getValue($object = null)
{
$name = $this->getName();
if ($object instanceof Proxy && ! $object->__isInitialized()) {
$originalInitializer = $object->__getInitializer();
$object->__setInitializer(null);
$val = isset($object->$name) ? $object->$name : null;
$object->__setInitializer($originalInitializer);
return $val;
}
return isset($object->$name) ? parent::getValue($object) : null;
}
/**
* {@inheritDoc}
*
* Avoids triggering lazy loading via `__set` if the provided object
* is a {@see \Doctrine\Common\Proxy\Proxy}.
* @link https://bugs.php.net/bug.php?id=63463
*/
public function setValue($object, $value = null)
{
if ( ! ($object instanceof Proxy && ! $object->__isInitialized())) {
parent::setValue($object, $value);
return;
}
$originalInitializer = $object->__getInitializer();
$object->__setInitializer(null);
parent::setValue($object, $value);
$object->__setInitializer($originalInitializer);
}
}
lib/Doctrine/Common/Reflection/StaticReflectionClass.php 0000666 00000021600 13052402471 0017345 0 ustar 00 .
*/
namespace Doctrine\Common\Reflection;
use ReflectionClass;
use ReflectionException;
class StaticReflectionClass extends ReflectionClass
{
/**
* The static reflection parser object.
*
* @var StaticReflectionParser
*/
private $staticReflectionParser;
/**
* @param StaticReflectionParser $staticReflectionParser
*/
public function __construct(StaticReflectionParser $staticReflectionParser)
{
$this->staticReflectionParser = $staticReflectionParser;
}
/**
* {@inheritDoc}
*/
public function getName()
{
return $this->staticReflectionParser->getClassName();
}
/**
* {@inheritDoc}
*/
public function getDocComment()
{
return $this->staticReflectionParser->getDocComment();
}
/**
* {@inheritDoc}
*/
public function getNamespaceName()
{
return $this->staticReflectionParser->getNamespaceName();
}
/**
* @return array
*/
public function getUseStatements()
{
return $this->staticReflectionParser->getUseStatements();
}
/**
* {@inheritDoc}
*/
public function getMethod($name)
{
return $this->staticReflectionParser->getReflectionMethod($name);
}
/**
* {@inheritDoc}
*/
public function getProperty($name)
{
return $this->staticReflectionParser->getReflectionProperty($name);
}
/**
* {@inheritDoc}
*/
public static function export($argument, $return = false)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getConstant($name)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getConstants()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getConstructor()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getDefaultProperties()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getEndLine()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getExtension()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getExtensionName()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getFileName()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getInterfaceNames()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getInterfaces()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getMethods($filter = null)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getModifiers()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getParentClass()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getProperties($filter = null)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getShortName()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getStartLine()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getStaticProperties()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getStaticPropertyValue($name, $default = '')
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getTraitAliases()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getTraitNames()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getTraits()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function hasConstant($name)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function hasMethod($name)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function hasProperty($name)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function implementsInterface($interface)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function inNamespace()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isAbstract()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isCloneable()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isFinal()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isInstance($object)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isInstantiable()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isInterface()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isInternal()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isIterateable()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isSubclassOf($class)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isTrait()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isUserDefined()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function newInstance($args)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function newInstanceArgs(array $args = array())
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function newInstanceWithoutConstructor()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function setStaticPropertyValue($name, $value)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function __toString()
{
throw new ReflectionException('Method not implemented');
}
}
lib/Doctrine/Common/Reflection/StaticReflectionMethod.php 0000666 00000017130 13052402471 0017523 0 ustar 00 .
*/
namespace Doctrine\Common\Reflection;
use ReflectionMethod;
use ReflectionException;
class StaticReflectionMethod extends ReflectionMethod
{
/**
* The PSR-0 parser object.
*
* @var StaticReflectionParser
*/
protected $staticReflectionParser;
/**
* The name of the method.
*
* @var string
*/
protected $methodName;
/**
* @param StaticReflectionParser $staticReflectionParser
* @param string $methodName
*/
public function __construct(StaticReflectionParser $staticReflectionParser, $methodName)
{
$this->staticReflectionParser = $staticReflectionParser;
$this->methodName = $methodName;
}
/**
* {@inheritDoc}
*/
public function getName()
{
return $this->methodName;
}
/**
* @return StaticReflectionParser
*/
protected function getStaticReflectionParser()
{
return $this->staticReflectionParser->getStaticReflectionParserForDeclaringClass('method', $this->methodName);
}
/**
* {@inheritDoc}
*/
public function getDeclaringClass()
{
return $this->getStaticReflectionParser()->getReflectionClass();
}
/**
* {@inheritDoc}
*/
public function getNamespaceName()
{
return $this->getStaticReflectionParser()->getNamespaceName();
}
/**
* {@inheritDoc}
*/
public function getDocComment()
{
return $this->getStaticReflectionParser()->getDocComment('method', $this->methodName);
}
/**
* @return array
*/
public function getUseStatements()
{
return $this->getStaticReflectionParser()->getUseStatements();
}
/**
* {@inheritDoc}
*/
public static function export($class, $name, $return = false)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getClosure($object)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getModifiers()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getPrototype()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function invoke($object, $parameter = null)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function invokeArgs($object, array $args)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isAbstract()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isConstructor()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isDestructor()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isFinal()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isPrivate()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isProtected()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isPublic()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isStatic()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function setAccessible($accessible)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function __toString()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getClosureThis()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getEndLine()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getExtension()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getExtensionName()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getFileName()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getNumberOfParameters()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getNumberOfRequiredParameters()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getParameters()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getShortName()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getStartLine()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getStaticVariables()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function inNamespace()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isClosure()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isDeprecated()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isInternal()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isUserDefined()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function returnsReference()
{
throw new ReflectionException('Method not implemented');
}
}
lib/Doctrine/Common/Reflection/StaticReflectionParser.php 0000666 00000023213 13052402471 0017536 0 ustar 00 .
*/
namespace Doctrine\Common\Reflection;
use ReflectionException;
use Doctrine\Common\Annotations\TokenParser;
/**
* Parses a file for namespaces/use/class declarations.
*
* @author Karoly Negyesi
*/
class StaticReflectionParser implements ReflectionProviderInterface
{
/**
* The fully qualified class name.
*
* @var string
*/
protected $className;
/**
* The short class name.
*
* @var string
*/
protected $shortClassName;
/**
* Whether the caller only wants class annotations.
*
* @var boolean.
*/
protected $classAnnotationOptimize;
/**
* Whether the parser has run.
*
* @var boolean
*/
protected $parsed = false;
/**
* The namespace of the class.
*
* @var string
*/
protected $namespace = '';
/**
* The use statements of the class.
*
* @var array
*/
protected $useStatements = array();
/**
* The docComment of the class.
*
* @var string
*/
protected $docComment = array(
'class' => '',
'property' => array(),
'method' => array()
);
/**
* The name of the class this class extends, if any.
*
* @var string
*/
protected $parentClassName = '';
/**
* The parent PSR-0 Parser.
*
* @var \Doctrine\Common\Reflection\StaticReflectionParser
*/
protected $parentStaticReflectionParser;
/**
* Parses a class residing in a PSR-0 hierarchy.
*
* @param string $className The full, namespaced class name.
* @param ClassFinderInterface $finder A ClassFinder object which finds the class.
* @param boolean $classAnnotationOptimize Only retrieve the class docComment.
* Presumes there is only one statement per line.
*/
public function __construct($className, $finder, $classAnnotationOptimize = false)
{
$this->className = ltrim($className, '\\');
$lastNsPos = strrpos($this->className, '\\');
if ($lastNsPos !== false) {
$this->namespace = substr($this->className, 0, $lastNsPos);
$this->shortClassName = substr($this->className, $lastNsPos + 1);
} else {
$this->shortClassName = $this->className;
}
$this->finder = $finder;
$this->classAnnotationOptimize = $classAnnotationOptimize;
}
/**
* @return void
*/
protected function parse()
{
if ($this->parsed || !$fileName = $this->finder->findFile($this->className)) {
return;
}
$this->parsed = true;
$contents = file_get_contents($fileName);
if ($this->classAnnotationOptimize) {
if (preg_match("/\A.*^\s*((abstract|final)\s+)?class\s+{$this->shortClassName}\s+/sm", $contents, $matches)) {
$contents = $matches[0];
}
}
$tokenParser = new TokenParser($contents);
$docComment = '';
while ($token = $tokenParser->next(false)) {
if (is_array($token)) {
switch ($token[0]) {
case T_USE:
$this->useStatements = array_merge($this->useStatements, $tokenParser->parseUseStatement());
break;
case T_DOC_COMMENT:
$docComment = $token[1];
break;
case T_CLASS:
$this->docComment['class'] = $docComment;
$docComment = '';
break;
case T_VAR:
case T_PRIVATE:
case T_PROTECTED:
case T_PUBLIC:
$token = $tokenParser->next();
if ($token[0] === T_VARIABLE) {
$propertyName = substr($token[1], 1);
$this->docComment['property'][$propertyName] = $docComment;
continue 2;
}
if ($token[0] !== T_FUNCTION) {
// For example, it can be T_FINAL.
continue 2;
}
// No break.
case T_FUNCTION:
// The next string after function is the name, but
// there can be & before the function name so find the
// string.
while (($token = $tokenParser->next()) && $token[0] !== T_STRING);
$methodName = $token[1];
$this->docComment['method'][$methodName] = $docComment;
$docComment = '';
break;
case T_EXTENDS:
$this->parentClassName = $tokenParser->parseClass();
$nsPos = strpos($this->parentClassName, '\\');
$fullySpecified = false;
if ($nsPos === 0) {
$fullySpecified = true;
} else {
if ($nsPos) {
$prefix = strtolower(substr($this->parentClassName, 0, $nsPos));
$postfix = substr($this->parentClassName, $nsPos);
} else {
$prefix = strtolower($this->parentClassName);
$postfix = '';
}
foreach ($this->useStatements as $alias => $use) {
if ($alias == $prefix) {
$this->parentClassName = '\\' . $use . $postfix;
$fullySpecified = true;
}
}
}
if (!$fullySpecified) {
$this->parentClassName = '\\' . $this->namespace . '\\' . $this->parentClassName;
}
break;
}
}
}
}
/**
* @return StaticReflectionParser
*/
protected function getParentStaticReflectionParser()
{
if (empty($this->parentStaticReflectionParser)) {
$this->parentStaticReflectionParser = new static($this->parentClassName, $this->finder);
}
return $this->parentStaticReflectionParser;
}
/**
* @return string
*/
public function getClassName()
{
return $this->className;
}
/**
* @return string
*/
public function getNamespaceName()
{
return $this->namespace;
}
/**
* {@inheritDoc}
*/
public function getReflectionClass()
{
return new StaticReflectionClass($this);
}
/**
* {@inheritDoc}
*/
public function getReflectionMethod($methodName)
{
return new StaticReflectionMethod($this, $methodName);
}
/**
* {@inheritDoc}
*/
public function getReflectionProperty($propertyName)
{
return new StaticReflectionProperty($this, $propertyName);
}
/**
* Gets the use statements from this file.
*
* @return array
*/
public function getUseStatements()
{
$this->parse();
return $this->useStatements;
}
/**
* Gets the doc comment.
*
* @param string $type The type: 'class', 'property' or 'method'.
* @param string $name The name of the property or method, not needed for 'class'.
*
* @return string The doc comment, empty string if none.
*/
public function getDocComment($type = 'class', $name = '')
{
$this->parse();
return $name ? $this->docComment[$type][$name] : $this->docComment[$type];
}
/**
* Gets the PSR-0 parser for the declaring class.
*
* @param string $type The type: 'property' or 'method'.
* @param string $name The name of the property or method.
*
* @return StaticReflectionParser A static reflection parser for the declaring class.
*
* @throws ReflectionException
*/
public function getStaticReflectionParserForDeclaringClass($type, $name)
{
$this->parse();
if (isset($this->docComment[$type][$name])) {
return $this;
}
if (!empty($this->parentClassName)) {
return $this->getParentStaticReflectionParser()->getStaticReflectionParserForDeclaringClass($type, $name);
}
throw new ReflectionException('Invalid ' . $type . ' "' . $name . '"');
}
}
lib/Doctrine/Common/Reflection/StaticReflectionProperty.php 0000666 00000010311 13052402471 0020121 0 ustar 00 .
*/
namespace Doctrine\Common\Reflection;
use ReflectionProperty;
use ReflectionException;
class StaticReflectionProperty extends ReflectionProperty
{
/**
* The PSR-0 parser object.
*
* @var StaticReflectionParser
*/
protected $staticReflectionParser;
/**
* The name of the property.
*
* @var string|null
*/
protected $propertyName;
/**
* @param StaticReflectionParser $staticReflectionParser
* @param string|null $propertyName
*/
public function __construct(StaticReflectionParser $staticReflectionParser, $propertyName)
{
$this->staticReflectionParser = $staticReflectionParser;
$this->propertyName = $propertyName;
}
/**
* {@inheritDoc}
*/
public function getName()
{
return $this->propertyName;
}
/**
* @return StaticReflectionParser
*/
protected function getStaticReflectionParser()
{
return $this->staticReflectionParser->getStaticReflectionParserForDeclaringClass('property', $this->propertyName);
}
/**
* {@inheritDoc}
*/
public function getDeclaringClass()
{
return $this->getStaticReflectionParser()->getReflectionClass();
}
/**
* {@inheritDoc}
*/
public function getDocComment()
{
return $this->getStaticReflectionParser()->getDocComment('property', $this->propertyName);
}
/**
* @return array
*/
public function getUseStatements()
{
return $this->getStaticReflectionParser()->getUseStatements();
}
/**
* {@inheritDoc}
*/
public static function export ($class, $name, $return = false)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getModifiers()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function getValue($object = null)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isDefault()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isPrivate()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isProtected()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isPublic()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function isStatic()
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function setAccessible ($accessible)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function setValue ($object, $value = null)
{
throw new ReflectionException('Method not implemented');
}
/**
* {@inheritDoc}
*/
public function __toString()
{
throw new ReflectionException('Method not implemented');
}
}
lib/Doctrine/Common/Util/ClassUtils.php 0000666 00000006121 13052402471 0014027 0 ustar 00 .
*/
namespace Doctrine\Common\Util;
use Doctrine\Common\Persistence\Proxy;
/**
* Class and reflection related functionality for objects that
* might or not be proxy objects at the moment.
*
* @author Benjamin Eberlei
* @author Johannes Schmitt
*/
class ClassUtils
{
/**
* Gets the real class name of a class name that could be a proxy.
*
* @param string $class
*
* @return string
*/
public static function getRealClass($class)
{
if (false === $pos = strrpos($class, '\\'.Proxy::MARKER.'\\')) {
return $class;
}
return substr($class, $pos + Proxy::MARKER_LENGTH + 2);
}
/**
* Gets the real class name of an object (even if its a proxy).
*
* @param object $object
*
* @return string
*/
public static function getClass($object)
{
return self::getRealClass(get_class($object));
}
/**
* Gets the real parent class name of a class or object.
*
* @param string $className
*
* @return string
*/
public static function getParentClass($className)
{
return get_parent_class( self::getRealClass( $className ) );
}
/**
* Creates a new reflection class.
*
* @param string $class
*
* @return \ReflectionClass
*/
public static function newReflectionClass($class)
{
return new \ReflectionClass( self::getRealClass( $class ) );
}
/**
* Creates a new reflection object.
*
* @param object $object
*
* @return \ReflectionObject
*/
public static function newReflectionObject($object)
{
return self::newReflectionClass( self::getClass( $object ) );
}
/**
* Given a class name and a proxy namespace returns the proxy name.
*
* @param string $className
* @param string $proxyNamespace
*
* @return string
*/
public static function generateProxyClassName($className, $proxyNamespace)
{
return rtrim($proxyNamespace, '\\') . '\\'.Proxy::MARKER.'\\' . ltrim($className, '\\');
}
}
lib/Doctrine/Common/Util/Debug.php 0000666 00000011227 13052402471 0012772 0 ustar 00 .
*/
namespace Doctrine\Common\Util;
use Doctrine\Common\Persistence\Proxy;
/**
* Static class containing most used debug methods.
*
* @link www.doctrine-project.org
* @since 2.0
* @author Guilherme Blanco
* @author Jonathan Wage
* @author Roman Borschel
* @author Giorgio Sironi
*/
final class Debug
{
/**
* Private constructor (prevents instantiation).
*/
private function __construct()
{
}
/**
* Prints a dump of the public, protected and private properties of $var.
*
* @link http://xdebug.org/
*
* @param mixed $var The variable to dump.
* @param integer $maxDepth The maximum nesting level for object properties.
* @param boolean $stripTags Whether output should strip HTML tags.
*/
public static function dump($var, $maxDepth = 2, $stripTags = true)
{
ini_set('html_errors', 'On');
if (extension_loaded('xdebug')) {
ini_set('xdebug.var_display_max_depth', $maxDepth);
}
$var = self::export($var, $maxDepth++);
ob_start();
var_dump($var);
$dump = ob_get_contents();
ob_end_clean();
echo ($stripTags ? strip_tags(html_entity_decode($dump)) : $dump);
ini_set('html_errors', 'Off');
}
/**
* @param mixed $var
* @param int $maxDepth
*
* @return mixed
*/
public static function export($var, $maxDepth)
{
$return = null;
$isObj = is_object($var);
if ($isObj && in_array('Doctrine\Common\Collections\Collection', class_implements($var))) {
$var = $var->toArray();
}
if ($maxDepth) {
if (is_array($var)) {
$return = array();
foreach ($var as $k => $v) {
$return[$k] = self::export($v, $maxDepth - 1);
}
} else if ($isObj) {
$return = new \stdclass();
if ($var instanceof \DateTime) {
$return->__CLASS__ = "DateTime";
$return->date = $var->format('c');
$return->timezone = $var->getTimeZone()->getName();
} else {
$reflClass = ClassUtils::newReflectionObject($var);
$return->__CLASS__ = ClassUtils::getClass($var);
if ($var instanceof Proxy) {
$return->__IS_PROXY__ = true;
$return->__PROXY_INITIALIZED__ = $var->__isInitialized();
}
if ($var instanceof \ArrayObject || $var instanceof \ArrayIterator) {
$return->__STORAGE__ = self::export($var->getArrayCopy(), $maxDepth - 1);
}
foreach ($reflClass->getProperties() as $reflProperty) {
$name = $reflProperty->getName();
$reflProperty->setAccessible(true);
$return->$name = self::export($reflProperty->getValue($var), $maxDepth - 1);
}
}
} else {
$return = $var;
}
} else {
$return = is_object($var) ? get_class($var)
: (is_array($var) ? 'Array(' . count($var) . ')' : $var);
}
return $return;
}
/**
* Returns a string representation of an object.
*
* @param object $obj
*
* @return string
*/
public static function toString($obj)
{
return method_exists($obj, '__toString') ? (string) $obj : get_class($obj) . '@' . spl_object_hash($obj);
}
}
lib/Doctrine/Common/Util/Inflector.php 0000666 00000002371 13052402471 0013671 0 ustar 00 .
*/
namespace Doctrine\Common\Util;
use Doctrine\Common\Inflector\Inflector as BaseInflector;
/**
* Doctrine inflector has static methods for inflecting text.
*
* Kept for backwards compatibility reasons, was moved to its own component.
*/
class Inflector extends BaseInflector
{
}
lib/Doctrine/Common/Version.php 0000666 00000003600 13052402471 0012450 0 ustar 00 .
*/
namespace Doctrine\Common;
/**
* Class to store and retrieve the version of Doctrine.
*
* @link www.doctrine-project.org
* @since 2.0
* @author Benjamin Eberlei
* @author Guilherme Blanco
* @author Jonathan Wage
* @author Roman Borschel
*/
class Version
{
/**
* Current Doctrine Version.
*/
const VERSION = '2.4.2';
/**
* Compares a Doctrine version with the current one.
*
* @param string $version Doctrine version to compare.
*
* @return int -1 if older, 0 if it is the same, 1 if version passed as argument is newer.
*/
public static function compare($version)
{
$currentVersion = str_replace(' ', '', strtolower(self::VERSION));
$version = str_replace(' ', '', $version);
return version_compare($version, $currentVersion);
}
}
phpunit.xml.dist 0000666 00000001462 13052402471 0007724 0 ustar 00
./tests/Doctrine/
./lib/Doctrine/
performance
lib/vendor/doctrine-build-common 0000777 00000000000 13052402471 0012724 5 ustar 00