diff --git a/core/composer.json b/core/composer.json
index 64928b1191f9a7ba1db0f015670268522131c06a..6d930cc2927d14b1f4cd98af836e2e0d6d9d5f22 100644
--- a/core/composer.json
+++ b/core/composer.json
@@ -7,7 +7,8 @@
"symfony/http-kernel": "2.1.*",
"symfony/routing": "2.1.*",
"symfony/yaml": "2.1.*",
- "twig/twig": "1.8.*"
+ "twig/twig": "1.8.*",
+ "doctrine/common": "2.2.*"
},
"minimum-stability": "beta"
}
diff --git a/core/composer.lock b/core/composer.lock
index c861d34a9042fabaaf94bfa48421db76dd80b9a8..e803ae3c8345c072b8b4563130d895332a7677fc 100644
--- a/core/composer.lock
+++ b/core/composer.lock
@@ -1,6 +1,10 @@
{
- "hash": "ec77094fc475b57afb7a27f63983ead1",
+ "hash": "2ea132b64c01235b70e9fb16c528ea0e",
"packages": [
+ {
+ "package": "doctrine/common",
+ "version": "2.2.2"
+ },
{
"package": "symfony/class-loader",
"version": "v2.1.0-BETA1"
diff --git a/core/includes/bootstrap.inc b/core/includes/bootstrap.inc
index 22eb5b82098461952d60ce95b9f07f0a03f2e5fc..07c9d67fc9ab24d3b25d1942a199a1dd060f42da 100644
--- a/core/includes/bootstrap.inc
+++ b/core/includes/bootstrap.inc
@@ -3048,6 +3048,7 @@ function drupal_classloader() {
'Symfony\Component\HttpKernel' => DRUPAL_ROOT . '/core/vendor/symfony/http-kernel',
'Symfony\Component\Routing' => DRUPAL_ROOT . '/core/vendor/symfony/routing',
'Symfony\Component\Yaml' => DRUPAL_ROOT . '/core/vendor/symfony/yaml',
+ 'Doctrine\Common' => DRUPAL_ROOT . '/core/vendor/doctrine/common/lib',
));
// Register PEAR-style vendor namespaces.
$loader->registerPrefixes(array(
diff --git a/core/vendor/composer/ClassLoader.php b/core/vendor/composer/ClassLoader.php
index 146276eb68cbce694489a0e801502013fc74fe16..d1c2cd57f28566827a2cff53bdc2795af056dabb 100644
--- a/core/vendor/composer/ClassLoader.php
+++ b/core/vendor/composer/ClassLoader.php
@@ -102,7 +102,7 @@ public function add($prefix, $paths)
/**
* Turns on searching the include path for class files.
*
- * @param Boolean $useIncludePath
+ * @param bool $useIncludePath
*/
public function setUseIncludePath($useIncludePath)
{
@@ -113,7 +113,7 @@ public function setUseIncludePath($useIncludePath)
* Can be used to check if the autoloader uses the include path to check
* for classes.
*
- * @return Boolean
+ * @return bool
*/
public function getUseIncludePath()
{
@@ -123,7 +123,7 @@ public function getUseIncludePath()
/**
* Registers this instance as an autoloader.
*
- * @param Boolean $prepend Whether to prepend the autoloader or not
+ * @param bool $prepend Whether to prepend the autoloader or not
*/
public function register($prepend = false)
{
@@ -141,13 +141,13 @@ public function unregister()
/**
* Loads the given class or interface.
*
- * @param string $class The name of the class
- * @return Boolean|null True, if loaded
+ * @param string $class The name of the class
+ * @return bool|null True, if loaded
*/
public function loadClass($class)
{
if ($file = $this->findFile($class)) {
- require $file;
+ include $file;
return true;
}
diff --git a/core/vendor/composer/autoload_namespaces.php b/core/vendor/composer/autoload_namespaces.php
index 6ae0e916e6beb48a7a6fad6b7a3dd98147dd446e..e7a0e60ac997817fe798da97b1cd38a1876ec4c4 100644
--- a/core/vendor/composer/autoload_namespaces.php
+++ b/core/vendor/composer/autoload_namespaces.php
@@ -14,4 +14,5 @@
'Symfony\\Component\\EventDispatcher' => $vendorDir . '/symfony/event-dispatcher/',
'Symfony\\Component\\DependencyInjection' => $vendorDir . '/symfony/dependency-injection/',
'Symfony\\Component\\ClassLoader' => $vendorDir . '/symfony/class-loader/',
+ 'Doctrine\\Common' => $vendorDir . '/doctrine/common/lib/',
);
diff --git a/core/vendor/composer/installed.json b/core/vendor/composer/installed.json
index 955de6886e685a03efcc8d2c0de24dfc225f5318..2e358270e21ca20f3409766b256716e9c02ad5dc 100644
--- a/core/vendor/composer/installed.json
+++ b/core/vendor/composer/installed.json
@@ -3,7 +3,7 @@
"name": "twig/twig",
"version": "v1.8.3",
"version_normalized": "1.8.3.0",
- "time": "2012-06-17 18:48:16",
+ "time": "2012-06-18 01:48:16",
"source": {
"type": "git",
"url": "git://github.com/fabpot/Twig.git",
@@ -58,7 +58,7 @@
"version": "v2.1.0-BETA1",
"version_normalized": "2.1.0.0-beta1",
"target-dir": "Symfony/Component/DependencyInjection",
- "time": "2012-06-12 11:59:42",
+ "time": "2012-06-12 18:59:42",
"source": {
"type": "git",
"url": "https://github.com/symfony/DependencyInjection",
@@ -108,7 +108,7 @@
"version": "v2.1.0-BETA1",
"version_normalized": "2.1.0.0-beta1",
"target-dir": "Symfony/Component/EventDispatcher",
- "time": "2012-05-15 16:56:32",
+ "time": "2012-05-15 23:56:32",
"source": {
"type": "git",
"url": "https://github.com/symfony/EventDispatcher",
@@ -155,7 +155,7 @@
"version": "v2.1.0-BETA1",
"version_normalized": "2.1.0.0-beta1",
"target-dir": "Symfony/Component/HttpFoundation",
- "time": "2012-06-12 06:10:53",
+ "time": "2012-06-12 13:10:53",
"source": {
"type": "git",
"url": "https://github.com/symfony/HttpFoundation",
@@ -202,7 +202,7 @@
"version": "v2.1.0-BETA1",
"version_normalized": "2.1.0.0-beta1",
"target-dir": "Symfony/Component/HttpKernel",
- "time": "2012-06-12 11:59:42",
+ "time": "2012-06-12 18:59:42",
"source": {
"type": "git",
"url": "https://github.com/symfony/HttpKernel",
@@ -259,7 +259,7 @@
"version": "v2.1.0-BETA1",
"version_normalized": "2.1.0.0-beta1",
"target-dir": "Symfony/Component/Routing",
- "time": "2012-06-12 11:59:42",
+ "time": "2012-06-12 18:59:42",
"source": {
"type": "git",
"url": "https://github.com/symfony/Routing",
@@ -310,7 +310,7 @@
"version": "v2.1.0-BETA1",
"version_normalized": "2.1.0.0-beta1",
"target-dir": "Symfony/Component/Yaml",
- "time": "2012-06-09 15:04:17",
+ "time": "2012-06-09 22:04:17",
"source": {
"type": "git",
"url": "https://github.com/symfony/Yaml",
@@ -357,7 +357,7 @@
"version": "v2.1.0-BETA1",
"version_normalized": "2.1.0.0-beta1",
"target-dir": "Symfony/Component/ClassLoader",
- "time": "2012-04-23 05:37:21",
+ "time": "2012-04-23 12:37:21",
"source": {
"type": "git",
"url": "https://github.com/symfony/ClassLoader",
@@ -398,5 +398,76 @@
"Symfony\\Component\\ClassLoader": ""
}
}
+ },
+ {
+ "name": "doctrine/common",
+ "version": "2.2.2",
+ "version_normalized": "2.2.2.0",
+ "time": "2012-04-13 07:46:44",
+ "source": {
+ "type": "git",
+ "url": "https://github.com/doctrine/common",
+ "reference": "2.2.2"
+ },
+ "dist": {
+ "type": "zip",
+ "url": "https://github.com/doctrine/common/zipball/2.2.2",
+ "reference": "2.2.2",
+ "shasum": ""
+ },
+ "require": {
+ "php": ">=5.3.2"
+ },
+ "type": "library",
+ "installation-source": "dist",
+ "license": [
+ "LGPL"
+ ],
+ "authors": [
+ {
+ "name": "Jonathan Wage",
+ "email": "jonwage@gmail.com",
+ "homepage": "http://www.jwage.com/",
+ "role": null
+ },
+ {
+ "name": "Guilherme Blanco",
+ "email": "guilhermeblanco@gmail.com",
+ "homepage": null,
+ "role": null
+ },
+ {
+ "name": "Roman Borschel",
+ "email": "roman@code-factory.org",
+ "homepage": null,
+ "role": null
+ },
+ {
+ "name": "Benjamin Eberlei",
+ "email": "kontakt@beberlei.de",
+ "homepage": null,
+ "role": null
+ },
+ {
+ "name": "Johannes Schmitt",
+ "email": "schmittjoh@gmail.com",
+ "homepage": "https://github.com/schmittjoh",
+ "role": null
+ }
+ ],
+ "description": "Common Library for Doctrine projects",
+ "homepage": "http://www.doctrine-project.org",
+ "keywords": [
+ "collections",
+ "spl",
+ "eventmanager",
+ "annotations",
+ "persistence"
+ ],
+ "autoload": {
+ "psr-0": {
+ "Doctrine\\Common": "lib/"
+ }
+ }
}
]
diff --git a/core/vendor/doctrine/common/.gitignore b/core/vendor/doctrine/common/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..fb5e79d652afa323dcfaf80369330ef195fb70c2
--- /dev/null
+++ b/core/vendor/doctrine/common/.gitignore
@@ -0,0 +1,4 @@
+build/
+logs/
+reports/
+dist/
diff --git a/core/vendor/doctrine/common/.gitmodules b/core/vendor/doctrine/common/.gitmodules
new file mode 100644
index 0000000000000000000000000000000000000000..51f0843511c8fc363f83634ff1063d9f969c3e86
--- /dev/null
+++ b/core/vendor/doctrine/common/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "lib/vendor/doctrine-build-common"]
+ path = lib/vendor/doctrine-build-common
+ url = git://github.com/doctrine/doctrine-build-common.git
diff --git a/core/vendor/doctrine/common/.travis.yml b/core/vendor/doctrine/common/.travis.yml
new file mode 100644
index 0000000000000000000000000000000000000000..4464d4f7900b6e3b1f55ff09a94bc68fe0282315
--- /dev/null
+++ b/core/vendor/doctrine/common/.travis.yml
@@ -0,0 +1,5 @@
+language: php
+
+php:
+ - 5.3
+ - 5.4
diff --git a/core/vendor/doctrine/common/LICENSE b/core/vendor/doctrine/common/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..1c03f74b99009a408313d614d47e4074ac7ce4be
--- /dev/null
+++ b/core/vendor/doctrine/common/LICENSE
@@ -0,0 +1,504 @@
+ GNU LESSER GENERAL PUBLIC LICENSE
+ Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL. It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+ Preamble
+
+ The licenses for most software are designed to take away your
+freedom to share and change it. By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+ This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it. You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+ When we speak of free software, we are referring to freedom of use,
+not price. Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+ To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights. These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+ For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you. You must make sure that they, too, receive or can get the source
+code. If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it. And you must show them these terms so they know their rights.
+
+ We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+ To protect each distributor, we want to make it very clear that
+there is no warranty for the free library. Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+ Finally, software patents pose a constant threat to the existence of
+any free program. We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder. Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+ Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License. This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License. We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+ When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library. The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom. The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+ We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License. It also provides other free software developers Less
+of an advantage over competing non-free programs. These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries. However, the Lesser license provides advantages in certain
+special circumstances.
+
+ For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard. To achieve this, non-free programs must be
+allowed to use the library. A more frequent case is that a free
+library does the same job as widely used non-free libraries. In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+ In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software. For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+ Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+ The precise terms and conditions for copying, distribution and
+modification follow. Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library". The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+ GNU LESSER GENERAL PUBLIC LICENSE
+ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+ A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+ The "Library", below, refers to any such software library or work
+which has been distributed under these terms. A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language. (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+ "Source code" for a work means the preferred form of the work for
+making modifications to it. For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+ Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope. The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it). Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+ 1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+ You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+ 2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+ a) The modified work must itself be a software library.
+
+ b) You must cause the files modified to carry prominent notices
+ stating that you changed the files and the date of any change.
+
+ c) You must cause the whole of the work to be licensed at no
+ charge to all third parties under the terms of this License.
+
+ d) If a facility in the modified Library refers to a function or a
+ table of data to be supplied by an application program that uses
+ the facility, other than as an argument passed when the facility
+ is invoked, then you must make a good faith effort to ensure that,
+ in the event an application does not supply such function or
+ table, the facility still operates, and performs whatever part of
+ its purpose remains meaningful.
+
+ (For example, a function in a library to compute square roots has
+ a purpose that is entirely well-defined independent of the
+ application. Therefore, Subsection 2d requires that any
+ application-supplied function or table used by this function must
+ be optional: if the application does not supply it, the square
+ root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole. If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works. But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+ 3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library. To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License. (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.) Do not make any other change in
+these notices.
+
+ Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+ This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+ 4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+ If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+ 5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library". Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+ However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library". The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+ When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library. The
+threshold for this to be true is not precisely defined by law.
+
+ If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work. (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+ Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+ 6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+ You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License. You must supply a copy of this License. If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License. Also, you must do one
+of these things:
+
+ a) Accompany the work with the complete corresponding
+ machine-readable source code for the Library including whatever
+ changes were used in the work (which must be distributed under
+ Sections 1 and 2 above); and, if the work is an executable linked
+ with the Library, with the complete machine-readable "work that
+ uses the Library", as object code and/or source code, so that the
+ user can modify the Library and then relink to produce a modified
+ executable containing the modified Library. (It is understood
+ that the user who changes the contents of definitions files in the
+ Library will not necessarily be able to recompile the application
+ to use the modified definitions.)
+
+ b) Use a suitable shared library mechanism for linking with the
+ Library. A suitable mechanism is one that (1) uses at run time a
+ copy of the library already present on the user's computer system,
+ rather than copying library functions into the executable, and (2)
+ will operate properly with a modified version of the library, if
+ the user installs one, as long as the modified version is
+ interface-compatible with the version that the work was made with.
+
+ c) Accompany the work with a written offer, valid for at
+ least three years, to give the same user the materials
+ specified in Subsection 6a, above, for a charge no more
+ than the cost of performing this distribution.
+
+ d) If distribution of the work is made by offering access to copy
+ from a designated place, offer equivalent access to copy the above
+ specified materials from the same place.
+
+ e) Verify that the user has already received a copy of these
+ materials or that you have already sent this user a copy.
+
+ For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it. However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+ It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system. Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+ 7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+ a) Accompany the combined library with a copy of the same work
+ based on the Library, uncombined with any other library
+ facilities. This must be distributed under the terms of the
+ Sections above.
+
+ b) Give prominent notice with the combined library of the fact
+ that part of it is a work based on the Library, and explaining
+ where to find the accompanying uncombined form of the same work.
+
+ 8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License. Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License. However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+ 9. You are not required to accept this License, since you have not
+signed it. However, nothing else grants you permission to modify or
+distribute the Library or its derivative works. These actions are
+prohibited by law if you do not accept this License. Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+ 10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions. You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+ 11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all. For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices. Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+ 12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded. In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+ 13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation. If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+ 14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission. For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this. Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+ NO WARRANTY
+
+ 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+ 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+ END OF TERMS AND CONDITIONS
+
+ How to Apply These Terms to Your New Libraries
+
+ If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change. You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+ To apply these terms, attach the following notices to the library. It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+ <one line to give the library's name and a brief idea of what it does.>
+ Copyright (C) <year> <name of author>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary. Here is a sample; alter the names:
+
+ Yoyodyne, Inc., hereby disclaims all copyright interest in the
+ library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+ <signature of Ty Coon>, 1 April 1990
+ Ty Coon, President of Vice
+
+That's all there is to it!
+
+
diff --git a/core/vendor/doctrine/common/README.md b/core/vendor/doctrine/common/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..c63f7627d9af25b68c69ee4db9109a6c0b61bacb
--- /dev/null
+++ b/core/vendor/doctrine/common/README.md
@@ -0,0 +1,12 @@
+# Doctrine Common
+
+[](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://www.doctrine-project.org/projects/common/current/docs/en)
+* [Issue Tracker](http://www.doctrine-project.org/jira/browse/DCOM)
+* [Downloads](http://github.com/doctrine/common/downloads)
diff --git a/core/vendor/doctrine/common/UPGRADE_TO_2_1 b/core/vendor/doctrine/common/UPGRADE_TO_2_1
new file mode 100644
index 0000000000000000000000000000000000000000..891a2e5c2bb46c160429c436def2dfb813ca78c6
--- /dev/null
+++ b/core/vendor/doctrine/common/UPGRADE_TO_2_1
@@ -0,0 +1,39 @@
+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.
+
diff --git a/core/vendor/doctrine/common/UPGRADE_TO_2_2 b/core/vendor/doctrine/common/UPGRADE_TO_2_2
new file mode 100644
index 0000000000000000000000000000000000000000..1d93a131ed192a113c8b7436210bd1c02794486b
--- /dev/null
+++ b/core/vendor/doctrine/common/UPGRADE_TO_2_2
@@ -0,0 +1,61 @@
+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
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/build.properties b/core/vendor/doctrine/common/build.properties
new file mode 100644
index 0000000000000000000000000000000000000000..ff311a45925fb3e911bb0012724d395b6bcd2635
--- /dev/null
+++ b/core/vendor/doctrine/common/build.properties
@@ -0,0 +1,6 @@
+# Project Name
+project.name=DoctrineCommon
+
+# Version class and file
+project.version_class = Doctrine\Common\Version
+project.version_file = lib/Doctrine/Common/Version.php
diff --git a/core/vendor/doctrine/common/build.xml b/core/vendor/doctrine/common/build.xml
new file mode 100644
index 0000000000000000000000000000000000000000..71a9a5000e4c260788c9d1522cd5fabda3d52052
--- /dev/null
+++ b/core/vendor/doctrine/common/build.xml
@@ -0,0 +1,59 @@
+<?xml version="1.0"?>
+<project name="Doctrine2" default="build" basedir=".">
+ <taskdef classname="phing.tasks.ext.d51PearPkg2Task" name="d51pearpkg2" />
+ <import file="${project.basedir}/lib/vendor/doctrine-build-common/packaging.xml" />
+
+ <property file="build.properties" />
+
+ <!--
+ Fileset for artifacts shared across all distributed packages.
+ -->
+ <fileset id="shared-artifacts" dir=".">
+ <include name="LICENSE"/>
+ <include name="COPYRIGHT"/>
+ <include name="CHANGELOG"/>
+ </fileset>
+
+ <!--
+ Fileset for the sources of the Doctrine Common package.
+ -->
+ <fileset id="common-sources" dir="./lib">
+ <include name="Doctrine/Common/**"/>
+ </fileset>
+
+ <!--
+ Builds Common package, preparing it for distribution.
+ -->
+ <target name="copy-files" depends="prepare">
+ <copy todir="${build.dir}/${project.name}-${version}">
+ <fileset refid="shared-artifacts"/>
+ </copy>
+ <copy todir="${build.dir}/${project.name}-${version}">
+ <fileset refid="common-sources"/>
+ </copy>
+ </target>
+
+ <!--
+ Builds distributable PEAR packages.
+ -->
+ <target name="define-pear-package" depends="copy-files">
+ <d51pearpkg2 baseinstalldir="/" dir="${build.dir}/${project.name}-${version}">
+ <name>DoctrineCommon</name>
+ <summary>Doctrine Common PHP Extensions</summary>
+ <channel>pear.doctrine-project.org</channel>
+ <description>The Doctrine Common package contains shared code between the other packages.</description>
+ <lead user="jwage" name="Jonathan H. Wage" email="jonwage@gmail.com" />
+ <lead user="guilhermeblanco" name="Guilherme Blanco" email="guilhermeblanco@gmail.com" />
+ <lead user="romanb" name="Roman Borschel" email="roman@code-factory.org" />
+ <lead user="beberlei" name="Benjamin Eberlei" email="kontakt@beberlei.de" />
+ <license>LGPL</license>
+ <version release="${pear.version}" api="${pear.version}" />
+ <stability release="${pear.stability}" api="${pear.stability}" />
+ <notes>-</notes>
+ <dependencies>
+ <php minimum_version="5.3.0" />
+ <pear minimum_version="1.6.0" recommended_version="1.6.1" />
+ </dependencies>
+ </d51pearpkg2>
+ </target>
+</project>
diff --git a/core/vendor/doctrine/common/composer.json b/core/vendor/doctrine/common/composer.json
new file mode 100644
index 0000000000000000000000000000000000000000..7780d93d617fb307f2ab2144765374cb790e6f61
--- /dev/null
+++ b/core/vendor/doctrine/common/composer.json
@@ -0,0 +1,21 @@
+{
+ "name": "doctrine/common",
+ "type": "library","version":"2.2.2",
+ "description": "Common Library for Doctrine projects",
+ "keywords": ["collections", "spl", "eventmanager", "annotations", "persistence"],
+ "homepage": "http://www.doctrine-project.org",
+ "license": "LGPL",
+ "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"
+ },
+ "autoload": {
+ "psr-0": { "Doctrine\\Common": "lib/" }
+ }
+}
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/Annotation.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/Annotation.php
new file mode 100644
index 0000000000000000000000000000000000000000..625125220f79c35693741a35e26c8923a89cebfa
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/Annotation.php
@@ -0,0 +1,75 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Annotations;
+
+/**
+ * Annotations class
+ *
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author Jonathan Wage <jonwage@gmail.com>
+ * @author Roman Borschel <roman@code-factory.org>
+ */
+class Annotation
+{
+ /**
+ * Value property. Common among all derived classes.
+ *
+ * @var string
+ */
+ public $value;
+
+ /**
+ * Constructor
+ *
+ * @param array $data Key-value for properties to be defined in this class
+ */
+ public final function __construct(array $data)
+ {
+ foreach ($data as $key => $value) {
+ $this->$key = $value;
+ }
+ }
+
+ /**
+ * Error handler for unknown property accessor in Annotation class.
+ *
+ * @param string $name Unknown property name
+ */
+ public function __get($name)
+ {
+ throw new \BadMethodCallException(
+ sprintf("Unknown property '%s' on annotation '%s'.", $name, get_class($this))
+ );
+ }
+
+ /**
+ * Error handler for unknown property mutator in Annotation class.
+ *
+ * @param string $name Unkown property name
+ * @param mixed $value Property value
+ */
+ public function __set($name, $value)
+ {
+ throw new \BadMethodCallException(
+ sprintf("Unknown property '%s' on annotation '%s'.", $name, get_class($this))
+ );
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/Annotation/Attribute.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/Annotation/Attribute.php
new file mode 100644
index 0000000000000000000000000000000000000000..21597b14c9f6c96848b6f810e3280a0f34c498e5
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/Annotation/Attribute.php
@@ -0,0 +1,47 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Annotations\Annotation;
+
+/**
+ * Annotation that can be used to signal to the parser
+ * to check the attribute type during the parsing process.
+ *
+ * @author Fabio B. Silva <fabio.bat.silva@gmail.com>
+ *
+ * @Annotation
+ */
+final class Attribute
+{
+ /**
+ * @var string
+ */
+ public $name;
+
+ /**
+ * @var string
+ */
+ public $type;
+
+ /**
+ * @var boolean
+ */
+ public $required = false;
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/Annotation/Attributes.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/Annotation/Attributes.php
new file mode 100644
index 0000000000000000000000000000000000000000..6e314be463c6bd27d9bf5c427010070c5fdfdeb2
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/Annotation/Attributes.php
@@ -0,0 +1,37 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Annotations\Annotation;
+
+/**
+ * Annotation that can be used to signal to the parser
+ * to check the types of all declared attributes during the parsing process.
+ *
+ * @author Fabio B. Silva <fabio.bat.silva@gmail.com>
+ *
+ * @Annotation
+ */
+final class Attributes
+{
+ /**
+ * @var array<Doctrine\Common\Annotations\Annotation\Attribute>
+ */
+ public $value;
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/Annotation/IgnoreAnnotation.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/Annotation/IgnoreAnnotation.php
new file mode 100644
index 0000000000000000000000000000000000000000..1b2b20ac194543b5b8f9cd611e6cee4ce4c66849
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/Annotation/IgnoreAnnotation.php
@@ -0,0 +1,44 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Annotations\Annotation;
+
+/**
+ * Annotation that can be used to signal to the parser to ignore specific
+ * annotations during the parsing process.
+ *
+ * @Annotation
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+final class IgnoreAnnotation
+{
+ public $names;
+
+ public function __construct(array $values)
+ {
+ if (is_string($values['value'])) {
+ $values['value'] = array($values['value']);
+ }
+ if (!is_array($values['value'])) {
+ throw new \RuntimeException(sprintf('@IgnoreAnnotation expects either a string name, or an array of strings, but got %s.', json_encode($values['value'])));
+ }
+
+ $this->names = $values['value'];
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/Annotation/Required.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/Annotation/Required.php
new file mode 100644
index 0000000000000000000000000000000000000000..7b89a02288f469bbf55dd950d0dc2220815f2370
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/Annotation/Required.php
@@ -0,0 +1,33 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Annotations\Annotation;
+
+/**
+ * Annotation that can be used to signal to the parser
+ * to check if that attribute is required during the parsing process.
+ *
+ * @author Fabio B. Silva <fabio.bat.silva@gmail.com>
+ *
+ * @Annotation
+ */
+final class Required
+{
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/Annotation/Target.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/Annotation/Target.php
new file mode 100644
index 0000000000000000000000000000000000000000..c41896add0b7943ae86a4cce029ecdc1043eb89d
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/Annotation/Target.php
@@ -0,0 +1,105 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Annotations\Annotation;
+
+/**
+ * Annotation that can be used to signal to the parser
+ * to check the annotation target during the parsing process.
+ *
+ * @author Fabio B. Silva <fabio.bat.silva@gmail.com>
+ *
+ * @Annotation
+ */
+final class Target
+{
+ const TARGET_CLASS = 1;
+ const TARGET_METHOD = 2;
+ const TARGET_PROPERTY = 4;
+ const TARGET_ANNOTATION = 8;
+ const TARGET_ALL = 15;
+
+ /**
+ * @var array
+ */
+ private static $map = array(
+ 'ALL' => self::TARGET_ALL,
+ 'CLASS' => self::TARGET_CLASS,
+ 'METHOD' => self::TARGET_METHOD,
+ 'PROPERTY' => self::TARGET_PROPERTY,
+ 'ANNOTATION' => self::TARGET_ANNOTATION,
+ );
+
+ /**
+ * @var array
+ */
+ public $value;
+
+ /**
+ * Targets as bitmask.
+ *
+ * @var integer
+ */
+ public $targets;
+
+ /**
+ * Literal target declaration.
+ *
+ * @var integer
+ */
+ public $literal;
+
+ /**
+ * Annotation construct
+ *
+ * @param array $values
+ */
+ public function __construct(array $values)
+ {
+ if (!isset($values['value'])){
+ $values['value'] = null;
+ }
+ if (is_string($values['value'])){
+ $values['value'] = array($values['value']);
+ }
+ if (!is_array($values['value'])){
+ throw new \InvalidArgumentException(
+ sprintf('@Target expects either a string value, or an array of strings, "%s" given.',
+ is_object($values['value']) ? get_class($values['value']) : gettype($values['value'])
+ )
+ );
+ }
+
+ $bitmask = 0;
+ foreach ($values['value'] as $literal) {
+ if(!isset(self::$map[$literal])){
+ throw new \InvalidArgumentException(
+ sprintf('Invalid Target "%s". Available targets: [%s]',
+ $literal, implode(', ', array_keys(self::$map)))
+ );
+ }
+ $bitmask += self::$map[$literal];
+ }
+
+ $this->targets = $bitmask;
+ $this->value = $values['value'];
+ $this->literal = implode(', ', $this->value);
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/AnnotationException.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/AnnotationException.php
new file mode 100644
index 0000000000000000000000000000000000000000..fdc1913a1281716874a0ea727c5329c268f0c25a
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/AnnotationException.php
@@ -0,0 +1,111 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Annotations;
+
+/**
+ * Description of AnnotationException
+ *
+ * @since 2.0
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author Jonathan Wage <jonwage@gmail.com>
+ * @author Roman Borschel <roman@code-factory.org>
+ */
+class AnnotationException extends \Exception
+{
+ /**
+ * Creates a new AnnotationException describing a Syntax error.
+ *
+ * @param string $message Exception message
+ * @return AnnotationException
+ */
+ public static function syntaxError($message)
+ {
+ return new self('[Syntax Error] ' . $message);
+ }
+
+ /**
+ * Creates a new AnnotationException describing a Semantical error.
+ *
+ * @param string $message Exception message
+ * @return AnnotationException
+ */
+ public static function semanticalError($message)
+ {
+ return new self('[Semantical Error] ' . $message);
+ }
+
+ /**
+ * Creates a new AnnotationException describing an error which occurred during
+ * the creation of the annotation.
+ *
+ * @since 2.2
+ * @param string $message
+ * @return AnnotationException
+ */
+ public static function creationError($message)
+ {
+ return new self('[Creation Error] ' . $message);
+ }
+
+ /**
+ * Creates a new AnnotationException describing an type error of an attribute.
+ *
+ * @since 2.2
+ * @param string $attributeName
+ * @param string $annotationName
+ * @param string $context
+ * @param string $expected
+ * @param mixed $actual
+ * @return AnnotationException
+ */
+ public static function typeError($attributeName, $annotationName, $context, $expected, $actual)
+ {
+ return new self(sprintf(
+ '[Type Error] Attribute "%s" of @%s declared on %s expects %s, but got %s.',
+ $attributeName,
+ $annotationName,
+ $context,
+ $expected,
+ is_object($actual) ? 'an instance of '.get_class($actual) : gettype($actual)
+ ));
+ }
+
+ /**
+ * Creates a new AnnotationException describing an required error of an attribute.
+ *
+ * @since 2.2
+ * @param string $attributeName
+ * @param string $annotationName
+ * @param string $context
+ * @param string $expected
+ * @return AnnotationException
+ */
+ public static function requiredError($attributeName, $annotationName, $context, $expected)
+ {
+ return new self(sprintf(
+ '[Type Error] Attribute "%s" of @%s declared on %s expects %s. This value should not be null.',
+ $attributeName,
+ $annotationName,
+ $context,
+ $expected
+ ));
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/AnnotationReader.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/AnnotationReader.php
new file mode 100644
index 0000000000000000000000000000000000000000..dda8b231f18d29a768434ec1e4463d20cbec9008
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/AnnotationReader.php
@@ -0,0 +1,301 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Annotations;
+
+use Doctrine\Common\Annotations\Annotation\IgnoreAnnotation;
+use Doctrine\Common\Annotations\Annotation\Target;
+use Closure;
+use ReflectionClass;
+use ReflectionMethod;
+use ReflectionProperty;
+
+/**
+ * A reader for docblock annotations.
+ *
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author Jonathan Wage <jonwage@gmail.com>
+ * @author Roman Borschel <roman@code-factory.org>
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+final class AnnotationReader implements Reader
+{
+ /**
+ * Global map for imports.
+ *
+ * @var array
+ */
+ private static $globalImports = array(
+ 'ignoreannotation' => 'Doctrine\Common\Annotations\Annotation\IgnoreAnnotation',
+ );
+
+ /**
+ * A list with annotations that are not causing exceptions when not resolved to an annotation class.
+ *
+ * The names are case sensitive.
+ *
+ * @var array
+ */
+ private static $globalIgnoredNames = array(
+ 'access'=> true, 'author'=> true, 'copyright'=> true, 'deprecated'=> true,
+ 'example'=> true, 'ignore'=> true, 'internal'=> true, 'link'=> true, 'see'=> true,
+ 'since'=> true, 'tutorial'=> true, 'version'=> true, 'package'=> true,
+ 'subpackage'=> true, 'name'=> true, 'global'=> true, 'param'=> true,
+ 'return'=> true, 'staticvar'=> true, 'category'=> true, 'staticVar'=> true,
+ 'static'=> true, 'var'=> true, 'throws'=> true, 'inheritdoc'=> true,
+ 'inheritDoc'=> true, 'license'=> true, 'todo'=> true, 'deprecated'=> true,
+ 'deprec'=> true, 'author'=> true, 'property' => true, 'method' => true,
+ 'abstract'=> true, 'exception'=> true, 'magic' => true, 'api' => true,
+ 'final'=> true, 'filesource'=> true, 'throw' => true, 'uses' => true,
+ 'usedby'=> true, 'private' => true, 'Annotation' => true, 'override' => true,
+ 'codeCoverageIgnore' => true, 'codeCoverageIgnoreStart' => true, 'codeCoverageIgnoreEnd' => true,
+ 'Required' => true, 'Attribute' => true, 'Attributes' => true,
+ 'Target' => true, 'SuppressWarnings' => true,
+ );
+
+ /**
+ * Add a new annotation to the globally ignored annotation names with regard to exception handling.
+ *
+ * @param string $name
+ */
+ static public function addGlobalIgnoredName($name)
+ {
+ self::$globalIgnoredNames[$name] = true;
+ }
+
+ /**
+ * Annotations Parser
+ *
+ * @var Doctrine\Common\Annotations\DocParser
+ */
+ private $parser;
+
+ /**
+ * Annotations Parser used to collect parsing metadata
+ *
+ * @var Doctrine\Common\Annotations\DocParser
+ */
+ private $preParser;
+
+ /**
+ * PHP Parser used to collect imports.
+ *
+ * @var Doctrine\Common\Annotations\PhpParser
+ */
+ private $phpParser;
+
+ /**
+ * In-memory cache mechanism to store imported annotations per class.
+ *
+ * @var array
+ */
+ private $imports = array();
+
+ /**
+ * In-memory cache mechanism to store ignored annotations per class.
+ *
+ * @var array
+ */
+ private $ignoredAnnotationNames = array();
+
+ /**
+ * Constructor.
+ *
+ * Initializes a new AnnotationReader.
+ */
+ public function __construct()
+ {
+ AnnotationRegistry::registerFile(__DIR__ . '/Annotation/IgnoreAnnotation.php');
+
+ $this->parser = new DocParser;
+
+ $this->preParser = new DocParser;
+ $this->preParser->setImports(self::$globalImports);
+ $this->preParser->setIgnoreNotImportedAnnotations(true);
+
+ $this->phpParser = new PhpParser;
+ }
+
+ /**
+ * Gets the annotations applied to a class.
+ *
+ * @param ReflectionClass $class The ReflectionClass of the class from which
+ * the class annotations should be read.
+ * @return array An array of Annotations.
+ */
+ public function getClassAnnotations(ReflectionClass $class)
+ {
+ $this->parser->setTarget(Target::TARGET_CLASS);
+ $this->parser->setImports($this->getImports($class));
+ $this->parser->setIgnoredAnnotationNames($this->getIgnoredAnnotationNames($class));
+
+ return $this->parser->parse($class->getDocComment(), 'class ' . $class->getName());
+ }
+
+ /**
+ * Gets a class annotation.
+ *
+ * @param ReflectionClass $class The ReflectionClass of the class from which
+ * the class annotations should be read.
+ * @param string $annotationName The name of the annotation.
+ * @return The Annotation or NULL, if the requested annotation does not exist.
+ */
+ public function getClassAnnotation(ReflectionClass $class, $annotationName)
+ {
+ $annotations = $this->getClassAnnotations($class);
+
+ foreach ($annotations as $annotation) {
+ if ($annotation instanceof $annotationName) {
+ return $annotation;
+ }
+ }
+
+ return null;
+ }
+
+ /**
+ * Gets the annotations applied to a property.
+ *
+ * @param ReflectionProperty $property The ReflectionProperty of the property
+ * from which the annotations should be read.
+ * @return array An array of Annotations.
+ */
+ public function getPropertyAnnotations(ReflectionProperty $property)
+ {
+ $class = $property->getDeclaringClass();
+ $context = 'property ' . $class->getName() . "::\$" . $property->getName();
+ $this->parser->setTarget(Target::TARGET_PROPERTY);
+ $this->parser->setImports($this->getImports($class));
+ $this->parser->setIgnoredAnnotationNames($this->getIgnoredAnnotationNames($class));
+
+ return $this->parser->parse($property->getDocComment(), $context);
+ }
+
+ /**
+ * Gets a property annotation.
+ *
+ * @param ReflectionProperty $property
+ * @param string $annotationName The name of the annotation.
+ * @return The Annotation or NULL, if the requested annotation does not exist.
+ */
+ public function getPropertyAnnotation(ReflectionProperty $property, $annotationName)
+ {
+ $annotations = $this->getPropertyAnnotations($property);
+
+ foreach ($annotations as $annotation) {
+ if ($annotation instanceof $annotationName) {
+ return $annotation;
+ }
+ }
+
+ return null;
+ }
+
+ /**
+ * Gets the annotations applied to a method.
+ *
+ * @param ReflectionMethod $property The ReflectionMethod of the method from which
+ * the annotations should be read.
+ * @return array An array of Annotations.
+ */
+ public function getMethodAnnotations(ReflectionMethod $method)
+ {
+ $class = $method->getDeclaringClass();
+ $context = 'method ' . $class->getName() . '::' . $method->getName() . '()';
+ $this->parser->setTarget(Target::TARGET_METHOD);
+ $this->parser->setImports($this->getImports($class));
+ $this->parser->setIgnoredAnnotationNames($this->getIgnoredAnnotationNames($class));
+
+ return $this->parser->parse($method->getDocComment(), $context);
+ }
+
+ /**
+ * Gets a method annotation.
+ *
+ * @param ReflectionMethod $method
+ * @param string $annotationName The name of the annotation.
+ * @return The Annotation or NULL, if the requested annotation does not exist.
+ */
+ public function getMethodAnnotation(ReflectionMethod $method, $annotationName)
+ {
+ $annotations = $this->getMethodAnnotations($method);
+
+ foreach ($annotations as $annotation) {
+ if ($annotation instanceof $annotationName) {
+ return $annotation;
+ }
+ }
+
+ return null;
+ }
+
+ /**
+ * Returns the ignored annotations for the given class.
+ *
+ * @param ReflectionClass $class
+ * @return array
+ */
+ private function getIgnoredAnnotationNames(ReflectionClass $class)
+ {
+ if (isset($this->ignoredAnnotationNames[$name = $class->getName()])) {
+ return $this->ignoredAnnotationNames[$name];
+ }
+ $this->collectParsingMetadata($class);
+
+ return $this->ignoredAnnotationNames[$name];
+ }
+
+ private function getImports(ReflectionClass $class)
+ {
+ if (isset($this->imports[$name = $class->getName()])) {
+ return $this->imports[$name];
+ }
+ $this->collectParsingMetadata($class);
+
+ return $this->imports[$name];
+ }
+
+ /**
+ * Collects parsing metadata for a given class
+ *
+ * @param ReflectionClass $class
+ */
+ private function collectParsingMetadata(ReflectionClass $class)
+ {
+ $ignoredAnnotationNames = self::$globalIgnoredNames;
+
+ $annotations = $this->preParser->parse($class->getDocComment(), 'class '.$class->name);
+ foreach ($annotations as $annotation) {
+ if ($annotation instanceof IgnoreAnnotation) {
+ foreach ($annotation->names AS $annot) {
+ $ignoredAnnotationNames[$annot] = true;
+ }
+ }
+ }
+
+ $name = $class->getName();
+ $this->imports[$name] = array_merge(
+ self::$globalImports,
+ $this->phpParser->parseClass($class),
+ array('__NAMESPACE__' => $class->getNamespaceName())
+ );
+ $this->ignoredAnnotationNames[$name] = $ignoredAnnotationNames;
+ }
+}
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/AnnotationRegistry.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/AnnotationRegistry.php
new file mode 100644
index 0000000000000000000000000000000000000000..60b00f5136387579c75c15e35f82494bf34b40ad
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/AnnotationRegistry.php
@@ -0,0 +1,129 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Annotations;
+
+final class AnnotationRegistry
+{
+ /**
+ * A map of namespaces to use for autoloading purposes based on a PSR-0 convention.
+ *
+ * Contains the namespace as key and an array of directories as value. If the value is NULL
+ * the include path is used for checking for the corresponding file.
+ *
+ * This autoloading mechanism does not utilize the PHP autoloading but implements autoloading on its own.
+ *
+ * @var array
+ */
+ static private $autoloadNamespaces = array();
+
+ /**
+ * A map of autoloader callables.
+ *
+ * @var array
+ */
+ static private $loaders = array();
+
+ static public function reset()
+ {
+ self::$autoloadNamespaces = array();
+ self::$loaders = array();
+ }
+
+ static public function registerFile($file)
+ {
+ require_once $file;
+ }
+
+ /**
+ * Add a namespace with one or many directories to look for files or null for the include path.
+ *
+ * Loading of this namespaces will be done with a PSR-0 namespace loading algorithm.
+ *
+ * @param string $namespace
+ * @param string|array|null $dirs
+ */
+ static public function registerAutoloadNamespace($namespace, $dirs = null)
+ {
+ self::$autoloadNamespaces[$namespace] = $dirs;
+ }
+
+ /**
+ * Register multiple namespaces
+ *
+ * Loading of this namespaces will be done with a PSR-0 namespace loading algorithm.
+ *
+ * @param array $namespaces
+ */
+ static public function registerAutoloadNamespaces(array $namespaces)
+ {
+ self::$autoloadNamespaces = array_merge(self::$autoloadNamespaces, $namespaces);
+ }
+
+ /**
+ * Register an autoloading callabale for annotations, much like spl_autoload_register().
+ *
+ * NOTE: These class loaders HAVE to be silent when a class was not found!
+ * IMPORTANT: Loaders have to return true if they loaded a class that could contain the searched annotation class.
+ *
+ * @param callabale $callabale
+ */
+ static public function registerLoader($callabale)
+ {
+ if (!is_callable($callabale)) {
+ throw new \InvalidArgumentException("A callable is expected in AnnotationRegistry::registerLoader().");
+ }
+ self::$loaders[] = $callabale;
+ }
+
+ /**
+ * Autoload an annotation class silently.
+ *
+ * @param string $class
+ * @return void
+ */
+ static public function loadAnnotationClass($class)
+ {
+ foreach (self::$autoloadNamespaces AS $namespace => $dirs) {
+ if (strpos($class, $namespace) === 0) {
+ $file = str_replace("\\", DIRECTORY_SEPARATOR, $class) . ".php";
+ if ($dirs === null) {
+ if ($path = stream_resolve_include_path($file)) {
+ require $path;
+ return true;
+ }
+ } else {
+ foreach((array)$dirs AS $dir) {
+ if (file_exists($dir . DIRECTORY_SEPARATOR . $file)) {
+ require $dir . DIRECTORY_SEPARATOR . $file;
+ return true;
+ }
+ }
+ }
+ }
+ }
+
+ foreach (self::$loaders AS $loader) {
+ if (call_user_func($loader, $class) === true) {
+ return true;
+ }
+ }
+ return false;
+ }
+}
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/CachedReader.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/CachedReader.php
new file mode 100644
index 0000000000000000000000000000000000000000..6ea47c6ac64c48c5161a06b49fe758d1701ddfcf
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/CachedReader.php
@@ -0,0 +1,179 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Annotations;
+
+use Doctrine\Common\Cache\Cache;
+
+/**
+ * A cache aware annotation reader.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ */
+final class CachedReader implements Reader
+{
+ private static $CACHE_SALT = '@[Annot]';
+
+ /**
+ * @var Reader
+ */
+ private $delegate;
+
+ /**
+ * @var Cache
+ */
+ private $cache;
+
+ /**
+ * @var boolean
+ */
+ private $debug;
+
+ /**
+ * @var array
+ */
+ private $loadedAnnotations;
+
+ /**
+ * @param Reader $reader
+ * @param Cache $cache
+ */
+ public function __construct(Reader $reader, Cache $cache, $debug = false)
+ {
+ $this->delegate = $reader;
+ $this->cache = $cache;
+ $this->debug = $debug;
+ }
+
+ public function getClassAnnotations(\ReflectionClass $class)
+ {
+ $cacheKey = $class->getName() . self::$CACHE_SALT;
+
+ if (isset($this->loadedAnnotations[$cacheKey])) {
+ return $this->loadedAnnotations[$cacheKey];
+ }
+
+ // Attempt to grab data from cache
+ if (($data = $this->cache->fetch($cacheKey)) !== false) {
+ if (!$this->debug || $this->isCacheFresh($cacheKey, $class)) {
+ return $data;
+ }
+ }
+
+ $annots = $this->delegate->getClassAnnotations($class);
+ $this->cache->save($cacheKey, $annots);
+ $this->cache->save('[C]'.$cacheKey, time());
+
+ return $this->loadedAnnotations[$cacheKey] = $annots;
+ }
+
+ public function getClassAnnotation(\ReflectionClass $class, $annotationName)
+ {
+ foreach ($this->getClassAnnotations($class) as $annot) {
+ if ($annot instanceof $annotationName) {
+ return $annot;
+ }
+ }
+
+ return null;
+ }
+
+ public function getPropertyAnnotations(\ReflectionProperty $property)
+ {
+ $class = $property->getDeclaringClass();
+ $cacheKey = $class->getName().'$'.$property->getName().self::$CACHE_SALT;
+
+ if (isset($this->loadedAnnotations[$cacheKey])) {
+ return $this->loadedAnnotations[$cacheKey];
+ }
+
+ // Attempt to grab data from cache
+ if (($data = $this->cache->fetch($cacheKey)) !== false) {
+ if (!$this->debug || $this->isCacheFresh($cacheKey, $class)) {
+ return $data;
+ }
+ }
+
+ $annots = $this->delegate->getPropertyAnnotations($property);
+ $this->cache->save($cacheKey, $annots);
+ $this->cache->save('[C]'.$cacheKey, time());
+
+ return $this->loadedAnnotations[$cacheKey] = $annots;
+ }
+
+ public function getPropertyAnnotation(\ReflectionProperty $property, $annotationName)
+ {
+ foreach ($this->getPropertyAnnotations($property) as $annot) {
+ if ($annot instanceof $annotationName) {
+ return $annot;
+ }
+ }
+
+ return null;
+ }
+
+ public function getMethodAnnotations(\ReflectionMethod $method)
+ {
+ $class = $method->getDeclaringClass();
+ $cacheKey = $class->getName().'#'.$method->getName().self::$CACHE_SALT;
+
+ if (isset($this->loadedAnnotations[$cacheKey])) {
+ return $this->loadedAnnotations[$cacheKey];
+ }
+
+ // Attempt to grab data from cache
+ if (($data = $this->cache->fetch($cacheKey)) !== false) {
+ if (!$this->debug || $this->isCacheFresh($cacheKey, $class)) {
+ return $data;
+ }
+ }
+
+ $annots = $this->delegate->getMethodAnnotations($method);
+ $this->cache->save($cacheKey, $annots);
+ $this->cache->save('[C]'.$cacheKey, time());
+
+ return $this->loadedAnnotations[$cacheKey] = $annots;
+ }
+
+ public function getMethodAnnotation(\ReflectionMethod $method, $annotationName)
+ {
+ foreach ($this->getMethodAnnotations($method) as $annot) {
+ if ($annot instanceof $annotationName) {
+ return $annot;
+ }
+ }
+
+ return null;
+ }
+
+ public function clearLoadedAnnotations()
+ {
+ $this->loadedAnnotations = array();
+ }
+
+ private function isCacheFresh($cacheKey, \ReflectionClass $class)
+ {
+ if (false === $filename = $class->getFilename()) {
+ return true;
+ }
+
+ return $this->cache->fetch('[C]'.$cacheKey) >= filemtime($filename);
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/DocLexer.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/DocLexer.php
new file mode 100644
index 0000000000000000000000000000000000000000..c6223e3647e089241b21869745b479a9fe99e6b9
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/DocLexer.php
@@ -0,0 +1,140 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Annotations;
+
+use Doctrine\Common\Lexer;
+
+/**
+ * Simple lexer for docblock annotations.
+ *
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author Jonathan Wage <jonwage@gmail.com>
+ * @author Roman Borschel <roman@code-factory.org>
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+final class DocLexer extends Lexer
+{
+ const T_NONE = 1;
+ const T_IDENTIFIER = 2;
+ const T_INTEGER = 3;
+ const T_STRING = 4;
+ const T_FLOAT = 5;
+
+ const T_AT = 101;
+ const T_CLOSE_CURLY_BRACES = 102;
+ const T_CLOSE_PARENTHESIS = 103;
+ const T_COMMA = 104;
+ const T_EQUALS = 105;
+ const T_FALSE = 106;
+ const T_NAMESPACE_SEPARATOR = 107;
+ const T_OPEN_CURLY_BRACES = 108;
+ const T_OPEN_PARENTHESIS = 109;
+ const T_TRUE = 110;
+ const T_NULL = 111;
+ const T_COLON = 112;
+
+ /**
+ * @inheritdoc
+ */
+ protected function getCatchablePatterns()
+ {
+ return array(
+ '[a-z_][a-z0-9_:]*',
+ '(?:[+-]?[0-9]+(?:[\.][0-9]+)*)(?:[eE][+-]?[0-9]+)?',
+ '"(?:[^"]|"")*"',
+ );
+ }
+
+ /**
+ * @inheritdoc
+ */
+ protected function getNonCatchablePatterns()
+ {
+ return array('\s+', '\*+', '(.)');
+ }
+
+ /**
+ * @inheritdoc
+ */
+ protected function getType(&$value)
+ {
+ $type = self::T_NONE;
+
+ // Checking numeric value
+ if (is_numeric($value)) {
+ return (strpos($value, '.') !== false || stripos($value, 'e') !== false)
+ ? self::T_FLOAT : self::T_INTEGER;
+ }
+
+ if ($value[0] === '"') {
+ $value = str_replace('""', '"', substr($value, 1, strlen($value) - 2));
+
+ return self::T_STRING;
+ } else {
+ switch (strtolower($value)) {
+ case '@':
+ return self::T_AT;
+
+ case ',':
+ return self::T_COMMA;
+
+ case '(':
+ return self::T_OPEN_PARENTHESIS;
+
+ case ')':
+ return self::T_CLOSE_PARENTHESIS;
+
+ case '{':
+ return self::T_OPEN_CURLY_BRACES;
+
+ case '}':
+ return self::T_CLOSE_CURLY_BRACES;
+
+ case '=':
+ return self::T_EQUALS;
+
+ case '\\':
+ return self::T_NAMESPACE_SEPARATOR;
+
+ case 'true':
+ return self::T_TRUE;
+
+ case 'false':
+ return self::T_FALSE;
+
+ case 'null':
+ return self::T_NULL;
+
+ case ':':
+ return self::T_COLON;
+
+ default:
+ if (ctype_alpha($value[0]) || $value[0] === '_') {
+ return self::T_IDENTIFIER;
+ }
+
+ break;
+ }
+ }
+
+ return $type;
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/DocParser.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/DocParser.php
new file mode 100644
index 0000000000000000000000000000000000000000..9d16b1762c0c06023d2a6f7cca66b6680c517a73
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/DocParser.php
@@ -0,0 +1,891 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Annotations;
+
+use Closure;
+use ReflectionClass;
+use Doctrine\Common\Annotations\Annotation\Target;
+use Doctrine\Common\Annotations\Annotation\Attribute;
+use Doctrine\Common\Annotations\Annotation\Attributes;
+
+/**
+ * A parser for docblock annotations.
+ *
+ * It is strongly discouraged to change the default annotation parsing process.
+ *
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author Jonathan Wage <jonwage@gmail.com>
+ * @author Roman Borschel <roman@code-factory.org>
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ * @author Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+final class DocParser
+{
+ /**
+ * An array of all valid tokens for a class name.
+ *
+ * @var array
+ */
+ private static $classIdentifiers = array(DocLexer::T_IDENTIFIER, DocLexer::T_TRUE, DocLexer::T_FALSE, DocLexer::T_NULL);
+
+ /**
+ * The lexer.
+ *
+ * @var Doctrine\Common\Annotations\DocLexer
+ */
+ private $lexer;
+
+ /**
+ * Current target context
+ *
+ * @var string
+ */
+ private $target;
+
+ /**
+ * Doc Parser used to collect annotation target
+ *
+ * @var Doctrine\Common\Annotations\DocParser
+ */
+ private static $metadataParser;
+
+ /**
+ * Flag to control if the current annotation is nested or not.
+ *
+ * @var boolean
+ */
+ private $isNestedAnnotation = false;
+
+ /**
+ * Hashmap containing all use-statements that are to be used when parsing
+ * the given doc block.
+ *
+ * @var array
+ */
+ private $imports = array();
+
+ /**
+ * This hashmap is used internally to cache results of class_exists()
+ * look-ups.
+ *
+ * @var array
+ */
+ private $classExists = array();
+
+ /**
+ * Whether annotations that have not been imported should be ignored.
+ *
+ * @var boolean
+ */
+ private $ignoreNotImportedAnnotations = false;
+
+ /**
+ * An array of default namespaces if operating in simple mode.
+ *
+ * @var array
+ */
+ private $namespaces = array();
+
+ /**
+ * A list with annotations that are not causing exceptions when not resolved to an annotation class.
+ *
+ * The names must be the raw names as used in the class, not the fully qualified
+ * class names.
+ *
+ * @var array
+ */
+ private $ignoredAnnotationNames = array();
+
+ /**
+ * @var string
+ */
+ private $context = '';
+
+ /**
+ * Hash-map for caching annotation metadata
+ * @var array
+ */
+ private static $annotationMetadata = array(
+ 'Doctrine\Common\Annotations\Annotation\Target' => array(
+ 'is_annotation' => true,
+ 'has_constructor' => true,
+ 'properties' => array(),
+ 'targets_literal' => 'ANNOTATION_CLASS',
+ 'targets' => Target::TARGET_CLASS,
+ 'default_property' => 'value',
+ 'attribute_types' => array(
+ 'value' => array(
+ 'required' => false,
+ 'type' =>'array',
+ 'array_type'=>'string',
+ 'value' =>'array<string>'
+ )
+ ),
+ ),
+ 'Doctrine\Common\Annotations\Annotation\Attribute' => array(
+ 'is_annotation' => true,
+ 'has_constructor' => false,
+ 'targets_literal' => 'ANNOTATION_ANNOTATION',
+ 'targets' => Target::TARGET_ANNOTATION,
+ 'default_property' => 'name',
+ 'properties' => array(
+ 'name' => 'name',
+ 'type' => 'type',
+ 'required' => 'required'
+ ),
+ 'attribute_types' => array(
+ 'value' => array(
+ 'required' => true,
+ 'type' =>'string',
+ 'value' =>'string'
+ ),
+ 'type' => array(
+ 'required' =>true,
+ 'type' =>'string',
+ 'value' =>'string'
+ ),
+ 'required' => array(
+ 'required' =>false,
+ 'type' =>'boolean',
+ 'value' =>'boolean'
+ )
+ ),
+ ),
+ 'Doctrine\Common\Annotations\Annotation\Attributes' => array(
+ 'is_annotation' => true,
+ 'has_constructor' => false,
+ 'targets_literal' => 'ANNOTATION_CLASS',
+ 'targets' => Target::TARGET_CLASS,
+ 'default_property' => 'value',
+ 'properties' => array(
+ 'value' => 'value'
+ ),
+ 'attribute_types' => array(
+ 'value' => array(
+ 'type' =>'array',
+ 'required' =>true,
+ 'array_type'=>'Doctrine\Common\Annotations\Annotation\Attribute',
+ 'value' =>'array<Doctrine\Common\Annotations\Annotation\Attribute>'
+ )
+ ),
+ ),
+ );
+
+ /**
+ * Hash-map for handle types declaration
+ *
+ * @var array
+ */
+ private static $typeMap = array(
+ 'float' => 'double',
+ 'bool' => 'boolean',
+ // allow uppercase Boolean in honor of George Boole
+ 'Boolean' => 'boolean',
+ 'int' => 'integer',
+ );
+
+ /**
+ * Constructs a new DocParser.
+ */
+ public function __construct()
+ {
+ $this->lexer = new DocLexer;
+ }
+
+ /**
+ * Sets the annotation names that are ignored during the parsing process.
+ *
+ * The names are supposed to be the raw names as used in the class, not the
+ * fully qualified class names.
+ *
+ * @param array $names
+ */
+ public function setIgnoredAnnotationNames(array $names)
+ {
+ $this->ignoredAnnotationNames = $names;
+ }
+
+ public function setIgnoreNotImportedAnnotations($bool)
+ {
+ $this->ignoreNotImportedAnnotations = (Boolean) $bool;
+ }
+
+ /**
+ * Sets the default namespaces.
+ * @param array $namespaces
+ */
+ public function addNamespace($namespace)
+ {
+ if ($this->imports) {
+ throw new \RuntimeException('You must either use addNamespace(), or setImports(), but not both.');
+ }
+ $this->namespaces[] = $namespace;
+ }
+
+ public function setImports(array $imports)
+ {
+ if ($this->namespaces) {
+ throw new \RuntimeException('You must either use addNamespace(), or setImports(), but not both.');
+ }
+ $this->imports = $imports;
+ }
+
+ /**
+ * Sets current target context as bitmask.
+ *
+ * @param integer $target
+ */
+ public function setTarget($target)
+ {
+ $this->target = $target;
+ }
+
+ /**
+ * Parses the given docblock string for annotations.
+ *
+ * @param string $input The docblock string to parse.
+ * @param string $context The parsing context.
+ * @return array Array of annotations. If no annotations are found, an empty array is returned.
+ */
+ public function parse($input, $context = '')
+ {
+ if (false === $pos = strpos($input, '@')) {
+ return array();
+ }
+
+ // also parse whatever character is before the @
+ if ($pos > 0) {
+ $pos -= 1;
+ }
+
+ $this->context = $context;
+ $this->lexer->setInput(trim(substr($input, $pos), '* /'));
+ $this->lexer->moveNext();
+
+ return $this->Annotations();
+ }
+
+ /**
+ * Attempts to match the given token with the current lookahead token.
+ * If they match, updates the lookahead token; otherwise raises a syntax error.
+ *
+ * @param int Token type.
+ * @return bool True if tokens match; false otherwise.
+ */
+ private function match($token)
+ {
+ if ( ! $this->lexer->isNextToken($token) ) {
+ $this->syntaxError($this->lexer->getLiteral($token));
+ }
+
+ return $this->lexer->moveNext();
+ }
+
+ /**
+ * Attempts to match the current lookahead token with any of the given tokens.
+ *
+ * If any of them matches, this method updates the lookahead token; otherwise
+ * a syntax error is raised.
+ *
+ * @param array $tokens
+ * @return bool
+ */
+ private function matchAny(array $tokens)
+ {
+ if ( ! $this->lexer->isNextTokenAny($tokens)) {
+ $this->syntaxError(implode(' or ', array_map(array($this->lexer, 'getLiteral'), $tokens)));
+ }
+
+ return $this->lexer->moveNext();
+ }
+
+ /**
+ * Generates a new syntax error.
+ *
+ * @param string $expected Expected string.
+ * @param array $token Optional token.
+ * @throws SyntaxException
+ */
+ private function syntaxError($expected, $token = null)
+ {
+ if ($token === null) {
+ $token = $this->lexer->lookahead;
+ }
+
+ $message = "Expected {$expected}, got ";
+
+ if ($this->lexer->lookahead === null) {
+ $message .= 'end of string';
+ } else {
+ $message .= "'{$token['value']}' at position {$token['position']}";
+ }
+
+ if (strlen($this->context)) {
+ $message .= ' in ' . $this->context;
+ }
+
+ $message .= '.';
+
+ throw AnnotationException::syntaxError($message);
+ }
+
+ /**
+ * Attempt to check if a class exists or not. This never goes through the PHP autoloading mechanism
+ * but uses the {@link AnnotationRegistry} to load classes.
+ *
+ * @param string $fqcn
+ * @return boolean
+ */
+ private function classExists($fqcn)
+ {
+ if (isset($this->classExists[$fqcn])) {
+ return $this->classExists[$fqcn];
+ }
+
+ // first check if the class already exists, maybe loaded through another AnnotationReader
+ if (class_exists($fqcn, false)) {
+ return $this->classExists[$fqcn] = true;
+ }
+
+ // final check, does this class exist?
+ return $this->classExists[$fqcn] = AnnotationRegistry::loadAnnotationClass($fqcn);
+ }
+
+ /**
+ * Collects parsing metadata for a given annotation class
+ *
+ * @param string $name The annotation name
+ */
+ private function collectAnnotationMetadata($name)
+ {
+ if (self::$metadataParser == null){
+ self::$metadataParser = new self();
+ self::$metadataParser->setTarget(Target::TARGET_CLASS);
+ self::$metadataParser->setIgnoreNotImportedAnnotations(true);
+ self::$metadataParser->setImports(array(
+ 'target' => 'Doctrine\Common\Annotations\Annotation\Target',
+ 'attribute' => 'Doctrine\Common\Annotations\Annotation\Attribute',
+ 'attributes' => 'Doctrine\Common\Annotations\Annotation\Attributes'
+ ));
+ AnnotationRegistry::registerFile(__DIR__ . '/Annotation/Target.php');
+ AnnotationRegistry::registerFile(__DIR__ . '/Annotation/Attribute.php');
+ AnnotationRegistry::registerFile(__DIR__ . '/Annotation/Attributes.php');
+ }
+
+ $class = new \ReflectionClass($name);
+ $docComment = $class->getDocComment();
+
+ // Sets default values for annotation metadata
+ $metadata = array(
+ 'default_property' => null,
+ 'has_constructor' => (null !== $constructor = $class->getConstructor()) && $constructor->getNumberOfParameters() > 0,
+ 'properties' => array(),
+ 'property_types' => array(),
+ 'attribute_types' => array(),
+ 'targets_literal' => null,
+ 'targets' => Target::TARGET_ALL,
+ 'is_annotation' => false !== strpos($docComment, '@Annotation'),
+ );
+
+ // verify that the class is really meant to be an annotation
+ if ($metadata['is_annotation']) {
+ foreach (self::$metadataParser->parse($docComment, 'class @' . $name) as $annotation) {
+ if ($annotation instanceof Target) {
+ $metadata['targets'] = $annotation->targets;
+ $metadata['targets_literal'] = $annotation->literal;
+
+ } elseif ($annotation instanceof Attributes) {
+ foreach ($annotation->value as $attrib) {
+ // handle internal type declaration
+ $type = isset(self::$typeMap[$attrib->type]) ? self::$typeMap[$attrib->type] : $attrib->type;
+
+ // handle the case if the property type is mixed
+ if ('mixed' !== $type) {
+ // Checks if the property has array<type>
+ if (false !== $pos = strpos($type, '<')) {
+ $arrayType = substr($type, $pos+1, -1);
+ $type = 'array';
+
+ if (isset(self::$typeMap[$arrayType])) {
+ $arrayType = self::$typeMap[$arrayType];
+ }
+
+ $metadata['attribute_types'][$attrib->name]['array_type'] = $arrayType;
+ }
+
+ $metadata['attribute_types'][$attrib->name]['type'] = $type;
+ $metadata['attribute_types'][$attrib->name]['value'] = $attrib->type;
+ $metadata['attribute_types'][$attrib->name]['required'] = $attrib->required;
+ }
+ }
+ }
+ }
+
+ // if not has a constructor will inject values into public properties
+ if (false === $metadata['has_constructor']) {
+ // collect all public properties
+ foreach ($class->getProperties(\ReflectionProperty::IS_PUBLIC) as $property) {
+ $metadata['properties'][$property->name] = $property->name;
+
+ // checks if the property has @var annotation
+ if ((false !== $propertyComment = $property->getDocComment())
+ && false !== strpos($propertyComment, '@var')
+ && preg_match('/@var\s+([^\s]+)/',$propertyComment, $matches)) {
+ // literal type declaration
+ $value = $matches[1];
+
+ // handle internal type declaration
+ $type = isset(self::$typeMap[$value]) ? self::$typeMap[$value] : $value;
+
+ // handle the case if the property type is mixed
+ if ('mixed' !== $type) {
+ // Checks if the property has @var array<type> annotation
+ if (false !== $pos = strpos($type, '<')) {
+ $arrayType = substr($type, $pos+1, -1);
+ $type = 'array';
+
+ if (isset(self::$typeMap[$arrayType])) {
+ $arrayType = self::$typeMap[$arrayType];
+ }
+
+ $metadata['attribute_types'][$property->name]['array_type'] = $arrayType;
+ }
+
+ $metadata['attribute_types'][$property->name]['type'] = $type;
+ $metadata['attribute_types'][$property->name]['value'] = $value;
+ $metadata['attribute_types'][$property->name]['required'] = false !== strpos($propertyComment, '@Required');
+ }
+ }
+ }
+
+ // choose the first property as default property
+ $metadata['default_property'] = reset($metadata['properties']);
+ }
+ }
+
+ self::$annotationMetadata[$name] = $metadata;
+ }
+
+ /**
+ * Annotations ::= Annotation {[ "*" ]* [Annotation]}*
+ *
+ * @return array
+ */
+ private function Annotations()
+ {
+ $annotations = array();
+
+ while (null !== $this->lexer->lookahead) {
+ if (DocLexer::T_AT !== $this->lexer->lookahead['type']) {
+ $this->lexer->moveNext();
+ continue;
+ }
+
+ // make sure the @ is preceded by non-catchable pattern
+ if (null !== $this->lexer->token && $this->lexer->lookahead['position'] === $this->lexer->token['position'] + strlen($this->lexer->token['value'])) {
+ $this->lexer->moveNext();
+ continue;
+ }
+
+ // make sure the @ is followed by either a namespace separator, or
+ // an identifier token
+ if ((null === $peek = $this->lexer->glimpse())
+ || (DocLexer::T_NAMESPACE_SEPARATOR !== $peek['type'] && !in_array($peek['type'], self::$classIdentifiers, true))
+ || $peek['position'] !== $this->lexer->lookahead['position'] + 1) {
+ $this->lexer->moveNext();
+ continue;
+ }
+
+ $this->isNestedAnnotation = false;
+ if (false !== $annot = $this->Annotation()) {
+ $annotations[] = $annot;
+ }
+ }
+
+ return $annotations;
+ }
+
+ /**
+ * Annotation ::= "@" AnnotationName ["(" [Values] ")"]
+ * AnnotationName ::= QualifiedName | SimpleName
+ * QualifiedName ::= NameSpacePart "\" {NameSpacePart "\"}* SimpleName
+ * NameSpacePart ::= identifier | null | false | true
+ * SimpleName ::= identifier | null | false | true
+ *
+ * @return mixed False if it is not a valid annotation.
+ */
+ private function Annotation()
+ {
+ $this->match(DocLexer::T_AT);
+
+ // check if we have an annotation
+ if ($this->lexer->isNextTokenAny(self::$classIdentifiers)) {
+ $this->lexer->moveNext();
+ $name = $this->lexer->token['value'];
+ } else if ($this->lexer->isNextToken(DocLexer::T_NAMESPACE_SEPARATOR)) {
+ $name = '';
+ } else {
+ $this->syntaxError('namespace separator or identifier');
+ }
+
+ while ($this->lexer->lookahead['position'] === $this->lexer->token['position'] + strlen($this->lexer->token['value']) && $this->lexer->isNextToken(DocLexer::T_NAMESPACE_SEPARATOR)) {
+ $this->match(DocLexer::T_NAMESPACE_SEPARATOR);
+ $this->matchAny(self::$classIdentifiers);
+ $name .= '\\'.$this->lexer->token['value'];
+ }
+
+ // only process names which are not fully qualified, yet
+ // fully qualified names must start with a \
+ $originalName = $name;
+ if ('\\' !== $name[0]) {
+ $alias = (false === $pos = strpos($name, '\\'))? $name : substr($name, 0, $pos);
+
+ $found = false;
+ if ($this->namespaces) {
+ foreach ($this->namespaces as $namespace) {
+ if ($this->classExists($namespace.'\\'.$name)) {
+ $name = $namespace.'\\'.$name;
+ $found = true;
+ break;
+ }
+ }
+ } elseif (isset($this->imports[$loweredAlias = strtolower($alias)])) {
+ if (false !== $pos) {
+ $name = $this->imports[$loweredAlias].substr($name, $pos);
+ } else {
+ $name = $this->imports[$loweredAlias];
+ }
+ $found = true;
+ } elseif (isset($this->imports['__NAMESPACE__']) && $this->classExists($this->imports['__NAMESPACE__'].'\\'.$name)) {
+ $name = $this->imports['__NAMESPACE__'].'\\'.$name;
+ $found = true;
+ } elseif ($this->classExists($name)) {
+ $found = true;
+ }
+
+ if (!$found) {
+ if ($this->ignoreNotImportedAnnotations || isset($this->ignoredAnnotationNames[$name])) {
+ return false;
+ }
+
+ throw AnnotationException::semanticalError(sprintf('The annotation "@%s" in %s was never imported. Did you maybe forget to add a "use" statement for this annotation?', $name, $this->context));
+ }
+ }
+
+ if (!$this->classExists($name)) {
+ throw AnnotationException::semanticalError(sprintf('The annotation "@%s" in %s does not exist, or could not be auto-loaded.', $name, $this->context));
+ }
+
+ // at this point, $name contains the fully qualified class name of the
+ // annotation, and it is also guaranteed that this class exists, and
+ // that it is loaded
+
+
+ // collects the metadata annotation only if there is not yet
+ if (!isset(self::$annotationMetadata[$name])) {
+ $this->collectAnnotationMetadata($name);
+ }
+
+ // verify that the class is really meant to be an annotation and not just any ordinary class
+ if (self::$annotationMetadata[$name]['is_annotation'] === false) {
+ if (isset($this->ignoredAnnotationNames[$originalName])) {
+ return false;
+ }
+
+ throw AnnotationException::semanticalError(sprintf('The class "%s" is not annotated with @Annotation. Are you sure this class can be used as annotation? If so, then you need to add @Annotation to the _class_ doc comment of "%s". If it is indeed no annotation, then you need to add @IgnoreAnnotation("%s") to the _class_ doc comment of %s.', $name, $name, $originalName, $this->context));
+ }
+
+ //if target is nested annotation
+ $target = $this->isNestedAnnotation ? Target::TARGET_ANNOTATION : $this->target;
+
+ // Next will be nested
+ $this->isNestedAnnotation = true;
+
+ //if annotation does not support current target
+ if (0 === (self::$annotationMetadata[$name]['targets'] & $target) && $target) {
+ throw AnnotationException::semanticalError(
+ sprintf('Annotation @%s is not allowed to be declared on %s. You may only use this annotation on these code elements: %s.',
+ $originalName, $this->context, self::$annotationMetadata[$name]['targets_literal'])
+ );
+ }
+
+ $values = array();
+ if ($this->lexer->isNextToken(DocLexer::T_OPEN_PARENTHESIS)) {
+ $this->match(DocLexer::T_OPEN_PARENTHESIS);
+
+ if ( ! $this->lexer->isNextToken(DocLexer::T_CLOSE_PARENTHESIS)) {
+ $values = $this->Values();
+ }
+
+ $this->match(DocLexer::T_CLOSE_PARENTHESIS);
+ }
+
+ // checks all declared attributes
+ foreach (self::$annotationMetadata[$name]['attribute_types'] as $property => $type) {
+ if ($property === self::$annotationMetadata[$name]['default_property']
+ && !isset($values[$property]) && isset($values['value'])) {
+ $property = 'value';
+ }
+
+ // handle a not given attribute or null value
+ if (!isset($values[$property])) {
+ if ($type['required']) {
+ throw AnnotationException::requiredError($property, $originalName, $this->context, 'a(n) '.$type['value']);
+ }
+
+ continue;
+ }
+
+ if ($type['type'] === 'array') {
+ // handle the case of a single value
+ if (!is_array($values[$property])) {
+ $values[$property] = array($values[$property]);
+ }
+
+ // checks if the attribute has array type declaration, such as "array<string>"
+ if (isset($type['array_type'])) {
+ foreach ($values[$property] as $item) {
+ if (gettype($item) !== $type['array_type'] && !$item instanceof $type['array_type']) {
+ throw AnnotationException::typeError($property, $originalName, $this->context, 'either a(n) '.$type['array_type'].', or an array of '.$type['array_type'].'s', $item);
+ }
+ }
+ }
+ } elseif (gettype($values[$property]) !== $type['type'] && !$values[$property] instanceof $type['type']) {
+ throw AnnotationException::typeError($property, $originalName, $this->context, 'a(n) '.$type['value'], $values[$property]);
+ }
+ }
+
+ // check if the annotation expects values via the constructor,
+ // or directly injected into public properties
+ if (self::$annotationMetadata[$name]['has_constructor'] === true) {
+ return new $name($values);
+ }
+
+ $instance = new $name();
+ foreach ($values as $property => $value) {
+ if (!isset(self::$annotationMetadata[$name]['properties'][$property])) {
+ if ('value' !== $property) {
+ throw AnnotationException::creationError(sprintf('The annotation @%s declared on %s does not have a property named "%s". Available properties: %s', $originalName, $this->context, $property, implode(', ', self::$annotationMetadata[$name]['properties'])));
+ }
+
+ // handle the case if the property has no annotations
+ if (!$property = self::$annotationMetadata[$name]['default_property']) {
+ throw AnnotationException::creationError(sprintf('The annotation @%s declared on %s does not accept any values, but got %s.', $originalName, $this->context, json_encode($values)));
+ }
+ }
+
+ $instance->{$property} = $value;
+ }
+
+ return $instance;
+ }
+
+ /**
+ * Values ::= Array | Value {"," Value}*
+ *
+ * @return array
+ */
+ private function Values()
+ {
+ $values = array();
+
+ // Handle the case of a single array as value, i.e. @Foo({....})
+ if ($this->lexer->isNextToken(DocLexer::T_OPEN_CURLY_BRACES)) {
+ $values['value'] = $this->Value();
+ return $values;
+ }
+
+ $values[] = $this->Value();
+
+ while ($this->lexer->isNextToken(DocLexer::T_COMMA)) {
+ $this->match(DocLexer::T_COMMA);
+ $token = $this->lexer->lookahead;
+ $value = $this->Value();
+
+ if ( ! is_object($value) && ! is_array($value)) {
+ $this->syntaxError('Value', $token);
+ }
+
+ $values[] = $value;
+ }
+
+ foreach ($values as $k => $value) {
+ if (is_object($value) && $value instanceof \stdClass) {
+ $values[$value->name] = $value->value;
+ } else if ( ! isset($values['value'])){
+ $values['value'] = $value;
+ } else {
+ if ( ! is_array($values['value'])) {
+ $values['value'] = array($values['value']);
+ }
+
+ $values['value'][] = $value;
+ }
+
+ unset($values[$k]);
+ }
+
+ return $values;
+ }
+
+ /**
+ * Value ::= PlainValue | FieldAssignment
+ *
+ * @return mixed
+ */
+ private function Value()
+ {
+ $peek = $this->lexer->glimpse();
+
+ if (DocLexer::T_EQUALS === $peek['type']) {
+ return $this->FieldAssignment();
+ }
+
+ return $this->PlainValue();
+ }
+
+ /**
+ * PlainValue ::= integer | string | float | boolean | Array | Annotation
+ *
+ * @return mixed
+ */
+ private function PlainValue()
+ {
+ if ($this->lexer->isNextToken(DocLexer::T_OPEN_CURLY_BRACES)) {
+ return $this->Arrayx();
+ }
+
+ if ($this->lexer->isNextToken(DocLexer::T_AT)) {
+ return $this->Annotation();
+ }
+
+ switch ($this->lexer->lookahead['type']) {
+ case DocLexer::T_STRING:
+ $this->match(DocLexer::T_STRING);
+ return $this->lexer->token['value'];
+
+ case DocLexer::T_INTEGER:
+ $this->match(DocLexer::T_INTEGER);
+ return (int)$this->lexer->token['value'];
+
+ case DocLexer::T_FLOAT:
+ $this->match(DocLexer::T_FLOAT);
+ return (float)$this->lexer->token['value'];
+
+ case DocLexer::T_TRUE:
+ $this->match(DocLexer::T_TRUE);
+ return true;
+
+ case DocLexer::T_FALSE:
+ $this->match(DocLexer::T_FALSE);
+ return false;
+
+ case DocLexer::T_NULL:
+ $this->match(DocLexer::T_NULL);
+ return null;
+
+ default:
+ $this->syntaxError('PlainValue');
+ }
+ }
+
+ /**
+ * FieldAssignment ::= FieldName "=" PlainValue
+ * FieldName ::= identifier
+ *
+ * @return array
+ */
+ private function FieldAssignment()
+ {
+ $this->match(DocLexer::T_IDENTIFIER);
+ $fieldName = $this->lexer->token['value'];
+
+ $this->match(DocLexer::T_EQUALS);
+
+ $item = new \stdClass();
+ $item->name = $fieldName;
+ $item->value = $this->PlainValue();
+
+ return $item;
+ }
+
+ /**
+ * Array ::= "{" ArrayEntry {"," ArrayEntry}* [","] "}"
+ *
+ * @return array
+ */
+ private function Arrayx()
+ {
+ $array = $values = array();
+
+ $this->match(DocLexer::T_OPEN_CURLY_BRACES);
+ $values[] = $this->ArrayEntry();
+
+ while ($this->lexer->isNextToken(DocLexer::T_COMMA)) {
+ $this->match(DocLexer::T_COMMA);
+
+ // optional trailing comma
+ if ($this->lexer->isNextToken(DocLexer::T_CLOSE_CURLY_BRACES)) {
+ break;
+ }
+
+ $values[] = $this->ArrayEntry();
+ }
+
+ $this->match(DocLexer::T_CLOSE_CURLY_BRACES);
+
+ foreach ($values as $value) {
+ list ($key, $val) = $value;
+
+ if ($key !== null) {
+ $array[$key] = $val;
+ } else {
+ $array[] = $val;
+ }
+ }
+
+ return $array;
+ }
+
+ /**
+ * ArrayEntry ::= Value | KeyValuePair
+ * KeyValuePair ::= Key ("=" | ":") PlainValue
+ * Key ::= string | integer
+ *
+ * @return array
+ */
+ private function ArrayEntry()
+ {
+ $peek = $this->lexer->glimpse();
+
+ if (DocLexer::T_EQUALS === $peek['type']
+ || DocLexer::T_COLON === $peek['type']) {
+ $this->matchAny(array(DocLexer::T_INTEGER, DocLexer::T_STRING));
+
+ $key = $this->lexer->token['value'];
+ $this->matchAny(array(DocLexer::T_EQUALS, DocLexer::T_COLON));
+
+ return array($key, $this->PlainValue());
+ }
+
+ return array(null, $this->Value());
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/FileCacheReader.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/FileCacheReader.php
new file mode 100644
index 0000000000000000000000000000000000000000..4a42b5832bbeabf5b47fc6ff492b91fceefb4675
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/FileCacheReader.php
@@ -0,0 +1,209 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Annotations;
+
+
+/**
+ * File cache reader for annotations.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ */
+class FileCacheReader implements Reader
+{
+ /**
+ * @var Reader
+ */
+ private $reader;
+ private $dir;
+ private $debug;
+ private $loadedAnnotations = array();
+
+ public function __construct(Reader $reader, $cacheDir, $debug = false)
+ {
+ $this->reader = $reader;
+ if (!is_dir($cacheDir) && !@mkdir($cacheDir, 0777, true)) {
+ throw new \InvalidArgumentException(sprintf('The directory "%s" does not exist and could not be created.', $cacheDir));
+ }
+ if (!is_writable($cacheDir)) {
+ throw new \InvalidArgumentException(sprintf('The directory "%s" is not writable. Both, the webserver and the console user need access. You can manage access rights for multiple users with "chmod +a". If your system does not support this, check out the acl package.', $cacheDir));
+ }
+
+ $this->dir = rtrim($cacheDir, '\\/');
+ $this->debug = $debug;
+ }
+
+ public function getClassAnnotations(\ReflectionClass $class)
+ {
+ $key = $class->getName();
+
+ if (isset($this->loadedAnnotations[$key])) {
+ return $this->loadedAnnotations[$key];
+ }
+
+ $path = $this->dir.'/'.strtr($key, '\\', '-').'.cache.php';
+ if (!file_exists($path)) {
+ $annot = $this->reader->getClassAnnotations($class);
+ $this->saveCacheFile($path, $annot);
+ return $this->loadedAnnotations[$key] = $annot;
+ }
+
+ if ($this->debug
+ && (false !== $filename = $class->getFilename())
+ && filemtime($path) < filemtime($filename)) {
+ @unlink($path);
+
+ $annot = $this->reader->getClassAnnotations($class);
+ $this->saveCacheFile($path, $annot);
+ return $this->loadedAnnotations[$key] = $annot;
+ }
+
+ return $this->loadedAnnotations[$key] = include $path;
+ }
+
+ public function getPropertyAnnotations(\ReflectionProperty $property)
+ {
+ $class = $property->getDeclaringClass();
+ $key = $class->getName().'$'.$property->getName();
+
+ if (isset($this->loadedAnnotations[$key])) {
+ return $this->loadedAnnotations[$key];
+ }
+
+ $path = $this->dir.'/'.strtr($key, '\\', '-').'.cache.php';
+ if (!file_exists($path)) {
+ $annot = $this->reader->getPropertyAnnotations($property);
+ $this->saveCacheFile($path, $annot);
+ return $this->loadedAnnotations[$key] = $annot;
+ }
+
+ if ($this->debug
+ && (false !== $filename = $class->getFilename())
+ && filemtime($path) < filemtime($filename)) {
+ unlink($path);
+
+ $annot = $this->reader->getPropertyAnnotations($property);
+ $this->saveCacheFile($path, $annot);
+ return $this->loadedAnnotations[$key] = $annot;
+ }
+
+ return $this->loadedAnnotations[$key] = include $path;
+ }
+
+ public function getMethodAnnotations(\ReflectionMethod $method)
+ {
+ $class = $method->getDeclaringClass();
+ $key = $class->getName().'#'.$method->getName();
+
+ if (isset($this->loadedAnnotations[$key])) {
+ return $this->loadedAnnotations[$key];
+ }
+
+ $path = $this->dir.'/'.strtr($key, '\\', '-').'.cache.php';
+ if (!file_exists($path)) {
+ $annot = $this->reader->getMethodAnnotations($method);
+ $this->saveCacheFile($path, $annot);
+ return $this->loadedAnnotations[$key] = $annot;
+ }
+
+ if ($this->debug
+ && (false !== $filename = $class->getFilename())
+ && filemtime($path) < filemtime($filename)) {
+ unlink($path);
+
+ $annot = $this->reader->getMethodAnnotations($method);
+ $this->saveCacheFile($path, $annot);
+ return $this->loadedAnnotations[$key] = $annot;
+ }
+
+ return $this->loadedAnnotations[$key] = include $path;
+ }
+
+ private function saveCacheFile($path, $data)
+ {
+ file_put_contents($path, '<?php return unserialize('.var_export(serialize($data), true).');');
+ }
+
+ /**
+ * Gets a class annotation.
+ *
+ * @param ReflectionClass $class The ReflectionClass of the class from which
+ * the class annotations should be read.
+ * @param string $annotationName The name of the annotation.
+ * @return The Annotation or NULL, if the requested annotation does not exist.
+ */
+ public function getClassAnnotation(\ReflectionClass $class, $annotationName)
+ {
+ $annotations = $this->getClassAnnotations($class);
+
+ foreach ($annotations as $annotation) {
+ if ($annotation instanceof $annotationName) {
+ return $annotation;
+ }
+ }
+
+ return null;
+ }
+
+ /**
+ * Gets a method annotation.
+ *
+ * @param ReflectionMethod $method
+ * @param string $annotationName The name of the annotation.
+ * @return The Annotation or NULL, if the requested annotation does not exist.
+ */
+ public function getMethodAnnotation(\ReflectionMethod $method, $annotationName)
+ {
+ $annotations = $this->getMethodAnnotations($method);
+
+ foreach ($annotations as $annotation) {
+ if ($annotation instanceof $annotationName) {
+ return $annotation;
+ }
+ }
+
+ return null;
+ }
+
+ /**
+ * Gets a property annotation.
+ *
+ * @param ReflectionProperty $property
+ * @param string $annotationName The name of the annotation.
+ * @return The Annotation or NULL, if the requested annotation does not exist.
+ */
+ public function getPropertyAnnotation(\ReflectionProperty $property, $annotationName)
+ {
+ $annotations = $this->getPropertyAnnotations($property);
+
+ foreach ($annotations as $annotation) {
+ if ($annotation instanceof $annotationName) {
+ return $annotation;
+ }
+ }
+
+ return null;
+ }
+
+ public function clearLoadedAnnotations()
+ {
+ $this->loadedAnnotations = array();
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/IndexedReader.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/IndexedReader.php
new file mode 100644
index 0000000000000000000000000000000000000000..1eea49210a3f8d64d2392bce6f9dd2cd8473efe0
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/IndexedReader.php
@@ -0,0 +1,94 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Annotations;
+
+use Doctrine\Common\Annotations\Reader;
+
+/**
+ * Allows the reader to be used in-place of Doctrine's reader.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class IndexedReader implements Reader
+{
+ private $delegate;
+
+ public function __construct(Reader $reader)
+ {
+ $this->delegate = $reader;
+ }
+
+ public function getClassAnnotations(\ReflectionClass $class)
+ {
+ $annotations = array();
+ foreach ($this->delegate->getClassAnnotations($class) as $annot) {
+ $annotations[get_class($annot)] = $annot;
+ }
+
+ return $annotations;
+ }
+
+ public function getClassAnnotation(\ReflectionClass $class, $annotation)
+ {
+ return $this->delegate->getClassAnnotation($class, $annotation);
+ }
+
+ public function getMethodAnnotations(\ReflectionMethod $method)
+ {
+ $annotations = array();
+ foreach ($this->delegate->getMethodAnnotations($method) as $annot) {
+ $annotations[get_class($annot)] = $annot;
+ }
+
+ return $annotations;
+ }
+
+ public function getMethodAnnotation(\ReflectionMethod $method, $annotation)
+ {
+ return $this->delegate->getMethodAnnotation($method, $annotation);
+ }
+
+ public function getPropertyAnnotations(\ReflectionProperty $property)
+ {
+ $annotations = array();
+ foreach ($this->delegate->getPropertyAnnotations($property) as $annot) {
+ $annotations[get_class($annot)] = $annot;
+ }
+
+ return $annotations;
+ }
+
+ public function getPropertyAnnotation(\ReflectionProperty $property, $annotation)
+ {
+ return $this->delegate->getPropertyAnnotation($property, $annotation);
+ }
+
+ /**
+ * Proxy all methods to the delegate.
+ *
+ * @param type $method
+ * @param type $args
+ * @return type
+ */
+ public function __call($method, $args)
+ {
+ return call_user_func_array(array($this->delegate, $method), $args);
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/PhpParser.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/PhpParser.php
new file mode 100644
index 0000000000000000000000000000000000000000..a14f8f5befcdce734ea045b65db65368c277cd34
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/PhpParser.php
@@ -0,0 +1,203 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Annotations;
+
+use SplFileObject;
+
+/**
+ * Parses a file for namespaces/use/class declarations.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ * @author Christian Kaps <christian.kaps@mohiva.com>
+ */
+final class PhpParser
+{
+ /**
+ * The token list.
+ *
+ * @var array
+ */
+ private $tokens;
+
+ /**
+ * The number of tokens.
+ *
+ * @var int
+ */
+ private $numTokens = 0;
+
+ /**
+ * The current array pointer.
+ *
+ * @var int
+ */
+ private $pointer = 0;
+
+ /**
+ * Parses a class.
+ *
+ * @param \ReflectionClass $class A <code>ReflectionClass</code> object.
+ * @return array A list with use statements in the form (Alias => FQN).
+ */
+ public function parseClass(\ReflectionClass $class)
+ {
+ if (false === $filename = $class->getFilename()) {
+ return array();
+ }
+
+ $content = $this->getFileContent($filename, $class->getStartLine());
+ $namespace = str_replace('\\', '\\\\', $class->getNamespaceName());
+ $content = preg_replace('/^.*?(\bnamespace\s+' . $namespace . '\s*[;{].*)$/s', '\\1', $content);
+ $this->tokens = token_get_all('<?php ' . $content);
+ $this->numTokens = count($this->tokens);
+ $this->pointer = 0;
+
+ $statements = $this->parseUseStatements($class->getNamespaceName());
+
+ return $statements;
+ }
+
+ /**
+ * Get the content of the file right up to the given line number.
+ *
+ * @param string $filename The name of the file to load.
+ * @param int $lineNumber The number of lines to read from file.
+ * @return string The content of the file.
+ */
+ private function getFileContent($filename, $lineNumber)
+ {
+ $content = '';
+ $lineCnt = 0;
+ $file = new SplFileObject($filename);
+ while(!$file->eof()) {
+ if ($lineCnt++ == $lineNumber) {
+ break;
+ }
+
+ $content .= $file->fgets();
+ }
+
+ return $content;
+ }
+
+ /**
+ * Gets the next non whitespace and non comment token.
+ *
+ * @return array The token if exists, null otherwise.
+ */
+ private function next()
+ {
+ for ($i = $this->pointer; $i < $this->numTokens; $i++) {
+ $this->pointer++;
+ if ($this->tokens[$i][0] === T_WHITESPACE ||
+ $this->tokens[$i][0] === T_COMMENT ||
+ $this->tokens[$i][0] === T_DOC_COMMENT) {
+
+ continue;
+ }
+
+ return $this->tokens[$i];
+ }
+
+ return null;
+ }
+
+ /**
+ * Get all use statements.
+ *
+ * @param string $namespaceName The namespace name of the reflected class.
+ * @return array A list with all found use statements.
+ */
+ private function parseUseStatements($namespaceName)
+ {
+ $statements = array();
+ while (($token = $this->next())) {
+ if ($token[0] === T_USE) {
+ $statements = array_merge($statements, $this->parseUseStatement());
+ continue;
+ } else if ($token[0] !== T_NAMESPACE || $this->parseNamespace() != $namespaceName) {
+ continue;
+ }
+
+ // Get fresh array for new namespace. This is to prevent the parser to collect the use statements
+ // for a previous namespace with the same name. This is the case if a namespace is defined twice
+ // or if a namespace with the same name is commented out.
+ $statements = array();
+ }
+
+ return $statements;
+ }
+
+ /**
+ * Get the namespace name.
+ *
+ * @return string The found namespace name.
+ */
+ private function parseNamespace()
+ {
+ $namespace = '';
+ while (($token = $this->next())){
+ if ($token[0] === T_STRING || $token[0] === T_NS_SEPARATOR) {
+ $namespace .= $token[1];
+ } else {
+ break;
+ }
+ }
+
+ return $namespace;
+ }
+
+ /**
+ * Parse a single use statement.
+ *
+ * @return array A list with all found class names for a use statement.
+ */
+ private function parseUseStatement()
+ {
+ $class = '';
+ $alias = '';
+ $statements = array();
+ $explicitAlias = false;
+ while (($token = $this->next())) {
+ $isNameToken = $token[0] === T_STRING || $token[0] === T_NS_SEPARATOR;
+ if (!$explicitAlias && $isNameToken) {
+ $class .= $token[1];
+ $alias = $token[1];
+ } else if ($explicitAlias && $isNameToken) {
+ $alias .= $token[1];
+ } else if ($token[0] === T_AS) {
+ $explicitAlias = true;
+ $alias = '';
+ } else if ($token === ',') {
+ $statements[strtolower($alias)] = $class;
+ $class = '';
+ $alias = '';
+ $explicitAlias = false;
+ } else if ($token === ';') {
+ $statements[strtolower($alias)] = $class;
+ break;
+ } else {
+ break;
+ }
+ }
+
+ return $statements;
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/Reader.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/Reader.php
new file mode 100644
index 0000000000000000000000000000000000000000..8e85d39200fc27e935b68bf764c95cd05b076666
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/Reader.php
@@ -0,0 +1,35 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Annotations;
+
+/**
+ * Interface for annotation readers.
+ *
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+interface Reader
+{
+ function getClassAnnotations(\ReflectionClass $class);
+ function getClassAnnotation(\ReflectionClass $class, $annotationName);
+ function getMethodAnnotations(\ReflectionMethod $method);
+ function getMethodAnnotation(\ReflectionMethod $method, $annotationName);
+ function getPropertyAnnotations(\ReflectionProperty $property);
+ function getPropertyAnnotation(\ReflectionProperty $property, $annotationName);
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/SimpleAnnotationReader.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/SimpleAnnotationReader.php
new file mode 100644
index 0000000000000000000000000000000000000000..a13c7fa0729f9c8a046641d27325b126dc7cda73
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Annotations/SimpleAnnotationReader.php
@@ -0,0 +1,152 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Annotations;
+
+use Doctrine\Common\Annotations\Annotation\Target;
+
+/**
+ * Simple Annotation Reader.
+ *
+ * This annotation reader is intended to be used in projects where you have
+ * full-control over all annotations that are available.
+ *
+ * @since 2.2
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ * @author Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+class SimpleAnnotationReader implements Reader
+{
+ /**
+ * @var DocParser
+ */
+ private $parser;
+
+ /**
+ * Constructor.
+ *
+ * Initializes a new SimpleAnnotationReader.
+ */
+ public function __construct()
+ {
+ $this->parser = new DocParser();
+ $this->parser->setIgnoreNotImportedAnnotations(true);
+ }
+
+ /**
+ * Adds a namespace in which we will look for annotations.
+ *
+ * @param string $namespace
+ */
+ public function addNamespace($namespace)
+ {
+ $this->parser->addNamespace($namespace);
+ }
+
+ /**
+ * Gets the annotations applied to a class.
+ *
+ * @param ReflectionClass $class The ReflectionClass of the class from which
+ * the class annotations should be read.
+ * @return array An array of Annotations.
+ */
+ public function getClassAnnotations(\ReflectionClass $class)
+ {
+ return $this->parser->parse($class->getDocComment(), 'class '.$class->getName());
+ }
+
+ /**
+ * Gets the annotations applied to a method.
+ *
+ * @param ReflectionMethod $property The ReflectionMethod of the method from which
+ * the annotations should be read.
+ * @return array An array of Annotations.
+ */
+ public function getMethodAnnotations(\ReflectionMethod $method)
+ {
+ return $this->parser->parse($method->getDocComment(), 'method '.$method->getDeclaringClass()->name.'::'.$method->getName().'()');
+ }
+
+ /**
+ * Gets the annotations applied to a property.
+ *
+ * @param ReflectionProperty $property The ReflectionProperty of the property
+ * from which the annotations should be read.
+ * @return array An array of Annotations.
+ */
+ public function getPropertyAnnotations(\ReflectionProperty $property)
+ {
+ return $this->parser->parse($property->getDocComment(), 'property '.$property->getDeclaringClass()->name.'::$'.$property->getName());
+ }
+
+ /**
+ * Gets a class annotation.
+ *
+ * @param ReflectionClass $class The ReflectionClass of the class from which
+ * the class annotations should be read.
+ * @param string $annotationName The name of the annotation.
+ * @return The Annotation or NULL, if the requested annotation does not exist.
+ */
+ public function getClassAnnotation(\ReflectionClass $class, $annotationName)
+ {
+ foreach ($this->getClassAnnotations($class) as $annot) {
+ if ($annot instanceof $annotationName) {
+ return $annot;
+ }
+ }
+
+ return null;
+ }
+
+ /**
+ * Gets a method annotation.
+ *
+ * @param ReflectionMethod $method
+ * @param string $annotationName The name of the annotation.
+ * @return The Annotation or NULL, if the requested annotation does not exist.
+ */
+ public function getMethodAnnotation(\ReflectionMethod $method, $annotationName)
+ {
+ foreach ($this->getMethodAnnotations($method) as $annot) {
+ if ($annot instanceof $annotationName) {
+ return $annot;
+ }
+ }
+
+ return null;
+ }
+
+ /**
+ * Gets a property annotation.
+ *
+ * @param ReflectionProperty $property
+ * @param string $annotationName The name of the annotation.
+ * @return The Annotation or NULL, if the requested annotation does not exist.
+ */
+ public function getPropertyAnnotation(\ReflectionProperty $property, $annotationName)
+ {
+ foreach ($this->getPropertyAnnotations($property) as $annot) {
+ if ($annot instanceof $annotationName) {
+ return $annot;
+ }
+ }
+
+ return null;
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Cache/ApcCache.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Cache/ApcCache.php
new file mode 100644
index 0000000000000000000000000000000000000000..a59296f5d657e7db6343e5f55e174e4ad1f2279a
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Cache/ApcCache.php
@@ -0,0 +1,97 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Cache;
+
+/**
+ * APC cache provider.
+ *
+ * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link www.doctrine-project.org
+ * @since 2.0
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author Jonathan Wage <jonwage@gmail.com>
+ * @author Roman Borschel <roman@code-factory.org>
+ * @author David Abdemoulaie <dave@hobodave.com>
+ */
+class ApcCache extends CacheProvider
+{
+ /**
+ * {@inheritdoc}
+ */
+ protected function doFetch($id)
+ {
+ return apc_fetch($id);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function doContains($id)
+ {
+ $found = false;
+
+ apc_fetch($id, $found);
+
+ return $found;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function doSave($id, $data, $lifeTime = 0)
+ {
+ return (bool) apc_store($id, $data, (int) $lifeTime);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function doDelete($id)
+ {
+ return apc_delete($id);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function doFlush()
+ {
+ return apc_clear_cache() && apc_clear_cache('user');
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function doGetStats()
+ {
+ $info = apc_cache_info();
+ $sma = apc_sma_info();
+
+ return array(
+ Cache::STATS_HITS => $info['num_hits'],
+ Cache::STATS_MISSES => $info['num_misses'],
+ Cache::STATS_UPTIME => $info['start_time'],
+ Cache::STATS_MEMORY_USAGE => $info['mem_size'],
+ Cache::STATS_MEMORY_AVAILIABLE => $sma['avail_mem'],
+ );
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Cache/ArrayCache.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Cache/ArrayCache.php
new file mode 100644
index 0000000000000000000000000000000000000000..8a0b982b4a59d2881dd5124d94b6de70e30d3c94
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Cache/ArrayCache.php
@@ -0,0 +1,96 @@
+<?php
+/*
+ * $Id$
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Cache;
+
+/**
+ * Array cache driver.
+ *
+ * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link www.doctrine-project.org
+ * @since 2.0
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author Jonathan Wage <jonwage@gmail.com>
+ * @author Roman Borschel <roman@code-factory.org>
+ * @author David Abdemoulaie <dave@hobodave.com>
+ */
+class ArrayCache extends CacheProvider
+{
+ /**
+ * @var array $data
+ */
+ private $data = array();
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function doFetch($id)
+ {
+ return (isset($this->data[$id])) ? $this->data[$id] : false;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function doContains($id)
+ {
+ return isset($this->data[$id]);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function doSave($id, $data, $lifeTime = 0)
+ {
+ $this->data[$id] = $data;
+
+ return true;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function doDelete($id)
+ {
+ unset($this->data[$id]);
+
+ return true;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function doFlush()
+ {
+ $this->data = array();
+
+ return true;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function doGetStats()
+ {
+ return null;
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Cache/Cache.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Cache/Cache.php
new file mode 100644
index 0000000000000000000000000000000000000000..d303bde4c6de93dba7da1b4020cadaed87d301e7
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Cache/Cache.php
@@ -0,0 +1,102 @@
+<?php
+/*
+ * $Id$
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Cache;
+
+/**
+ * Interface for cache drivers.
+ *
+ * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link www.doctrine-project.org
+ * @since 2.0
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author Jonathan Wage <jonwage@gmail.com>
+ * @author Roman Borschel <roman@code-factory.org>
+ * @author Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+interface Cache
+{
+ const STATS_HITS = 'hits';
+ const STATS_MISSES = 'misses';
+ const STATS_UPTIME = 'uptime';
+ const STATS_MEMORY_USAGE = 'memory_usage';
+ const STATS_MEMORY_AVAILIABLE = 'memory_available';
+
+ /**
+ * Fetches an entry from the cache.
+ *
+ * @param string $id cache id The id of the cache entry to fetch.
+ * @return string The cached data or FALSE, if no cache entry exists for the given id.
+ */
+ function fetch($id);
+
+ /**
+ * Test if an entry exists in the cache.
+ *
+ * @param string $id cache id The cache id of the entry to check for.
+ * @return boolean TRUE if a cache entry exists for the given cache id, FALSE otherwise.
+ */
+ function contains($id);
+
+ /**
+ * Puts data into the cache.
+ *
+ * @param string $id The cache id.
+ * @param string $data The cache entry/data.
+ * @param int $lifeTime The lifetime. If != 0, sets a specific lifetime for this cache entry (0 => infinite lifeTime).
+ * @return boolean TRUE if the entry was successfully stored in the cache, FALSE otherwise.
+ */
+ function save($id, $data, $lifeTime = 0);
+
+ /**
+ * Deletes a cache entry.
+ *
+ * @param string $id cache id
+ * @return boolean TRUE if the cache entry was successfully deleted, FALSE otherwise.
+ */
+ function delete($id);
+
+ /**
+ * Retrieves cached information from data store
+ *
+ * The server's statistics array has the following values:
+ *
+ * - <b>hits</b>
+ * Number of keys that have been requested and found present.
+ *
+ * - <b>misses</b>
+ * Number of items that have been requested and not found.
+ *
+ * - <b>uptime</b>
+ * Time that the server is running.
+ *
+ * - <b>memory_usage</b>
+ * Memory used by this server to store items.
+ *
+ * - <b>memory_available</b>
+ * Memory allowed to use for storage.
+ *
+ * @since 2.2
+ * @var array Associative array with server's statistics if available, NULL otherwise.
+ */
+ function getStats();
+}
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Cache/CacheProvider.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Cache/CacheProvider.php
new file mode 100644
index 0000000000000000000000000000000000000000..fa11fc22fab1012dc81703a1ed75867bdcdb8d7d
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Cache/CacheProvider.php
@@ -0,0 +1,188 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Cache;
+
+/**
+ * Base class for cache provider implementations.
+ *
+ * @since 2.2
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author Jonathan Wage <jonwage@gmail.com>
+ * @author Roman Borschel <roman@code-factory.org>
+ * @author Fabio B. Silva <fabio.bat.silva@gmail.com>
+ */
+abstract class CacheProvider implements Cache
+{
+ const DOCTRINE_NAMESPACE_CACHEKEY = 'DoctrineNamespaceCacheKey[%s]';
+
+ /**
+ * @var string The namespace to prefix all cache ids with
+ */
+ private $namespace = '';
+
+ /**
+ * Set the namespace to prefix all cache ids with.
+ *
+ * @param string $namespace
+ * @return void
+ */
+ public function setNamespace($namespace)
+ {
+ $this->namespace = (string) $namespace;
+ }
+
+ /**
+ * Retrieve the namespace that prefixes all cache ids.
+ *
+ * @return string
+ */
+ public function getNamespace()
+ {
+ return $this->namespace;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function fetch($id)
+ {
+ return $this->doFetch($this->getNamespacedId($id));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function contains($id)
+ {
+ return $this->doContains($this->getNamespacedId($id));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function save($id, $data, $lifeTime = 0)
+ {
+ return $this->doSave($this->getNamespacedId($id), $data, $lifeTime);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function delete($id)
+ {
+ return $this->doDelete($this->getNamespacedId($id));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getStats()
+ {
+ return $this->doGetStats();
+ }
+
+ /**
+ * Deletes all cache entries.
+ *
+ * @return boolean TRUE if the cache entries were successfully flushed, FALSE otherwise.
+ */
+ public function flushAll()
+ {
+ return $this->doFlush();
+ }
+
+ /**
+ * Delete all cache entries.
+ *
+ * @return boolean TRUE if the cache entries were successfully deleted, FALSE otherwise.
+ */
+ public function deleteAll()
+ {
+ $namespaceCacheKey = sprintf(self::DOCTRINE_NAMESPACE_CACHEKEY, $this->namespace);
+ $namespaceVersion = ($this->doContains($namespaceCacheKey)) ? $this->doFetch($namespaceCacheKey) : 1;
+
+ return $this->doSave($namespaceCacheKey, $namespaceVersion + 1);
+ }
+
+ /**
+ * Prefix the passed id with the configured namespace value
+ *
+ * @param string $id The id to namespace
+ * @return string $id The namespaced id
+ */
+ private function getNamespacedId($id)
+ {
+ $namespaceCacheKey = sprintf(self::DOCTRINE_NAMESPACE_CACHEKEY, $this->namespace);
+ $namespaceVersion = ($this->doContains($namespaceCacheKey)) ? $this->doFetch($namespaceCacheKey) : 1;
+
+ return sprintf('%s[%s][%s]', $this->namespace, $id, $namespaceVersion);
+ }
+
+ /**
+ * Fetches an entry from the cache.
+ *
+ * @param string $id cache id The id of the cache entry to fetch.
+ * @return string The cached data or FALSE, if no cache entry exists for the given id.
+ */
+ abstract protected function doFetch($id);
+
+ /**
+ * Test if an entry exists in the cache.
+ *
+ * @param string $id cache id The cache id of the entry to check for.
+ * @return boolean TRUE if a cache entry exists for the given cache id, FALSE otherwise.
+ */
+ abstract protected function doContains($id);
+
+ /**
+ * Puts data into the cache.
+ *
+ * @param string $id The cache id.
+ * @param string $data The cache entry/data.
+ * @param int $lifeTime The lifetime. If != false, sets a specific lifetime for this cache entry (null => infinite lifeTime).
+ * @return boolean TRUE if the entry was successfully stored in the cache, FALSE otherwise.
+ */
+ abstract protected function doSave($id, $data, $lifeTime = false);
+
+ /**
+ * Deletes a cache entry.
+ *
+ * @param string $id cache id
+ * @return boolean TRUE if the cache entry was successfully deleted, FALSE otherwise.
+ */
+ abstract protected function doDelete($id);
+
+ /**
+ * Deletes all cache entries.
+ *
+ * @return boolean TRUE if the cache entry was successfully deleted, FALSE otherwise.
+ */
+ abstract protected function doFlush();
+
+ /**
+ * Retrieves cached information from data store
+ *
+ * @since 2.2
+ * @return array An associative array with server's statistics if available, NULL otherwise.
+ */
+ abstract protected function doGetStats();
+}
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Cache/MemcacheCache.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Cache/MemcacheCache.php
new file mode 100644
index 0000000000000000000000000000000000000000..dd6d1e31476c6df23600dc6b380d502374ff5da1
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Cache/MemcacheCache.php
@@ -0,0 +1,121 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Cache;
+
+use \Memcache;
+
+/**
+ * Memcache cache provider.
+ *
+ * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link www.doctrine-project.org
+ * @since 2.0
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author Jonathan Wage <jonwage@gmail.com>
+ * @author Roman Borschel <roman@code-factory.org>
+ * @author David Abdemoulaie <dave@hobodave.com>
+ */
+class MemcacheCache extends CacheProvider
+{
+ /**
+ * @var Memcache
+ */
+ private $memcache;
+
+ /**
+ * Sets the memcache instance to use.
+ *
+ * @param Memcache $memcache
+ */
+ public function setMemcache(Memcache $memcache)
+ {
+ $this->memcache = $memcache;
+ }
+
+ /**
+ * Gets the memcache instance used by the cache.
+ *
+ * @return Memcache
+ */
+ public function getMemcache()
+ {
+ return $this->memcache;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function doFetch($id)
+ {
+ return $this->memcache->get($id);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function doContains($id)
+ {
+ return (bool) $this->memcache->get($id);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function doSave($id, $data, $lifeTime = 0)
+ {
+ if ($lifeTime > 30 * 24 * 3600) {
+ $lifeTime = time() + $lifeTime;
+ }
+ return $this->memcache->set($id, $data, 0, (int) $lifeTime);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function doDelete($id)
+ {
+ return $this->memcache->delete($id);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function doFlush()
+ {
+ return $this->memcache->flush();
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function doGetStats()
+ {
+ $stats = $this->memcache->getStats();
+ return array(
+ Cache::STATS_HITS => $stats['get_hits'],
+ Cache::STATS_MISSES => $stats['get_misses'],
+ Cache::STATS_UPTIME => $stats['uptime'],
+ Cache::STATS_MEMORY_USAGE => $stats['bytes'],
+ Cache::STATS_MEMORY_AVAILIABLE => $stats['limit_maxbytes'],
+ );
+ }
+}
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Cache/MemcachedCache.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Cache/MemcachedCache.php
new file mode 100644
index 0000000000000000000000000000000000000000..4675fae70bbee6757a3e73ac6b635fb858a25487
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Cache/MemcachedCache.php
@@ -0,0 +1,124 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Cache;
+
+use \Memcached;
+
+/**
+ * Memcached cache provider.
+ *
+ * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link www.doctrine-project.org
+ * @since 2.2
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author Jonathan Wage <jonwage@gmail.com>
+ * @author Roman Borschel <roman@code-factory.org>
+ * @author David Abdemoulaie <dave@hobodave.com>
+ */
+class MemcachedCache extends CacheProvider
+{
+ /**
+ * @var Memcached
+ */
+ private $memcached;
+
+ /**
+ * Sets the memcache instance to use.
+ *
+ * @param Memcached $memcached
+ */
+ public function setMemcached(Memcached $memcached)
+ {
+ $this->memcached = $memcached;
+ }
+
+ /**
+ * Gets the memcached instance used by the cache.
+ *
+ * @return Memcached
+ */
+ public function getMemcached()
+ {
+ return $this->memcached;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function doFetch($id)
+ {
+ return $this->memcached->get($id);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function doContains($id)
+ {
+ return (false !== $this->memcached->get($id));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function doSave($id, $data, $lifeTime = 0)
+ {
+ if ($lifeTime > 30 * 24 * 3600) {
+ $lifeTime = time() + $lifeTime;
+ }
+ return $this->memcached->set($id, $data, (int) $lifeTime);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function doDelete($id)
+ {
+ return $this->memcached->delete($id);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function doFlush()
+ {
+ return $this->memcached->flush();
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function doGetStats()
+ {
+ $stats = $this->memcached->getStats();
+ $servers = $this->memcached->getServerList();
+ $key = $servers[0]['host'] . ':' . $servers[0]['port'];
+ $stats = $stats[$key];
+ return array(
+ Cache::STATS_HITS => $stats['get_hits'],
+ Cache::STATS_MISSES => $stats['get_misses'],
+ Cache::STATS_UPTIME => $stats['uptime'],
+ Cache::STATS_MEMORY_USAGE => $stats['bytes'],
+ Cache::STATS_MEMORY_AVAILIABLE => $stats['limit_maxbytes'],
+ );
+ }
+}
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Cache/WinCacheCache.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Cache/WinCacheCache.php
new file mode 100644
index 0000000000000000000000000000000000000000..ed8ca74ab43ac3779b83aadafd3c1ca75a4e8e9b
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Cache/WinCacheCache.php
@@ -0,0 +1,92 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Cache;
+
+/**
+ * WinCache cache provider.
+ *
+ * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link www.doctrine-project.org
+ * @since 2.2
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author Jonathan Wage <jonwage@gmail.com>
+ * @author Roman Borschel <roman@code-factory.org>
+ * @author David Abdemoulaie <dave@hobodave.com>
+ */
+class WincacheCache extends CacheProvider
+{
+ /**
+ * {@inheritdoc}
+ */
+ protected function doFetch($id)
+ {
+ return wincache_ucache_get($id);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function doContains($id)
+ {
+ return wincache_ucache_exists($id);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function doSave($id, $data, $lifeTime = 0)
+ {
+ return (bool) wincache_ucache_set($id, $data, (int) $lifeTime);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function doDelete($id)
+ {
+ return wincache_ucache_delete($id);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function doFlush()
+ {
+ return wincache_ucache_clear();
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function doGetStats()
+ {
+ $info = wincache_ucache_info();
+ $meminfo= wincache_ucache_meminfo();
+ return array(
+ Cache::STATS_HITS => $info['total_hit_count'],
+ Cache::STATS_MISSES => $info['total_miss_count'],
+ Cache::STATS_UPTIME => $info['total_cache_uptime'],
+ Cache::STATS_MEMORY_USAGE => $meminfo['memory_total'],
+ Cache::STATS_MEMORY_AVAILIABLE => $meminfo['memory_free'],
+ );
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Cache/XcacheCache.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Cache/XcacheCache.php
new file mode 100644
index 0000000000000000000000000000000000000000..6e22d26541976e2abf75364e6d42bb73226ae4f4
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Cache/XcacheCache.php
@@ -0,0 +1,110 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Cache;
+
+/**
+ * Xcache cache driver.
+ *
+ * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link www.doctrine-project.org
+ * @since 2.0
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author Jonathan Wage <jonwage@gmail.com>
+ * @author Roman Borschel <roman@code-factory.org>
+ * @author David Abdemoulaie <dave@hobodave.com>
+ */
+class XcacheCache extends CacheProvider
+{
+ /**
+ * {@inheritdoc}
+ */
+ protected function doFetch($id)
+ {
+ return $this->doContains($id) ? unserialize(xcache_get($id)) : false;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function doContains($id)
+ {
+ return xcache_isset($id);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function doSave($id, $data, $lifeTime = 0)
+ {
+ return xcache_set($id, serialize($data), (int) $lifeTime);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function doDelete($id)
+ {
+ return xcache_unset($id);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function doFlush()
+ {
+ $this->checkAuthorization();
+
+ xcache_clear_cache(XC_TYPE_VAR, 0);
+
+ return true;
+ }
+
+ /**
+ * Checks that xcache.admin.enable_auth is Off
+ *
+ * @throws \BadMethodCallException When xcache.admin.enable_auth is On
+ * @return void
+ */
+ protected function checkAuthorization()
+ {
+ if (ini_get('xcache.admin.enable_auth')) {
+ throw new \BadMethodCallException('To use all features of \Doctrine\Common\Cache\XcacheCache, you must set "xcache.admin.enable_auth" to "Off" in your php.ini.');
+ }
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function doGetStats()
+ {
+ $this->checkAuthorization();
+
+ $info = xcache_info(XC_TYPE_VAR, 0);
+ return array(
+ Cache::STATS_HITS => $info['hits'],
+ Cache::STATS_MISSES => $info['misses'],
+ Cache::STATS_UPTIME => null,
+ Cache::STATS_MEMORY_USAGE => $info['size'],
+ Cache::STATS_MEMORY_AVAILIABLE => $info['avail'],
+ );
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Cache/ZendDataCache.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Cache/ZendDataCache.php
new file mode 100644
index 0000000000000000000000000000000000000000..4e4dabe775e2633a9b50867e5731af71b809cda4
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Cache/ZendDataCache.php
@@ -0,0 +1,84 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Cache;
+
+/**
+ * Zend Data Cache cache driver.
+ *
+ * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link www.doctrine-project.org
+ * @since 2.0
+ * @author Ralph Schindler <ralph.schindler@zend.com>
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ */
+class ZendDataCache extends CacheProvider
+{
+ /**
+ * {@inheritdoc}
+ */
+ protected function doFetch($id)
+ {
+ return zend_shm_cache_fetch($id);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function doContains($id)
+ {
+ return (false !== zend_shm_cache_fetch($id));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function doSave($id, $data, $lifeTime = 0)
+ {
+ return zend_shm_cache_store($id, $data, $lifeTime);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function doDelete($id)
+ {
+ return zend_shm_cache_delete($id);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function doFlush()
+ {
+ $namespace = $this->getNamespace();
+ if (empty($namespace)) {
+ return zend_shm_cache_clear();
+ }
+ return zend_shm_cache_clear($namespace);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function doGetStats()
+ {
+ return null;
+ }
+}
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/ClassLoader.php b/core/vendor/doctrine/common/lib/Doctrine/Common/ClassLoader.php
new file mode 100644
index 0000000000000000000000000000000000000000..375b0d6b4933ebf0c3b62246032f77aba95331de
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/ClassLoader.php
@@ -0,0 +1,262 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common;
+
+/**
+ * A <tt>ClassLoader</tt> 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 <code>include_path</code>.
+ *
+ * @author Roman Borschel <roman@code-factory.org>
+ * @since 2.0
+ */
+class ClassLoader
+{
+ /**
+ * @var string PHP file extension
+ */
+ protected $fileExtension = '.php';
+
+ /**
+ * @var string Current namespace
+ */
+ protected $namespace;
+
+ /**
+ * @var string Current include path
+ */
+ protected $includePath;
+
+ /**
+ * @var string PHP namespace separator
+ */
+ protected $namespaceSeparator = '\\';
+
+ /**
+ * Creates a new <tt>ClassLoader</tt> 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 $ns The namespace of the classes to load.
+ * @param string $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.
+ */
+ 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 $includePath
+ */
+ public function setIncludePath($includePath)
+ {
+ $this->includePath = $includePath;
+ }
+
+ /**
+ * Gets the base include path for all class files in the namespace of this ClassLoader.
+ *
+ * @return string
+ */
+ public function getIncludePath()
+ {
+ return $this->includePath;
+ }
+
+ /**
+ * Sets the file extension of class files in the namespace of this ClassLoader.
+ *
+ * @param string $fileExtension
+ */
+ 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.
+ */
+ public function register()
+ {
+ spl_autoload_register(array($this, 'loadClass'));
+ }
+
+ /**
+ * Removes this ClassLoader from the SPL autoload stack.
+ */
+ 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 file_exists($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 <tt>ClassLoader</tt>, {@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 <tt>ClassLoader</tt>, 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;
+ }
+ }
+
+ return class_exists($className, false) || interface_exists($className, false);
+ }
+
+ /**
+ * Gets the <tt>ClassLoader</tt> 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 The <tt>ClassLoader</tt> for the class or NULL if no such <tt>ClassLoader</tt> 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;
+ }
+}
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Collections/ArrayCollection.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Collections/ArrayCollection.php
new file mode 100644
index 0000000000000000000000000000000000000000..2a7d4eaf86de914784aac5162377c3b805793148
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Collections/ArrayCollection.php
@@ -0,0 +1,447 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Collections;
+
+use Closure, ArrayIterator;
+
+/**
+ * An ArrayCollection is a Collection implementation that wraps a regular PHP array.
+ *
+ * @since 2.0
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author Jonathan Wage <jonwage@gmail.com>
+ * @author Roman Borschel <roman@code-factory.org>
+ */
+class ArrayCollection implements Collection
+{
+ /**
+ * An array containing the entries of this collection.
+ *
+ * @var array
+ */
+ private $_elements;
+
+ /**
+ * Initializes a new ArrayCollection.
+ *
+ * @param array $elements
+ */
+ public function __construct(array $elements = array())
+ {
+ $this->_elements = $elements;
+ }
+
+ /**
+ * Gets the PHP array representation of this collection.
+ *
+ * @return array The PHP array representation of this collection.
+ */
+ public function toArray()
+ {
+ return $this->_elements;
+ }
+
+ /**
+ * Sets the internal iterator to the first element in the collection and
+ * returns this element.
+ *
+ * @return mixed
+ */
+ public function first()
+ {
+ return reset($this->_elements);
+ }
+
+ /**
+ * Sets the internal iterator to the last element in the collection and
+ * returns this element.
+ *
+ * @return mixed
+ */
+ public function last()
+ {
+ return end($this->_elements);
+ }
+
+ /**
+ * Gets the current key/index at the current internal iterator position.
+ *
+ * @return mixed
+ */
+ public function key()
+ {
+ return key($this->_elements);
+ }
+
+ /**
+ * Moves the internal iterator position to the next element.
+ *
+ * @return mixed
+ */
+ public function next()
+ {
+ return next($this->_elements);
+ }
+
+ /**
+ * Gets the element of the collection at the current internal iterator position.
+ *
+ * @return mixed
+ */
+ public function current()
+ {
+ return current($this->_elements);
+ }
+
+ /**
+ * Removes an element with a specific key/index from the collection.
+ *
+ * @param mixed $key
+ * @return mixed The removed element or NULL, if no element exists for the given key.
+ */
+ public function remove($key)
+ {
+ if (isset($this->_elements[$key])) {
+ $removed = $this->_elements[$key];
+ unset($this->_elements[$key]);
+
+ return $removed;
+ }
+
+ return null;
+ }
+
+ /**
+ * Removes the specified element from the collection, if it is found.
+ *
+ * @param mixed $element The element to remove.
+ * @return boolean TRUE if this collection contained the specified element, FALSE otherwise.
+ */
+ public function removeElement($element)
+ {
+ $key = array_search($element, $this->_elements, true);
+
+ if ($key !== false) {
+ unset($this->_elements[$key]);
+
+ return true;
+ }
+
+ return false;
+ }
+
+ /**
+ * ArrayAccess implementation of offsetExists()
+ *
+ * @see containsKey()
+ */
+ public function offsetExists($offset)
+ {
+ return $this->containsKey($offset);
+ }
+
+ /**
+ * ArrayAccess implementation of offsetGet()
+ *
+ * @see get()
+ */
+ public function offsetGet($offset)
+ {
+ return $this->get($offset);
+ }
+
+ /**
+ * ArrayAccess implementation of offsetGet()
+ *
+ * @see add()
+ * @see set()
+ */
+ public function offsetSet($offset, $value)
+ {
+ if ( ! isset($offset)) {
+ return $this->add($value);
+ }
+ return $this->set($offset, $value);
+ }
+
+ /**
+ * ArrayAccess implementation of offsetUnset()
+ *
+ * @see remove()
+ */
+ public function offsetUnset($offset)
+ {
+ return $this->remove($offset);
+ }
+
+ /**
+ * Checks whether the collection contains a specific key/index.
+ *
+ * @param mixed $key The key to check for.
+ * @return boolean TRUE if the given key/index exists, FALSE otherwise.
+ */
+ public function containsKey($key)
+ {
+ return isset($this->_elements[$key]);
+ }
+
+ /**
+ * Checks whether the given element is contained in the collection.
+ * Only element values are compared, not keys. The comparison of two elements
+ * is strict, that means not only the value but also the type must match.
+ * For objects this means reference equality.
+ *
+ * @param mixed $element
+ * @return boolean TRUE if the given element is contained in the collection,
+ * FALSE otherwise.
+ */
+ public function contains($element)
+ {
+ foreach ($this->_elements as $collectionElement) {
+ if ($element === $collectionElement) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ /**
+ * Tests for the existance of an element that satisfies the given predicate.
+ *
+ * @param Closure $p The predicate.
+ * @return boolean TRUE if the predicate is TRUE for at least one element, FALSE otherwise.
+ */
+ public function exists(Closure $p)
+ {
+ foreach ($this->_elements as $key => $element) {
+ if ($p($key, $element)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Searches for a given element and, if found, returns the corresponding key/index
+ * of that element. The comparison of two elements is strict, that means not
+ * only the value but also the type must match.
+ * For objects this means reference equality.
+ *
+ * @param mixed $element The element to search for.
+ * @return mixed The key/index of the element or FALSE if the element was not found.
+ */
+ public function indexOf($element)
+ {
+ return array_search($element, $this->_elements, true);
+ }
+
+ /**
+ * Gets the element with the given key/index.
+ *
+ * @param mixed $key The key.
+ * @return mixed The element or NULL, if no element exists for the given key.
+ */
+ public function get($key)
+ {
+ if (isset($this->_elements[$key])) {
+ return $this->_elements[$key];
+ }
+ return null;
+ }
+
+ /**
+ * Gets all keys/indexes of the collection elements.
+ *
+ * @return array
+ */
+ public function getKeys()
+ {
+ return array_keys($this->_elements);
+ }
+
+ /**
+ * Gets all elements.
+ *
+ * @return array
+ */
+ public function getValues()
+ {
+ return array_values($this->_elements);
+ }
+
+ /**
+ * Returns the number of elements in the collection.
+ *
+ * Implementation of the Countable interface.
+ *
+ * @return integer The number of elements in the collection.
+ */
+ public function count()
+ {
+ return count($this->_elements);
+ }
+
+ /**
+ * Adds/sets an element in the collection at the index / with the specified key.
+ *
+ * When the collection is a Map this is like put(key,value)/add(key,value).
+ * When the collection is a List this is like add(position,value).
+ *
+ * @param mixed $key
+ * @param mixed $value
+ */
+ public function set($key, $value)
+ {
+ $this->_elements[$key] = $value;
+ }
+
+ /**
+ * Adds an element to the collection.
+ *
+ * @param mixed $value
+ * @return boolean Always TRUE.
+ */
+ public function add($value)
+ {
+ $this->_elements[] = $value;
+ return true;
+ }
+
+ /**
+ * Checks whether the collection is empty.
+ *
+ * Note: This is preferrable over count() == 0.
+ *
+ * @return boolean TRUE if the collection is empty, FALSE otherwise.
+ */
+ public function isEmpty()
+ {
+ return ! $this->_elements;
+ }
+
+ /**
+ * Gets an iterator for iterating over the elements in the collection.
+ *
+ * @return ArrayIterator
+ */
+ public function getIterator()
+ {
+ return new ArrayIterator($this->_elements);
+ }
+
+ /**
+ * Applies the given function to each element in the collection and returns
+ * a new collection with the elements returned by the function.
+ *
+ * @param Closure $func
+ * @return Collection
+ */
+ public function map(Closure $func)
+ {
+ return new static(array_map($func, $this->_elements));
+ }
+
+ /**
+ * Returns all the elements of this collection that satisfy the predicate p.
+ * The order of the elements is preserved.
+ *
+ * @param Closure $p The predicate used for filtering.
+ * @return Collection A collection with the results of the filter operation.
+ */
+ public function filter(Closure $p)
+ {
+ return new static(array_filter($this->_elements, $p));
+ }
+
+ /**
+ * Applies the given predicate p to all elements of this collection,
+ * returning true, if the predicate yields true for all elements.
+ *
+ * @param Closure $p The predicate.
+ * @return boolean TRUE, if the predicate yields TRUE for all elements, FALSE otherwise.
+ */
+ public function forAll(Closure $p)
+ {
+ foreach ($this->_elements as $key => $element) {
+ if ( ! $p($key, $element)) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ /**
+ * Partitions this collection in two collections according to a predicate.
+ * Keys are preserved in the resulting collections.
+ *
+ * @param Closure $p The predicate on which to partition.
+ * @return array An array with two elements. The first element contains the collection
+ * of elements where the predicate returned TRUE, the second element
+ * contains the collection of elements where the predicate returned FALSE.
+ */
+ public function partition(Closure $p)
+ {
+ $coll1 = $coll2 = array();
+ foreach ($this->_elements as $key => $element) {
+ if ($p($key, $element)) {
+ $coll1[$key] = $element;
+ } else {
+ $coll2[$key] = $element;
+ }
+ }
+ return array(new static($coll1), new static($coll2));
+ }
+
+ /**
+ * Returns a string representation of this object.
+ *
+ * @return string
+ */
+ public function __toString()
+ {
+ return __CLASS__ . '@' . spl_object_hash($this);
+ }
+
+ /**
+ * Clears the collection.
+ */
+ public function clear()
+ {
+ $this->_elements = array();
+ }
+
+ /**
+ * Extract a slice of $length elements starting at position $offset from the Collection.
+ *
+ * If $length is null it returns all elements from $offset to the end of the Collection.
+ * Keys have to be preserved by this method. Calling this method will only return the
+ * selected slice and NOT change the elements contained in the collection slice is called on.
+ *
+ * @param int $offset
+ * @param int $length
+ * @return array
+ */
+ public function slice($offset, $length = null)
+ {
+ return array_slice($this->_elements, $offset, $length, true);
+ }
+}
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Collections/Collection.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Collections/Collection.php
new file mode 100644
index 0000000000000000000000000000000000000000..9fca659c654005b3195441b992f0ba9434674aed
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Collections/Collection.php
@@ -0,0 +1,243 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Collections;
+
+use Closure, Countable, IteratorAggregate, ArrayAccess;
+
+/**
+ * The missing (SPL) Collection/Array/OrderedMap interface.
+ *
+ * A Collection resembles the nature of a regular PHP array. That is,
+ * it is essentially an <b>ordered map</b> that can also be used
+ * like a list.
+ *
+ * A Collection has an internal iterator just like a PHP array. In addition,
+ * a Collection can be iterated with external iterators, which is preferrable.
+ * To use an external iterator simply use the foreach language construct to
+ * iterate over the collection (which calls {@link getIterator()} internally) or
+ * explicitly retrieve an iterator though {@link getIterator()} which can then be
+ * used to iterate over the collection.
+ * You can not rely on the internal iterator of the collection being at a certain
+ * position unless you explicitly positioned it before. Prefer iteration with
+ * external iterators.
+ *
+ * @since 2.0
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author Jonathan Wage <jonwage@gmail.com>
+ * @author Roman Borschel <roman@code-factory.org>
+ */
+interface Collection extends Countable, IteratorAggregate, ArrayAccess
+{
+ /**
+ * Adds an element at the end of the collection.
+ *
+ * @param mixed $element The element to add.
+ * @return boolean Always TRUE.
+ */
+ function add($element);
+
+ /**
+ * Clears the collection, removing all elements.
+ */
+ function clear();
+
+ /**
+ * Checks whether an element is contained in the collection.
+ * This is an O(n) operation, where n is the size of the collection.
+ *
+ * @param mixed $element The element to search for.
+ * @return boolean TRUE if the collection contains the element, FALSE otherwise.
+ */
+ function contains($element);
+
+ /**
+ * Checks whether the collection is empty (contains no elements).
+ *
+ * @return boolean TRUE if the collection is empty, FALSE otherwise.
+ */
+ function isEmpty();
+
+ /**
+ * Removes the element at the specified index from the collection.
+ *
+ * @param string|integer $key The kex/index of the element to remove.
+ * @return mixed The removed element or NULL, if the collection did not contain the element.
+ */
+ function remove($key);
+
+ /**
+ * Removes the specified element from the collection, if it is found.
+ *
+ * @param mixed $element The element to remove.
+ * @return boolean TRUE if this collection contained the specified element, FALSE otherwise.
+ */
+ function removeElement($element);
+
+ /**
+ * Checks whether the collection contains an element with the specified key/index.
+ *
+ * @param string|integer $key The key/index to check for.
+ * @return boolean TRUE if the collection contains an element with the specified key/index,
+ * FALSE otherwise.
+ */
+ function containsKey($key);
+
+ /**
+ * Gets the element at the specified key/index.
+ *
+ * @param string|integer $key The key/index of the element to retrieve.
+ * @return mixed
+ */
+ function get($key);
+
+ /**
+ * Gets all keys/indices of the collection.
+ *
+ * @return array The keys/indices of the collection, in the order of the corresponding
+ * elements in the collection.
+ */
+ function getKeys();
+
+ /**
+ * Gets all values of the collection.
+ *
+ * @return array The values of all elements in the collection, in the order they
+ * appear in the collection.
+ */
+ function getValues();
+
+ /**
+ * Sets an element in the collection at the specified key/index.
+ *
+ * @param string|integer $key The key/index of the element to set.
+ * @param mixed $value The element to set.
+ */
+ function set($key, $value);
+
+ /**
+ * Gets a native PHP array representation of the collection.
+ *
+ * @return array
+ */
+ function toArray();
+
+ /**
+ * Sets the internal iterator to the first element in the collection and
+ * returns this element.
+ *
+ * @return mixed
+ */
+ function first();
+
+ /**
+ * Sets the internal iterator to the last element in the collection and
+ * returns this element.
+ *
+ * @return mixed
+ */
+ function last();
+
+ /**
+ * Gets the key/index of the element at the current iterator position.
+ *
+ */
+ function key();
+
+ /**
+ * Gets the element of the collection at the current iterator position.
+ *
+ */
+ function current();
+
+ /**
+ * Moves the internal iterator position to the next element.
+ *
+ */
+ function next();
+
+ /**
+ * Tests for the existence of an element that satisfies the given predicate.
+ *
+ * @param Closure $p The predicate.
+ * @return boolean TRUE if the predicate is TRUE for at least one element, FALSE otherwise.
+ */
+ function exists(Closure $p);
+
+ /**
+ * Returns all the elements of this collection that satisfy the predicate p.
+ * The order of the elements is preserved.
+ *
+ * @param Closure $p The predicate used for filtering.
+ * @return Collection A collection with the results of the filter operation.
+ */
+ function filter(Closure $p);
+
+ /**
+ * Applies the given predicate p to all elements of this collection,
+ * returning true, if the predicate yields true for all elements.
+ *
+ * @param Closure $p The predicate.
+ * @return boolean TRUE, if the predicate yields TRUE for all elements, FALSE otherwise.
+ */
+ function forAll(Closure $p);
+
+ /**
+ * Applies the given function to each element in the collection and returns
+ * a new collection with the elements returned by the function.
+ *
+ * @param Closure $func
+ * @return Collection
+ */
+ function map(Closure $func);
+
+ /**
+ * Partitions this collection in two collections according to a predicate.
+ * Keys are preserved in the resulting collections.
+ *
+ * @param Closure $p The predicate on which to partition.
+ * @return array An array with two elements. The first element contains the collection
+ * of elements where the predicate returned TRUE, the second element
+ * contains the collection of elements where the predicate returned FALSE.
+ */
+ function partition(Closure $p);
+
+ /**
+ * Gets the index/key of a given element. The comparison of two elements is strict,
+ * that means not only the value but also the type must match.
+ * For objects this means reference equality.
+ *
+ * @param mixed $element The element to search for.
+ * @return mixed The key/index of the element or FALSE if the element was not found.
+ */
+ function indexOf($element);
+
+ /**
+ * Extract a slice of $length elements starting at position $offset from the Collection.
+ *
+ * If $length is null it returns all elements from $offset to the end of the Collection.
+ * Keys have to be preserved by this method. Calling this method will only return the
+ * selected slice and NOT change the elements contained in the collection slice is called on.
+ *
+ * @param int $offset
+ * @param int $length
+ * @return array
+ */
+ function slice($offset, $length = null);
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/CommonException.php b/core/vendor/doctrine/common/lib/Doctrine/Common/CommonException.php
new file mode 100644
index 0000000000000000000000000000000000000000..8c5669be52dcfbc762000d9afdb25c5745163c68
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/CommonException.php
@@ -0,0 +1,28 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common;
+
+/**
+ * Base exception class for package Doctrine\Common
+ * @author heinrich
+ *
+ */
+class CommonException extends \Exception {
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Comparable.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Comparable.php
new file mode 100644
index 0000000000000000000000000000000000000000..bc95d3030389eac9d9af0c70948fe717ba10f7d7
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Comparable.php
@@ -0,0 +1,47 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+
+namespace Doctrine\Common;
+
+/**
+ * Comparable interface that allows to compare two value objects to each other for similarity.
+ *
+ * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link www.doctrine-project.com
+ * @since 2.2
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ */
+interface Comparable
+{
+ /**
+ * Compare 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.
+ *
+ * @return int
+ */
+ public function compareTo($other);
+}
+
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/EventArgs.php b/core/vendor/doctrine/common/lib/Doctrine/Common/EventArgs.php
new file mode 100644
index 0000000000000000000000000000000000000000..6a3c0699ad2233894125634d2ae35e4767d2822d
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/EventArgs.php
@@ -0,0 +1,69 @@
+<?php
+/*
+ * $Id$
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\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}.
+ *
+ * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link www.doctrine-project.org
+ * @since 2.0
+ * @version $Revision: 3938 $
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author Jonathan Wage <jonwage@gmail.com>
+ * @author Roman Borschel <roman@code-factory.org>
+ */
+class EventArgs
+{
+ /**
+ * @var EventArgs Single instance of EventArgs
+ * @static
+ */
+ 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
+ * @static
+ * @return EventArgs
+ */
+ public static function getEmptyInstance()
+ {
+ if ( ! self::$_emptyEventArgsInstance) {
+ self::$_emptyEventArgsInstance = new EventArgs;
+ }
+
+ return self::$_emptyEventArgsInstance;
+ }
+}
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/EventManager.php b/core/vendor/doctrine/common/lib/Doctrine/Common/EventManager.php
new file mode 100644
index 0000000000000000000000000000000000000000..a1f11ed237ab81f802e919267d7a12606bd1ffd5
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/EventManager.php
@@ -0,0 +1,136 @@
+<?php
+/*
+ * $Id$
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\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.
+ *
+ * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link www.doctrine-project.org
+ * @since 2.0
+ * @version $Revision: 3938 $
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author Jonathan Wage <jonwage@gmail.com>
+ * @author Roman Borschel <roman@code-factory.org>
+ */
+class EventManager
+{
+ /**
+ * Map of registered listeners.
+ * <event> => <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 $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 $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.
+ */
+ 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
+ */
+ 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 he is
+ * interested in and added as a listener for these events.
+ *
+ * @param Doctrine\Common\EventSubscriber $subscriber The subscriber.
+ */
+ public function addEventSubscriber(EventSubscriber $subscriber)
+ {
+ $this->addEventListener($subscriber->getSubscribedEvents(), $subscriber);
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/EventSubscriber.php b/core/vendor/doctrine/common/lib/Doctrine/Common/EventSubscriber.php
new file mode 100644
index 0000000000000000000000000000000000000000..ed3383fafecb66d602c345e3ee431733a662b040
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/EventSubscriber.php
@@ -0,0 +1,45 @@
+<?php
+/*
+ * $Id: EventListener.php 4653 2008-07-10 17:17:58Z romanb $
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\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.
+ *
+ * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link www.doctrine-project.org
+ * @since 2.0
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author Jonathan Wage <jonwage@gmail.com>
+ * @author Roman Borschel <roman@code-factory.org>
+ */
+interface EventSubscriber
+{
+ /**
+ * Returns an array of events this subscriber wants to listen to.
+ *
+ * @return array
+ */
+ function getSubscribedEvents();
+}
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Lexer.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Lexer.php
new file mode 100644
index 0000000000000000000000000000000000000000..8df3b8437e3077c6dea0ecec6bd1c69bba476441
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Lexer.php
@@ -0,0 +1,266 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common;
+
+/**
+ * Base class for writing simple lexers, i.e. for creating small DSLs.
+ *
+ * @since 2.0
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author Jonathan Wage <jonwage@gmail.com>
+ * @author Roman Borschel <roman@code-factory.org>
+ * @todo Rename: AbstractLexer
+ */
+abstract class Lexer
+{
+ /**
+ * @var array Array of scanned tokens
+ */
+ private $tokens = array();
+
+ /**
+ * @var integer Current lexer position in input string
+ */
+ private $position = 0;
+
+ /**
+ * @var integer Current peek of current lexer position
+ */
+ private $peek = 0;
+
+ /**
+ * @var array The next token in the input.
+ */
+ public $lookahead;
+
+ /**
+ * @var array The last matched/seen token.
+ */
+ public $token;
+
+ /**
+ * Sets the input data to be tokenized.
+ *
+ * The Lexer is immediately reset and the new input tokenized.
+ * Any unprocessed tokens from any previous input are lost.
+ *
+ * @param string $input The input to be tokenized.
+ */
+ public function setInput($input)
+ {
+ $this->tokens = array();
+ $this->reset();
+ $this->scan($input);
+ }
+
+ /**
+ * Resets the lexer.
+ */
+ public function reset()
+ {
+ $this->lookahead = null;
+ $this->token = null;
+ $this->peek = 0;
+ $this->position = 0;
+ }
+
+ /**
+ * Resets the peek pointer to 0.
+ */
+ public function resetPeek()
+ {
+ $this->peek = 0;
+ }
+
+ /**
+ * Resets the lexer position on the input to the given position.
+ *
+ * @param integer $position Position to place the lexical scanner
+ */
+ public function resetPosition($position = 0)
+ {
+ $this->position = $position;
+ }
+
+ /**
+ * Checks whether a given token matches the current lookahead.
+ *
+ * @param integer|string $token
+ * @return boolean
+ */
+ public function isNextToken($token)
+ {
+ return null !== $this->lookahead && $this->lookahead['type'] === $token;
+ }
+
+ /**
+ * Checks whether any of the given tokens matches the current lookahead
+ *
+ * @param array $tokens
+ * @return boolean
+ */
+ public function isNextTokenAny(array $tokens)
+ {
+ return null !== $this->lookahead && in_array($this->lookahead['type'], $tokens, true);
+ }
+
+ /**
+ * Moves to the next token in the input string.
+ *
+ * A token is an associative array containing three items:
+ * - 'value' : the string value of the token in the input string
+ * - 'type' : the type of the token (identifier, numeric, string, input
+ * parameter, none)
+ * - 'position' : the position of the token in the input string
+ *
+ * @return array|null the next token; null if there is no more tokens left
+ */
+ public function moveNext()
+ {
+ $this->peek = 0;
+ $this->token = $this->lookahead;
+ $this->lookahead = (isset($this->tokens[$this->position]))
+ ? $this->tokens[$this->position++] : null;
+
+ return $this->lookahead !== null;
+ }
+
+ /**
+ * Tells the lexer to skip input tokens until it sees a token with the given value.
+ *
+ * @param $type The token type to skip until.
+ */
+ public function skipUntil($type)
+ {
+ while ($this->lookahead !== null && $this->lookahead['type'] !== $type) {
+ $this->moveNext();
+ }
+ }
+
+ /**
+ * Checks if given value is identical to the given token
+ *
+ * @param mixed $value
+ * @param integer $token
+ * @return boolean
+ */
+ public function isA($value, $token)
+ {
+ return $this->getType($value) === $token;
+ }
+
+ /**
+ * Moves the lookahead token forward.
+ *
+ * @return array | null The next token or NULL if there are no more tokens ahead.
+ */
+ public function peek()
+ {
+ if (isset($this->tokens[$this->position + $this->peek])) {
+ return $this->tokens[$this->position + $this->peek++];
+ } else {
+ return null;
+ }
+ }
+
+ /**
+ * Peeks at the next token, returns it and immediately resets the peek.
+ *
+ * @return array|null The next token or NULL if there are no more tokens ahead.
+ */
+ public function glimpse()
+ {
+ $peek = $this->peek();
+ $this->peek = 0;
+ return $peek;
+ }
+
+ /**
+ * Scans the input string for tokens.
+ *
+ * @param string $input a query string
+ */
+ protected function scan($input)
+ {
+ static $regex;
+
+ if ( ! isset($regex)) {
+ $regex = '/(' . implode(')|(', $this->getCatchablePatterns()) . ')|'
+ . implode('|', $this->getNonCatchablePatterns()) . '/i';
+ }
+
+ $flags = PREG_SPLIT_NO_EMPTY | PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_OFFSET_CAPTURE;
+ $matches = preg_split($regex, $input, -1, $flags);
+
+ foreach ($matches as $match) {
+ // Must remain before 'value' assignment since it can change content
+ $type = $this->getType($match[0]);
+
+ $this->tokens[] = array(
+ 'value' => $match[0],
+ 'type' => $type,
+ 'position' => $match[1],
+ );
+ }
+ }
+
+ /**
+ * Gets the literal for a given token.
+ *
+ * @param integer $token
+ * @return string
+ */
+ public function getLiteral($token)
+ {
+ $className = get_class($this);
+ $reflClass = new \ReflectionClass($className);
+ $constants = $reflClass->getConstants();
+
+ foreach ($constants as $name => $value) {
+ if ($value === $token) {
+ return $className . '::' . $name;
+ }
+ }
+
+ return $token;
+ }
+
+ /**
+ * Lexical catchable patterns.
+ *
+ * @return array
+ */
+ abstract protected function getCatchablePatterns();
+
+ /**
+ * Lexical non-catchable patterns.
+ *
+ * @return array
+ */
+ abstract protected function getNonCatchablePatterns();
+
+ /**
+ * Retrieve token type. Also processes the token value if necessary.
+ *
+ * @param string $value
+ * @return integer
+ */
+ abstract protected function getType(&$value);
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/NotifyPropertyChanged.php b/core/vendor/doctrine/common/lib/Doctrine/Common/NotifyPropertyChanged.php
new file mode 100644
index 0000000000000000000000000000000000000000..93e504aec1d62d15f363252d6ecded926d116a4a
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/NotifyPropertyChanged.php
@@ -0,0 +1,45 @@
+<?php
+/*
+ * $Id$
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common;
+
+/**
+ * Contract for classes that provide the service of notifying listeners of
+ * changes to their properties.
+ *
+ * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link www.doctrine-project.org
+ * @since 2.0
+ * @version $Revision: 3938 $
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author Jonathan Wage <jonwage@gmail.com>
+ * @author Roman Borschel <roman@code-factory.org>
+ */
+interface NotifyPropertyChanged
+{
+ /**
+ * Adds a listener that wants to be notified about property changes.
+ *
+ * @param PropertyChangedListener $listener
+ */
+ function addPropertyChangedListener(PropertyChangedListener $listener);
+}
+
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/AbstractManagerRegistry.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/AbstractManagerRegistry.php
new file mode 100644
index 0000000000000000000000000000000000000000..f0452866bdae261a43b4035d383beae7ed9d1021
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/AbstractManagerRegistry.php
@@ -0,0 +1,218 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Persistence;
+
+use Doctrine\Common\Persistence\ManagerRegistry;
+
+/**
+ * Abstract implementation of the ManagerRegistry contract.
+ *
+ * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link www.doctrine-project.org
+ * @since 2.2
+ * @author Fabien Potencier <fabien@symfony.com>
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ * @author Lukas Kahwe Smith <smith@pooteeweet.org>
+ */
+abstract class AbstractManagerRegistry implements ManagerRegistry
+{
+ private $name;
+ private $connections;
+ private $managers;
+ private $defaultConnection;
+ private $defaultManager;
+ private $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 name of the service
+ * @return object 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 name of the service
+ * @return void
+ */
+ abstract protected function resetService($name);
+
+ /**
+ * Get 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
+ */
+ 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)
+ {
+ $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]);
+ }
+}
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/ConnectionRegistry.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/ConnectionRegistry.php
new file mode 100644
index 0000000000000000000000000000000000000000..a47727fa0766b9c7c97b1c53ffd6d7b1e3d5272b
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/ConnectionRegistry.php
@@ -0,0 +1,63 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Persistence;
+
+/**
+ * Contract covering connection for a Doctrine persistence layer ManagerRegistry class to implement.
+ *
+ * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link www.doctrine-project.org
+ * @since 2.2
+ * @author Fabien Potencier <fabien@symfony.com>
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ * @author Lukas Kahwe Smith <smith@pooteeweet.org>
+ */
+interface ConnectionRegistry
+{
+ /**
+ * Gets the default connection name.
+ *
+ * @return string The default connection name
+ */
+ function getDefaultConnectionName();
+
+ /**
+ * Gets the named connection.
+ *
+ * @param string $name The connection name (null for the default one)
+ *
+ * @return Connection
+ */
+ function getConnection($name = null);
+
+ /**
+ * Gets an array of all registered connections
+ *
+ * @return array An array of Connection instances
+ */
+ function getConnections();
+
+ /**
+ * Gets all connection names.
+ *
+ * @return array An array of connection names
+ */
+ function getConnectionNames();
+}
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Event/LifecycleEventArgs.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Event/LifecycleEventArgs.php
new file mode 100644
index 0000000000000000000000000000000000000000..8055b66d6bf94da7aa94b6ea9c53f7527fff6055
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Event/LifecycleEventArgs.php
@@ -0,0 +1,77 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+*/
+
+namespace Doctrine\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 <roman@code-factory.de>
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ */
+class LifecycleEventArgs extends EventArgs
+{
+ /**
+ * @var ObjectManager
+ */
+ private $objectManager;
+
+ /**
+ * @var object
+ */
+ private $entity;
+
+ /**
+ * Constructor
+ *
+ * @param object $entity
+ * @param ObjectManager $objectManager
+ */
+ public function __construct($entity, ObjectManager $objectManager)
+ {
+ $this->entity = $entity;
+ $this->objectManager = $objectManager;
+ }
+
+ /**
+ * Retireve associated Entity.
+ *
+ * @return object
+ */
+ public function getEntity()
+ {
+ return $this->entity;
+ }
+
+ /**
+ * Retrieve associated ObjectManager.
+ *
+ * @return ObjectManager
+ */
+ public function getObjectManager()
+ {
+ return $this->objectManager;
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Event/LoadClassMetadataEventArgs.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Event/LoadClassMetadataEventArgs.php
new file mode 100644
index 0000000000000000000000000000000000000000..4a18d16759e023f3e0c8d2ac3c6647420559d74e
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Event/LoadClassMetadataEventArgs.php
@@ -0,0 +1,76 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\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 <jonwage@gmail.com>
+ * @since 2.2
+ */
+class LoadClassMetadataEventArgs extends EventArgs
+{
+ /**
+ * @var ClassMetadata
+ */
+ private $classMetadata;
+
+ /**
+ * @var ObjectManager
+ */
+ private $objectManager;
+
+ /**
+ * Constructor.
+ *
+ * @param ClasseMetadata $classMetadata
+ * @param ObjectManager $objectManager
+ */
+ public function __construct(ClassMetadata $classMetadata, ObjectManager $objectManager)
+ {
+ $this->classMetadata = $classMetadata;
+ $this->objectManager = $objectManager;
+ }
+
+ /**
+ * Retrieve associated ClassMetadata.
+ *
+ * @return ClassMetadata
+ */
+ public function getClassMetadata()
+ {
+ return $this->classMetadata;
+ }
+
+ /**
+ * Retrieve associated ObjectManager.
+ *
+ * @return ObjectManager
+ */
+ public function getObjectManager()
+ {
+ return $this->objectManager;
+ }
+}
+
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Event/ManagerEventArgs.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Event/ManagerEventArgs.php
new file mode 100644
index 0000000000000000000000000000000000000000..33c4d7964e9043e1dcdd16808094983227c15c73
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Event/ManagerEventArgs.php
@@ -0,0 +1,59 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+*/
+
+namespace Doctrine\Common\Persistence\Event;
+
+use Doctrine\Common\Persistence\ObjectManager;
+
+/**
+ * Provides event arguments for the preFlush event.
+ *
+ * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link www.doctrine-project.org
+ * @since 2.2
+ * @author Roman Borschel <roman@code-factory.de>
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ */
+class ManagerEventArgs extends \Doctrine\Common\EventArgs
+{
+ /**
+ * @var ObjectManager
+ */
+ private $objectManager;
+
+ /**
+ * Constructor.
+ *
+ * @param ObjectManager $objectManager
+ */
+ public function __construct(ObjectManager $objectManager)
+ {
+ $this->objectManager = $objectManager;
+ }
+
+ /**
+ * Retrieve associated ObjectManager.
+ *
+ * @return ObjectManager
+ */
+ public function getObjectManager()
+ {
+ return $this->objectManager;
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Event/OnClearEventArgs.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Event/OnClearEventArgs.php
new file mode 100644
index 0000000000000000000000000000000000000000..f67ab50e67bb5274b1c00d32d253a952fbcbe698
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Event/OnClearEventArgs.php
@@ -0,0 +1,84 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Persistence\Event;
+
+/**
+ * Provides event arguments for the onClear event.
+ *
+ * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link www.doctrine-project.org
+ * @since 2.2
+ * @author Roman Borschel <roman@code-factory.de>
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ */
+class OnClearEventArgs extends \Doctrine\Common\EventArgs
+{
+ /**
+ * @var ObjectManager
+ */
+ private $objectManager;
+
+ /**
+ * @var string
+ */
+ private $entityClass;
+
+ /**
+ * Constructor.
+ *
+ * @param ObjectManager $objectManager
+ * @param string $entityClass Optional entity class
+ */
+ public function __construct($objectManager, $entityClass = null)
+ {
+ $this->objectManager = $objectManager;
+ $this->entityClass = $entityClass;
+ }
+
+ /**
+ * Retrieve associated ObjectManager.
+ *
+ * @return ObjectManager
+ */
+ public function getObjectManager()
+ {
+ return $this->objectManager;
+ }
+
+ /**
+ * Name of the entity class that is cleared, or empty if all are cleared.
+ *
+ * @return string
+ */
+ public function getEntityClass()
+ {
+ return $this->entityClass;
+ }
+
+ /**
+ * Check if event clears all entities.
+ *
+ * @return bool
+ */
+ public function clearsAllEntities()
+ {
+ return ($this->entityClass === null);
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Event/PreUpdateEventArgs.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Event/PreUpdateEventArgs.php
new file mode 100644
index 0000000000000000000000000000000000000000..191d053abb9baf791e6fcb09b7c78ae67c91b3ef
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Event/PreUpdateEventArgs.php
@@ -0,0 +1,129 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Persistence\Event;
+
+use Doctrine\Common\EventArgs,
+ Doctrine\Common\Persistence\ObjectManager;
+
+/**
+ * Class that holds event arguments for a preUpdate event.
+ *
+ * @author Guilherme Blanco <guilehrmeblanco@hotmail.com>
+ * @author Roman Borschel <roman@code-factory.org>
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ * @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;
+ }
+
+ /**
+ * Retrieve entity changeset.
+ *
+ * @return array
+ */
+ public function getEntityChangeSet()
+ {
+ return $this->entityChangeSet;
+ }
+
+ /**
+ * Check if field has a changeset.
+ *
+ * @return boolean
+ */
+ public function hasChangedField($field)
+ {
+ return isset($this->entityChangeSet[$field]);
+ }
+
+ /**
+ * Get 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];
+ }
+
+ /**
+ * Get 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];
+ }
+
+ /**
+ * Set the new value of this field.
+ *
+ * @param string $field
+ * @param mixed $value
+ */
+ public function setNewValue($field, $value)
+ {
+ $this->assertValidField($field);
+
+ $this->entityChangeSet[$field][1] = $value;
+ }
+
+ /**
+ * Assert the field exists in changeset.
+ *
+ * @param string $field
+ */
+ 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())
+ ));
+ }
+ }
+}
+
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/ManagerRegistry.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/ManagerRegistry.php
new file mode 100644
index 0000000000000000000000000000000000000000..4d92426b12d436f7429389ac4dbad5142ff12bcb
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/ManagerRegistry.php
@@ -0,0 +1,112 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Persistence;
+
+/**
+ * Contract covering object managers for a Doctrine persistence layer ManagerRegistry class to implement.
+ *
+ * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link www.doctrine-project.org
+ * @since 2.2
+ * @author Fabien Potencier <fabien@symfony.com>
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ * @author Lukas Kahwe Smith <smith@pooteeweet.org>
+ */
+interface ManagerRegistry extends ConnectionRegistry
+{
+ /**
+ * Gets the default object manager name.
+ *
+ * @return string The default object manager name
+ */
+ function getDefaultManagerName();
+
+ /**
+ * Gets a named object manager.
+ *
+ * @param string $name The object manager name (null for the default one)
+ *
+ * @return \Doctrine\Common\Persistence\ObjectManager
+ */
+ function getManager($name = null);
+
+ /**
+ * Gets an array of all registered object managers
+ *
+ * @return array An array of ObjectManager instances
+ */
+ 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 $name The object manager name (null for the default one)
+ *
+ * @return \Doctrine\Common\Persistence\ObjectManager
+ */
+ 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
+ */
+ function getAliasNamespace($alias);
+
+ /**
+ * Gets all connection names.
+ *
+ * @return array An array of connection names
+ */
+ 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
+ */
+ 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
+ */
+ function getManagerForClass($class);
+}
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/AbstractClassMetadataFactory.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/AbstractClassMetadataFactory.php
new file mode 100644
index 0000000000000000000000000000000000000000..a2a618506e926ca023cfd81b1444a1be6b519d09
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/AbstractClassMetadataFactory.php
@@ -0,0 +1,359 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Persistence\Mapping;
+
+use Doctrine\Common\Cache\Cache;
+
+/**
+ * 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 <kontakt@beberlei.de>
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author Jonathan Wage <jonwage@gmail.com>
+ * @author Roman Borschel <roman@code-factory.org>
+ */
+abstract class AbstractClassMetadataFactory implements ClassMetadataFactory
+{
+ /**
+ * Salt used by specific Object Manager implementation.
+ *
+ * @var string
+ */
+ protected $cacheSalt = "\$CLASSMETADATA";
+
+ /**
+ * @var \Doctrine\Common\Cache\Cache
+ */
+ private $cacheDriver;
+
+ /**
+ * @var array
+ */
+ private $loadedMetadata = array();
+
+ /**
+ * @var bool
+ */
+ protected $initialized = false;
+
+ /**
+ * @var ReflectionService
+ */
+ private $reflectionService;
+
+ /**
+ * Sets the cache driver used by the factory to cache ClassMetadata instances.
+ *
+ * @param Doctrine\Common\Cache\Cache $cacheDriver
+ */
+ 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
+ */
+ public function getCacheDriver()
+ {
+ return $this->cacheDriver;
+ }
+
+ /**
+ * Return 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();
+
+ /**
+ * Get the fully qualified class-name from the namespace alias.
+ *
+ * @param string $namespaceAlias
+ * @param string $simpleClassName
+ * @return string
+ */
+ abstract protected function getFqcnFromAlias($namespaceAlias, $simpleClassName);
+
+ /**
+ * Return the mapping driver implementation.
+ *
+ * @return MappingDriver
+ */
+ abstract protected function getDriver();
+
+ /**
+ * Wakeup reflection after ClassMetadata gets unserialized from cache.
+ *
+ * @param ClassMetadata $class
+ * @param ReflectionService $reflService
+ * @return void
+ */
+ abstract protected function wakeupReflection(ClassMetadata $class, ReflectionService $reflService);
+
+ /**
+ * Initialize Reflection after ClassMetadata was constructed.
+ *
+ * @param ClassMetadata $class
+ * @param ReflectionSErvice $reflService
+ * @return void
+ */
+ abstract protected function initializeReflection(ClassMetadata $class, ReflectionService $reflService);
+
+ /**
+ * 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])) {
+ $realClassName = $className;
+
+ // Check for namespace alias
+ if (strpos($className, ':') !== false) {
+ list($namespaceAlias, $simpleClassName) = explode(':', $className);
+ $realClassName = $this->getFqcnFromAlias($namespaceAlias, $simpleClassName);
+
+ 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
+ */
+ public function setMetadataFor($className, $class)
+ {
+ $this->loadedMetadata[$className] = $class;
+ }
+
+ /**
+ * Get array of parent classes for the given entity class
+ *
+ * @param string $name
+ * @return array $parentClasses
+ */
+ 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.
+ *
+ * @param string $name The name of the class for which the metadata should get loaded.
+ * @param array $tables The metadata collection to which the loaded metadata is added.
+ */
+ 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 (isset($parent->isMappedSuperclass) && $parent->isMappedSuperclass === false) {
+ $rootEntityFound = true;
+ array_unshift($visited, $className);
+ }
+ continue;
+ }
+
+ $class = $this->newClassMetadataInstance($className);
+ $this->initializeReflection($class, $reflService);
+
+ $this->doLoadMetadata($class, $parent, $rootEntityFound);
+
+ $this->loadedMetadata[$className] = $class;
+
+ $parent = $class;
+
+ if (isset($parent->isMappedSuperclass) && $class->isMappedSuperclass === false) {
+ $rootEntityFound = true;
+ array_unshift($visited, $className);
+ }
+
+ $this->wakeupReflection($class, $reflService);
+
+ $loaded[] = $className;
+ }
+
+ return $loaded;
+ }
+
+ /**
+ * Actually load the metadata from the underlying metadata
+ *
+ * @param ClassMetadata $class
+ * @param ClassMetadata $parent
+ * @param bool $rootEntityFound
+ * @return void
+ */
+ abstract protected function doLoadMetadata($class, $parent, $rootEntityFound);
+
+ /**
+ * Creates a new ClassMetadata instance for the given class name.
+ *
+ * @param string $className
+ * @return ClassMetadata
+ */
+ abstract protected function newClassMetadataInstance($className);
+
+ /**
+ * Check if this class is mapped by this Object Manager + ClassMetadata configuration
+ *
+ * @param $class
+ * @return bool
+ */
+ public function isTransient($class)
+ {
+ if ( ! $this->initialized) {
+ $this->initialize();
+ }
+
+ return $this->getDriver()->isTransient($class);
+ }
+
+ /**
+ * Set reflectionService.
+ *
+ * @param ReflectionService $reflectionService
+ */
+ public function setReflectionService(ReflectionService $reflectionService)
+ {
+ $this->reflectionService = $reflectionService;
+ }
+
+ /**
+ * Get the reflection service associated with this metadata factory.
+ *
+ * @return ReflectionService
+ */
+ public function getReflectionService()
+ {
+ if ($this->reflectionService === null) {
+ $this->reflectionService = new RuntimeReflectionService();
+ }
+ return $this->reflectionService;
+ }
+}
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/ClassMetadata.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/ClassMetadata.php
new file mode 100644
index 0000000000000000000000000000000000000000..705d59acf18e1c3f44c03593690d394303688f65
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/ClassMetadata.php
@@ -0,0 +1,165 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Persistence\Mapping;
+
+/**
+ * Contract for a Doctrine persistence layer ClassMetadata class to implement.
+ *
+ * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link www.doctrine-project.org
+ * @since 2.1
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ * @author Jonathan Wage <jonwage@gmail.com>
+ */
+interface ClassMetadata
+{
+ /**
+ * Get fully-qualified class name of this persistent class.
+ *
+ * @return string
+ */
+ function getName();
+
+ /**
+ * Gets the mapped identifier field name.
+ *
+ * The returned structure is an array of the identifier field names.
+ *
+ * @return array
+ */
+ function getIdentifier();
+
+ /**
+ * Gets the ReflectionClass instance for this mapped class.
+ *
+ * @return ReflectionClass
+ */
+ function getReflectionClass();
+
+ /**
+ * Checks if the given field name is a mapped identifier for this class.
+ *
+ * @param string $fieldName
+ * @return boolean
+ */
+ function isIdentifier($fieldName);
+
+ /**
+ * Checks if the given field is a mapped property for this class.
+ *
+ * @param string $fieldName
+ * @return boolean
+ */
+ function hasField($fieldName);
+
+ /**
+ * Checks if the given field is a mapped association for this class.
+ *
+ * @param string $fieldName
+ * @return boolean
+ */
+ function hasAssociation($fieldName);
+
+ /**
+ * Checks if the given field is a mapped single valued association for this class.
+ *
+ * @param string $fieldName
+ * @return boolean
+ */
+ function isSingleValuedAssociation($fieldName);
+
+ /**
+ * Checks if the given field is a mapped collection valued association for this class.
+ *
+ * @param string $fieldName
+ * @return boolean
+ */
+ 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
+ */
+ function getFieldNames();
+
+ /**
+ * Returns an array of identifier field names numerically indexed.
+ *
+ * @return array
+ */
+ function getIdentifierFieldNames();
+
+ /**
+ * A numerically indexed list of association names of this persistent class.
+ *
+ * This array includes identifier associations if present on this class.
+ *
+ * @return array
+ */
+ 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
+ */
+ function getTypeOfField($fieldName);
+
+ /**
+ * Returns the target class name of the given association.
+ *
+ * @param string $assocName
+ * @return string
+ */
+ function getAssociationTargetClass($assocName);
+
+ /**
+ * Checks if the association is the inverse side of a bidirectional association
+ *
+ * @param string $assocName
+ * @return boolean
+ */
+ function isAssociationInverseSide($assocName);
+
+ /**
+ * Returns the target field of the owning side of the association
+ *
+ * @param string $assocName
+ * @return string
+ */
+ function getAssociationMappedByTargetField($assocName);
+
+ /**
+ * Return 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
+ */
+ function getIdentifierValues($object);
+}
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/ClassMetadataFactory.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/ClassMetadataFactory.php
new file mode 100644
index 0000000000000000000000000000000000000000..bf27ba9aba9b274b9e85f0d9ed3f521266a9b5c1
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/ClassMetadataFactory.php
@@ -0,0 +1,74 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Persistence\Mapping;
+
+/**
+ * Contract for a Doctrine persistence layer ClassMetadata class to implement.
+ *
+ * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link www.doctrine-project.org
+ * @since 2.1
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ * @author Jonathan Wage <jonwage@gmail.com>
+ */
+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.
+ */
+ function getAllMetadata();
+
+ /**
+ * Gets the class metadata descriptor for a class.
+ *
+ * @param string $className The name of the class.
+ * @return ClassMetadata
+ */
+ 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.
+ */
+ function hasMetadataFor($className);
+
+ /**
+ * Sets the metadata descriptor for a specific class.
+ *
+ * @param string $className
+ * @param ClassMetadata $class
+ */
+ function setMetadataFor($className, $class);
+
+ /**
+ * 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
+ */
+ function isTransient($className);
+}
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/Driver/AnnotationDriver.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/Driver/AnnotationDriver.php
new file mode 100644
index 0000000000000000000000000000000000000000..f52d37eee713c7c8bb1839ff637bd64957da4705
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/Driver/AnnotationDriver.php
@@ -0,0 +1,214 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Persistence\Mapping\Driver;
+
+use Doctrine\Common\Cache\ArrayCache,
+ Doctrine\Common\Annotations\AnnotationReader,
+ Doctrine\Common\Annotations\AnnotationRegistry,
+ Doctrine\Common\Persistence\Mapping\MappingException;
+
+/**
+ * The AnnotationDriver reads the mapping metadata from docblock annotations.
+ *
+ * @since 2.2
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author Jonathan H. Wage <jonwage@gmail.com>
+ * @author Roman Borschel <roman@code-factory.org>
+ */
+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 file extension of mapping documents.
+ *
+ * @var string
+ */
+ protected $fileExtension = '.php';
+
+ /**
+ * Cache for AnnotationDriver#getAllClassNames()
+ *
+ * @var array
+ */
+ 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 $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);
+ }
+ }
+
+ /**
+ * Append lookup paths to metadata driver.
+ *
+ * @param array $paths
+ */
+ public function addPaths(array $paths)
+ {
+ $this->paths = array_unique(array_merge($this->paths, $paths));
+ }
+
+ /**
+ * Retrieve the defined metadata lookup paths.
+ *
+ * @return array
+ */
+ public function getPaths()
+ {
+ return $this->paths;
+ }
+
+ /**
+ * Retrieve the current annotation reader
+ *
+ * @return AnnotationReader
+ */
+ public function getReader()
+ {
+ return $this->reader;
+ }
+
+ /**
+ * Get the file extension used to look for mapping files under
+ *
+ * @return void
+ */
+ public function getFileExtension()
+ {
+ return $this->fileExtension;
+ }
+
+ /**
+ * Set 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;
+ }
+
+ /**
+ * 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
+ ),
+ '/^.+' . str_replace('.', '\.', $this->fileExtension) . '$/i',
+ \RecursiveRegexIterator::GET_MATCH
+ );
+
+ foreach ($iterator as $file) {
+ $sourceFile = realpath($file[0]);
+
+ 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;
+ }
+}
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/Driver/DefaultFileLocator.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/Driver/DefaultFileLocator.php
new file mode 100644
index 0000000000000000000000000000000000000000..efaf545ee484e9fcab3a268a8fe8661f02f73ecb
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/Driver/DefaultFileLocator.php
@@ -0,0 +1,169 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+*/
+
+namespace Doctrine\Common\Persistence\Mapping\Driver;
+
+use Doctrine\Common\Persistence\Mapping\MappingException;
+
+/**
+ * Locate the file that contains the metadata information for a given class name.
+ *
+ * This behavior is inpependent of the actual content of the file. It just detects
+ * the file which is responsible for the given class name.
+ *
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+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
+ */
+ 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.
+ */
+ public function __construct($paths, $fileExtension = null)
+ {
+ $this->addPaths((array) $paths);
+ $this->fileExtension = $fileExtension;
+ }
+
+ /**
+ * Append lookup paths to metadata driver.
+ *
+ * @param array $paths
+ */
+ public function addPaths(array $paths)
+ {
+ $this->paths = array_unique(array_merge($this->paths, $paths));
+ }
+
+ /**
+ * Retrieve the defined metadata lookup paths.
+ *
+ * @return array
+ */
+ public function getPaths()
+ {
+ return $this->paths;
+ }
+
+ /**
+ * Get the file extension used to look for mapping files under
+ *
+ * @return void
+ */
+ public function getFileExtension()
+ {
+ return $this->fileExtension;
+ }
+
+ /**
+ * Set 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 findMappingFile($className)
+ {
+ $fileName = str_replace('\\', '.', $className) . $this->fileExtension;
+
+ // Check whether file exists
+ foreach ($this->paths as $path) {
+ if (file_exists($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 (file_exists($path . DIRECTORY_SEPARATOR . $fileName)) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/Driver/FileDriver.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/Driver/FileDriver.php
new file mode 100644
index 0000000000000000000000000000000000000000..22cf117d5a2c95083166e96d1dd602a5c1c6821e
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/Driver/FileDriver.php
@@ -0,0 +1,178 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\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 '.'.
+ *
+ * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link www.doctrine-project.com
+ * @since 2.2
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author Jonathan H. Wage <jonwage@gmail.com>
+ * @author Roman Borschel <roman@code-factory.org>
+ */
+abstract class FileDriver implements MappingDriver
+{
+ /**
+ * @var FileLocator
+ */
+ protected $locator;
+
+ /**
+ * @var array
+ */
+ protected $classCache;
+
+ /**
+ * @var string
+ */
+ 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 $paths A FileLocator or one/multiple paths where mapping documents can be found.
+ * @param string $fileExtension
+ */
+ public function __construct($locator, $fileExtension = null)
+ {
+ if ($locator instanceof FileLocator) {
+ $this->locator = $locator;
+ } else {
+ $this->locator = new DefaultFileLocator((array)$locator, $fileExtension);
+ }
+ }
+
+ public function setGlobalBasename($file)
+ {
+ $this->globalBasename = $file;
+ }
+
+ public function getGlobalBasename()
+ {
+ return $this->globalBasename;
+ }
+
+ /**
+ * Get 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
+ *
+ * @return array $element The element of schema meta data
+ */
+ 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));
+
+ return $result[$className];
+ }
+
+ /**
+ * 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)
+ {
+ if ($this->classCache === null) {
+ $this->initialize();
+ }
+
+ if (isset($this->classCache[$className])) {
+ return false;
+ }
+
+ return !$this->locator->fileExists($className);
+ }
+
+ /**
+ * 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()
+ {
+ 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);
+
+ /**
+ * Initialize 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)
+ );
+ }
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/Driver/FileLocator.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/Driver/FileLocator.php
new file mode 100644
index 0000000000000000000000000000000000000000..a1019d71f14559c1e80a801d83887f8051db646e
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/Driver/FileLocator.php
@@ -0,0 +1,69 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+*/
+
+namespace Doctrine\Common\Persistence\Mapping\Driver;
+
+/**
+ * Locate the file that contains the metadata information for a given class name.
+ *
+ * This behavior is inpependent of the actual content of the file. It just detects
+ * the file which is responsible for the given class name.
+ *
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+interface FileLocator
+{
+ /**
+ * Locate mapping file for the given class name.
+ *
+ * @param string $className
+ * @return string
+ */
+ function findMappingFile($className);
+
+ /**
+ * Get all class names that are found with this file locator.
+ *
+ * @param string $globalBasename Passed to allow excluding the basename
+ * @return array
+ */
+ function getAllClassNames($globalBasename);
+
+ /**
+ * Check if a file can be found for this class name.
+ *
+ * @return bool
+ */
+ function fileExists($className);
+
+ /**
+ * Get all the paths that this file locator looks for mapping files.
+ *
+ * @return array
+ */
+ function getPaths();
+
+ /**
+ * Get the file extension that mapping files are suffixed with.
+ *
+ * @return string
+ */
+ function getFileExtension();
+}
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/Driver/MappingDriver.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/Driver/MappingDriver.php
new file mode 100644
index 0000000000000000000000000000000000000000..c050d32337319bdc98eedd139320ce744f3e0c92
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/Driver/MappingDriver.php
@@ -0,0 +1,56 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Persistence\Mapping\Driver;
+
+use Doctrine\Common\Persistence\Mapping\ClassMetadata;
+
+/**
+ * Contract for metadata drivers.
+ *
+ * @since 2.2
+ * @author Jonathan H. Wage <jonwage@gmail.com>
+ */
+interface MappingDriver
+{
+ /**
+ * Loads the metadata for the specified class into the provided container.
+ *
+ * @param string $className
+ * @param ClassMetadata $metadata
+ */
+ 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.
+ */
+ function getAllClassNames();
+
+ /**
+ * 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
+ */
+ function isTransient($className);
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/Driver/MappingDriverChain.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/Driver/MappingDriverChain.php
new file mode 100644
index 0000000000000000000000000000000000000000..c7c145270e0675c213d279cfb7650b80708aba4b
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/Driver/MappingDriverChain.php
@@ -0,0 +1,125 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Persistence\Mapping\Driver;
+
+use Doctrine\Common\Persistence\Mapping\Driver\MappingDriver,
+ Doctrine\Common\Persistence\Mapping\ClassMetadata,
+ Doctrine\Common\Persistence\Mapping\MappingException;
+
+/**
+ * The DriverChain allows you to add multiple other mapping drivers for
+ * certain namespaces
+ *
+ * @since 2.2
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author Jonathan H. Wage <jonwage@gmail.com>
+ * @author Roman Borschel <roman@code-factory.org>
+ */
+class MappingDriverChain implements MappingDriver
+{
+ /**
+ * @var array
+ */
+ private $drivers = array();
+
+ /**
+ * Add a nested driver.
+ *
+ * @param Driver $nestedDriver
+ * @param string $namespace
+ */
+ public function addDriver(MappingDriver $nestedDriver, $namespace)
+ {
+ $this->drivers[$namespace] = $nestedDriver;
+ }
+
+ /**
+ * Get the array of nested drivers.
+ *
+ * @return array $drivers
+ */
+ public function getDrivers()
+ {
+ return $this->drivers;
+ }
+
+ /**
+ * Loads the metadata for the specified class into the provided container.
+ *
+ * @param string $className
+ * @param ClassMetadataInfo $metadata
+ */
+ public function loadMetadataForClass($className, ClassMetadata $metadata)
+ {
+ foreach ($this->drivers as $namespace => $driver) {
+ if (strpos($className, $namespace) === 0) {
+ $driver->loadMetadataForClass($className, $metadata);
+ return;
+ }
+ }
+
+ throw MappingException::classNotFoundInNamespaces($className, array_keys($this->drivers));
+ }
+
+ /**
+ * 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()
+ {
+ $classNames = array();
+ $driverClasses = array();
+ 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;
+ }
+ }
+ }
+ return array_keys($classNames);
+ }
+
+ /**
+ * Whether the class with the specified name should have its metadata loaded.
+ *
+ * This is only the case for non-transient classes either mapped as an Entity or MappedSuperclass.
+ *
+ * @param string $className
+ * @return boolean
+ */
+ public function isTransient($className)
+ {
+ foreach ($this->drivers AS $namespace => $driver) {
+ if (strpos($className, $namespace) === 0) {
+ return $driver->isTransient($className);
+ }
+ }
+
+ // class isTransient, i.e. not an entity or mapped superclass
+ return true;
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/Driver/PHPDriver.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/Driver/PHPDriver.php
new file mode 100644
index 0000000000000000000000000000000000000000..7751dae3b5588f0864d5d5bf767ca648bcc84e23
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/Driver/PHPDriver.php
@@ -0,0 +1,70 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Persistence\Mapping\Driver;
+
+use Doctrine\Common\Persistence\Mapping\ClassMetadata;
+
+/**
+ * The PHPDriver includes php files which just populate ClassMetadataInfo
+ * instances with plain php code
+ *
+ * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link www.doctrine-project.org
+ * @since 2.0
+ * @version $Revision$
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author Jonathan H. Wage <jonwage@gmail.com>
+ * @author Roman Borschel <roman@code-factory.org>
+ */
+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;
+ }
+}
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/Driver/StaticPHPDriver.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/Driver/StaticPHPDriver.php
new file mode 100644
index 0000000000000000000000000000000000000000..9103ed863bf2c8e4aeb3e3c0ebf013035a98f724
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/Driver/StaticPHPDriver.php
@@ -0,0 +1,131 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\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.
+ *
+ * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link www.doctrine-project.org
+ * @since 2.2
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author Jonathan H. Wage <jonwage@gmail.com>
+ * @author Roman Borschel <roman@code-factory.org>
+ */
+class StaticPHPDriver implements MappingDriver
+{
+ /**
+ * Paths of entity directories.
+ *
+ * @var array
+ */
+ private $paths = array();
+
+ /**
+ * Map of all class names.
+ *
+ * @var array
+ */
+ private $classNames;
+
+ public function __construct($paths)
+ {
+ $this->addPaths((array) $paths);
+ }
+
+ 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');
+ }
+}
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/Driver/SymfonyFileLocator.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/Driver/SymfonyFileLocator.php
new file mode 100644
index 0000000000000000000000000000000000000000..d338cf6079e16900cae9f86d5529bac69088a60c
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/Driver/SymfonyFileLocator.php
@@ -0,0 +1,198 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+*/
+
+namespace Doctrine\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 <fabien@symfony.com>
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ * @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
+ */
+ protected $fileExtension;
+
+ public function __construct(array $prefixes, $fileExtension = null)
+ {
+ $this->addNamespacePrefixes($prefixes);
+ $this->fileExtension = $fileExtension;
+ }
+
+ public function addNamespacePrefixes(array $prefixes)
+ {
+ $this->prefixes = array_merge($this->prefixes, $prefixes);
+ $this->paths = array_merge($this->paths, array_keys($prefixes));
+ }
+
+ public function getNamespacePrefixes()
+ {
+ return $this->prefixes;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function getPaths()
+ {
+ return $this->paths;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public function getFileExtension()
+ {
+ return $this->fileExtension;
+ }
+
+ /**
+ * Set 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);
+ }
+}
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/MappingException.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/MappingException.php
new file mode 100644
index 0000000000000000000000000000000000000000..4ecd2ad5531fa9f0447cc5c1384049e5ec5f5a1e
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/MappingException.php
@@ -0,0 +1,57 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.phpdoctrine.org>.
+ */
+
+namespace Doctrine\Common\Persistence\Mapping;
+
+/**
+ * A MappingException indicates that something is wrong with the mapping setup.
+ *
+ * @since 2.2
+ */
+class MappingException extends \Exception
+{
+ public static function classNotFoundInNamespaces($className, $namespaces)
+ {
+ return new self("The class '" . $className . "' was not found in the ".
+ "chain configured namespaces " . implode(", ", $namespaces));
+ }
+
+ public static function pathRequired()
+ {
+ return new self("Specifying the paths to your entities is required ".
+ "in the AnnotationDriver to retrieve all class names.");
+ }
+
+ 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!'
+ );
+ }
+
+ public static function mappingFileNotFound($entityName, $fileName)
+ {
+ return new self("No mapping file found named '$fileName' for class '$entityName'.");
+ }
+}
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/ReflectionService.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/ReflectionService.php
new file mode 100644
index 0000000000000000000000000000000000000000..4e0e312fd440e3d71f0a313418ca8c4cb47c76df
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/ReflectionService.php
@@ -0,0 +1,80 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\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 <kontakt@beberlei.de>
+ */
+interface ReflectionService
+{
+ /**
+ * Return an array of the parent classes (not interfaces) for the given class.
+ *
+ * @param string $class
+ * @return array
+ */
+ function getParentClasses($class);
+
+ /**
+ * Return the shortname of a class.
+ *
+ * @param string $class
+ * @return string
+ */
+ function getClassShortName($class);
+
+ /**
+ * @param string $class
+ * @return string
+ */
+ function getClassNamespace($class);
+
+ /**
+ * Return a reflection class instance or null
+ *
+ * @param string $class
+ * @return ReflectionClass|null
+ */
+ function getClass($class);
+
+ /**
+ * Return an accessible property (setAccessible(true)) or null.
+ *
+ * @param string $class
+ * @param string $property
+ * @return ReflectionProperty|null
+ */
+ function getAccessibleProperty($class, $property);
+
+ /**
+ * Check if the class have a public method with the given name.
+ *
+ * @param mixed $class
+ * @param mixed $method
+ * @return bool
+ */
+ function hasPublicMethod($class, $method);
+}
+
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/RuntimeReflectionService.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/RuntimeReflectionService.php
new file mode 100644
index 0000000000000000000000000000000000000000..abcff58139efd386c82980b05ad14eef8948110b
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/RuntimeReflectionService.php
@@ -0,0 +1,102 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Persistence\Mapping;
+
+use ReflectionClass;
+use ReflectionProperty;
+
+/**
+ * PHP Runtime Reflection Service
+ *
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ */
+class RuntimeReflectionService implements ReflectionService
+{
+ /**
+ * Return an array of the parent classes (not interfaces) for the given class.
+ *
+ * @param string $class
+ * @return array
+ */
+ public function getParentClasses($class)
+ {
+ return class_parents($class);
+ }
+
+ /**
+ * Return the shortname of a class.
+ *
+ * @param string $class
+ * @return string
+ */
+ public function getClassShortName($class)
+ {
+ $r = new ReflectionClass($class);
+ return $r->getShortName();
+ }
+
+ /**
+ * @param string $class
+ * @return string
+ */
+ public function getClassNamespace($class)
+ {
+ $r = new ReflectionClass($class);
+ return $r->getNamespaceName();
+ }
+
+ /**
+ * Return a reflection class instance or null
+ *
+ * @param string $class
+ * @return ReflectionClass|null
+ */
+ public function getClass($class)
+ {
+ return new ReflectionClass($class);
+ }
+
+ /**
+ * Return an accessible property (setAccessible(true)) or null.
+ *
+ * @param string $class
+ * @param string $property
+ * @return ReflectionProperty|null
+ */
+ public function getAccessibleProperty($class, $property)
+ {
+ $property = new ReflectionProperty($class, $property);
+ $property->setAccessible(true);
+ return $property;
+ }
+
+ /**
+ * Check if the class have a public method with the given name.
+ *
+ * @param mixed $class
+ * @param mixed $method
+ * @return bool
+ */
+ public function hasPublicMethod($class, $method)
+ {
+ return method_exists($class, $method) && is_callable(array($class, $method));
+ }
+}
+
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/StaticReflectionService.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/StaticReflectionService.php
new file mode 100644
index 0000000000000000000000000000000000000000..2de6e761326ed55a1de36fdfab45b5e82398f146
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Mapping/StaticReflectionService.php
@@ -0,0 +1,107 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Persistence\Mapping;
+
+use ReflectionClass;
+use ReflectionProperty;
+
+/**
+ * PHP Runtime Reflection Service
+ *
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ */
+class StaticReflectionService implements ReflectionService
+{
+ /**
+ * Return an array of the parent classes (not interfaces) for the given class.
+ *
+ * @param string $class
+ * @return array
+ */
+ public function getParentClasses($class)
+ {
+ return array();
+ }
+
+ /**
+ * Return the shortname of a class.
+ *
+ * @param string $className
+ * @return string
+ */
+ public function getClassShortName($className)
+ {
+ if (strpos($className, '\\') !== false) {
+ $className = substr($className, strrpos($className, "\\")+1);
+ }
+ return $className;
+ }
+
+ /**
+ * Return the namespace of a class.
+ *
+ * @param string $className
+ * @return string
+ */
+ public function getClassNamespace($className)
+ {
+ $namespace = '';
+ if (strpos($className, '\\') !== false) {
+ $namespace = strrev(substr( strrev($className), strpos(strrev($className), '\\')+1 ));
+ }
+ return $namespace;
+ }
+
+ /**
+ * Return a reflection class instance or null
+ *
+ * @param string $class
+ * @return ReflectionClass|null
+ */
+ public function getClass($class)
+ {
+ return null;
+ }
+
+ /**
+ * Return an accessible property (setAccessible(true)) or null.
+ *
+ * @param string $class
+ * @param string $property
+ * @return ReflectionProperty|null
+ */
+ public function getAccessibleProperty($class, $property)
+ {
+ return null;
+ }
+
+ /**
+ * Check if the class have a public method with the given name.
+ *
+ * @param mixed $class
+ * @param mixed $method
+ * @return bool
+ */
+ public function hasPublicMethod($class, $method)
+ {
+ return method_exists($class, $method) && is_callable(array($class, $method));
+ }
+}
+
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/ObjectManager.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/ObjectManager.php
new file mode 100644
index 0000000000000000000000000000000000000000..6d70fc1227c63c0f27deb9f33e382b463604b656
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/ObjectManager.php
@@ -0,0 +1,143 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Persistence;
+
+/**
+ * Contract for a Doctrine persistence layer ObjectManager class to implement.
+ *
+ * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link www.doctrine-project.org
+ * @since 2.1
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ * @author Jonathan Wage <jonwage@gmail.com>
+ */
+interface ObjectManager
+{
+ /**
+ * Finds a object by its identifier.
+ *
+ * This is just a convenient shortcut for getRepository($className)->find($id).
+ *
+ * @param string
+ * @param mixed
+ * @return object
+ */
+ 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.
+ */
+ 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.
+ */
+ 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
+ */
+ function merge($object);
+
+ /**
+ * 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.
+ */
+ 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.
+ */
+ 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.
+ */
+ function flush();
+
+ /**
+ * Gets the repository for a class.
+ *
+ * @param string $className
+ * @return \Doctrine\Common\Persistence\ObjectRepository
+ */
+ 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
+ */
+ function getClassMetadata($className);
+
+ /**
+ * Gets the metadata factory used to gather the metadata of classes.
+ *
+ * @return Doctrine\Common\Persistence\Mapping\ClassMetadataFactory
+ */
+ 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
+ */
+ function initializeObject($obj);
+
+ /**
+ * Check if the object is part of the current UnitOfWork and therefore
+ * managed.
+ *
+ * @param object $object
+ * @return bool
+ */
+ function contains($object);
+}
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/ObjectManagerAware.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/ObjectManagerAware.php
new file mode 100644
index 0000000000000000000000000000000000000000..015dd3dd9e5b67f54d8e48ba5d0d70d2d890b0a7
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/ObjectManagerAware.php
@@ -0,0 +1,49 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\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 persistance-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 <kontakt@beberlei.de>
+ */
+interface ObjectManagerAware
+{
+ /**
+ * Injects responsible ObjectManager and the ClassMetadata into this persistent object.
+ *
+ * @param ObjectManager $objectManager
+ * @param ClassMetadata $classMetadata
+ */
+ public function injectObjectManager(ObjectManager $objectManager, ClassMetadata $classMetadata);
+}
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/ObjectRepository.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/ObjectRepository.php
new file mode 100644
index 0000000000000000000000000000000000000000..22633288ee30b40a3c338817fb6fdee9e542458d
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/ObjectRepository.php
@@ -0,0 +1,78 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Persistence;
+
+/**
+ * Contract for a Doctrine persistence layer ObjectRepository class to implement.
+ *
+ * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link www.doctrine-project.org
+ * @since 2.1
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ * @author Jonathan Wage <jonwage@gmail.com>
+ */
+interface ObjectRepository
+{
+ /**
+ * Finds an object by its primary key / identifier.
+ *
+ * @param $id The identifier.
+ * @return object The object.
+ */
+ function find($id);
+
+ /**
+ * Finds all objects in the repository.
+ *
+ * @return mixed The objects.
+ */
+ 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.
+ *
+ * @throws UnexpectedValueException
+ * @param array $criteria
+ * @param array|null $orderBy
+ * @param int|null $limit
+ * @param int|null $offset
+ * @return mixed The objects.
+ */
+ function findBy(array $criteria, array $orderBy = null, $limit = null, $offset = null);
+
+ /**
+ * Finds a single object by a set of criteria.
+ *
+ * @param array $criteria
+ * @return object The object.
+ */
+ function findOneBy(array $criteria);
+
+ /**
+ * Returns the class name of the object managed by the repository
+ *
+ * @return string
+ */
+ function getClassName();
+}
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/PersistentObject.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/PersistentObject.php
new file mode 100644
index 0000000000000000000000000000000000000000..4274af62461df969ac79f1d511e53671543b6c8e
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/PersistentObject.php
@@ -0,0 +1,233 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\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 aswell. 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 <kontakt@beberlei.de>
+ */
+abstract class PersistentObject implements ObjectManagerAware
+{
+ /**
+ * @var ObjectManager
+ */
+ private static $objectManager;
+
+ /**
+ * @var ClassMetadata
+ */
+ private $cm;
+
+ /**
+ * Set the object manager responsible for all persistent object base classes.
+ *
+ * @param ObjectManager $objectManager
+ */
+ static public function setObjectManager(ObjectManager $objectManager = null)
+ {
+ self::$objectManager = $objectManager;
+ }
+
+ /**
+ * @return ObjectManager
+ */
+ static public function getObjectManager()
+ {
+ return self::$objectManager;
+ }
+
+ /**
+ * Inject Doctrine Object Manager
+ *
+ * @param ObjectManager $objectManager
+ * @param ClassMetadata $classMetadata
+ */
+ 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.
+ *
+ * @throws InvalidArgumentException - When the wrong target object type is passed to an association
+ * @throws BadMethodCallException - When no persistent field exists by that name.
+ * @param string $field
+ * @param array $args
+ * @return void
+ */
+ 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()."'");
+ }
+ }
+
+ /**
+ * Get persistent field value.
+ *
+ * @throws BadMethodCallException - When no persistent field exists by that name.
+ * @param string $field
+ * @return mixed
+ */
+ 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 complete the owning side.
+ *
+ * @param string $field
+ * @param ClassMetadata $targetClass
+ * @param object $targetObject
+ */
+ private function completeOwningSide($field, $targetClass, $targetObject)
+ {
+ // add this object on the owning side aswell, 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);
+ }
+ }
+
+ /**
+ * Add an object to a collection
+ *
+ * @param type $field
+ * @param assoc $args
+ */
+ 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());
+ }
+ }
+
+ /**
+ * Initialize Doctrine Metadata for this class.
+ *
+ * @return void
+ */
+ 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 method that implements
+ *
+ * @param string $method
+ * @param array $args
+ * @return mixed
+ */
+ 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());
+ }
+ }
+}
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Proxy.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Proxy.php
new file mode 100644
index 0000000000000000000000000000000000000000..726979fcf384333b0939083158c98ca3ecb4e1d2
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Persistence/Proxy.php
@@ -0,0 +1,60 @@
+<?php
+
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Persistence;
+
+/**
+ * Interface for proxy classes.
+ *
+ * @author Roman Borschel <roman@code-factory.org>
+ * @since 2.2
+ */
+interface Proxy
+{
+ /**
+ * Marker for Proxy class names.
+ *
+ * @var string
+ */
+ const MARKER = '__CG__';
+
+ /**
+ * Length of the proxy marker
+ *
+ * @var int
+ */
+ const MARKER_LENGTH = 6;
+
+ /**
+ * Initialize this proxy if its not yet initialized.
+ *
+ * Acts as a no-op if already initialized.
+ *
+ * @return void
+ */
+ public function __load();
+
+ /**
+ * Is this proxy initialized or not.
+ *
+ * @return bool
+ */
+ public function __isInitialized();
+}
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/PropertyChangedListener.php b/core/vendor/doctrine/common/lib/Doctrine/Common/PropertyChangedListener.php
new file mode 100644
index 0000000000000000000000000000000000000000..87c5b413dd9c50eb12c227f5ca8951314b8ea968
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/PropertyChangedListener.php
@@ -0,0 +1,48 @@
+<?php
+/*
+ * $Id$
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common;
+
+/**
+ * Contract for classes that are potential listeners of a <tt>NotifyPropertyChanged</tt>
+ * implementor.
+ *
+ * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link www.doctrine-project.org
+ * @since 2.0
+ * @version $Revision: 3938 $
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author Jonathan Wage <jonwage@gmail.com>
+ * @author Roman Borschel <roman@code-factory.org>
+ */
+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.
+ */
+ function propertyChanged($sender, $propertyName, $oldValue, $newValue);
+}
+
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Util/ClassUtils.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Util/ClassUtils.php
new file mode 100644
index 0000000000000000000000000000000000000000..c346278280808f28cb5897a31aeab09d7dbaa2b0
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Util/ClassUtils.php
@@ -0,0 +1,103 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\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 <kontakt@beberlei.de>
+ * @author Johannes Schmitt <schmittjoh@gmail.com>
+ */
+class ClassUtils
+{
+ /**
+ * Get the real class name of a class name that could be a proxy.
+ *
+ * @param string
+ * @return string
+ */
+ public static function getRealClass($class)
+ {
+ if (false === $pos = strrpos($class, '\\'.Proxy::MARKER.'\\')) {
+ return $class;
+ }
+
+ return substr($class, $pos + Proxy::MARKER_LENGTH + 2);
+ }
+
+ /**
+ * Get the real class name of an object (even if its a proxy)
+ *
+ * @param object
+ * @return string
+ */
+ public static function getClass($object)
+ {
+ return self::getRealClass(get_class($object));
+ }
+
+ /**
+ * Get the real parent class name of a class or object
+ *
+ * @param string
+ * @return string
+ */
+ public static function getParentClass($className)
+ {
+ return get_parent_class( self::getRealClass( $className ) );
+ }
+
+ /**
+ * Create a new reflection class
+ *
+ * @param string
+ * @return ReflectionClass
+ */
+ public static function newReflectionClass($class)
+ {
+ return new \ReflectionClass( self::getRealClass( $class ) );
+ }
+
+ /**
+ * Create a new reflection object
+ *
+ * @param object
+ * @return ReflectionObject
+ */
+ public static function newReflectionObject($object)
+ {
+ return self::newReflectionClass( self::getClass( $object ) );
+ }
+
+ /**
+ * Given a class name and a proxy namespace return the proxy name.
+ *
+ * @param string $className
+ * @param string $proxyNamespace
+ * @return string
+ */
+ public static function generateProxyClassName($className, $proxyNamespace)
+ {
+ return rtrim($proxyNamespace, '\\') . '\\'.Proxy::MARKER.'\\' . ltrim($className, '\\');
+ }
+}
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Util/Debug.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Util/Debug.php
new file mode 100644
index 0000000000000000000000000000000000000000..57ae312028f267d70a2d0374a3825da1be369f28
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Util/Debug.php
@@ -0,0 +1,123 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Util;
+
+/**
+ * Static class containing most used debug methods.
+ *
+ * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link www.doctrine-project.org
+ * @since 2.0
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author Jonathan Wage <jonwage@gmail.com>
+ * @author Roman Borschel <roman@code-factory.org>
+ * @author Giorgio Sironi <piccoloprincipeazzurro@gmail.com>
+ */
+final class Debug
+{
+ /**
+ * Private constructor (prevents from instantiation)
+ *
+ */
+ private function __construct() {}
+
+ /**
+ * Prints a dump of the public, protected and private properties of $var.
+ *
+ * @static
+ * @link http://xdebug.org/
+ * @param mixed $var
+ * @param integer $maxDepth Maximum nesting level for object properties
+ * @param boolean $stripTags Flag that indicate if 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');
+ }
+
+ 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 \Doctrine\Common\Persistence\Proxy) {
+ $return->__IS_PROXY__ = true;
+ $return->__PROXY_INITIALIZED__ = $var->__isInitialized();
+ }
+
+ 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;
+ }
+
+ public static function toString($obj)
+ {
+ return method_exists('__toString', $obj) ? (string) $obj : get_class($obj) . '@' . spl_object_hash($obj);
+ }
+}
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Util/Inflector.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Util/Inflector.php
new file mode 100644
index 0000000000000000000000000000000000000000..ba1eb17b2da01ce5c0a87731f08c989d79680e21
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Util/Inflector.php
@@ -0,0 +1,72 @@
+<?php
+/*
+ * $Id: Inflector.php 3189 2007-11-18 20:37:44Z meus $
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common\Util;
+
+/**
+ * Doctrine inflector has static methods for inflecting text
+ *
+ * The methods in these classes are from several different sources collected
+ * across several different php projects and several different authors. The
+ * original author names and emails are not known
+ *
+ * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link www.doctrine-project.org
+ * @since 1.0
+ * @version $Revision: 3189 $
+ * @author Konsta Vesterinen <kvesteri@cc.hut.fi>
+ * @author Jonathan H. Wage <jonwage@gmail.com>
+ */
+class Inflector
+{
+ /**
+ * Convert word in to the format for a Doctrine table name. Converts 'ModelName' to 'model_name'
+ *
+ * @param string $word Word to tableize
+ * @return string $word Tableized word
+ */
+ public static function tableize($word)
+ {
+ return strtolower(preg_replace('~(?<=\\w)([A-Z])~', '_$1', $word));
+ }
+
+ /**
+ * Convert a word in to the format for a Doctrine class name. Converts 'table_name' to 'TableName'
+ *
+ * @param string $word Word to classify
+ * @return string $word Classified word
+ */
+ public static function classify($word)
+ {
+ return str_replace(" ", "", ucwords(strtr($word, "_-", " ")));
+ }
+
+ /**
+ * Camelize a word. This uses the classify() method and turns the first character to lowercase
+ *
+ * @param string $word
+ * @return string $word
+ */
+ public static function camelize($word)
+ {
+ return lcfirst(self::classify($word));
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/lib/Doctrine/Common/Version.php b/core/vendor/doctrine/common/lib/Doctrine/Common/Version.php
new file mode 100644
index 0000000000000000000000000000000000000000..b7c9a8284e560d26097d327b756df1dca968a850
--- /dev/null
+++ b/core/vendor/doctrine/common/lib/Doctrine/Common/Version.php
@@ -0,0 +1,55 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Common;
+
+/**
+ * Class to store and retrieve the version of Doctrine
+ *
+ * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
+ * @link www.doctrine-project.org
+ * @since 2.0
+ * @version $Revision$
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
+ * @author Jonathan Wage <jonwage@gmail.com>
+ * @author Roman Borschel <roman@code-factory.org>
+ */
+class Version
+{
+ /**
+ * Current Doctrine Version
+ */
+ const VERSION = '2.2.2';
+
+ /**
+ * Compares a Doctrine version with the current one.
+ *
+ * @param string $version Doctrine version to compare.
+ * @return int Returns -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);
+ }
+}
diff --git a/core/vendor/doctrine/common/phpunit.xml.dist b/core/vendor/doctrine/common/phpunit.xml.dist
new file mode 100644
index 0000000000000000000000000000000000000000..b9d3b3401c479da47b81d18d47fa439c8ac7e956
--- /dev/null
+++ b/core/vendor/doctrine/common/phpunit.xml.dist
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<phpunit backupGlobals="false"
+ backupStaticAttributes="false"
+ colors="true"
+ convertErrorsToExceptions="true"
+ convertNoticesToExceptions="true"
+ convertWarningsToExceptions="true"
+ processIsolation="false"
+ stopOnFailure="false"
+ syntaxCheck="false"
+ bootstrap="./tests/Doctrine/Tests/TestInit.php"
+>
+ <testsuites>
+ <testsuite name="Doctrine Common Test Suite">
+ <directory>./tests/Doctrine/</directory>
+ </testsuite>
+ </testsuites>
+
+ <filter>
+ <whitelist>
+ <directory>./lib/Doctrine/</directory>
+ </whitelist>
+ </filter>
+
+ <groups>
+ <exclude>
+ <group>performance</group>
+ </exclude>
+ </groups>
+</phpunit>
diff --git a/core/vendor/doctrine/common/tests/.gitignore b/core/vendor/doctrine/common/tests/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..7210405266da5faba2e5e7ca33ce525c6795d486
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/.gitignore
@@ -0,0 +1,3 @@
+Doctrine/Tests/Proxies/
+Doctrine/Tests/ORM/Proxy/generated/
+Doctrine/Tests/ORM/Tools/Export/export
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/AbstractReaderTest.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/AbstractReaderTest.php
new file mode 100644
index 0000000000000000000000000000000000000000..0a329a3c01d62ce9f090d0ed996c53c830fac7a1
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/AbstractReaderTest.php
@@ -0,0 +1,538 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations;
+
+use Doctrine\Common\Annotations\DoctrineReader;
+use Doctrine\Common\Annotations\Annotation\IgnoreAnnotation;
+use Doctrine\Common\Annotations\Annotation\IgnorePhpDoc;
+use ReflectionClass, Doctrine\Common\Annotations\AnnotationReader;
+
+use Doctrine\Tests\Common\Annotations\DummyAnnotation;
+use Doctrine\Tests\Common\Annotations\Name;
+use Doctrine\Tests\Common\Annotations\DummyId;
+use Doctrine\Tests\Common\Annotations\DummyJoinTable;
+use Doctrine\Tests\Common\Annotations\DummyJoinColumn;
+use Doctrine\Tests\Common\Annotations\DummyColumn;
+use Doctrine\Tests\Common\Annotations\DummyGeneratedValue;
+
+require_once __DIR__ . '/TopLevelAnnotation.php';
+
+abstract class AbstractReaderTest extends \PHPUnit_Framework_TestCase
+{
+ public function testAnnotations()
+ {
+ $reader = $this->getReader();
+
+ $class = new ReflectionClass('Doctrine\Tests\Common\Annotations\DummyClass');
+ $this->assertEquals(1, count($reader->getClassAnnotations($class)));
+ $this->assertInstanceOf($annotName = 'Doctrine\Tests\Common\Annotations\DummyAnnotation', $annot = $reader->getClassAnnotation($class, $annotName));
+ $this->assertEquals("hello", $annot->dummyValue);
+
+ $field1Prop = $class->getProperty('field1');
+ $propAnnots = $reader->getPropertyAnnotations($field1Prop);
+ $this->assertEquals(1, count($propAnnots));
+ $this->assertInstanceOf($annotName, $annot = $reader->getPropertyAnnotation($field1Prop, $annotName));
+ $this->assertEquals("fieldHello", $annot->dummyValue);
+
+ $getField1Method = $class->getMethod('getField1');
+ $methodAnnots = $reader->getMethodAnnotations($getField1Method);
+ $this->assertEquals(1, count($methodAnnots));
+ $this->assertInstanceOf($annotName, $annot = $reader->getMethodAnnotation($getField1Method, $annotName));
+ $this->assertEquals(array(1, 2, "three"), $annot->value);
+
+ $field2Prop = $class->getProperty('field2');
+ $propAnnots = $reader->getPropertyAnnotations($field2Prop);
+ $this->assertEquals(1, count($propAnnots));
+ $this->assertInstanceOf($annotName = 'Doctrine\Tests\Common\Annotations\DummyJoinTable', $joinTableAnnot = $reader->getPropertyAnnotation($field2Prop, $annotName));
+ $this->assertEquals(1, count($joinTableAnnot->joinColumns));
+ $this->assertEquals(1, count($joinTableAnnot->inverseJoinColumns));
+ $this->assertTrue($joinTableAnnot->joinColumns[0] instanceof DummyJoinColumn);
+ $this->assertTrue($joinTableAnnot->inverseJoinColumns[0] instanceof DummyJoinColumn);
+ $this->assertEquals('col1', $joinTableAnnot->joinColumns[0]->name);
+ $this->assertEquals('col2', $joinTableAnnot->joinColumns[0]->referencedColumnName);
+ $this->assertEquals('col3', $joinTableAnnot->inverseJoinColumns[0]->name);
+ $this->assertEquals('col4', $joinTableAnnot->inverseJoinColumns[0]->referencedColumnName);
+
+ $dummyAnnot = $reader->getMethodAnnotation($class->getMethod('getField1'), 'Doctrine\Tests\Common\Annotations\DummyAnnotation');
+ $this->assertEquals('', $dummyAnnot->dummyValue);
+ $this->assertEquals(array(1, 2, 'three'), $dummyAnnot->value);
+
+ $dummyAnnot = $reader->getPropertyAnnotation($class->getProperty('field1'), 'Doctrine\Tests\Common\Annotations\DummyAnnotation');
+ $this->assertEquals('fieldHello', $dummyAnnot->dummyValue);
+
+ $classAnnot = $reader->getClassAnnotation($class, 'Doctrine\Tests\Common\Annotations\DummyAnnotation');
+ $this->assertEquals('hello', $classAnnot->dummyValue);
+ }
+
+ public function testAnnotationsWithValidTargets()
+ {
+ $reader = $this->getReader();
+ $class = new ReflectionClass('Doctrine\Tests\Common\Annotations\Fixtures\ClassWithValidAnnotationTarget');
+
+ $this->assertEquals(1,count($reader->getClassAnnotations($class)));
+ $this->assertEquals(1,count($reader->getPropertyAnnotations($class->getProperty('foo'))));
+ $this->assertEquals(1,count($reader->getMethodAnnotations($class->getMethod('someFunction'))));
+ $this->assertEquals(1,count($reader->getPropertyAnnotations($class->getProperty('nested'))));
+ }
+
+ public function testAnnotationsWithVarType()
+ {
+ $reader = $this->getReader();
+ $class = new ReflectionClass('Doctrine\Tests\Common\Annotations\Fixtures\ClassWithAnnotationWithVarType');
+
+ $this->assertEquals(1,count($fooAnnot = $reader->getPropertyAnnotations($class->getProperty('foo'))));
+ $this->assertEquals(1,count($barAnnot = $reader->getMethodAnnotations($class->getMethod('bar'))));
+
+ $this->assertInternalType('string', $fooAnnot[0]->string);
+ $this->assertInstanceOf('Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll', $barAnnot[0]->annotation);
+ }
+
+ /**
+ * @expectedException Doctrine\Common\Annotations\AnnotationException
+ * @expectedExceptionMessage [Semantical Error] Annotation @AnnotationTargetPropertyMethod is not allowed to be declared on class Doctrine\Tests\Common\Annotations\Fixtures\ClassWithInvalidAnnotationTargetAtClass. You may only use this annotation on these code elements: METHOD, PROPERTY
+ */
+ public function testClassWithInvalidAnnotationTargetAtClassDocBlock()
+ {
+ $reader = $this->getReader();
+ $reader->getClassAnnotations(new \ReflectionClass('Doctrine\Tests\Common\Annotations\Fixtures\ClassWithInvalidAnnotationTargetAtClass'));
+ }
+
+ /**
+ * @expectedException Doctrine\Common\Annotations\AnnotationException
+ * @expectedExceptionMessage [Semantical Error] Annotation @AnnotationTargetClass is not allowed to be declared on property Doctrine\Tests\Common\Annotations\Fixtures\ClassWithInvalidAnnotationTargetAtProperty::$foo. You may only use this annotation on these code elements: CLASS
+ */
+ public function testClassWithInvalidAnnotationTargetAtPropertyDocBlock()
+ {
+ $reader = $this->getReader();
+ $reader->getPropertyAnnotations(new \ReflectionProperty('Doctrine\Tests\Common\Annotations\Fixtures\ClassWithInvalidAnnotationTargetAtProperty', 'foo'));
+ }
+
+ /**
+ * @expectedException Doctrine\Common\Annotations\AnnotationException
+ * @expectedExceptionMessage [Semantical Error] Annotation @AnnotationTargetAnnotation is not allowed to be declared on property Doctrine\Tests\Common\Annotations\Fixtures\ClassWithInvalidAnnotationTargetAtProperty::$bar. You may only use this annotation on these code elements: ANNOTATION
+ */
+ public function testClassWithInvalidNestedAnnotationTargetAtPropertyDocBlock()
+ {
+ $reader = $this->getReader();
+ $reader->getPropertyAnnotations(new \ReflectionProperty('Doctrine\Tests\Common\Annotations\Fixtures\ClassWithInvalidAnnotationTargetAtProperty', 'bar'));
+ }
+
+ /**
+ * @expectedException Doctrine\Common\Annotations\AnnotationException
+ * @expectedExceptionMessage [Semantical Error] Annotation @AnnotationTargetClass is not allowed to be declared on method Doctrine\Tests\Common\Annotations\Fixtures\ClassWithInvalidAnnotationTargetAtMethod::functionName(). You may only use this annotation on these code elements: CLASS
+ */
+ public function testClassWithInvalidAnnotationTargetAtMethodDocBlock()
+ {
+ $reader = $this->getReader();
+ $reader->getMethodAnnotations(new \ReflectionMethod('Doctrine\Tests\Common\Annotations\Fixtures\ClassWithInvalidAnnotationTargetAtMethod', 'functionName'));
+ }
+
+ /**
+ * @expectedException Doctrine\Common\Annotations\AnnotationException
+ * @expectedExceptionMessage Expected namespace separator or identifier, got ')' at position 24 in class @Doctrine\Tests\Common\Annotations\Fixtures\AnnotationWithTargetSyntaxError.
+ */
+ public function testClassWithAnnotationWithTargetSyntaxErrorAtClassDocBlock()
+ {
+ $reader = $this->getReader();
+ $reader->getClassAnnotations(new \ReflectionClass('Doctrine\Tests\Common\Annotations\Fixtures\ClassWithAnnotationWithTargetSyntaxError'));
+ }
+
+ /**
+ * @expectedException Doctrine\Common\Annotations\AnnotationException
+ * @expectedExceptionMessage Expected namespace separator or identifier, got ')' at position 24 in class @Doctrine\Tests\Common\Annotations\Fixtures\AnnotationWithTargetSyntaxError.
+ */
+ public function testClassWithAnnotationWithTargetSyntaxErrorAtPropertyDocBlock()
+ {
+ $reader = $this->getReader();
+ $reader->getPropertyAnnotations(new \ReflectionProperty('Doctrine\Tests\Common\Annotations\Fixtures\ClassWithAnnotationWithTargetSyntaxError','foo'));
+ }
+
+ /**
+ * @expectedException Doctrine\Common\Annotations\AnnotationException
+ * @expectedExceptionMessage Expected namespace separator or identifier, got ')' at position 24 in class @Doctrine\Tests\Common\Annotations\Fixtures\AnnotationWithTargetSyntaxError.
+ */
+ public function testClassWithAnnotationWithTargetSyntaxErrorAtMethodDocBlock()
+ {
+ $reader = $this->getReader();
+ $reader->getMethodAnnotations(new \ReflectionMethod('Doctrine\Tests\Common\Annotations\Fixtures\ClassWithAnnotationWithTargetSyntaxError','bar'));
+ }
+
+ /**
+ * @expectedException Doctrine\Common\Annotations\AnnotationException
+ * @expectedExceptionMessage [Type Error] Attribute "string" of @AnnotationWithVarType declared on property Doctrine\Tests\Common\Annotations\Fixtures\ClassWithAnnotationWithVarType::$invalidProperty expects a(n) string, but got integer.
+ */
+ public function testClassWithPropertyInvalidVarTypeError()
+ {
+ $reader = $this->getReader();
+ $class = new ReflectionClass('Doctrine\Tests\Common\Annotations\Fixtures\ClassWithAnnotationWithVarType');
+
+ $reader->getPropertyAnnotations($class->getProperty('invalidProperty'));
+ }
+
+ /**
+ * @expectedException Doctrine\Common\Annotations\AnnotationException
+ * @expectedExceptionMessage [Type Error] Attribute "annotation" of @AnnotationWithVarType declared on method Doctrine\Tests\Common\Annotations\Fixtures\ClassWithAnnotationWithVarType::invalidMethod() expects a(n) Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll, but got an instance of Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAnnotation.
+ */
+ public function testClassWithMethodInvalidVarTypeError()
+ {
+ $reader = $this->getReader();
+ $class = new ReflectionClass('Doctrine\Tests\Common\Annotations\Fixtures\ClassWithAnnotationWithVarType');
+
+ $reader->getMethodAnnotations($class->getMethod('invalidMethod'));
+ }
+
+ /**
+ * @expectedException Doctrine\Common\Annotations\AnnotationException
+ * @expectedExceptionMessage Expected namespace separator or identifier, got ')' at position 18 in class Doctrine\Tests\Common\Annotations\DummyClassSyntaxError.
+ */
+ public function testClassSyntaxErrorContext()
+ {
+ $reader = $this->getReader();
+ $reader->getClassAnnotations(new \ReflectionClass('Doctrine\Tests\Common\Annotations\DummyClassSyntaxError'));
+ }
+
+ /**
+ * @expectedException Doctrine\Common\Annotations\AnnotationException
+ * @expectedExceptionMessage Expected namespace separator or identifier, got ')' at position 18 in method Doctrine\Tests\Common\Annotations\DummyClassMethodSyntaxError::foo().
+ */
+ public function testMethodSyntaxErrorContext()
+ {
+ $reader = $this->getReader();
+ $reader->getMethodAnnotations(new \ReflectionMethod('Doctrine\Tests\Common\Annotations\DummyClassMethodSyntaxError', 'foo'));
+ }
+
+ /**
+ * @expectedException Doctrine\Common\Annotations\AnnotationException
+ * @expectedExceptionMessage Expected namespace separator or identifier, got ')' at position 18 in property Doctrine\Tests\Common\Annotations\DummyClassPropertySyntaxError::$foo.
+ */
+ public function testPropertySyntaxErrorContext()
+ {
+ $reader = $this->getReader();
+ $reader->getPropertyAnnotations(new \ReflectionProperty('Doctrine\Tests\Common\Annotations\DummyClassPropertySyntaxError', 'foo'));
+ }
+
+ /**
+ * @group regression
+ */
+ public function testMultipleAnnotationsOnSameLine()
+ {
+ $reader = $this->getReader();
+ $annots = $reader->getPropertyAnnotations(new \ReflectionProperty('Doctrine\Tests\Common\Annotations\DummyClass2', 'id'));
+ $this->assertEquals(3, count($annots));
+ }
+
+ public function testNonAnnotationProblem()
+ {
+ $reader = $this->getReader();
+
+ $this->assertNotNull($annot = $reader->getPropertyAnnotation(new \ReflectionProperty('Doctrine\Tests\Common\Annotations\DummyClassNonAnnotationProblem', 'foo'), $name = 'Doctrine\Tests\Common\Annotations\DummyAnnotation'));
+ $this->assertInstanceOf($name, $annot);
+ }
+
+ public function testImportWithConcreteAnnotation()
+ {
+ $reader = $this->getReader();
+ $property = new \ReflectionProperty('Doctrine\Tests\Common\Annotations\TestImportWithConcreteAnnotation', 'field');
+ $annotations = $reader->getPropertyAnnotations($property);
+ $this->assertEquals(1, count($annotations));
+ $this->assertNotNull($reader->getPropertyAnnotation($property, 'Doctrine\Tests\Common\Annotations\DummyAnnotation'));
+ }
+
+ public function testImportWithInheritance()
+ {
+ $reader = $this->getReader();
+
+ $class = new TestParentClass();
+ $ref = new \ReflectionClass($class);
+
+ $childAnnotations = $reader->getPropertyAnnotations($ref->getProperty('child'));
+ $this->assertEquals(1, count($childAnnotations));
+ $this->assertInstanceOf('Doctrine\Tests\Common\Annotations\Foo\Name', reset($childAnnotations));
+
+ $parentAnnotations = $reader->getPropertyAnnotations($ref->getProperty('parent'));
+ $this->assertEquals(1, count($parentAnnotations));
+ $this->assertInstanceOf('Doctrine\Tests\Common\Annotations\Bar\Name', reset($parentAnnotations));
+ }
+
+ /**
+ * @expectedException Doctrine\Common\Annotations\AnnotationException
+ * @expectedExceptionMessage The annotation "@NameFoo" in property Doctrine\Tests\Common\Annotations\TestAnnotationNotImportedClass::$field was never imported.
+ */
+ public function testImportDetectsNotImportedAnnotation()
+ {
+ $reader = $this->getReader();
+ $reader->getPropertyAnnotations(new \ReflectionProperty('Doctrine\Tests\Common\Annotations\TestAnnotationNotImportedClass', 'field'));
+ }
+
+ /**
+ * @expectedException Doctrine\Common\Annotations\AnnotationException
+ * @expectedExceptionMessage The annotation "@Foo\Bar\Name" in property Doctrine\Tests\Common\Annotations\TestNonExistentAnnotationClass::$field was never imported.
+ */
+ public function testImportDetectsNonExistentAnnotation()
+ {
+ $reader = $this->getReader();
+ $reader->getPropertyAnnotations(new \ReflectionProperty('Doctrine\Tests\Common\Annotations\TestNonExistentAnnotationClass', 'field'));
+ }
+
+ public function testTopLevelAnnotation()
+ {
+ $reader = $this->getReader();
+ $annotations = $reader->getPropertyAnnotations(new \ReflectionProperty('Doctrine\Tests\Common\Annotations\TestTopLevelAnnotationClass', 'field'));
+
+ $this->assertEquals(1, count($annotations));
+ $this->assertInstanceOf('\TopLevelAnnotation', reset($annotations));
+ }
+
+ public function testIgnoresAnnotationsNotPrefixedWithWhitespace()
+ {
+ $reader = $this->getReader();
+
+ $annotation = $reader->getClassAnnotation(new \ReflectionClass(new TestIgnoresNonAnnotationsClass()), 'Doctrine\Tests\Common\Annotations\Name');
+ $this->assertInstanceOf('Doctrine\Tests\Common\Annotations\Name', $annotation);
+ }
+
+ /**
+ * @expectedException Doctrine\Common\Annotations\AnnotationException
+ * @expectedExceptionMessage The class "Doctrine\Tests\Common\Annotations\Fixtures\NoAnnotation" is not annotated with @Annotation. Are you sure this class can be used as annotation? If so, then you need to add @Annotation to the _class_ doc comment of "Doctrine\Tests\Common\Annotations\Fixtures\NoAnnotation". If it is indeed no annotation, then you need to add @IgnoreAnnotation("NoAnnotation") to the _class_ doc comment of class Doctrine\Tests\Common\Annotations\Fixtures\InvalidAnnotationUsageClass.
+ */
+ public function testErrorWhenInvalidAnnotationIsUsed()
+ {
+ $reader = $this->getReader();
+ $ref = new \ReflectionClass('Doctrine\Tests\Common\Annotations\Fixtures\InvalidAnnotationUsageClass');
+ $reader->getClassAnnotations($ref);
+ }
+
+ public function testInvalidAnnotationUsageButIgnoredClass()
+ {
+ $reader = $this->getReader();
+ $ref = new \ReflectionClass('Doctrine\Tests\Common\Annotations\Fixtures\InvalidAnnotationUsageButIgnoredClass');
+ $annots = $reader->getClassAnnotations($ref);
+
+ $this->assertEquals(2, count($annots));
+ }
+
+ /**
+ * @group DDC-1660
+ * @group regression
+ */
+ public function testInvalidAnnotationButIgnored()
+ {
+ $reader = $this->getReader();
+ $class = new \ReflectionClass('Doctrine\Tests\Common\Annotations\Fixtures\ClassDDC1660');
+
+ $this->assertTrue(class_exists('Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Version'));
+ $this->assertCount(0, $reader->getClassAnnotations($class));
+ $this->assertCount(0, $reader->getMethodAnnotations($class->getMethod('bar')));
+ $this->assertCount(0, $reader->getPropertyAnnotations($class->getProperty('foo')));
+ }
+
+ abstract protected function getReader();
+}
+
+/**
+ * @parseAnnotation("var")
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ *
+ */
+class TestParseAnnotationClass
+{
+ /**
+ * @var
+ */
+ private $field;
+}
+
+/**
+ * @Name
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class TestIgnoresNonAnnotationsClass
+{
+}
+
+class TestTopLevelAnnotationClass
+{
+ /**
+ * @\TopLevelAnnotation
+ */
+ private $field;
+}
+
+class TestNonExistentAnnotationClass
+{
+ /**
+ * @Foo\Bar\Name
+ */
+ private $field;
+}
+
+class TestAnnotationNotImportedClass
+{
+ /**
+ * @NameFoo
+ */
+ private $field;
+}
+
+class TestChildClass
+{
+ /**
+ * @\Doctrine\Tests\Common\Annotations\Foo\Name(name = "foo")
+ */
+ protected $child;
+}
+
+class TestParentClass extends TestChildClass
+{
+ /**
+ * @\Doctrine\Tests\Common\Annotations\Bar\Name(name = "bar")
+ */
+ private $parent;
+}
+
+class TestImportWithConcreteAnnotation
+{
+ /**
+ * @DummyAnnotation(dummyValue = "bar")
+ */
+ private $field;
+}
+
+/**
+ * A description of this class.
+ *
+ * Let's see if the parser recognizes that this @ is not really referring to an
+ * annotation. Also make sure that @var \ is not concated to "@var\is".
+ *
+ * @author robo
+ * @since 2.0
+ * @DummyAnnotation(dummyValue="hello")
+ */
+class DummyClass {
+ /**
+ * A nice property.
+ *
+ * @var mixed
+ * @DummyAnnotation(dummyValue="fieldHello")
+ */
+ private $field1;
+
+ /**
+ * @DummyJoinTable(name="join_table",
+ * joinColumns={@DummyJoinColumn(name="col1", referencedColumnName="col2")},
+ * inverseJoinColumns={
+ * @DummyJoinColumn(name="col3", referencedColumnName="col4")
+ * })
+ */
+ private $field2;
+
+ /**
+ * Gets the value of field1.
+ *
+ * @return mixed
+ * @DummyAnnotation({1,2,"three"})
+ */
+ public function getField1() {
+ }
+}
+
+/**
+ * @ignoreAnnotation("var")
+ */
+class DummyClass2 {
+ /**
+ * @DummyId @DummyColumn(type="integer") @DummyGeneratedValue
+ * @var integer
+ */
+ private $id;
+}
+
+/** @Annotation */
+class DummyId extends \Doctrine\Common\Annotations\Annotation {}
+/** @Annotation */
+class DummyColumn extends \Doctrine\Common\Annotations\Annotation {
+ public $type;
+}
+/** @Annotation */
+class DummyGeneratedValue extends \Doctrine\Common\Annotations\Annotation {}
+/** @Annotation */
+class DummyAnnotation extends \Doctrine\Common\Annotations\Annotation {
+ public $dummyValue;
+}
+/** @Annotation */
+class DummyJoinColumn extends \Doctrine\Common\Annotations\Annotation {
+ public $name;
+ public $referencedColumnName;
+}
+/** @Annotation */
+class DummyJoinTable extends \Doctrine\Common\Annotations\Annotation {
+ public $name;
+ public $joinColumns;
+ public $inverseJoinColumns;
+}
+
+/**
+ * @DummyAnnotation(@)
+ */
+class DummyClassSyntaxError
+{
+
+}
+
+class DummyClassMethodSyntaxError
+{
+ /**
+ * @DummyAnnotation(@)
+ */
+ public function foo()
+ {
+
+ }
+}
+
+class DummyClassPropertySyntaxError
+{
+ /**
+ * @DummyAnnotation(@)
+ */
+ public $foo;
+}
+
+/**
+ * @ignoreAnnotation({"since", "var"})
+ */
+class DummyClassNonAnnotationProblem
+{
+ /**
+ * @DummyAnnotation
+ *
+ * @var \Test
+ * @since 0.1
+ */
+ public $foo;
+}
+
+
+/**
+* @DummyAnnotation Foo bar <foobar@1domain.com>
+*/
+class DummyClassWithEmail
+{
+
+}
+
+namespace Doctrine\Tests\Common\Annotations\Foo;
+
+/** @Annotation */
+class Name extends \Doctrine\Common\Annotations\Annotation
+{
+ public $name;
+}
+
+namespace Doctrine\Tests\Common\Annotations\Bar;
+
+/** @Annotation */
+class Name extends \Doctrine\Common\Annotations\Annotation
+{
+ public $name;
+}
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/AnnotationReaderTest.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/AnnotationReaderTest.php
new file mode 100644
index 0000000000000000000000000000000000000000..d2cc6678d5204824861cfcc2dc4196ea29f64cfe
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/AnnotationReaderTest.php
@@ -0,0 +1,13 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations;
+
+use Doctrine\Common\Annotations\AnnotationReader;
+
+class AnnotationReaderTest extends AbstractReaderTest
+{
+ protected function getReader()
+ {
+ return new AnnotationReader();
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/CachedReaderTest.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/CachedReaderTest.php
new file mode 100644
index 0000000000000000000000000000000000000000..5dd89f75d1a8ddf438963d58879ec966eea52fdd
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/CachedReaderTest.php
@@ -0,0 +1,56 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route;
+use Doctrine\Common\Annotations\AnnotationReader;
+use Doctrine\Common\Annotations\CachedReader;
+use Doctrine\Common\Cache\ArrayCache;
+
+class CachedReaderTest extends AbstractReaderTest
+{
+ private $cache;
+
+ public function testIgnoresStaleCache()
+ {
+ $file = __DIR__.'/Fixtures/Controller.php';
+ touch($file);
+ $name = 'Doctrine\Tests\Common\Annotations\Fixtures\Controller';
+ $cacheKey = $name.'@[Annot]';
+
+ $cache = $this->getMock('Doctrine\Common\Cache\Cache');
+ $cache
+ ->expects($this->at(0))
+ ->method('fetch')
+ ->with($this->equalTo($cacheKey))
+ ->will($this->returnValue(array()))
+ ;
+ $cache
+ ->expects($this->at(1))
+ ->method('fetch')
+ ->with($this->equalTo('[C]'.$cacheKey))
+ ->will($this->returnValue(time() - 10))
+ ;
+ $cache
+ ->expects($this->at(2))
+ ->method('save')
+ ->with($this->equalTo($cacheKey))
+ ;
+ $cache
+ ->expects($this->at(3))
+ ->method('save')
+ ->with($this->equalTo('[C]'.$cacheKey))
+ ;
+
+ $reader = new CachedReader(new AnnotationReader(), $cache, true);
+ $route = new Route();
+ $route->pattern = '/someprefix';
+ $this->assertEquals(array($route), $reader->getClassAnnotations(new \ReflectionClass($name)));
+ }
+
+ protected function getReader()
+ {
+ $this->cache = new ArrayCache();
+ return new CachedReader(new AnnotationReader(), $this->cache);
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/DocLexerTest.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/DocLexerTest.php
new file mode 100644
index 0000000000000000000000000000000000000000..cb080f08203ad76fe97fad9075abeda14d37905b
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/DocLexerTest.php
@@ -0,0 +1,27 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations;
+
+use Doctrine\Common\Annotations\DocLexer;
+
+class DocLexerTest extends \PHPUnit_Framework_TestCase
+{
+ public function testMarkerAnnotation()
+ {
+ $lexer = new DocLexer;
+
+ $lexer->setInput("@Name");
+ $this->assertNull($lexer->token);
+ $this->assertNull($lexer->lookahead);
+
+ $this->assertTrue($lexer->moveNext());
+ $this->assertNull($lexer->token);
+ $this->assertEquals('@', $lexer->lookahead['value']);
+
+ $this->assertTrue($lexer->moveNext());
+ $this->assertEquals('@', $lexer->token['value']);
+ $this->assertEquals('Name', $lexer->lookahead['value']);
+
+ $this->assertFalse($lexer->moveNext());
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/DocParserTest.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/DocParserTest.php
new file mode 100644
index 0000000000000000000000000000000000000000..56cae7fd60dd297b2c96172df92879f170486a6d
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/DocParserTest.php
@@ -0,0 +1,1118 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations;
+
+use Doctrine\Common\Annotations\Annotation\IgnorePhpDoc;
+use Doctrine\Common\Annotations\Annotation\IgnoreAnnotation;
+use Doctrine\Common\Annotations\DocParser;
+use Doctrine\Common\Annotations\AnnotationRegistry;
+use Doctrine\Common\Annotations\Annotation\Target;
+
+class DocParserTest extends \PHPUnit_Framework_TestCase
+{
+ public function testNestedArraysWithNestedAnnotation()
+ {
+ $parser = $this->createTestParser();
+
+ // Nested arrays with nested annotations
+ $result = $parser->parse('@Name(foo={1,2, {"key"=@Name}})');
+ $annot = $result[0];
+
+ $this->assertTrue($annot instanceof Name);
+ $this->assertNull($annot->value);
+ $this->assertEquals(3, count($annot->foo));
+ $this->assertEquals(1, $annot->foo[0]);
+ $this->assertEquals(2, $annot->foo[1]);
+ $this->assertTrue(is_array($annot->foo[2]));
+
+ $nestedArray = $annot->foo[2];
+ $this->assertTrue(isset($nestedArray['key']));
+ $this->assertTrue($nestedArray['key'] instanceof Name);
+ }
+
+ public function testBasicAnnotations()
+ {
+ $parser = $this->createTestParser();
+
+ // Marker annotation
+ $result = $parser->parse("@Name");
+ $annot = $result[0];
+ $this->assertTrue($annot instanceof Name);
+ $this->assertNull($annot->value);
+ $this->assertNull($annot->foo);
+
+ // Associative arrays
+ $result = $parser->parse('@Name(foo={"key1" = "value1"})');
+ $annot = $result[0];
+ $this->assertNull($annot->value);
+ $this->assertTrue(is_array($annot->foo));
+ $this->assertTrue(isset($annot->foo['key1']));
+
+ // Numerical arrays
+ $result = $parser->parse('@Name({2="foo", 4="bar"})');
+ $annot = $result[0];
+ $this->assertTrue(is_array($annot->value));
+ $this->assertEquals('foo', $annot->value[2]);
+ $this->assertEquals('bar', $annot->value[4]);
+ $this->assertFalse(isset($annot->value[0]));
+ $this->assertFalse(isset($annot->value[1]));
+ $this->assertFalse(isset($annot->value[3]));
+
+ // Multiple values
+ $result = $parser->parse('@Name(@Name, @Name)');
+ $annot = $result[0];
+
+ $this->assertTrue($annot instanceof Name);
+ $this->assertTrue(is_array($annot->value));
+ $this->assertTrue($annot->value[0] instanceof Name);
+ $this->assertTrue($annot->value[1] instanceof Name);
+
+ // Multiple types as values
+ $result = $parser->parse('@Name(foo="Bar", @Name, {"key1"="value1", "key2"="value2"})');
+ $annot = $result[0];
+
+ $this->assertTrue($annot instanceof Name);
+ $this->assertTrue(is_array($annot->value));
+ $this->assertTrue($annot->value[0] instanceof Name);
+ $this->assertTrue(is_array($annot->value[1]));
+ $this->assertEquals('value1', $annot->value[1]['key1']);
+ $this->assertEquals('value2', $annot->value[1]['key2']);
+
+ // Complete docblock
+ $docblock = <<<DOCBLOCK
+/**
+ * Some nifty class.
+ *
+ * @author Mr.X
+ * @Name(foo="bar")
+ */
+DOCBLOCK;
+
+ $result = $parser->parse($docblock);
+ $this->assertEquals(1, count($result));
+ $annot = $result[0];
+ $this->assertTrue($annot instanceof Name);
+ $this->assertEquals("bar", $annot->foo);
+ $this->assertNull($annot->value);
+ }
+
+ public function testNamespacedAnnotations()
+ {
+ $parser = new DocParser;
+ $parser->setIgnoreNotImportedAnnotations(true);
+
+ $docblock = <<<DOCBLOCK
+/**
+ * Some nifty class.
+ *
+ * @package foo
+ * @subpackage bar
+ * @author Mr.X <mr@x.com>
+ * @Doctrine\Tests\Common\Annotations\Name(foo="bar")
+ * @ignore
+ */
+DOCBLOCK;
+
+ $result = $parser->parse($docblock);
+ $this->assertEquals(1, count($result));
+ $annot = $result[0];
+ $this->assertTrue($annot instanceof Name);
+ $this->assertEquals("bar", $annot->foo);
+ }
+
+ /**
+ * @group debug
+ */
+ public function testTypicalMethodDocBlock()
+ {
+ $parser = $this->createTestParser();
+
+ $docblock = <<<DOCBLOCK
+/**
+ * Some nifty method.
+ *
+ * @since 2.0
+ * @Doctrine\Tests\Common\Annotations\Name(foo="bar")
+ * @param string \$foo This is foo.
+ * @param mixed \$bar This is bar.
+ * @return string Foo and bar.
+ * @This is irrelevant
+ * @Marker
+ */
+DOCBLOCK;
+
+ $result = $parser->parse($docblock);
+ $this->assertEquals(2, count($result));
+ $this->assertTrue(isset($result[0]));
+ $this->assertTrue(isset($result[1]));
+ $annot = $result[0];
+ $this->assertTrue($annot instanceof Name);
+ $this->assertEquals("bar", $annot->foo);
+ $marker = $result[1];
+ $this->assertTrue($marker instanceof Marker);
+ }
+
+
+ public function testAnnotationWithoutConstructor()
+ {
+ $parser = $this->createTestParser();
+
+
+ $docblock = <<<DOCBLOCK
+/**
+ * @SomeAnnotationClassNameWithoutConstructor("Some data")
+ */
+DOCBLOCK;
+
+ $result = $parser->parse($docblock);
+ $this->assertEquals(count($result), 1);
+ $annot = $result[0];
+
+ $this->assertNotNull($annot);
+ $this->assertTrue($annot instanceof SomeAnnotationClassNameWithoutConstructor);
+
+ $this->assertNull($annot->name);
+ $this->assertNotNull($annot->data);
+ $this->assertEquals($annot->data, "Some data");
+
+
+
+
+$docblock = <<<DOCBLOCK
+/**
+ * @SomeAnnotationClassNameWithoutConstructor(name="Some Name", data = "Some data")
+ */
+DOCBLOCK;
+
+
+ $result = $parser->parse($docblock);
+ $this->assertEquals(count($result), 1);
+ $annot = $result[0];
+
+ $this->assertNotNull($annot);
+ $this->assertTrue($annot instanceof SomeAnnotationClassNameWithoutConstructor);
+
+ $this->assertEquals($annot->name, "Some Name");
+ $this->assertEquals($annot->data, "Some data");
+
+
+
+
+$docblock = <<<DOCBLOCK
+/**
+ * @SomeAnnotationClassNameWithoutConstructor(data = "Some data")
+ */
+DOCBLOCK;
+
+ $result = $parser->parse($docblock);
+ $this->assertEquals(count($result), 1);
+ $annot = $result[0];
+
+ $this->assertEquals($annot->data, "Some data");
+ $this->assertNull($annot->name);
+
+
+ $docblock = <<<DOCBLOCK
+/**
+ * @SomeAnnotationClassNameWithoutConstructor(name = "Some name")
+ */
+DOCBLOCK;
+
+ $result = $parser->parse($docblock);
+ $this->assertEquals(count($result), 1);
+ $annot = $result[0];
+
+ $this->assertEquals($annot->name, "Some name");
+ $this->assertNull($annot->data);
+
+ $docblock = <<<DOCBLOCK
+/**
+ * @SomeAnnotationClassNameWithoutConstructor("Some data")
+ */
+DOCBLOCK;
+
+ $result = $parser->parse($docblock);
+ $this->assertEquals(count($result), 1);
+ $annot = $result[0];
+
+ $this->assertEquals($annot->data, "Some data");
+ $this->assertNull($annot->name);
+
+
+
+ $docblock = <<<DOCBLOCK
+/**
+ * @SomeAnnotationClassNameWithoutConstructor("Some data",name = "Some name")
+ */
+DOCBLOCK;
+
+ $result = $parser->parse($docblock);
+ $this->assertEquals(count($result), 1);
+ $annot = $result[0];
+
+ $this->assertEquals($annot->name, "Some name");
+ $this->assertEquals($annot->data, "Some data");
+
+
+ $docblock = <<<DOCBLOCK
+/**
+ * @SomeAnnotationWithConstructorWithoutParams(name = "Some name")
+ */
+DOCBLOCK;
+
+ $result = $parser->parse($docblock);
+ $this->assertEquals(count($result), 1);
+ $annot = $result[0];
+
+ $this->assertEquals($annot->name, "Some name");
+ $this->assertEquals($annot->data, "Some data");
+
+ $docblock = <<<DOCBLOCK
+/**
+ * @SomeAnnotationClassNameWithoutConstructorAndProperties()
+ */
+DOCBLOCK;
+
+ $result = $parser->parse($docblock);
+ $this->assertEquals(count($result), 1);
+ $this->assertTrue($result[0] instanceof SomeAnnotationClassNameWithoutConstructorAndProperties);
+ }
+
+ public function testAnnotationTarget()
+ {
+
+ $parser = new DocParser;
+ $parser->setImports(array(
+ '__NAMESPACE__' => 'Doctrine\Tests\Common\Annotations\Fixtures',
+ ));
+ $class = new \ReflectionClass('Doctrine\Tests\Common\Annotations\Fixtures\ClassWithValidAnnotationTarget');
+
+
+ $context = 'class ' . $class->getName();
+ $docComment = $class->getDocComment();
+
+ $parser->setTarget(Target::TARGET_CLASS);
+ $this->assertNotNull($parser->parse($docComment,$context));
+
+
+ $property = $class->getProperty('foo');
+ $docComment = $property->getDocComment();
+ $context = 'property ' . $class->getName() . "::\$" . $property->getName();
+
+ $parser->setTarget(Target::TARGET_PROPERTY);
+ $this->assertNotNull($parser->parse($docComment,$context));
+
+
+
+ $method = $class->getMethod('someFunction');
+ $docComment = $property->getDocComment();
+ $context = 'method ' . $class->getName() . '::' . $method->getName() . '()';
+
+ $parser->setTarget(Target::TARGET_METHOD);
+ $this->assertNotNull($parser->parse($docComment,$context));
+
+
+ try {
+ $class = new \ReflectionClass('Doctrine\Tests\Common\Annotations\Fixtures\ClassWithInvalidAnnotationTargetAtClass');
+ $context = 'class ' . $class->getName();
+ $docComment = $class->getDocComment();
+
+ $parser->setTarget(Target::TARGET_CLASS);
+ $parser->parse($class->getDocComment(),$context);
+
+ $this->fail();
+ } catch (\Doctrine\Common\Annotations\AnnotationException $exc) {
+ $this->assertNotNull($exc->getMessage());
+ }
+
+
+ try {
+
+ $class = new \ReflectionClass('Doctrine\Tests\Common\Annotations\Fixtures\ClassWithInvalidAnnotationTargetAtMethod');
+ $method = $class->getMethod('functionName');
+ $docComment = $method->getDocComment();
+ $context = 'method ' . $class->getName() . '::' . $method->getName() . '()';
+
+ $parser->setTarget(Target::TARGET_METHOD);
+ $parser->parse($docComment,$context);
+
+ $this->fail();
+ } catch (\Doctrine\Common\Annotations\AnnotationException $exc) {
+ $this->assertNotNull($exc->getMessage());
+ }
+
+
+ try {
+ $class = new \ReflectionClass('Doctrine\Tests\Common\Annotations\Fixtures\ClassWithInvalidAnnotationTargetAtProperty');
+ $property = $class->getProperty('foo');
+ $docComment = $property->getDocComment();
+ $context = 'property ' . $class->getName() . "::\$" . $property->getName();
+
+ $parser->setTarget(Target::TARGET_PROPERTY);
+ $parser->parse($docComment,$context);
+
+ $this->fail();
+ } catch (\Doctrine\Common\Annotations\AnnotationException $exc) {
+ $this->assertNotNull($exc->getMessage());
+ }
+
+ }
+
+ public function getAnnotationVarTypeProviderValid()
+ {
+ //({attribute name}, {attribute value})
+ return array(
+ // mixed type
+ array('mixed', '"String Value"'),
+ array('mixed', 'true'),
+ array('mixed', 'false'),
+ array('mixed', '1'),
+ array('mixed', '1.2'),
+ array('mixed', '@Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll'),
+
+ // boolean type
+ array('boolean', 'true'),
+ array('boolean', 'false'),
+
+ // alias for internal type boolean
+ array('bool', 'true'),
+ array('bool', 'false'),
+
+ // integer type
+ array('integer', '0'),
+ array('integer', '1'),
+ array('integer', '123456789'),
+ array('integer', '9223372036854775807'),
+
+ // alias for internal type double
+ array('float', '0.1'),
+ array('float', '1.2'),
+ array('float', '123.456'),
+
+ // string type
+ array('string', '"String Value"'),
+ array('string', '"true"'),
+ array('string', '"123"'),
+
+ // array type
+ array('array', '{@AnnotationExtendsAnnotationTargetAll}'),
+ array('array', '{@AnnotationExtendsAnnotationTargetAll,@AnnotationExtendsAnnotationTargetAll}'),
+
+ array('arrayOfIntegers', '1'),
+ array('arrayOfIntegers', '{1}'),
+ array('arrayOfIntegers', '{1,2,3,4}'),
+ array('arrayOfAnnotations', '@AnnotationExtendsAnnotationTargetAll'),
+ array('arrayOfAnnotations', '{@Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll}'),
+ array('arrayOfAnnotations', '{@AnnotationExtendsAnnotationTargetAll, @Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll}'),
+
+ // annotation instance
+ array('annotation', '@Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll'),
+ array('annotation', '@AnnotationExtendsAnnotationTargetAll'),
+ );
+ }
+
+ public function getAnnotationVarTypeProviderInvalid()
+ {
+ //({attribute name}, {type declared type}, {attribute value} , {given type or class})
+ return array(
+ // boolean type
+ array('boolean','boolean','1','integer'),
+ array('boolean','boolean','1.2','double'),
+ array('boolean','boolean','"str"','string'),
+ array('boolean','boolean','{1,2,3}','array'),
+ array('boolean','boolean','@Name', 'an instance of Doctrine\Tests\Common\Annotations\Name'),
+
+ // alias for internal type boolean
+ array('bool','bool', '1','integer'),
+ array('bool','bool', '1.2','double'),
+ array('bool','bool', '"str"','string'),
+ array('bool','bool', '{"str"}','array'),
+
+ // integer type
+ array('integer','integer', 'true','boolean'),
+ array('integer','integer', 'false','boolean'),
+ array('integer','integer', '1.2','double'),
+ array('integer','integer', '"str"','string'),
+ array('integer','integer', '{"str"}','array'),
+ array('integer','integer', '{1,2,3,4}','array'),
+
+ // alias for internal type double
+ array('float','float', 'true','boolean'),
+ array('float','float', 'false','boolean'),
+ array('float','float', '123','integer'),
+ array('float','float', '"str"','string'),
+ array('float','float', '{"str"}','array'),
+ array('float','float', '{12.34}','array'),
+ array('float','float', '{1,2,3}','array'),
+
+ // string type
+ array('string','string', 'true','boolean'),
+ array('string','string', 'false','boolean'),
+ array('string','string', '12','integer'),
+ array('string','string', '1.2','double'),
+ array('string','string', '{"str"}','array'),
+ array('string','string', '{1,2,3,4}','array'),
+
+ // annotation instance
+ array('annotation','Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll', 'true','boolean'),
+ array('annotation','Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll', 'false','boolean'),
+ array('annotation','Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll', '12','integer'),
+ array('annotation','Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll', '1.2','double'),
+ array('annotation','Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll', '{"str"}','array'),
+ array('annotation','Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll', '{1,2,3,4}','array'),
+ array('annotation','Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll', '@Name','an instance of Doctrine\Tests\Common\Annotations\Name'),
+ );
+ }
+
+ public function getAnnotationVarTypeArrayProviderInvalid()
+ {
+ //({attribute name}, {type declared type}, {attribute value} , {given type or class})
+ return array(
+ array('arrayOfIntegers','integer', 'true','boolean'),
+ array('arrayOfIntegers','integer', 'false','boolean'),
+ array('arrayOfIntegers','integer', '{true,true}','boolean'),
+ array('arrayOfIntegers','integer', '{1,true}','boolean'),
+ array('arrayOfIntegers','integer', '{1,2,1.2}','double'),
+ array('arrayOfIntegers','integer', '{1,2,"str"}','string'),
+
+
+ array('arrayOfAnnotations','Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll', 'true','boolean'),
+ array('arrayOfAnnotations','Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll', 'false','boolean'),
+ array('arrayOfAnnotations','Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll', '{@Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll,true}','boolean'),
+ array('arrayOfAnnotations','Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll', '{@Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll,true}','boolean'),
+ array('arrayOfAnnotations','Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll', '{@Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll,1.2}','double'),
+ array('arrayOfAnnotations','Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll', '{@Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll,@AnnotationExtendsAnnotationTargetAll,"str"}','string'),
+ );
+ }
+
+ /**
+ * @dataProvider getAnnotationVarTypeProviderValid
+ */
+ public function testAnnotationWithVarType($attribute, $value)
+ {
+ $parser = $this->createTestParser();
+ $context = 'property SomeClassName::$invalidProperty.';
+ $docblock = sprintf('@Doctrine\Tests\Common\Annotations\Fixtures\AnnotationWithVarType(%s = %s)',$attribute, $value);
+ $parser->setTarget(Target::TARGET_PROPERTY);
+
+ $result = $parser->parse($docblock, $context);
+
+ $this->assertTrue(sizeof($result) === 1);
+ $this->assertInstanceOf('Doctrine\Tests\Common\Annotations\Fixtures\AnnotationWithVarType', $result[0]);
+ $this->assertNotNull($result[0]->$attribute);
+ }
+
+ /**
+ * @dataProvider getAnnotationVarTypeProviderInvalid
+ */
+ public function testAnnotationWithVarTypeError($attribute,$type,$value,$given)
+ {
+ $parser = $this->createTestParser();
+ $context = 'property SomeClassName::invalidProperty.';
+ $docblock = sprintf('@Doctrine\Tests\Common\Annotations\Fixtures\AnnotationWithVarType(%s = %s)',$attribute, $value);
+ $parser->setTarget(Target::TARGET_PROPERTY);
+
+ try {
+ $parser->parse($docblock, $context);
+ $this->fail();
+ } catch (\Doctrine\Common\Annotations\AnnotationException $exc) {
+ $this->assertContains("[Type Error] Attribute \"$attribute\" of @Doctrine\Tests\Common\Annotations\Fixtures\AnnotationWithVarType declared on property SomeClassName::invalidProperty. expects a(n) $type, but got $given.", $exc->getMessage());
+ }
+ }
+
+
+ /**
+ * @dataProvider getAnnotationVarTypeArrayProviderInvalid
+ */
+ public function testAnnotationWithVarTypeArrayError($attribute,$type,$value,$given)
+ {
+ $parser = $this->createTestParser();
+ $context = 'property SomeClassName::invalidProperty.';
+ $docblock = sprintf('@Doctrine\Tests\Common\Annotations\Fixtures\AnnotationWithVarType(%s = %s)',$attribute, $value);
+ $parser->setTarget(Target::TARGET_PROPERTY);
+
+ try {
+ $parser->parse($docblock, $context);
+ $this->fail();
+ } catch (\Doctrine\Common\Annotations\AnnotationException $exc) {
+ $this->assertContains("[Type Error] Attribute \"$attribute\" of @Doctrine\Tests\Common\Annotations\Fixtures\AnnotationWithVarType declared on property SomeClassName::invalidProperty. expects either a(n) $type, or an array of {$type}s, but got $given.", $exc->getMessage());
+ }
+ }
+
+ /**
+ * @dataProvider getAnnotationVarTypeProviderValid
+ */
+ public function testAnnotationWithAttributes($attribute, $value)
+ {
+ $parser = $this->createTestParser();
+ $context = 'property SomeClassName::$invalidProperty.';
+ $docblock = sprintf('@Doctrine\Tests\Common\Annotations\Fixtures\AnnotationWithAttributes(%s = %s)',$attribute, $value);
+ $parser->setTarget(Target::TARGET_PROPERTY);
+
+ $result = $parser->parse($docblock, $context);
+
+ $this->assertTrue(sizeof($result) === 1);
+ $this->assertInstanceOf('Doctrine\Tests\Common\Annotations\Fixtures\AnnotationWithAttributes', $result[0]);
+ $getter = "get".ucfirst($attribute);
+ $this->assertNotNull($result[0]->$getter());
+ }
+
+ /**
+ * @dataProvider getAnnotationVarTypeProviderInvalid
+ */
+ public function testAnnotationWithAttributesError($attribute,$type,$value,$given)
+ {
+ $parser = $this->createTestParser();
+ $context = 'property SomeClassName::invalidProperty.';
+ $docblock = sprintf('@Doctrine\Tests\Common\Annotations\Fixtures\AnnotationWithAttributes(%s = %s)',$attribute, $value);
+ $parser->setTarget(Target::TARGET_PROPERTY);
+
+ try {
+ $parser->parse($docblock, $context);
+ $this->fail();
+ } catch (\Doctrine\Common\Annotations\AnnotationException $exc) {
+ $this->assertContains("[Type Error] Attribute \"$attribute\" of @Doctrine\Tests\Common\Annotations\Fixtures\AnnotationWithAttributes declared on property SomeClassName::invalidProperty. expects a(n) $type, but got $given.", $exc->getMessage());
+ }
+ }
+
+
+ /**
+ * @dataProvider getAnnotationVarTypeArrayProviderInvalid
+ */
+ public function testAnnotationWithAttributesWithVarTypeArrayError($attribute,$type,$value,$given)
+ {
+ $parser = $this->createTestParser();
+ $context = 'property SomeClassName::invalidProperty.';
+ $docblock = sprintf('@Doctrine\Tests\Common\Annotations\Fixtures\AnnotationWithAttributes(%s = %s)',$attribute, $value);
+ $parser->setTarget(Target::TARGET_PROPERTY);
+
+ try {
+ $parser->parse($docblock, $context);
+ $this->fail();
+ } catch (\Doctrine\Common\Annotations\AnnotationException $exc) {
+ $this->assertContains("[Type Error] Attribute \"$attribute\" of @Doctrine\Tests\Common\Annotations\Fixtures\AnnotationWithAttributes declared on property SomeClassName::invalidProperty. expects either a(n) $type, or an array of {$type}s, but got $given.", $exc->getMessage());
+ }
+ }
+
+ public function testAnnotationWithRequiredAttributes()
+ {
+ $parser = $this->createTestParser();
+ $context = 'property SomeClassName::invalidProperty.';
+ $parser->setTarget(Target::TARGET_PROPERTY);
+
+
+ $docblock = '@Doctrine\Tests\Common\Annotations\Fixtures\AnnotationWithRequiredAttributes("Some Value", annot = @Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAnnotation)';
+ $result = $parser->parse($docblock);
+
+ $this->assertTrue(sizeof($result) === 1);
+ $this->assertInstanceOf('Doctrine\Tests\Common\Annotations\Fixtures\AnnotationWithRequiredAttributes', $result[0]);
+ $this->assertEquals("Some Value",$result[0]->getValue());
+ $this->assertInstanceOf('Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAnnotation', $result[0]->getAnnot());
+
+
+ $docblock = '@Doctrine\Tests\Common\Annotations\Fixtures\AnnotationWithRequiredAttributes("Some Value")';
+ try {
+ $result = $parser->parse($docblock,$context);
+ $this->fail();
+ } catch (\Doctrine\Common\Annotations\AnnotationException $exc) {
+ $this->assertContains('Attribute "annot" of @Doctrine\Tests\Common\Annotations\Fixtures\AnnotationWithRequiredAttributes declared on property SomeClassName::invalidProperty. expects a(n) Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAnnotation. This value should not be null.', $exc->getMessage());
+ }
+
+ $docblock = '@Doctrine\Tests\Common\Annotations\Fixtures\AnnotationWithRequiredAttributes(annot = @Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAnnotation)';
+ try {
+ $result = $parser->parse($docblock,$context);
+ $this->fail();
+ } catch (\Doctrine\Common\Annotations\AnnotationException $exc) {
+ $this->assertContains('Attribute "value" of @Doctrine\Tests\Common\Annotations\Fixtures\AnnotationWithRequiredAttributes declared on property SomeClassName::invalidProperty. expects a(n) string. This value should not be null.', $exc->getMessage());
+ }
+
+ }
+
+ public function testAnnotationWithRequiredAttributesWithoutContructor()
+ {
+ $parser = $this->createTestParser();
+ $context = 'property SomeClassName::invalidProperty.';
+ $parser->setTarget(Target::TARGET_PROPERTY);
+
+
+ $docblock = '@Doctrine\Tests\Common\Annotations\Fixtures\AnnotationWithRequiredAttributesWithoutContructor("Some Value", annot = @Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAnnotation)';
+ $result = $parser->parse($docblock);
+
+ $this->assertTrue(sizeof($result) === 1);
+ $this->assertInstanceOf('Doctrine\Tests\Common\Annotations\Fixtures\AnnotationWithRequiredAttributesWithoutContructor', $result[0]);
+ $this->assertEquals("Some Value", $result[0]->value);
+ $this->assertInstanceOf('Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAnnotation', $result[0]->annot);
+
+
+ $docblock = '@Doctrine\Tests\Common\Annotations\Fixtures\AnnotationWithRequiredAttributesWithoutContructor("Some Value")';
+ try {
+ $result = $parser->parse($docblock,$context);
+ $this->fail();
+ } catch (\Doctrine\Common\Annotations\AnnotationException $exc) {
+ $this->assertContains('Attribute "annot" of @Doctrine\Tests\Common\Annotations\Fixtures\AnnotationWithRequiredAttributesWithoutContructor declared on property SomeClassName::invalidProperty. expects a(n) Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAnnotation. This value should not be null.', $exc->getMessage());
+ }
+
+ $docblock = '@Doctrine\Tests\Common\Annotations\Fixtures\AnnotationWithRequiredAttributesWithoutContructor(annot = @Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAnnotation)';
+ try {
+ $result = $parser->parse($docblock,$context);
+ $this->fail();
+ } catch (\Doctrine\Common\Annotations\AnnotationException $exc) {
+ $this->assertContains('Attribute "value" of @Doctrine\Tests\Common\Annotations\Fixtures\AnnotationWithRequiredAttributesWithoutContructor declared on property SomeClassName::invalidProperty. expects a(n) string. This value should not be null.', $exc->getMessage());
+ }
+
+ }
+
+
+ /**
+ * @expectedException Doctrine\Common\Annotations\AnnotationException
+ * @expectedExceptionMessage The annotation @SomeAnnotationClassNameWithoutConstructorAndProperties declared on does not accept any values, but got {"value":"Foo"}.
+ */
+ public function testWithoutConstructorWhenIsNotDefaultValue()
+ {
+ $parser = $this->createTestParser();
+ $docblock = <<<DOCBLOCK
+/**
+ * @SomeAnnotationClassNameWithoutConstructorAndProperties("Foo")
+ */
+DOCBLOCK;
+
+
+ $parser->setTarget(Target::TARGET_CLASS);
+ $parser->parse($docblock);
+ }
+
+ /**
+ * @expectedException Doctrine\Common\Annotations\AnnotationException
+ * @expectedExceptionMessage The annotation @SomeAnnotationClassNameWithoutConstructorAndProperties declared on does not accept any values, but got {"value":"Foo"}.
+ */
+ public function testWithoutConstructorWhenHasNoProperties()
+ {
+ $parser = $this->createTestParser();
+ $docblock = <<<DOCBLOCK
+/**
+ * @SomeAnnotationClassNameWithoutConstructorAndProperties(value = "Foo")
+ */
+DOCBLOCK;
+
+ $parser->setTarget(Target::TARGET_CLASS);
+ $parser->parse($docblock);
+ }
+
+ /**
+ * @expectedException Doctrine\Common\Annotations\AnnotationException
+ * @expectedExceptionMessage Expected namespace separator or identifier, got ')' at position 24 in class @Doctrine\Tests\Common\Annotations\Fixtures\AnnotationWithTargetSyntaxError.
+ */
+ public function testAnnotationTargetSyntaxError()
+ {
+ $parser = $this->createTestParser();
+ $context = 'class ' . 'SomeClassName';
+ $docblock = <<<DOCBLOCK
+/**
+ * @Doctrine\Tests\Common\Annotations\Fixtures\AnnotationWithTargetSyntaxError()
+ */
+DOCBLOCK;
+
+ $parser->setTarget(Target::TARGET_CLASS);
+ $parser->parse($docblock,$context);
+ }
+
+ /**
+ * @expectedException \InvalidArgumentException
+ * @expectedExceptionMessage Invalid Target "Foo". Available targets: [ALL, CLASS, METHOD, PROPERTY, ANNOTATION]
+ */
+ public function testAnnotationWithInvalidTargetDeclarationError()
+ {
+ $parser = $this->createTestParser();
+ $context = 'class ' . 'SomeClassName';
+ $docblock = <<<DOCBLOCK
+/**
+ * @AnnotationWithInvalidTargetDeclaration()
+ */
+DOCBLOCK;
+
+ $parser->setTarget(Target::TARGET_CLASS);
+ $parser->parse($docblock,$context);
+ }
+
+ /**
+ * @expectedException \InvalidArgumentException
+ * @expectedExceptionMessage @Target expects either a string value, or an array of strings, "NULL" given.
+ */
+ public function testAnnotationWithTargetEmptyError()
+ {
+ $parser = $this->createTestParser();
+ $context = 'class ' . 'SomeClassName';
+ $docblock = <<<DOCBLOCK
+/**
+ * @AnnotationWithTargetEmpty()
+ */
+DOCBLOCK;
+
+ $parser->setTarget(Target::TARGET_CLASS);
+ $parser->parse($docblock,$context);
+ }
+
+ /**
+ * @group DDC-575
+ */
+ public function testRegressionDDC575()
+ {
+ $parser = $this->createTestParser();
+
+ $docblock = <<<DOCBLOCK
+/**
+ * @Name
+ *
+ * Will trigger error.
+ */
+DOCBLOCK;
+
+ $result = $parser->parse($docblock);
+
+ $this->assertInstanceOf("Doctrine\Tests\Common\Annotations\Name", $result[0]);
+
+ $docblock = <<<DOCBLOCK
+/**
+ * @Name
+ * @Marker
+ *
+ * Will trigger error.
+ */
+DOCBLOCK;
+
+ $result = $parser->parse($docblock);
+
+ $this->assertInstanceOf("Doctrine\Tests\Common\Annotations\Name", $result[0]);
+ }
+
+ /**
+ * @group DDC-77
+ */
+ public function testAnnotationWithoutClassIsIgnoredWithoutWarning()
+ {
+ $parser = new DocParser();
+ $parser->setIgnoreNotImportedAnnotations(true);
+ $result = $parser->parse("@param");
+
+ $this->assertEquals(0, count($result));
+ }
+
+ /**
+ * @expectedException Doctrine\Common\Annotations\AnnotationException
+ * @expectedExceptionMessage Expected PlainValue, got ''' at position 10.
+ */
+ public function testAnnotationDontAcceptSingleQuotes()
+ {
+ $parser = $this->createTestParser();
+ $parser->parse("@Name(foo='bar')");
+ }
+
+ /**
+ * @group DCOM-41
+ */
+ public function testAnnotationDoesntThrowExceptionWhenAtSignIsNotFollowedByIdentifier()
+ {
+ $parser = new DocParser();
+ $result = $parser->parse("'@'");
+
+ $this->assertEquals(0, count($result));
+ }
+
+ /**
+ * @group DCOM-41
+ * @expectedException Doctrine\Common\Annotations\AnnotationException
+ */
+ public function testAnnotationThrowsExceptionWhenAtSignIsNotFollowedByIdentifierInNestedAnnotation()
+ {
+ $parser = new DocParser();
+ $result = $parser->parse("@Doctrine\Tests\Common\Annotations\Name(@')");
+ }
+
+ /**
+ * @group DCOM-56
+ */
+ public function testAutoloadAnnotation()
+ {
+ $this->assertFalse(class_exists('Doctrine\Tests\Common\Annotations\Fixture\Annotation\Autoload', false), 'Pre-condition: Doctrine\Tests\Common\Annotations\Fixture\Annotation\Autoload not allowed to be loaded.');
+
+ $parser = new DocParser();
+
+ AnnotationRegistry::registerAutoloadNamespace('Doctrine\Tests\Common\Annotations\Fixtures\Annotation', __DIR__ . '/../../../../');
+
+ $parser->setImports(array(
+ 'autoload' => 'Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Autoload',
+ ));
+ $annotations = $parser->parse('@Autoload');
+
+ $this->assertEquals(1, count($annotations));
+ $this->assertInstanceOf('Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Autoload', $annotations[0]);
+ }
+
+ public function createTestParser()
+ {
+ $parser = new DocParser();
+ $parser->setIgnoreNotImportedAnnotations(true);
+ $parser->setImports(array(
+ 'name' => 'Doctrine\Tests\Common\Annotations\Name',
+ '__NAMESPACE__' => 'Doctrine\Tests\Common\Annotations',
+ ));
+
+ return $parser;
+ }
+
+ /**
+ * @group DDC-78
+ * @expectedException Doctrine\Common\Annotations\AnnotationException
+ * @expectedExceptionMessage Expected PlainValue, got ''' at position 10 in class \Doctrine\Tests\Common\Annotations\Name
+ */
+ public function testSyntaxErrorWithContextDescription()
+ {
+ $parser = $this->createTestParser();
+ $parser->parse("@Name(foo='bar')", "class \Doctrine\Tests\Common\Annotations\Name");
+ }
+
+ /**
+ * @group DDC-183
+ */
+ public function testSyntaxErrorWithUnknownCharacters()
+ {
+ $docblock = <<<DOCBLOCK
+/**
+ * @test at.
+ */
+class A {
+}
+DOCBLOCK;
+
+ //$lexer = new \Doctrine\Common\Annotations\Lexer();
+ //$lexer->setInput(trim($docblock, '/ *'));
+ //var_dump($lexer);
+
+ try {
+ $parser = $this->createTestParser();
+ $result = $parser->parse($docblock);
+ } catch (Exception $e) {
+ $this->fail($e->getMessage());
+ }
+ }
+
+ /**
+ * @group DCOM-14
+ */
+ public function testIgnorePHPDocThrowTag()
+ {
+ $docblock = <<<DOCBLOCK
+/**
+ * @throws \RuntimeException
+ */
+class A {
+}
+DOCBLOCK;
+
+ try {
+ $parser = $this->createTestParser();
+ $result = $parser->parse($docblock);
+ } catch (Exception $e) {
+ $this->fail($e->getMessage());
+ }
+ }
+
+ /**
+ * @group DCOM-38
+ */
+ public function testCastInt()
+ {
+ $parser = $this->createTestParser();
+
+ $result = $parser->parse("@Name(foo=1234)");
+ $annot = $result[0];
+ $this->assertInternalType('int', $annot->foo);
+ }
+
+ /**
+ * @group DCOM-38
+ */
+ public function testCastNegativeInt()
+ {
+ $parser = $this->createTestParser();
+
+ $result = $parser->parse("@Name(foo=-1234)");
+ $annot = $result[0];
+ $this->assertInternalType('int', $annot->foo);
+ }
+
+ /**
+ * @group DCOM-38
+ */
+ public function testCastFloat()
+ {
+ $parser = $this->createTestParser();
+
+ $result = $parser->parse("@Name(foo=1234.345)");
+ $annot = $result[0];
+ $this->assertInternalType('float', $annot->foo);
+ }
+
+ /**
+ * @group DCOM-38
+ */
+ public function testCastNegativeFloat()
+ {
+ $parser = $this->createTestParser();
+
+ $result = $parser->parse("@Name(foo=-1234.345)");
+ $annot = $result[0];
+ $this->assertInternalType('float', $annot->foo);
+
+ $result = $parser->parse("@Marker(-1234.345)");
+ $annot = $result[0];
+ $this->assertInternalType('float', $annot->value);
+ }
+
+ public function testReservedKeywordsInAnnotations()
+ {
+ $parser = $this->createTestParser();
+
+ $result = $parser->parse('@Doctrine\Tests\Common\Annotations\True');
+ $this->assertTrue($result[0] instanceof True);
+ $result = $parser->parse('@Doctrine\Tests\Common\Annotations\False');
+ $this->assertTrue($result[0] instanceof False);
+ $result = $parser->parse('@Doctrine\Tests\Common\Annotations\Null');
+ $this->assertTrue($result[0] instanceof Null);
+
+ $result = $parser->parse('@True');
+ $this->assertTrue($result[0] instanceof True);
+ $result = $parser->parse('@False');
+ $this->assertTrue($result[0] instanceof False);
+ $result = $parser->parse('@Null');
+ $this->assertTrue($result[0] instanceof Null);
+ }
+
+ /**
+ * @expectedException Doctrine\Common\Annotations\AnnotationException
+ * @expectedExceptionMessage [Creation Error] The annotation @SomeAnnotationClassNameWithoutConstructor declared on some class does not have a property named "invalidaProperty". Available properties: data, name
+ */
+ public function testSetValuesExeption()
+ {
+ $docblock = <<<DOCBLOCK
+/**
+ * @SomeAnnotationClassNameWithoutConstructor(invalidaProperty = "Some val")
+ */
+DOCBLOCK;
+
+ $this->createTestParser()->parse($docblock, 'some class');
+ }
+
+ /**
+ * @expectedException Doctrine\Common\Annotations\AnnotationException
+ * @expectedExceptionMessage [Syntax Error] Expected Doctrine\Common\Annotations\DocLexer::T_IDENTIFIER or Doctrine\Common\Annotations\DocLexer::T_TRUE or Doctrine\Common\Annotations\DocLexer::T_FALSE or Doctrine\Common\Annotations\DocLexer::T_NULL, got '3.42' at position 5.
+ */
+ public function testInvalidIdentifierInAnnotation()
+ {
+ $parser = $this->createTestParser();
+ $parser->parse('@Foo\3.42');
+ }
+
+ public function testTrailingCommaIsAllowed()
+ {
+ $parser = $this->createTestParser();
+
+ $annots = $parser->parse('@Name({
+ "Foo",
+ "Bar",
+ })');
+ $this->assertEquals(1, count($annots));
+ $this->assertEquals(array('Foo', 'Bar'), $annots[0]->value);
+ }
+
+ public function testDefaultAnnotationValueIsNotOverwritten()
+ {
+ $parser = $this->createTestParser();
+
+ $annots = $parser->parse('@Doctrine\Tests\Common\Annotations\Fixtures\Annotation\AnnotWithDefaultValue');
+ $this->assertEquals(1, count($annots));
+ $this->assertEquals('bar', $annots[0]->foo);
+ }
+
+ public function testArrayWithColon()
+ {
+ $parser = $this->createTestParser();
+
+ $annots = $parser->parse('@Name({"foo": "bar"})');
+ $this->assertEquals(1, count($annots));
+ $this->assertEquals(array('foo' => 'bar'), $annots[0]->value);
+ }
+
+ /**
+ * @expectedException Doctrine\Common\Annotations\AnnotationException
+ * @expectedExceptionMessage [Syntax Error] Expected PlainValue, got 'foo:' at position 6.
+ */
+ public function testColonNotAllowedOnTopLevel()
+ {
+ $parser = $this->createTestParser();
+ $parser->parse('@Name(foo: "bar")');
+ }
+}
+
+/** @Annotation */
+class SomeAnnotationClassNameWithoutConstructor
+{
+ public $data;
+ public $name;
+}
+
+/** @Annotation */
+class SomeAnnotationWithConstructorWithoutParams
+{
+ function __construct()
+ {
+ $this->data = "Some data";
+ }
+ public $data;
+ public $name;
+}
+
+/** @Annotation */
+class SomeAnnotationClassNameWithoutConstructorAndProperties{}
+
+/**
+ * @Annotation
+ * @Target("Foo")
+ */
+class AnnotationWithInvalidTargetDeclaration{}
+
+/**
+ * @Annotation
+ * @Target
+ */
+class AnnotationWithTargetEmpty{}
+
+/** @Annotation */
+class AnnotationExtendsAnnotationTargetAll extends \Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll
+{
+}
+
+/** @Annotation */
+class Name extends \Doctrine\Common\Annotations\Annotation {
+ public $foo;
+}
+
+/** @Annotation */
+class Marker {
+ public $value;
+}
+
+/** @Annotation */
+class True {}
+
+/** @Annotation */
+class False {}
+
+/** @Annotation */
+class Null {}
+
+namespace Doctrine\Tests\Common\Annotations\FooBar;
+
+/** @Annotation */
+class Name extends \Doctrine\Common\Annotations\Annotation {
+}
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/FileCacheReaderTest.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/FileCacheReaderTest.php
new file mode 100644
index 0000000000000000000000000000000000000000..c84344d81e4caae8b9bdb00ab8ac3d7cd404ab19
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/FileCacheReaderTest.php
@@ -0,0 +1,40 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations;
+
+use Doctrine\Common\Annotations\AnnotationReader;
+use Doctrine\Common\Annotations\FileCacheReader;
+
+class FileCacheReaderTest extends AbstractReaderTest
+{
+ private $cacheDir;
+
+ protected function getReader()
+ {
+ $this->cacheDir = sys_get_temp_dir() . "/annotations_". uniqid();
+ @mkdir($this->cacheDir);
+ return new FileCacheReader(new AnnotationReader(), $this->cacheDir);
+ }
+
+ public function tearDown()
+ {
+ foreach (glob($this->cacheDir.'/*.php') AS $file) {
+ unlink($file);
+ }
+ rmdir($this->cacheDir);
+ }
+
+ /**
+ * @group DCOM-81
+ */
+ public function testAttemptToCreateAnnotationCacheDir()
+ {
+ $this->cacheDir = sys_get_temp_dir() . "/not_existed_dir_". uniqid();
+
+ $this->assertFalse(is_dir($this->cacheDir));
+
+ $cache = new FileCacheReader(new AnnotationReader(), $this->cacheDir);
+
+ $this->assertTrue(is_dir($this->cacheDir));
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/Annotation/AnnotWithDefaultValue.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/Annotation/AnnotWithDefaultValue.php
new file mode 100644
index 0000000000000000000000000000000000000000..44108e192460243ba843d8ba6ddeae10b472fe41
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/Annotation/AnnotWithDefaultValue.php
@@ -0,0 +1,10 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures\Annotation;
+
+/** @Annotation */
+class AnnotWithDefaultValue
+{
+ /** @var string */
+ public $foo = 'bar';
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/Annotation/Autoload.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/Annotation/Autoload.php
new file mode 100644
index 0000000000000000000000000000000000000000..e2a4cad9613cd19213bf5e97d4e2dcac0058e3d4
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/Annotation/Autoload.php
@@ -0,0 +1,10 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures\Annotation;
+
+/**
+ * @Annotation
+ */
+class Autoload
+{
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/Annotation/Route.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/Annotation/Route.php
new file mode 100644
index 0000000000000000000000000000000000000000..eb1bdee309ed9da2deb5e578a02da90484f1e7c5
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/Annotation/Route.php
@@ -0,0 +1,11 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures\Annotation;
+
+/** @Annotation */
+class Route
+{
+ /** @var string @Required */
+ public $pattern;
+ public $name;
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/Annotation/Secure.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/Annotation/Secure.php
new file mode 100644
index 0000000000000000000000000000000000000000..332544fa3dc6042bb426e05b23e198144d0a72e3
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/Annotation/Secure.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures\Annotation;
+
+/** @Annotation */
+class Secure
+{
+ private $roles;
+
+ public function __construct(array $values)
+ {
+ if (is_string($values['value'])) {
+ $values['value'] = array($values['value']);
+ }
+
+ $this->roles = $values['value'];
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/Annotation/Template.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/Annotation/Template.php
new file mode 100644
index 0000000000000000000000000000000000000000..b507e602aa0c460d5d03fec44e372b7322bdc202
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/Annotation/Template.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures\Annotation;
+
+/** @Annotation */
+class Template
+{
+ private $name;
+
+ public function __construct(array $values)
+ {
+ $this->name = isset($values['value']) ? $values['value'] : null;
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/Annotation/Version.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/Annotation/Version.php
new file mode 100644
index 0000000000000000000000000000000000000000..09ef03177f79bcee1c3278bea78ede719272af53
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/Annotation/Version.php
@@ -0,0 +1,11 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures\Annotation;
+
+/**
+ * @Annotation
+ * @Target("PROPERTY")
+ */
+final class Version
+{
+}
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationTargetAll.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationTargetAll.php
new file mode 100644
index 0000000000000000000000000000000000000000..f1c7746090627a8198bfb84ab243a87f7e48493d
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationTargetAll.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+/**
+ * @Annotation
+ * @Target("ALL")
+ */
+class AnnotationTargetAll
+{
+ public $data;
+ public $name;
+ public $target;
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationTargetAnnotation.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationTargetAnnotation.php
new file mode 100644
index 0000000000000000000000000000000000000000..9ee1b4056f57283fc1139cb354f7b0f1150227c6
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationTargetAnnotation.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+/**
+ * @Annotation
+ * @Target({ "ANNOTATION" })
+ */
+final class AnnotationTargetAnnotation
+{
+ public $data;
+ public $name;
+ public $target;
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationTargetClass.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationTargetClass.php
new file mode 100644
index 0000000000000000000000000000000000000000..5e5d19efb3f49fbd557f78d8b26aeb00d4163f37
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationTargetClass.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+
+/**
+ * @Annotation
+ * @Target("CLASS")
+ */
+final class AnnotationTargetClass
+{
+ public $data;
+ public $name;
+ public $target;
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationTargetMethod.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationTargetMethod.php
new file mode 100644
index 0000000000000000000000000000000000000000..2ab066cbf12dd35ff4ec5a700d9dccf8d5e91be1
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationTargetMethod.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+
+/**
+ * @Annotation
+ * @Target("METHOD")
+ */
+final class AnnotationTargetMethod
+{
+ public $data;
+ public $name;
+ public $target;
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationTargetPropertyMethod.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationTargetPropertyMethod.php
new file mode 100644
index 0000000000000000000000000000000000000000..f7145612c336ef3e59208f1811976f1c1c55d2fa
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationTargetPropertyMethod.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+/**
+ * @Annotation
+ * @Target({ "METHOD", "PROPERTY" })
+ */
+final class AnnotationTargetPropertyMethod
+{
+ public $data;
+ public $name;
+ public $target;
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationWithAttributes.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationWithAttributes.php
new file mode 100644
index 0000000000000000000000000000000000000000..def24d364f63f44a2c923916b7f203e7ab979e5f
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationWithAttributes.php
@@ -0,0 +1,119 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+/**
+ * @Annotation
+ * @Target("ALL")
+ * @Attributes({
+ @Attribute("mixed", type = "mixed"),
+ @Attribute("boolean", type = "boolean"),
+ @Attribute("bool", type = "bool"),
+ @Attribute("float", type = "float"),
+ @Attribute("string", type = "string"),
+ @Attribute("integer", type = "integer"),
+ @Attribute("array", type = "array"),
+ @Attribute("arrayOfIntegers", type = "array<integer>"),
+ @Attribute("annotation", type = "Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll"),
+ @Attribute("arrayOfAnnotations", type = "array<Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll>"),
+ })
+ */
+final class AnnotationWithAttributes
+{
+
+ public final function __construct(array $data)
+ {
+ foreach ($data as $key => $value) {
+ $this->$key = $value;
+ }
+ }
+
+ private $mixed;
+ private $boolean;
+ private $bool;
+ private $float;
+ private $string;
+ private $integer;
+ private $array;
+ private $annotation;
+ private $arrayOfIntegers;
+ private $arrayOfAnnotations;
+
+ /**
+ * @return mixed
+ */
+ public function getMixed()
+ {
+ return $this->mixed;
+ }
+
+ /**
+ * @return boolean
+ */
+ public function getBoolean()
+ {
+ return $this->boolean;
+ }
+
+ /**
+ * @return bool
+ */
+ public function getBool()
+ {
+ return $this->bool;
+ }
+
+ /**
+ * @return float
+ */
+ public function getFloat()
+ {
+ return $this->float;
+ }
+
+ /**
+ * @return string
+ */
+ public function getString()
+ {
+ return $this->string;
+ }
+
+ public function getInteger()
+ {
+ return $this->integer;
+ }
+
+ /**
+ * @return array
+ */
+ public function getArray()
+ {
+ return $this->array;
+ }
+
+ /**
+ * @return Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll
+ */
+ public function getAnnotation()
+ {
+ return $this->annotation;
+ }
+
+ /**
+ * @return array<integer>
+ */
+ public function getArrayOfIntegers()
+ {
+ return $this->arrayOfIntegers;
+ }
+
+ /**
+ * @return array<Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll>
+ */
+ public function getArrayOfAnnotations()
+ {
+ return $this->arrayOfAnnotations;
+ }
+
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationWithRequiredAttributes.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationWithRequiredAttributes.php
new file mode 100644
index 0000000000000000000000000000000000000000..6eb1bc5aac58b930077c5f806f01580dd99b4730
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationWithRequiredAttributes.php
@@ -0,0 +1,50 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+/**
+ * @Annotation
+ * @Target("ALL")
+ * @Attributes({
+ @Attribute("value", required = true , type = "string"),
+ @Attribute("annot", required = true , type = "Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAnnotation"),
+ })
+ */
+final class AnnotationWithRequiredAttributes
+{
+
+ public final function __construct(array $data)
+ {
+ foreach ($data as $key => $value) {
+ $this->$key = $value;
+ }
+ }
+
+ /**
+ * @var string
+ */
+ private $value;
+
+ /**
+ *
+ * @var Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAnnotation
+ */
+ private $annot;
+
+ /**
+ * @return string
+ */
+ public function getValue()
+ {
+ return $this->value;
+ }
+
+ /**
+ * @return Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAnnotation
+ */
+ public function getAnnot()
+ {
+ return $this->annot;
+ }
+
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationWithRequiredAttributesWithoutContructor.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationWithRequiredAttributesWithoutContructor.php
new file mode 100644
index 0000000000000000000000000000000000000000..bf458ee77a993ae5242d9f99a8f23855047e5c4b
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationWithRequiredAttributesWithoutContructor.php
@@ -0,0 +1,24 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+/**
+ * @Annotation
+ * @Target("ALL")
+ */
+final class AnnotationWithRequiredAttributesWithoutContructor
+{
+
+ /**
+ * @Required
+ * @var string
+ */
+ public $value;
+
+ /**
+ * @Required
+ * @var Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAnnotation
+ */
+ public $annot;
+
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationWithTargetSyntaxError.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationWithTargetSyntaxError.php
new file mode 100644
index 0000000000000000000000000000000000000000..7638ce889af17f3a346ad741d66d90eef7ffe76d
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationWithTargetSyntaxError.php
@@ -0,0 +1,11 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+/**
+ * @Annotation
+ * @Target(@)
+ */
+final class AnnotationWithTargetSyntaxError
+{
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationWithVarType.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationWithVarType.php
new file mode 100644
index 0000000000000000000000000000000000000000..f8706003a0ae2c78eeac98dbd27aaa421b6e413a
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/AnnotationWithVarType.php
@@ -0,0 +1,62 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+/**
+ * @Annotation
+ * @Target("ALL")
+ */
+final class AnnotationWithVarType
+{
+
+ /**
+ * @var mixed
+ */
+ public $mixed;
+
+ /**
+ * @var boolean
+ */
+ public $boolean;
+
+ /**
+ * @var bool
+ */
+ public $bool;
+
+ /**
+ * @var float
+ */
+ public $float;
+
+ /**
+ * @var string
+ */
+ public $string;
+
+ /**
+ * @var integer
+ */
+ public $integer;
+
+ /**
+ * @var array
+ */
+ public $array;
+
+ /**
+ * @var Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll
+ */
+ public $annotation;
+
+ /**
+ * @var array<integer>
+ */
+ public $arrayOfIntegers;
+
+ /**
+ * @var array<Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll>
+ */
+ public $arrayOfAnnotations;
+
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassDDC1660.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassDDC1660.php
new file mode 100644
index 0000000000000000000000000000000000000000..4e652e138810e9c00d851a2feb0fc28c3214d0c2
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassDDC1660.php
@@ -0,0 +1,30 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+/**
+ * @since 2.0
+ * @version $Id: SomeEntityClass.php 509 2012-02-03 09:38:48Z mf $
+ */
+class ClassDDC1660
+{
+
+ /**
+ * @var string
+ * @since 2.0
+ * @version 1
+ */
+ public $foo;
+
+ /**
+ * @param string
+ * @return string
+ * @since 2.0
+ * @version 1
+ */
+ public function bar($param)
+ {
+ return null;
+ }
+
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithAnnotationWithTargetSyntaxError.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithAnnotationWithTargetSyntaxError.php
new file mode 100644
index 0000000000000000000000000000000000000000..6fd31688b88acf28dbfe33d25da300d29f8e1e40
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithAnnotationWithTargetSyntaxError.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\AnnotationWithTargetSyntaxError;
+
+/**
+ * @AnnotationWithTargetSyntaxError()
+ */
+class ClassWithAnnotationWithTargetSyntaxError
+{
+ /**
+ * @AnnotationWithTargetSyntaxError()
+ */
+ public $foo;
+
+ /**
+ * @AnnotationWithTargetSyntaxError()
+ */
+ public function bar(){}
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithAnnotationWithVarType.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithAnnotationWithVarType.php
new file mode 100644
index 0000000000000000000000000000000000000000..ed467dbfbec35d22cdfdf1b62737b650747d67f4
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithAnnotationWithVarType.php
@@ -0,0 +1,31 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\AnnotationWithVarType;
+use Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll;
+use Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAnnotation;
+
+class ClassWithAnnotationWithVarType
+{
+ /**
+ * @AnnotationWithVarType(string = "String Value")
+ */
+ public $foo;
+
+ /**
+ * @AnnotationWithVarType(annotation = @AnnotationTargetAll)
+ */
+ public function bar(){}
+
+
+ /**
+ * @AnnotationWithVarType(string = 123)
+ */
+ public $invalidProperty;
+
+ /**
+ * @AnnotationWithVarType(annotation = @AnnotationTargetAnnotation)
+ */
+ public function invalidMethod(){}
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithFullyQualifiedUseStatements.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithFullyQualifiedUseStatements.php
new file mode 100644
index 0000000000000000000000000000000000000000..ddb207bef790967d42ec038f9416bbacf5005687
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithFullyQualifiedUseStatements.php
@@ -0,0 +1,11 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use
+ \Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Secure,
+ \Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route
+;
+use \Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Template;
+
+class ClassWithFullyQualifiedUseStatements {}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithInvalidAnnotationTargetAtClass.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithInvalidAnnotationTargetAtClass.php
new file mode 100644
index 0000000000000000000000000000000000000000..f8d961cf85c620cc767d700bf8cf78e1766fae6f
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithInvalidAnnotationTargetAtClass.php
@@ -0,0 +1,17 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetPropertyMethod;
+
+/**
+ * @AnnotationTargetPropertyMethod("Some data")
+ */
+class ClassWithInvalidAnnotationTargetAtClass
+{
+
+ /**
+ * @AnnotationTargetPropertyMethod("Bar")
+ */
+ public $foo;
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithInvalidAnnotationTargetAtMethod.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithInvalidAnnotationTargetAtMethod.php
new file mode 100644
index 0000000000000000000000000000000000000000..ea6348047f608238cb1ec3a9e294f4b226a603de
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithInvalidAnnotationTargetAtMethod.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetClass;
+
+/**
+ * @AnnotationTargetClass("Some data")
+ */
+class ClassWithInvalidAnnotationTargetAtMethod
+{
+
+ /**
+ * @AnnotationTargetClass("functionName")
+ */
+ public function functionName($param)
+ {
+
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithInvalidAnnotationTargetAtProperty.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithInvalidAnnotationTargetAtProperty.php
new file mode 100644
index 0000000000000000000000000000000000000000..80befcfc24f24b9a1845ac9a129547e70528b13c
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithInvalidAnnotationTargetAtProperty.php
@@ -0,0 +1,24 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetClass;
+use Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAnnotation;
+
+/**
+ * @AnnotationTargetClass("Some data")
+ */
+class ClassWithInvalidAnnotationTargetAtProperty
+{
+
+ /**
+ * @AnnotationTargetClass("Bar")
+ */
+ public $foo;
+
+
+ /**
+ * @AnnotationTargetAnnotation("Foo")
+ */
+ public $bar;
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithValidAnnotationTarget.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithValidAnnotationTarget.php
new file mode 100644
index 0000000000000000000000000000000000000000..ada78382c036248ce48575d9a32b921b8d82bb65
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/ClassWithValidAnnotationTarget.php
@@ -0,0 +1,41 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetClass;
+use Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetAll;
+use Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetPropertyMethod;
+use Doctrine\Tests\Common\Annotations\Fixtures\AnnotationTargetNestedAnnotation;
+
+/**
+ * @AnnotationTargetClass("Some data")
+ */
+class ClassWithValidAnnotationTarget
+{
+
+ /**
+ * @AnnotationTargetPropertyMethod("Some data")
+ */
+ public $foo;
+
+
+ /**
+ * @AnnotationTargetAll("Some data",name="Some name")
+ */
+ public $name;
+
+ /**
+ * @AnnotationTargetPropertyMethod("Some data",name="Some name")
+ */
+ public function someFunction()
+ {
+
+ }
+
+
+ /**
+ * @AnnotationTargetAll(@AnnotationTargetAnnotation)
+ */
+ public $nested;
+
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/Controller.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/Controller.php
new file mode 100644
index 0000000000000000000000000000000000000000..85320642e6aa768c47c66f30be3e9222f713d359
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/Controller.php
@@ -0,0 +1,300 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Template;
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route;
+
+/**
+ * @Route("/someprefix")
+ * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ */
+class Controller
+{
+ /**
+ * @Route("/", name="_demo")
+ * @Template()
+ */
+ public function indexAction()
+ {
+ return array();
+ }
+
+ /**
+ * @Route("/hello/{name}", name="_demo_hello")
+ * @Template()
+ */
+ public function helloAction($name)
+ {
+ return array('name' => $name);
+ }
+
+ /**
+ * @Route("/contact", name="_demo_contact")
+ * @Template()
+ */
+ public function contactAction()
+ {
+ $form = ContactForm::create($this->get('form.context'), 'contact');
+
+ $form->bind($this->container->get('request'), $form);
+ if ($form->isValid()) {
+ $form->send($this->get('mailer'));
+
+ $this->get('session')->setFlash('notice', 'Message sent!');
+
+ return new RedirectResponse($this->generateUrl('_demo'));
+ }
+
+ return array('form' => $form);
+ }
+
+ /**
+ * Creates the ACL for the passed object identity
+ *
+ * @param ObjectIdentityInterface $oid
+ * @return void
+ */
+ private function createObjectIdentity(ObjectIdentityInterface $oid)
+ {
+ $classId = $this->createOrRetrieveClassId($oid->getType());
+
+ $this->connection->executeQuery($this->getInsertObjectIdentitySql($oid->getIdentifier(), $classId, true));
+ }
+
+ /**
+ * Returns the primary key for the passed class type.
+ *
+ * If the type does not yet exist in the database, it will be created.
+ *
+ * @param string $classType
+ * @return integer
+ */
+ private function createOrRetrieveClassId($classType)
+ {
+ if (false !== $id = $this->connection->executeQuery($this->getSelectClassIdSql($classType))->fetchColumn()) {
+ return $id;
+ }
+
+ $this->connection->executeQuery($this->getInsertClassSql($classType));
+
+ return $this->connection->executeQuery($this->getSelectClassIdSql($classType))->fetchColumn();
+ }
+
+ /**
+ * Returns the primary key for the passed security identity.
+ *
+ * If the security identity does not yet exist in the database, it will be
+ * created.
+ *
+ * @param SecurityIdentityInterface $sid
+ * @return integer
+ */
+ private function createOrRetrieveSecurityIdentityId(SecurityIdentityInterface $sid)
+ {
+ if (false !== $id = $this->connection->executeQuery($this->getSelectSecurityIdentityIdSql($sid))->fetchColumn()) {
+ return $id;
+ }
+
+ $this->connection->executeQuery($this->getInsertSecurityIdentitySql($sid));
+
+ return $this->connection->executeQuery($this->getSelectSecurityIdentityIdSql($sid))->fetchColumn();
+ }
+
+ /**
+ * Deletes all ACEs for the given object identity primary key.
+ *
+ * @param integer $oidPK
+ * @return void
+ */
+ private function deleteAccessControlEntries($oidPK)
+ {
+ $this->connection->executeQuery($this->getDeleteAccessControlEntriesSql($oidPK));
+ }
+
+ /**
+ * Deletes the object identity from the database.
+ *
+ * @param integer $pk
+ * @return void
+ */
+ private function deleteObjectIdentity($pk)
+ {
+ $this->connection->executeQuery($this->getDeleteObjectIdentitySql($pk));
+ }
+
+ /**
+ * Deletes all entries from the relations table from the database.
+ *
+ * @param integer $pk
+ * @return void
+ */
+ private function deleteObjectIdentityRelations($pk)
+ {
+ $this->connection->executeQuery($this->getDeleteObjectIdentityRelationsSql($pk));
+ }
+
+ /**
+ * This regenerates the ancestor table which is used for fast read access.
+ *
+ * @param AclInterface $acl
+ * @return void
+ */
+ private function regenerateAncestorRelations(AclInterface $acl)
+ {
+ $pk = $acl->getId();
+ $this->connection->executeQuery($this->getDeleteObjectIdentityRelationsSql($pk));
+ $this->connection->executeQuery($this->getInsertObjectIdentityRelationSql($pk, $pk));
+
+ $parentAcl = $acl->getParentAcl();
+ while (null !== $parentAcl) {
+ $this->connection->executeQuery($this->getInsertObjectIdentityRelationSql($pk, $parentAcl->getId()));
+
+ $parentAcl = $parentAcl->getParentAcl();
+ }
+ }
+
+ /**
+ * This processes changes on an ACE related property (classFieldAces, or objectFieldAces).
+ *
+ * @param string $name
+ * @param array $changes
+ * @return void
+ */
+ private function updateFieldAceProperty($name, array $changes)
+ {
+ $sids = new \SplObjectStorage();
+ $classIds = new \SplObjectStorage();
+ $currentIds = array();
+ foreach ($changes[1] as $field => $new) {
+ for ($i=0,$c=count($new); $i<$c; $i++) {
+ $ace = $new[$i];
+
+ if (null === $ace->getId()) {
+ if ($sids->contains($ace->getSecurityIdentity())) {
+ $sid = $sids->offsetGet($ace->getSecurityIdentity());
+ } else {
+ $sid = $this->createOrRetrieveSecurityIdentityId($ace->getSecurityIdentity());
+ }
+
+ $oid = $ace->getAcl()->getObjectIdentity();
+ if ($classIds->contains($oid)) {
+ $classId = $classIds->offsetGet($oid);
+ } else {
+ $classId = $this->createOrRetrieveClassId($oid->getType());
+ }
+
+ $objectIdentityId = $name === 'classFieldAces' ? null : $ace->getAcl()->getId();
+
+ $this->connection->executeQuery($this->getInsertAccessControlEntrySql($classId, $objectIdentityId, $field, $i, $sid, $ace->getStrategy(), $ace->getMask(), $ace->isGranting(), $ace->isAuditSuccess(), $ace->isAuditFailure()));
+ $aceId = $this->connection->executeQuery($this->getSelectAccessControlEntryIdSql($classId, $objectIdentityId, $field, $i))->fetchColumn();
+ $this->loadedAces[$aceId] = $ace;
+
+ $aceIdProperty = new \ReflectionProperty('Symfony\Component\Security\Acl\Domain\Entry', 'id');
+ $aceIdProperty->setAccessible(true);
+ $aceIdProperty->setValue($ace, intval($aceId));
+ } else {
+ $currentIds[$ace->getId()] = true;
+ }
+ }
+ }
+
+ foreach ($changes[0] as $old) {
+ for ($i=0,$c=count($old); $i<$c; $i++) {
+ $ace = $old[$i];
+
+ if (!isset($currentIds[$ace->getId()])) {
+ $this->connection->executeQuery($this->getDeleteAccessControlEntrySql($ace->getId()));
+ unset($this->loadedAces[$ace->getId()]);
+ }
+ }
+ }
+ }
+
+ /**
+ * This processes changes on an ACE related property (classAces, or objectAces).
+ *
+ * @param string $name
+ * @param array $changes
+ * @return void
+ */
+ private function updateAceProperty($name, array $changes)
+ {
+ list($old, $new) = $changes;
+
+ $sids = new \SplObjectStorage();
+ $classIds = new \SplObjectStorage();
+ $currentIds = array();
+ for ($i=0,$c=count($new); $i<$c; $i++) {
+ $ace = $new[$i];
+
+ if (null === $ace->getId()) {
+ if ($sids->contains($ace->getSecurityIdentity())) {
+ $sid = $sids->offsetGet($ace->getSecurityIdentity());
+ } else {
+ $sid = $this->createOrRetrieveSecurityIdentityId($ace->getSecurityIdentity());
+ }
+
+ $oid = $ace->getAcl()->getObjectIdentity();
+ if ($classIds->contains($oid)) {
+ $classId = $classIds->offsetGet($oid);
+ } else {
+ $classId = $this->createOrRetrieveClassId($oid->getType());
+ }
+
+ $objectIdentityId = $name === 'classAces' ? null : $ace->getAcl()->getId();
+
+ $this->connection->executeQuery($this->getInsertAccessControlEntrySql($classId, $objectIdentityId, null, $i, $sid, $ace->getStrategy(), $ace->getMask(), $ace->isGranting(), $ace->isAuditSuccess(), $ace->isAuditFailure()));
+ $aceId = $this->connection->executeQuery($this->getSelectAccessControlEntryIdSql($classId, $objectIdentityId, null, $i))->fetchColumn();
+ $this->loadedAces[$aceId] = $ace;
+
+ $aceIdProperty = new \ReflectionProperty($ace, 'id');
+ $aceIdProperty->setAccessible(true);
+ $aceIdProperty->setValue($ace, intval($aceId));
+ } else {
+ $currentIds[$ace->getId()] = true;
+ }
+ }
+
+ for ($i=0,$c=count($old); $i<$c; $i++) {
+ $ace = $old[$i];
+
+ if (!isset($currentIds[$ace->getId()])) {
+ $this->connection->executeQuery($this->getDeleteAccessControlEntrySql($ace->getId()));
+ unset($this->loadedAces[$ace->getId()]);
+ }
+ }
+ }
+
+ /**
+ * Persists the changes which were made to ACEs to the database.
+ *
+ * @param \SplObjectStorage $aces
+ * @return void
+ */
+ private function updateAces(\SplObjectStorage $aces)
+ {
+ foreach ($aces as $ace) {
+ $propertyChanges = $aces->offsetGet($ace);
+ $sets = array();
+
+ if (isset($propertyChanges['mask'])) {
+ $sets[] = sprintf('mask = %d', $propertyChanges['mask'][1]);
+ }
+ if (isset($propertyChanges['strategy'])) {
+ $sets[] = sprintf('granting_strategy = %s', $this->connection->quote($propertyChanges['strategy']));
+ }
+ if (isset($propertyChanges['aceOrder'])) {
+ $sets[] = sprintf('ace_order = %d', $propertyChanges['aceOrder'][1]);
+ }
+ if (isset($propertyChanges['auditSuccess'])) {
+ $sets[] = sprintf('audit_success = %s', $this->connection->getDatabasePlatform()->convertBooleans($propertyChanges['auditSuccess'][1]));
+ }
+ if (isset($propertyChanges['auditFailure'])) {
+ $sets[] = sprintf('audit_failure = %s', $this->connection->getDatabasePlatform()->convertBooleans($propertyChanges['auditFailure'][1]));
+ }
+
+ $this->connection->executeQuery($this->getUpdateAccessControlEntrySql($ace->getId(), $sets));
+ }
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/DifferentNamespacesPerFileWithClassAsFirst.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/DifferentNamespacesPerFileWithClassAsFirst.php
new file mode 100644
index 0000000000000000000000000000000000000000..bda2cc21ba1f857326b0128d162632129797752e
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/DifferentNamespacesPerFileWithClassAsFirst.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures {
+ use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Secure;
+
+ class DifferentNamespacesPerFileWithClassAsFirst {}
+}
+
+namespace {
+ use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route;
+}
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures\Foo {
+ use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Template;
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/DifferentNamespacesPerFileWithClassAsLast.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/DifferentNamespacesPerFileWithClassAsLast.php
new file mode 100644
index 0000000000000000000000000000000000000000..aff3146d5b0fd34e63f9211a1162247fb87d0ed9
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/DifferentNamespacesPerFileWithClassAsLast.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures\Foo {
+ use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Secure;
+}
+
+namespace {
+ use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route;
+}
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures {
+ use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Template;
+
+ class DifferentNamespacesPerFileWithClassAsLast {}
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/EqualNamespacesPerFileWithClassAsFirst.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/EqualNamespacesPerFileWithClassAsFirst.php
new file mode 100644
index 0000000000000000000000000000000000000000..3484bf8cea97d439bccaf52bf1598cc939055ff9
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/EqualNamespacesPerFileWithClassAsFirst.php
@@ -0,0 +1,13 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Secure;
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route;
+
+class EqualNamespacesPerFileWithClassAsFirst {}
+
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Template;
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/EqualNamespacesPerFileWithClassAsLast.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/EqualNamespacesPerFileWithClassAsLast.php
new file mode 100644
index 0000000000000000000000000000000000000000..87f1dbf57538fdde49146c3ca39c18e4864a12b3
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/EqualNamespacesPerFileWithClassAsLast.php
@@ -0,0 +1,12 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Secure;
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route;
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Template;
+
+class EqualNamespacesPerFileWithClassAsLast {}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/GlobalNamespacesPerFileWithClassAsFirst.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/GlobalNamespacesPerFileWithClassAsFirst.php
new file mode 100644
index 0000000000000000000000000000000000000000..b2c5d5ce74f6892473238e6f230b0709834ebc33
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/GlobalNamespacesPerFileWithClassAsFirst.php
@@ -0,0 +1,12 @@
+<?php
+
+namespace {
+ use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Secure;
+ use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route;
+
+ class GlobalNamespacesPerFileWithClassAsFirst {}
+}
+
+namespace {
+ use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Template;
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/GlobalNamespacesPerFileWithClassAsLast.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/GlobalNamespacesPerFileWithClassAsLast.php
new file mode 100644
index 0000000000000000000000000000000000000000..6b600ff1e37e4378a9d8090fd7d0f5f0aad87d65
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/GlobalNamespacesPerFileWithClassAsLast.php
@@ -0,0 +1,12 @@
+<?php
+
+namespace {
+ use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Secure;
+}
+
+namespace {
+ use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route;
+ use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Template;
+
+ class GlobalNamespacesPerFileWithClassAsLast {}
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/InvalidAnnotationUsageButIgnoredClass.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/InvalidAnnotationUsageButIgnoredClass.php
new file mode 100644
index 0000000000000000000000000000000000000000..6fa0d51dad802fc24a8a83b3185a67938d750fa8
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/InvalidAnnotationUsageButIgnoredClass.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route;
+
+/**
+ * @NoAnnotation
+ * @IgnoreAnnotation("NoAnnotation")
+ * @Route("foo")
+ */
+class InvalidAnnotationUsageButIgnoredClass
+{
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/InvalidAnnotationUsageClass.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/InvalidAnnotationUsageClass.php
new file mode 100644
index 0000000000000000000000000000000000000000..cf3fc0236199bbabbc14da0eb76cc124c250e5c4
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/InvalidAnnotationUsageClass.php
@@ -0,0 +1,10 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+/**
+ * @NoAnnotation
+ */
+class InvalidAnnotationUsageClass
+{
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/MultipleClassesInFile.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/MultipleClassesInFile.php
new file mode 100644
index 0000000000000000000000000000000000000000..149f1bf536cd1243fdee71f2cc0c2ac348f98174
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/MultipleClassesInFile.php
@@ -0,0 +1,9 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Secure;
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route;
+
+class AnotherClass { }
+class MultipleClassesInFile { }
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/MultipleImportsInUseStatement.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/MultipleImportsInUseStatement.php
new file mode 100644
index 0000000000000000000000000000000000000000..38c954a3ccfc19d83b966f2b21b254d2d22b4945
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/MultipleImportsInUseStatement.php
@@ -0,0 +1,10 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use
+ Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route,
+ Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Secure
+;
+
+class MultipleImportsInUseStatement {}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/NamespaceAndClassCommentedOut.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/NamespaceAndClassCommentedOut.php
new file mode 100644
index 0000000000000000000000000000000000000000..9909e31b2c95c9cfa434322a4cd176279222bb79
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/NamespaceAndClassCommentedOut.php
@@ -0,0 +1,20 @@
+<?php
+
+// namespace Doctrine\Tests\Common\Annotations\Fixtures;
+namespace Doctrine\Tests\Common\Annotations\Fixtures\Foo {
+
+ use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Secure;
+
+ // class NamespaceAndClassCommentedOut {}
+}
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures {
+
+ // class NamespaceAndClassCommentedOut {}
+ use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route;
+
+ // namespace Doctrine\Tests\Common\Annotations\Fixtures;
+ use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Template;
+
+ class NamespaceAndClassCommentedOut {}
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/NamespaceWithClosureDeclaration.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/NamespaceWithClosureDeclaration.php
new file mode 100644
index 0000000000000000000000000000000000000000..4cffe465644658c1e396e667832c50ba5621dbd2
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/NamespaceWithClosureDeclaration.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+$var = 1;
+function () use ($var) {};
+
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Secure;
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route;
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Template;
+
+$var = 1;
+function () use ($var) {};
+
+class NamespaceWithClosureDeclaration {}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/NamespacedSingleClassLOC1000.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/NamespacedSingleClassLOC1000.php
new file mode 100644
index 0000000000000000000000000000000000000000..5e16dd031829b11a52e9e1d3c198b381f2aec8ed
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/NamespacedSingleClassLOC1000.php
@@ -0,0 +1,1009 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use ReflectionClass, ReflectionProperty, ReflectionMethod;
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Secure;
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route;
+
+class NamespacedSingleClassLOC1000
+{
+ const TEST1 = 1234567890;
+ const TEST2 = 1234567890;
+ const TEST3 = 1234567890;
+ const TEST4 = 1234567890;
+ const TEST5 = 1234567890;
+ const TEST6 = 1234567890;
+ const TEST7 = 1234567890;
+ const TEST8 = 1234567890;
+ const TEST9 = 1234567890;
+
+ private $test1 = null;
+ private $test2 = null;
+ private $test3 = null;
+ private $test4 = null;
+ private $test5 = null;
+ private $test6 = null;
+ private $test7 = null;
+ private $test8 = null;
+ private $test9 = null;
+
+ public function test1()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test2()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test3()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test4()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test5()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test6()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test7()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test8()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+
+ }
+
+ public function test9()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test10()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test11()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test12()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test13()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test14()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test15()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test16()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test17()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+
+ }
+
+ public function test18()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test19()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test20()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test21()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test22()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test23()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test24()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test25()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test26()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test27()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+
+ }
+
+ public function test28()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test29()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test30()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test31()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test32()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test33()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test34()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test35()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test36()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test37()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+
+ }
+
+ public function test38()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test39()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/NoAnnotation.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/NoAnnotation.php
new file mode 100644
index 0000000000000000000000000000000000000000..1dae104a4439b71474e8a235ed4ff7376ccacc26
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/NoAnnotation.php
@@ -0,0 +1,5 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+class NoAnnotation {}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/NonNamespacedClass.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/NonNamespacedClass.php
new file mode 100644
index 0000000000000000000000000000000000000000..c373843b733a10847016b625f9816734c2d9b6f5
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/NonNamespacedClass.php
@@ -0,0 +1,10 @@
+<?php
+
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Template;
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route;
+
+/**
+ * @Route("foo")
+ * @Template
+ */
+class AnnotationsTestsFixturesNonNamespacedClass { }
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/SingleClassLOC1000.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/SingleClassLOC1000.php
new file mode 100644
index 0000000000000000000000000000000000000000..134adbc12d9131a37c7728c3b4c5bc0f7bf31b17
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/SingleClassLOC1000.php
@@ -0,0 +1,1006 @@
+<?php
+
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Secure;
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route;
+
+class SingleClassLOC1000
+{
+ const TEST1 = 1234567890;
+ const TEST2 = 1234567890;
+ const TEST3 = 1234567890;
+ const TEST4 = 1234567890;
+ const TEST5 = 1234567890;
+ const TEST6 = 1234567890;
+ const TEST7 = 1234567890;
+ const TEST8 = 1234567890;
+ const TEST9 = 1234567890;
+
+ private $test1 = null;
+ private $test2 = null;
+ private $test3 = null;
+ private $test4 = null;
+ private $test5 = null;
+ private $test6 = null;
+ private $test7 = null;
+ private $test8 = null;
+ private $test9 = null;
+
+ public function test1()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test2()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test3()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test4()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test5()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test6()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test7()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test8()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+
+ }
+
+ public function test9()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test10()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test11()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test12()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test13()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test14()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test15()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test16()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test17()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+
+ }
+
+ public function test18()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test19()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test20()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test21()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test22()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test23()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test24()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test25()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test26()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test27()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+
+ }
+
+ public function test28()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test29()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test30()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test31()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test32()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test33()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test34()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test35()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test36()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test37()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+
+ }
+
+ public function test38()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+
+ public function test39()
+ {
+ echo $this->test1;
+ echo $this->test2;
+ echo $this->test3;
+ $array = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ foreach ($array as $key => $value) {
+ echo $key . ' => ' . $value;
+ }
+
+ $val = (string)self::TEST1;
+ $val .= (string)self::TEST2;
+ $val .= (string)self::TEST3;
+ $val .= (string)self::TEST4;
+ $val .= (string)self::TEST5;
+ $val .= (string)self::TEST6;
+ $val .= (string)self::TEST7;
+ $val .= (string)self::TEST8;
+ $val .= (string)self::TEST9;
+
+ strtolower($val);
+
+ return $val;
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/TestInterface.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/TestInterface.php
new file mode 100644
index 0000000000000000000000000000000000000000..58c5e6af5e3a03fdf11f8a4fa57d9b5dcce6ef4e
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Fixtures/TestInterface.php
@@ -0,0 +1,13 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Fixtures;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Secure;
+
+interface TestInterface
+{
+ /**
+ * @Secure
+ */
+ function foo();
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/PerformanceTest.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/PerformanceTest.php
new file mode 100644
index 0000000000000000000000000000000000000000..c7778b2aeebb3c0347665fb37f5b159d72a3fddd
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/PerformanceTest.php
@@ -0,0 +1,194 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations;
+
+use Doctrine\Common\Annotations\FileCacheReader;
+use Doctrine\Common\Cache\ArrayCache;
+use Doctrine\Common\Annotations\CachedReader;
+use Doctrine\Common\Annotations\DocLexer;
+use Doctrine\Common\Annotations\DocParser;
+use Doctrine\Common\Annotations\PhpParser;
+use Doctrine\Common\Annotations\AnnotationReader;
+
+require_once __DIR__ . '/Fixtures/Annotation/Route.php';
+require_once __DIR__ . '/Fixtures/Annotation/Template.php';
+require_once __DIR__ . '/Fixtures/Annotation/Secure.php';
+require_once __DIR__ . '/Fixtures/SingleClassLOC1000.php';
+
+class PerformanceTest extends \PHPUnit_Framework_TestCase
+{
+ /**
+ * @group performance
+ */
+ public function testCachedReadPerformanceWithInMemory()
+ {
+ $reader = new CachedReader(new AnnotationReader(), new ArrayCache());
+ $method = $this->getMethod();
+
+ $time = microtime(true);
+ for ($i=0,$c=500; $i<$c; $i++) {
+ $reader->getMethodAnnotations($method);
+ }
+ $time = microtime(true) - $time;
+
+ $this->printResults('cached reader (in-memory)', $time, $c);
+ }
+
+ /**
+ * @group performance
+ */
+ public function testCachedReadPerformanceWithFileCache()
+ {
+ $method = $this->getMethod();
+
+ // prime cache
+ $reader = new FileCacheReader(new AnnotationReader(), sys_get_temp_dir());
+ $reader->getMethodAnnotations($method);
+
+ $time = microtime(true);
+ for ($i=0,$c=500; $i<$c; $i++) {
+ $reader = new FileCacheReader(new AnnotationReader(), sys_get_temp_dir());
+ $reader->getMethodAnnotations($method);
+ clearstatcache();
+ }
+ $time = microtime(true) - $time;
+
+ $this->printResults('cached reader (file)', $time, $c);
+ }
+
+ /**
+ * @group performance
+ */
+ public function testReadPerformance()
+ {
+ $method = $this->getMethod();
+
+ $time = microtime(true);
+ for ($i=0,$c=150; $i<$c; $i++) {
+ $reader = new AnnotationReader();
+ $reader->getMethodAnnotations($method);
+ }
+ $time = microtime(true) - $time;
+
+ $this->printResults('reader', $time, $c);
+ }
+
+ /**
+ * @group performance
+ */
+ public function testDocParsePerformance()
+ {
+ $imports = array(
+ 'ignorephpdoc' => 'Annotations\Annotation\IgnorePhpDoc',
+ 'ignoreannotation' => 'Annotations\Annotation\IgnoreAnnotation',
+ 'route' => 'Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Route',
+ 'template' => 'Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Template',
+ '__NAMESPACE__' => 'Doctrine\Tests\Common\Annotations\Fixtures',
+ );
+ $ignored = array(
+ 'access', 'author', 'copyright', 'deprecated', 'example', 'ignore',
+ 'internal', 'link', 'see', 'since', 'tutorial', 'version', 'package',
+ 'subpackage', 'name', 'global', 'param', 'return', 'staticvar',
+ 'static', 'var', 'throws', 'inheritdoc',
+ );
+
+ $method = $this->getMethod();
+ $methodComment = $method->getDocComment();
+ $classComment = $method->getDeclaringClass()->getDocComment();
+
+ $time = microtime(true);
+ for ($i=0,$c=200; $i<$c; $i++) {
+ $parser = new DocParser();
+ $parser->setImports($imports);
+ $parser->setIgnoredAnnotationNames($ignored);
+ $parser->setIgnoreNotImportedAnnotations(true);
+
+ $parser->parse($methodComment);
+ $parser->parse($classComment);
+ }
+ $time = microtime(true) - $time;
+
+ $this->printResults('doc-parser', $time, $c);
+ }
+
+ /**
+ * @group performance
+ */
+ public function testDocLexerPerformance()
+ {
+ $method = $this->getMethod();
+ $methodComment = $method->getDocComment();
+ $classComment = $method->getDeclaringClass()->getDocComment();
+
+ $time = microtime(true);
+ for ($i=0,$c=500; $i<$c; $i++) {
+ $lexer = new DocLexer();
+ $lexer->setInput($methodComment);
+ $lexer->setInput($classComment);
+ }
+ $time = microtime(true) - $time;
+
+ $this->printResults('doc-lexer', $time, $c);
+ }
+
+ /**
+ * @group performance
+ */
+ public function testPhpParserPerformanceWithShortCut()
+ {
+ $class = new \ReflectionClass('Doctrine\Tests\Common\Annotations\Fixtures\NamespacedSingleClassLOC1000');
+
+ $time = microtime(true);
+ for ($i=0,$c=500; $i<$c; $i++) {
+ $parser = new PhpParser();
+ $parser->parseClass($class);
+ }
+ $time = microtime(true) - $time;
+
+ $this->printResults('doc-parser-with-short-cut', $time, $c);
+ }
+
+ /**
+ * @group performance
+ */
+ public function testPhpParserPerformanceWithoutShortCut()
+ {
+ $class = new \ReflectionClass('SingleClassLOC1000');
+
+ $time = microtime(true);
+ for ($i=0,$c=500; $i<$c; $i++) {
+ $parser = new PhpParser();
+ $parser->parseClass($class);
+ }
+ $time = microtime(true) - $time;
+
+ $this->printResults('doc-parser-without-short-cut', $time, $c);
+ }
+
+ private function getMethod()
+ {
+ return new \ReflectionMethod('Doctrine\Tests\Common\Annotations\Fixtures\Controller', 'helloAction');
+ }
+
+ private function printResults($test, $time, $iterations)
+ {
+ if (0 == $iterations) {
+ throw new \InvalidArgumentException('$iterations cannot be zero.');
+ }
+
+ $title = $test." results:\n";
+ $iterationsText = sprintf("Iterations: %d\n", $iterations);
+ $totalTime = sprintf("Total Time: %.3f s\n", $time);
+ $iterationTime = sprintf("Time per iteration: %.3f ms\n", $time/$iterations * 1000);
+
+ $max = max(strlen($title), strlen($iterationTime)) - 1;
+
+ echo "\n".str_repeat('-', $max)."\n";
+ echo $title;
+ echo str_repeat('=', $max)."\n";
+ echo $iterationsText;
+ echo $totalTime;
+ echo $iterationTime;
+ echo str_repeat('-', $max)."\n";
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/PhpParserTest.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/PhpParserTest.php
new file mode 100644
index 0000000000000000000000000000000000000000..8de4aabf42dc1713b39ccc5825d2f814333d4156
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/PhpParserTest.php
@@ -0,0 +1,179 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations;
+
+use ReflectionClass;
+use Doctrine\Common\Annotations\PhpParser;
+
+require_once __DIR__.'/Fixtures/NonNamespacedClass.php';
+require_once __DIR__.'/Fixtures/GlobalNamespacesPerFileWithClassAsFirst.php';
+require_once __DIR__.'/Fixtures/GlobalNamespacesPerFileWithClassAsLast.php';
+
+class PhpParserTest extends \PHPUnit_Framework_TestCase
+{
+ public function testParseClassWithMultipleClassesInFile()
+ {
+ $class = new ReflectionClass(__NAMESPACE__ . '\Fixtures\MultipleClassesInFile');
+ $parser = new PhpParser();
+
+ $this->assertEquals(array(
+ 'route' => __NAMESPACE__ . '\Fixtures\Annotation\Route',
+ 'secure' => __NAMESPACE__ . '\Fixtures\Annotation\Secure',
+ ), $parser->parseClass($class));
+ }
+
+ public function testParseClassWithMultipleImportsInUseStatement()
+ {
+ $class = new ReflectionClass(__NAMESPACE__ . '\Fixtures\MultipleImportsInUseStatement');
+ $parser = new PhpParser();
+
+ $this->assertEquals(array(
+ 'route' => __NAMESPACE__ . '\Fixtures\Annotation\Route',
+ 'secure' => __NAMESPACE__ . '\Fixtures\Annotation\Secure',
+ ), $parser->parseClass($class));
+ }
+
+ public function testParseClassWhenNotUserDefined()
+ {
+ $parser = new PhpParser();
+ $this->assertEquals(array(), $parser->parseClass(new \ReflectionClass('\stdClass')));
+ }
+
+ public function testParseClassWhenClassIsNotNamespaced()
+ {
+ $parser = new PhpParser();
+ $class = new ReflectionClass('\AnnotationsTestsFixturesNonNamespacedClass');
+
+ $this->assertEquals(array(
+ 'route' => __NAMESPACE__ . '\Fixtures\Annotation\Route',
+ 'template' => __NAMESPACE__ . '\Fixtures\Annotation\Template',
+ ), $parser->parseClass($class));
+ }
+
+ public function testParseClassWhenClassIsInterface()
+ {
+ $parser = new PhpParser();
+ $class = new ReflectionClass(__NAMESPACE__ . '\Fixtures\TestInterface');
+
+ $this->assertEquals(array(
+ 'secure' => __NAMESPACE__ . '\Fixtures\Annotation\Secure',
+ ), $parser->parseClass($class));
+ }
+
+ public function testClassWithFullyQualifiedUseStatements()
+ {
+ $parser = new PhpParser();
+ $class = new ReflectionClass(__NAMESPACE__ . '\Fixtures\ClassWithFullyQualifiedUseStatements');
+
+ $this->assertEquals(array(
+ 'secure' => '\\' . __NAMESPACE__ . '\Fixtures\Annotation\Secure',
+ 'route' => '\\' . __NAMESPACE__ . '\Fixtures\Annotation\Route',
+ 'template' => '\\' . __NAMESPACE__ . '\Fixtures\Annotation\Template',
+ ), $parser->parseClass($class));
+ }
+
+ public function testNamespaceAndClassCommentedOut()
+ {
+ $parser = new PhpParser();
+ $class = new ReflectionClass(__NAMESPACE__ . '\Fixtures\NamespaceAndClassCommentedOut');
+
+ $this->assertEquals(array(
+ 'route' => __NAMESPACE__ . '\Fixtures\Annotation\Route',
+ 'template' => __NAMESPACE__ . '\Fixtures\Annotation\Template',
+ ), $parser->parseClass($class));
+ }
+
+ public function testEqualNamespacesPerFileWithClassAsFirst()
+ {
+ $parser = new PhpParser();
+ $class = new ReflectionClass(__NAMESPACE__ . '\Fixtures\EqualNamespacesPerFileWithClassAsFirst');
+
+ $this->assertEquals(array(
+ 'secure' => __NAMESPACE__ . '\Fixtures\Annotation\Secure',
+ 'route' => __NAMESPACE__ . '\Fixtures\Annotation\Route',
+ ), $parser->parseClass($class));
+ }
+
+ public function testEqualNamespacesPerFileWithClassAsLast()
+ {
+ $parser = new PhpParser();
+ $class = new ReflectionClass(__NAMESPACE__ . '\Fixtures\EqualNamespacesPerFileWithClassAsLast');
+
+ $this->assertEquals(array(
+ 'route' => __NAMESPACE__ . '\Fixtures\Annotation\Route',
+ 'template' => __NAMESPACE__ . '\Fixtures\Annotation\Template',
+ ), $parser->parseClass($class));
+ }
+
+ public function testDifferentNamespacesPerFileWithClassAsFirst()
+ {
+ $parser = new PhpParser();
+ $class = new ReflectionClass(__NAMESPACE__ . '\Fixtures\DifferentNamespacesPerFileWithClassAsFirst');
+
+ $this->assertEquals(array(
+ 'secure' => __NAMESPACE__ . '\Fixtures\Annotation\Secure',
+ ), $parser->parseClass($class));
+ }
+
+ public function testDifferentNamespacesPerFileWithClassAsLast()
+ {
+ $parser = new PhpParser();
+ $class = new ReflectionClass(__NAMESPACE__ . '\Fixtures\DifferentNamespacesPerFileWithClassAsLast');
+
+ $this->assertEquals(array(
+ 'template' => __NAMESPACE__ . '\Fixtures\Annotation\Template',
+ ), $parser->parseClass($class));
+ }
+
+ public function testGlobalNamespacesPerFileWithClassAsFirst()
+ {
+ $parser = new PhpParser();
+ $class = new \ReflectionClass('\GlobalNamespacesPerFileWithClassAsFirst');
+
+ $this->assertEquals(array(
+ 'secure' => __NAMESPACE__ . '\Fixtures\Annotation\Secure',
+ 'route' => __NAMESPACE__ . '\Fixtures\Annotation\Route',
+ ), $parser->parseClass($class));
+ }
+
+ public function testGlobalNamespacesPerFileWithClassAsLast()
+ {
+ $parser = new PhpParser();
+ $class = new ReflectionClass('\GlobalNamespacesPerFileWithClassAsLast');
+
+ $this->assertEquals(array(
+ 'route' => __NAMESPACE__ . '\Fixtures\Annotation\Route',
+ 'template' => __NAMESPACE__ . '\Fixtures\Annotation\Template',
+ ), $parser->parseClass($class));
+ }
+
+ public function testNamespaceWithClosureDeclaration()
+ {
+ $parser = new PhpParser();
+ $class = new ReflectionClass(__NAMESPACE__ . '\Fixtures\NamespaceWithClosureDeclaration');
+
+ $this->assertEquals(array(
+ 'secure' => __NAMESPACE__ . '\Fixtures\Annotation\Secure',
+ 'route' => __NAMESPACE__ . '\Fixtures\Annotation\Route',
+ 'template' => __NAMESPACE__ . '\Fixtures\Annotation\Template',
+ ), $parser->parseClass($class));
+ }
+
+ public function testIfPointerResetsOnMultipleParsingTries()
+ {
+ $parser = new PhpParser();
+ $class = new ReflectionClass(__NAMESPACE__ . '\Fixtures\NamespaceWithClosureDeclaration');
+
+ $this->assertEquals(array(
+ 'secure' => __NAMESPACE__ . '\Fixtures\Annotation\Secure',
+ 'route' => __NAMESPACE__ . '\Fixtures\Annotation\Route',
+ 'template' => __NAMESPACE__ . '\Fixtures\Annotation\Template',
+ ), $parser->parseClass($class));
+
+ $this->assertEquals(array(
+ 'secure' => __NAMESPACE__ . '\Fixtures\Annotation\Secure',
+ 'route' => __NAMESPACE__ . '\Fixtures\Annotation\Route',
+ 'template' => __NAMESPACE__ . '\Fixtures\Annotation\Template',
+ ), $parser->parseClass($class));
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/SimpleAnnotationReaderTest.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/SimpleAnnotationReaderTest.php
new file mode 100644
index 0000000000000000000000000000000000000000..376539ff844285602cbbda113af394e07ef196c8
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/SimpleAnnotationReaderTest.php
@@ -0,0 +1,97 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations;
+
+use Doctrine\Common\Annotations\SimpleAnnotationReader;
+
+class SimpleAnnotationReaderTest extends AbstractReaderTest
+{
+ /**
+ * Contrary to the behavior of the default annotation reader, we do just ignore
+ * these in the simple annotation reader (so, no expected exception here).
+ */
+ public function testImportDetectsNotImportedAnnotation()
+ {
+ parent::testImportDetectsNotImportedAnnotation();
+ }
+
+ /**
+ * Contrary to the behavior of the default annotation reader, we do just ignore
+ * these in the simple annotation reader (so, no expected exception here).
+ */
+ public function testImportDetectsNonExistentAnnotation()
+ {
+ parent::testImportDetectsNonExistentAnnotation();
+ }
+
+ /**
+ * Contrary to the behavior of the default annotation reader, we do just ignore
+ * these in the simple annotation reader (so, no expected exception here).
+ */
+ public function testClassWithInvalidAnnotationTargetAtClassDocBlock()
+ {
+ parent::testClassWithInvalidAnnotationTargetAtClassDocBlock();
+ }
+
+ /**
+ * Contrary to the behavior of the default annotation reader, we do just ignore
+ * these in the simple annotation reader (so, no expected exception here).
+ */
+ public function testClassWithInvalidAnnotationTargetAtPropertyDocBlock()
+ {
+ parent::testClassWithInvalidAnnotationTargetAtPropertyDocBlock();
+ }
+
+ /**
+ * Contrary to the behavior of the default annotation reader, we do just ignore
+ * these in the simple annotation reader (so, no expected exception here).
+ */
+ public function testClassWithInvalidNestedAnnotationTargetAtPropertyDocBlock()
+ {
+ parent::testClassWithInvalidNestedAnnotationTargetAtPropertyDocBlock();
+ }
+
+ /**
+ * Contrary to the behavior of the default annotation reader, we do just ignore
+ * these in the simple annotation reader (so, no expected exception here).
+ */
+ public function testClassWithInvalidAnnotationTargetAtMethodDocBlock()
+ {
+ parent::testClassWithInvalidAnnotationTargetAtMethodDocBlock();
+ }
+
+ /**
+ * @expectedException Doctrine\Common\Annotations\AnnotationException
+ */
+ public function testInvalidAnnotationUsageButIgnoredClass()
+ {
+ parent::testInvalidAnnotationUsageButIgnoredClass();
+ }
+
+ /**
+ * @group DDC-1660
+ * @group regression
+ *
+ * Contrary to the behavior of the default annotation reader, @version is not ignored
+ */
+ public function testInvalidAnnotationButIgnored()
+ {
+ $reader = $this->getReader();
+ $class = new \ReflectionClass('Doctrine\Tests\Common\Annotations\Fixtures\ClassDDC1660');
+
+ $this->assertTrue(class_exists('Doctrine\Tests\Common\Annotations\Fixtures\Annotation\Version'));
+ $this->assertCount(1, $reader->getClassAnnotations($class));
+ $this->assertCount(1, $reader->getMethodAnnotations($class->getMethod('bar')));
+ $this->assertCount(1, $reader->getPropertyAnnotations($class->getProperty('foo')));
+ }
+
+ protected function getReader()
+ {
+ $reader = new SimpleAnnotationReader();
+ $reader->addNamespace(__NAMESPACE__);
+ $reader->addNamespace(__NAMESPACE__ . '\Fixtures');
+ $reader->addNamespace(__NAMESPACE__ . '\Fixtures\Annotation');
+
+ return $reader;
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Ticket/DCOM55Test.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Ticket/DCOM55Test.php
new file mode 100644
index 0000000000000000000000000000000000000000..a7b9e2f2b0c1f00f6d85788449a263286e952b34
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Ticket/DCOM55Test.php
@@ -0,0 +1,65 @@
+<?php
+
+namespace Doctrine\Tests\Common\Annotations\Ticket;
+
+use Doctrine\Tests\Common\Annotations\Fixtures\Controller;
+
+/**
+ * @group
+ */
+class DCOM55Test extends \PHPUnit_Framework_TestCase
+{
+ /**
+ * @expectedException Doctrine\Common\Annotations\AnnotationException
+ * @expectedExceptionMessage [Semantical Error] The class "Doctrine\Tests\Common\Annotations\Fixtures\Controller" is not annotated with @Annotation. Are you sure this class can be used as annotation? If so, then you need to add @Annotation to the _class_ doc comment of "Doctrine\Tests\Common\Annotations\Fixtures\Controller". If it is indeed no annotation, then you need to add @IgnoreAnnotation("Controller") to the _class_ doc comment of class Doctrine\Tests\Common\Annotations\Ticket\Dummy.
+ */
+ public function testIssue()
+ {
+ $class = new \ReflectionClass(__NAMESPACE__ . '\\Dummy');
+ $reader = new \Doctrine\Common\Annotations\AnnotationReader();
+ $reader->getClassAnnotations($class);
+ }
+
+ public function testAnnotation()
+ {
+ $class = new \ReflectionClass(__NAMESPACE__ . '\\DCOM55Consumer');
+ $reader = new \Doctrine\Common\Annotations\AnnotationReader();
+ $annots = $reader->getClassAnnotations($class);
+
+ $this->assertEquals(1, count($annots));
+ $this->assertInstanceOf(__NAMESPACE__.'\\DCOM55Annotation', $annots[0]);
+ }
+
+ public function testParseAnnotationDocblocks()
+ {
+ $class = new \ReflectionClass(__NAMESPACE__ . '\\DCOM55Annotation');
+ $reader = new \Doctrine\Common\Annotations\AnnotationReader();
+ $annots = $reader->getClassAnnotations($class);
+
+ $this->assertEquals(0, count($annots));
+ }
+}
+
+/**
+ * @Controller
+ */
+class Dummy
+{
+
+}
+
+/**
+ * @Annotation
+ */
+class DCOM55Annotation
+{
+
+}
+
+/**
+ * @DCOM55Annotation
+ */
+class DCOM55Consumer
+{
+
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Ticket/DCOM58Entity.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Ticket/DCOM58Entity.php
new file mode 100644
index 0000000000000000000000000000000000000000..708bcc992b05a5ee368cfc6186c35be9ea332b16
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Ticket/DCOM58Entity.php
@@ -0,0 +1,8 @@
+<?php
+// Some class named Entity in the global namespace
+/**
+ * @Annotation
+ */
+class Entity
+{
+}
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Ticket/DCOM58Test.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Ticket/DCOM58Test.php
new file mode 100644
index 0000000000000000000000000000000000000000..f27d17ab6f653a4fcb4efb9a946bb135f9e8f78b
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/Ticket/DCOM58Test.php
@@ -0,0 +1,112 @@
+<?php
+namespace Doctrine\Tests\Common\Annotations\Ticket;
+
+//Some class named Entity in the global namespace
+include __DIR__ .'/DCOM58Entity.php';
+
+/**
+ * @group DCOM58
+ */
+class DCOM58Test extends \PHPUnit_Framework_TestCase
+{
+ public function testIssue()
+ {
+ $reader = new \Doctrine\Common\Annotations\AnnotationReader();
+ $result = $reader->getClassAnnotations(new \ReflectionClass(__NAMESPACE__."\MappedClass"));
+
+ foreach ($result as $annot) {
+ $classAnnotations[get_class($annot)] = $annot;
+ }
+
+ $this->assertTrue(!isset($classAnnotations['']), 'Class "xxx" is not a valid entity or mapped super class.');
+ }
+
+ public function testIssueGlobalNamespace()
+ {
+ $docblock = "@Entity";
+ $parser = new \Doctrine\Common\Annotations\DocParser();
+ $parser->setImports(array(
+ "__NAMESPACE__" =>"Doctrine\Tests\Common\Annotations\Ticket\Doctrine\ORM\Mapping"
+ ));
+
+ $annots = $parser->parse($docblock);
+
+ $this->assertEquals(1, count($annots));
+ $this->assertInstanceOf("Doctrine\Tests\Common\Annotations\Ticket\Doctrine\ORM\Mapping\Entity", $annots[0]);
+ }
+
+ public function testIssueNamespaces()
+ {
+ $docblock = "@Entity";
+ $parser = new \Doctrine\Common\Annotations\DocParser();
+ $parser->addNamespace("Doctrine\Tests\Common\Annotations\Ticket\Doctrine\ORM");
+
+ $annots = $parser->parse($docblock);
+
+ $this->assertEquals(1, count($annots));
+ $this->assertInstanceOf("Doctrine\Tests\Common\Annotations\Ticket\Doctrine\ORM\Entity", $annots[0]);
+ }
+
+ public function testIssueMultipleNamespaces()
+ {
+ $docblock = "@Entity";
+ $parser = new \Doctrine\Common\Annotations\DocParser();
+ $parser->addNamespace("Doctrine\Tests\Common\Annotations\Ticket\Doctrine\ORM\Mapping");
+ $parser->addNamespace("Doctrine\Tests\Common\Annotations\Ticket\Doctrine\ORM");
+
+ $annots = $parser->parse($docblock);
+
+ $this->assertEquals(1, count($annots));
+ $this->assertInstanceOf("Doctrine\Tests\Common\Annotations\Ticket\Doctrine\ORM\Mapping\Entity", $annots[0]);
+ }
+
+ public function testIssueWithNamespacesOrImports()
+ {
+ $docblock = "@Entity";
+ $parser = new \Doctrine\Common\Annotations\DocParser();
+ $annots = $parser->parse($docblock);
+
+ $this->assertEquals(1, count($annots));
+ $this->assertInstanceOf("Entity", $annots[0]);
+ $this->assertEquals(1, count($annots));
+ }
+
+
+ public function testIssueSimpleAnnotationReader()
+ {
+ $reader = new \Doctrine\Common\Annotations\SimpleAnnotationReader();
+ $reader->addNamespace('Doctrine\Tests\Common\Annotations\Ticket\Doctrine\ORM\Mapping');
+ $annots = $reader->getClassAnnotations(new \ReflectionClass(__NAMESPACE__."\MappedClass"));
+
+ $this->assertEquals(1, count($annots));
+ $this->assertInstanceOf("Doctrine\Tests\Common\Annotations\Ticket\Doctrine\ORM\Mapping\Entity", $annots[0]);
+ }
+
+}
+
+/**
+ * @Entity
+ */
+class MappedClass
+{
+
+}
+
+
+namespace Doctrine\Tests\Common\Annotations\Ticket\Doctrine\ORM\Mapping;
+/**
+* @Annotation
+*/
+class Entity
+{
+
+}
+
+namespace Doctrine\Tests\Common\Annotations\Ticket\Doctrine\ORM;
+/**
+* @Annotation
+*/
+class Entity
+{
+
+}
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/TopLevelAnnotation.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/TopLevelAnnotation.php
new file mode 100644
index 0000000000000000000000000000000000000000..ff3ca376bca512974f7caa68f311e638575172ab
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Annotations/TopLevelAnnotation.php
@@ -0,0 +1,8 @@
+<?php
+
+use Doctrine\Common\Annotations\Annotation;
+
+/** @Annotation */
+class TopLevelAnnotation extends Annotation
+{
+}
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Cache/ApcCacheTest.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Cache/ApcCacheTest.php
new file mode 100644
index 0000000000000000000000000000000000000000..df812620103328d5f7a4a986a99b3001e2f6f268
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Cache/ApcCacheTest.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace Doctrine\Tests\Common\Cache;
+
+use Doctrine\Common\Cache\ApcCache;
+
+class ApcCacheTest extends CacheTest
+{
+ public function setUp()
+ {
+ if ( ! extension_loaded('apc') || false === @apc_cache_info()) {
+ $this->markTestSkipped('The ' . __CLASS__ .' requires the use of APC');
+ }
+ }
+
+ protected function _getCacheDriver()
+ {
+ return new ApcCache();
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Cache/ArrayCacheTest.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Cache/ArrayCacheTest.php
new file mode 100644
index 0000000000000000000000000000000000000000..719271747d09a33544c928cf126cbd32cc980015
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Cache/ArrayCacheTest.php
@@ -0,0 +1,13 @@
+<?php
+
+namespace Doctrine\Tests\Common\Cache;
+
+use Doctrine\Common\Cache\ArrayCache;
+
+class ArrayCacheTest extends CacheTest
+{
+ protected function _getCacheDriver()
+ {
+ return new ArrayCache();
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Cache/CacheTest.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Cache/CacheTest.php
new file mode 100644
index 0000000000000000000000000000000000000000..2ae15f2aff537760a535fce03f2553bb651b6448
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Cache/CacheTest.php
@@ -0,0 +1,87 @@
+<?php
+
+namespace Doctrine\Tests\Common\Cache;
+
+use Doctrine\Common\Cache\Cache;
+
+abstract class CacheTest extends \Doctrine\Tests\DoctrineTestCase
+{
+ public function testBasics()
+ {
+ $cache = $this->_getCacheDriver();
+
+ // Test save
+ $cache->save('test_key', 'testing this out');
+
+ // Test contains to test that save() worked
+ $this->assertTrue($cache->contains('test_key'));
+
+ // Test fetch
+ $this->assertEquals('testing this out', $cache->fetch('test_key'));
+
+ // Test delete
+ $cache->save('test_key2', 'test2');
+ $cache->delete('test_key2');
+ $this->assertFalse($cache->contains('test_key2'));
+ }
+
+ public function testDeleteAll()
+ {
+ $cache = $this->_getCacheDriver();
+ $cache->save('test_key1', '1');
+ $cache->save('test_key2', '2');
+ $cache->deleteAll();
+
+ $this->assertFalse($cache->contains('test_key1'));
+ $this->assertFalse($cache->contains('test_key2'));
+ }
+
+ public function testFlushAll()
+ {
+ $cache = $this->_getCacheDriver();
+ $cache->save('test_key1', '1');
+ $cache->save('test_key2', '2');
+ $cache->flushAll();
+
+ $this->assertFalse($cache->contains('test_key1'));
+ $this->assertFalse($cache->contains('test_key2'));
+ }
+
+ public function testNamespace()
+ {
+ $cache = $this->_getCacheDriver();
+ $cache->setNamespace('test_');
+ $cache->save('key1', 'test');
+
+ $this->assertTrue($cache->contains('key1'));
+
+ $cache->setNamespace('test2_');
+
+ $this->assertFalse($cache->contains('key1'));
+ }
+
+ /**
+ * @group DCOM-43
+ */
+ public function testGetStats()
+ {
+ if ($this instanceof ArrayCacheTest || $this instanceof ZendDataCacheTest ) {
+ $this->markTestSkipped("Statistics are not available for this driver");
+ }
+
+ $cache = $this->_getCacheDriver();
+ $stats = $cache->getStats();
+
+
+ $this->assertArrayHasKey(Cache::STATS_HITS, $stats);
+ $this->assertArrayHasKey(Cache::STATS_MISSES, $stats);
+ $this->assertArrayHasKey(Cache::STATS_UPTIME, $stats);
+ $this->assertArrayHasKey(Cache::STATS_MEMORY_USAGE, $stats);
+ $this->assertArrayHasKey(Cache::STATS_MEMORY_AVAILIABLE, $stats);
+ }
+
+ /**
+ * @return \Doctrine\Common\Cache\CacheProvider
+ */
+ abstract protected function _getCacheDriver();
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Cache/MemcacheCacheTest.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Cache/MemcacheCacheTest.php
new file mode 100644
index 0000000000000000000000000000000000000000..362ff69a30ef08daf2f1bf1d785acb7889c4f34f
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Cache/MemcacheCacheTest.php
@@ -0,0 +1,38 @@
+<?php
+
+namespace Doctrine\Tests\Common\Cache;
+
+use Doctrine\Common\Cache\MemcacheCache;
+
+class MemcacheCacheTest extends CacheTest
+{
+ private $_memcache;
+
+ public function setUp()
+ {
+ if (extension_loaded('memcache')) {
+ $this->_memcache = new \Memcache;
+ $ok = @$this->_memcache->connect('localhost', 11211);
+ if (!$ok) {
+ $this->markTestSkipped('The ' . __CLASS__ .' requires the use of memcache');
+ }
+ } else {
+ $this->markTestSkipped('The ' . __CLASS__ .' requires the use of memcache');
+ }
+ }
+
+ public function testNoExpire() {
+ $cache = $this->_getCacheDriver();
+ $cache->save('noexpire', 'value', 0);
+ sleep(1);
+ $this->assertTrue($cache->contains('noexpire'), 'Memcache provider should support no-expire');
+ }
+
+ protected function _getCacheDriver()
+ {
+ $driver = new MemcacheCache();
+ $driver->setMemcache($this->_memcache);
+ return $driver;
+ }
+
+}
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Cache/MemcachedCacheTest.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Cache/MemcachedCacheTest.php
new file mode 100644
index 0000000000000000000000000000000000000000..947ba75265c503a79b6e5403139e92b79607382c
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Cache/MemcachedCacheTest.php
@@ -0,0 +1,40 @@
+<?php
+
+namespace Doctrine\Tests\Common\Cache;
+
+use Doctrine\Common\Cache\MemcachedCache;
+
+class MemcachedCacheTest extends CacheTest
+{
+ private $memcached;
+
+ public function setUp()
+ {
+ if (extension_loaded('memcached')) {
+ $this->memcached = new \Memcached();
+ $this->memcached->setOption(\Memcached::OPT_COMPRESSION, false);
+ $this->memcached->addServer('127.0.0.1', 11211);
+
+ $fh = @fsockopen('127.0.0.1', 11211);
+ if (!$fh) {
+ $this->markTestSkipped('The ' . __CLASS__ .' requires the use of memcache');
+ }
+ } else {
+ $this->markTestSkipped('The ' . __CLASS__ .' requires the use of memcache');
+ }
+ }
+
+ public function testNoExpire() {
+ $cache = $this->_getCacheDriver();
+ $cache->save('noexpire', 'value', 0);
+ sleep(1);
+ $this->assertTrue($cache->contains('noexpire'), 'Memcache provider should support no-expire');
+ }
+
+ protected function _getCacheDriver()
+ {
+ $driver = new MemcachedCache();
+ $driver->setMemcached($this->memcached);
+ return $driver;
+ }
+}
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Cache/WinCacheCacheTest.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Cache/WinCacheCacheTest.php
new file mode 100644
index 0000000000000000000000000000000000000000..cb363df9568b0523ba7fb89c965974545a22efa3
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Cache/WinCacheCacheTest.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace Doctrine\Tests\Common\Cache;
+
+use Doctrine\Common\Cache\WincacheCache;
+
+class WincacheCacheTest extends CacheTest
+{
+ public function setUp()
+ {
+ if ( ! extension_loaded('wincache') || ! function_exists('wincache_ucache_info')) {
+ $this->markTestSkipped('The ' . __CLASS__ .' requires the use of Wincache');
+ }
+ }
+
+ protected function _getCacheDriver()
+ {
+ return new WincacheCache();
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Cache/XcacheCacheTest.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Cache/XcacheCacheTest.php
new file mode 100644
index 0000000000000000000000000000000000000000..6259848776210e31311b04f5900a42cf13461c47
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Cache/XcacheCacheTest.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace Doctrine\Tests\Common\Cache;
+
+use Doctrine\Common\Cache\XcacheCache;
+
+class XcacheCacheTest extends CacheTest
+{
+ public function setUp()
+ {
+ if ( ! extension_loaded('xcache')) {
+ $this->markTestSkipped('The ' . __CLASS__ .' requires the use of xcache');
+ }
+ }
+
+ protected function _getCacheDriver()
+ {
+ return new XcacheCache();
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Cache/ZendDataCacheTest.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Cache/ZendDataCacheTest.php
new file mode 100644
index 0000000000000000000000000000000000000000..27dcf359a0eb883eceba8c1d25a9d88647af484b
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Cache/ZendDataCacheTest.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace Doctrine\Tests\Common\Cache;
+
+use Doctrine\Common\Cache\ZendDataCache;
+
+class ZendDataCacheTest extends CacheTest
+{
+ public function setUp()
+ {
+ if (!function_exists('zend_shm_cache_fetch') || (php_sapi_name() != 'apache2handler')) {
+ $this->markTestSkipped('The ' . __CLASS__ .' requires the use of Zend Data Cache which only works in apache2handler SAPI');
+ }
+ }
+
+ protected function _getCacheDriver()
+ {
+ return new ZendDataCache();
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/ClassLoaderTest.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/ClassLoaderTest.php
new file mode 100644
index 0000000000000000000000000000000000000000..567cf91852ee85a39139f5494ba5b189c5f650d5
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/ClassLoaderTest.php
@@ -0,0 +1,45 @@
+<?php
+
+namespace Doctrine\Tests\Common;
+
+use Doctrine\Common\ClassLoader;
+
+class ClassLoaderTest extends \Doctrine\Tests\DoctrineTestCase
+{
+ public function testClassLoader()
+ {
+ $classLoader = new ClassLoader('ClassLoaderTest');
+ $classLoader->setIncludePath(__DIR__);
+ $classLoader->setFileExtension('.class.php');
+ $classLoader->setNamespaceSeparator('_');
+
+ $this->assertTrue($classLoader->canLoadClass('ClassLoaderTest_ClassA'));
+ $this->assertTrue($classLoader->canLoadClass('ClassLoaderTest_ClassB'));
+ $this->assertTrue($classLoader->canLoadClass('ClassLoaderTest_ClassC'));
+ $this->assertFalse($classLoader->canLoadClass('OtherClass'));
+ $this->assertEquals($classLoader->loadClass('ClassLoaderTest_ClassA'), true);
+ $this->assertEquals($classLoader->loadClass('ClassLoaderTest_ClassB'), true);
+ $this->assertEquals($classLoader->loadClass('ClassLoaderTest_ClassC'), true);
+ }
+
+ public function testClassExists()
+ {
+ $this->assertFalse(ClassLoader::classExists('ClassLoaderTest\ClassD'));
+ $badLoader = function($className) {
+ require __DIR__ . '/ClassLoaderTest/ClassD.php';
+ return true;
+ };
+ spl_autoload_register($badLoader);
+ $this->assertTrue(ClassLoader::classExists('ClassLoaderTest\ClassD'));
+ spl_autoload_unregister($badLoader);
+ }
+
+ public function testGetClassLoader()
+ {
+ $cl = new ClassLoader('ClassLoaderTest', __DIR__);
+ $cl->register();
+ $this->assertTrue(ClassLoader::getClassLoader('ClassLoaderTest\ClassD') instanceof \Doctrine\Common\ClassLoader);
+ $this->assertNull(ClassLoader::getClassLoader('This\Class\Does\Not\Exist'));
+ $cl->unregister();
+ }
+}
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/ClassLoaderTest/ClassA.class.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/ClassLoaderTest/ClassA.class.php
new file mode 100644
index 0000000000000000000000000000000000000000..8554654738b91c9b35595485309be4a42e37bf5b
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/ClassLoaderTest/ClassA.class.php
@@ -0,0 +1,6 @@
+<?php
+
+class ClassLoaderTest_ClassA
+{
+
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/ClassLoaderTest/ClassB.class.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/ClassLoaderTest/ClassB.class.php
new file mode 100644
index 0000000000000000000000000000000000000000..5afcbebafa69666d6b659c6863e6d0c4660268a5
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/ClassLoaderTest/ClassB.class.php
@@ -0,0 +1,6 @@
+<?php
+
+class ClassLoaderTest_ClassB
+{
+
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/ClassLoaderTest/ClassC.class.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/ClassLoaderTest/ClassC.class.php
new file mode 100644
index 0000000000000000000000000000000000000000..0548118d984f241a85688ad35ca944c494e468e0
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/ClassLoaderTest/ClassC.class.php
@@ -0,0 +1,6 @@
+<?php
+
+class ClassLoaderTest_ClassC
+{
+
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/ClassLoaderTest/ClassD.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/ClassLoaderTest/ClassD.php
new file mode 100644
index 0000000000000000000000000000000000000000..06e4e848239fc15cae8053b8a4406d92dbdbedfe
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/ClassLoaderTest/ClassD.php
@@ -0,0 +1,5 @@
+<?php
+
+namespace ClassLoaderTest;
+
+class ClassD {}
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Collections/CollectionTest.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Collections/CollectionTest.php
new file mode 100644
index 0000000000000000000000000000000000000000..8c2bb3c1825ede4e3bd71cc97bbcccd198de6918
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Collections/CollectionTest.php
@@ -0,0 +1,195 @@
+<?php
+
+namespace Doctrine\Tests\Common\Collections;
+
+use Doctrine\Tests;
+
+class CollectionTest extends \Doctrine\Tests\DoctrineTestCase
+{
+ /**
+ * @var \Doctrine\Common\Collections\Collection
+ */
+ private $_coll;
+
+ protected function setUp()
+ {
+ $this->_coll = new \Doctrine\Common\Collections\ArrayCollection;
+ }
+
+ public function testIssetAndUnset()
+ {
+ $this->assertFalse(isset($this->_coll[0]));
+ $this->_coll->add('testing');
+ $this->assertTrue(isset($this->_coll[0]));
+ unset($this->_coll[0]);
+ $this->assertFalse(isset($this->_coll[0]));
+ }
+
+ public function testToString()
+ {
+ $this->_coll->add('testing');
+ $this->assertTrue(is_string((string) $this->_coll));
+ }
+
+ public function testRemovingNonExistentEntryReturnsNull()
+ {
+ $this->assertEquals(null, $this->_coll->remove('testing_does_not_exist'));
+ }
+
+ public function testExists()
+ {
+ $this->_coll->add("one");
+ $this->_coll->add("two");
+ $exists = $this->_coll->exists(function($k, $e) { return $e == "one"; });
+ $this->assertTrue($exists);
+ $exists = $this->_coll->exists(function($k, $e) { return $e == "other"; });
+ $this->assertFalse($exists);
+ }
+
+ public function testMap()
+ {
+ $this->_coll->add(1);
+ $this->_coll->add(2);
+ $res = $this->_coll->map(function($e) { return $e * 2; });
+ $this->assertEquals(array(2, 4), $res->toArray());
+ }
+
+ public function testFilter()
+ {
+ $this->_coll->add(1);
+ $this->_coll->add("foo");
+ $this->_coll->add(3);
+ $res = $this->_coll->filter(function($e) { return is_numeric($e); });
+ $this->assertEquals(array(0 => 1, 2 => 3), $res->toArray());
+ }
+
+ public function testFirstAndLast()
+ {
+ $this->_coll->add('one');
+ $this->_coll->add('two');
+
+ $this->assertEquals($this->_coll->first(), 'one');
+ $this->assertEquals($this->_coll->last(), 'two');
+ }
+
+ public function testArrayAccess()
+ {
+ $this->_coll[] = 'one';
+ $this->_coll[] = 'two';
+
+ $this->assertEquals($this->_coll[0], 'one');
+ $this->assertEquals($this->_coll[1], 'two');
+
+ unset($this->_coll[0]);
+ $this->assertEquals($this->_coll->count(), 1);
+ }
+
+ public function testContainsKey()
+ {
+ $this->_coll[5] = 'five';
+ $this->assertTrue($this->_coll->containsKey(5));
+ }
+
+ public function testContains()
+ {
+ $this->_coll[0] = 'test';
+ $this->assertTrue($this->_coll->contains('test'));
+ }
+
+ public function testSearch()
+ {
+ $this->_coll[0] = 'test';
+ $this->assertEquals(0, $this->_coll->indexOf('test'));
+ }
+
+ public function testGet()
+ {
+ $this->_coll[0] = 'test';
+ $this->assertEquals('test', $this->_coll->get(0));
+ }
+
+ public function testGetKeys()
+ {
+ $this->_coll[] = 'one';
+ $this->_coll[] = 'two';
+ $this->assertEquals(array(0, 1), $this->_coll->getKeys());
+ }
+
+ public function testGetValues()
+ {
+ $this->_coll[] = 'one';
+ $this->_coll[] = 'two';
+ $this->assertEquals(array('one', 'two'), $this->_coll->getValues());
+ }
+
+ public function testCount()
+ {
+ $this->_coll[] = 'one';
+ $this->_coll[] = 'two';
+ $this->assertEquals($this->_coll->count(), 2);
+ $this->assertEquals(count($this->_coll), 2);
+ }
+
+ public function testForAll()
+ {
+ $this->_coll[] = 'one';
+ $this->_coll[] = 'two';
+ $this->assertEquals($this->_coll->forAll(function($k, $e) { return is_string($e); }), true);
+ $this->assertEquals($this->_coll->forAll(function($k, $e) { return is_array($e); }), false);
+ }
+
+ public function testPartition()
+ {
+ $this->_coll[] = true;
+ $this->_coll[] = false;
+ $partition = $this->_coll->partition(function($k, $e) { return $e == true; });
+ $this->assertEquals($partition[0][0], true);
+ $this->assertEquals($partition[1][0], false);
+ }
+
+ public function testClear()
+ {
+ $this->_coll[] = 'one';
+ $this->_coll[] = 'two';
+ $this->_coll->clear();
+ $this->assertEquals($this->_coll->isEmpty(), true);
+ }
+
+ public function testRemove()
+ {
+ $this->_coll[] = 'one';
+ $this->_coll[] = 'two';
+ $el = $this->_coll->remove(0);
+
+ $this->assertEquals('one', $el);
+ $this->assertEquals($this->_coll->contains('one'), false);
+ $this->assertNull($this->_coll->remove(0));
+ }
+
+ public function testRemoveElement()
+ {
+ $this->_coll[] = 'one';
+ $this->_coll[] = 'two';
+
+ $this->assertTrue($this->_coll->removeElement('two'));
+ $this->assertFalse($this->_coll->contains('two'));
+ $this->assertFalse($this->_coll->removeElement('two'));
+ }
+
+ public function testSlice()
+ {
+ $this->_coll[] = 'one';
+ $this->_coll[] = 'two';
+ $this->_coll[] = 'three';
+
+ $slice = $this->_coll->slice(0, 1);
+ $this->assertInternalType('array', $slice);
+ $this->assertEquals(array('one'), $slice);
+
+ $slice = $this->_coll->slice(1);
+ $this->assertEquals(array(1 => 'two', 2 => 'three'), $slice);
+
+ $slice = $this->_coll->slice(1, 1);
+ $this->assertEquals(array(1 => 'two'), $slice);
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/DoctrineExceptionTest.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/DoctrineExceptionTest.php
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/EventManagerTest.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/EventManagerTest.php
new file mode 100644
index 0000000000000000000000000000000000000000..2b11b20e27d5049302dbbcb3bb482cf39d3c10b7
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/EventManagerTest.php
@@ -0,0 +1,88 @@
+<?php
+
+namespace Doctrine\Tests\Common;
+
+use Doctrine\Common\EventManager;
+use Doctrine\Common\EventArgs;
+
+class EventManagerTest extends \Doctrine\Tests\DoctrineTestCase
+{
+ /* Some pseudo events */
+ const preFoo = 'preFoo';
+ const postFoo = 'postFoo';
+ const preBar = 'preBar';
+ const postBar = 'postBar';
+
+ private $_preFooInvoked = false;
+ private $_postFooInvoked = false;
+
+ private $_eventManager;
+
+ protected function setUp()
+ {
+ $this->_eventManager = new EventManager;
+ $this->_preFooInvoked = false;
+ $this->_postFooInvoked = false;
+ }
+
+ public function testInitialState()
+ {
+ $this->assertEquals(array(), $this->_eventManager->getListeners());
+ $this->assertFalse($this->_eventManager->hasListeners(self::preFoo));
+ $this->assertFalse($this->_eventManager->hasListeners(self::postFoo));
+ }
+
+ public function testAddEventListener()
+ {
+ $this->_eventManager->addEventListener(array('preFoo', 'postFoo'), $this);
+ $this->assertTrue($this->_eventManager->hasListeners(self::preFoo));
+ $this->assertTrue($this->_eventManager->hasListeners(self::postFoo));
+ $this->assertEquals(1, count($this->_eventManager->getListeners(self::preFoo)));
+ $this->assertEquals(1, count($this->_eventManager->getListeners(self::postFoo)));
+ $this->assertEquals(2, count($this->_eventManager->getListeners()));
+ }
+
+ public function testDispatchEvent()
+ {
+ $this->_eventManager->addEventListener(array('preFoo', 'postFoo'), $this);
+ $this->_eventManager->dispatchEvent(self::preFoo);
+ $this->assertTrue($this->_preFooInvoked);
+ $this->assertFalse($this->_postFooInvoked);
+ }
+
+ public function testRemoveEventListener()
+ {
+ $this->_eventManager->addEventListener(array('preBar'), $this);
+ $this->assertTrue($this->_eventManager->hasListeners(self::preBar));
+ $this->_eventManager->removeEventListener(array('preBar'), $this);
+ $this->assertFalse($this->_eventManager->hasListeners(self::preBar));
+ }
+
+ public function testAddEventSubscriber()
+ {
+ $eventSubscriber = new TestEventSubscriber();
+ $this->_eventManager->addEventSubscriber($eventSubscriber);
+ $this->assertTrue($this->_eventManager->hasListeners(self::preFoo));
+ $this->assertTrue($this->_eventManager->hasListeners(self::postFoo));
+ }
+
+ /* Listener methods */
+
+ public function preFoo(EventArgs $e)
+ {
+ $this->_preFooInvoked = true;
+ }
+
+ public function postFoo(EventArgs $e)
+ {
+ $this->_postFooInvoked = true;
+ }
+}
+
+class TestEventSubscriber implements \Doctrine\Common\EventSubscriber
+{
+ public function getSubscribedEvents()
+ {
+ return array('preFoo', 'postFoo');
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/Mapping/ChainDriverTest.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/Mapping/ChainDriverTest.php
new file mode 100644
index 0000000000000000000000000000000000000000..e1825ae2b591356cd1ef6772108332720f369be8
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/Mapping/ChainDriverTest.php
@@ -0,0 +1,94 @@
+<?php
+
+namespace Doctrine\Tests\Common\Persistence\Mapping;
+
+use Doctrine\Common\Persistence\Mapping\Driver\MappingDriverChain;
+use Doctrine\Tests\DoctrineTestCase;
+
+class DriverChainTest extends DoctrineTestCase
+{
+ public function testDelegateToMatchingNamespaceDriver()
+ {
+ $className = 'Doctrine\Tests\Common\Persistence\Mapping\DriverChainEntity';
+ $classMetadata = $this->getMock('Doctrine\Common\Persistence\Mapping\ClassMetadata');
+
+ $chain = new MappingDriverChain();
+
+ $driver1 = $this->getMock('Doctrine\Common\Persistence\Mapping\Driver\MappingDriver');
+ $driver1->expects($this->never())
+ ->method('loadMetadataForClass');
+ $driver1->expectS($this->never())
+ ->method('isTransient');
+
+ $driver2 = $this->getMock('Doctrine\Common\Persistence\Mapping\Driver\MappingDriver');
+ $driver2->expects($this->at(0))
+ ->method('loadMetadataForClass')
+ ->with($this->equalTo($className), $this->equalTo($classMetadata));
+ $driver2->expects($this->at(1))
+ ->method('isTransient')
+ ->with($this->equalTo($className))
+ ->will($this->returnValue( true ));
+
+ $chain->addDriver($driver1, 'Doctrine\Tests\Models\Company');
+ $chain->addDriver($driver2, 'Doctrine\Tests\Common\Persistence\Mapping');
+
+ $chain->loadMetadataForClass($className, $classMetadata);
+
+ $this->assertTrue( $chain->isTransient($className) );
+ }
+
+ public function testLoadMetadata_NoDelegatorFound_ThrowsMappingException()
+ {
+ $className = 'Doctrine\Tests\Common\Persistence\Mapping\DriverChainEntity';
+ $classMetadata = $this->getMock('Doctrine\Common\Persistence\Mapping\ClassMetadata');
+
+ $chain = new MappingDriverChain();
+
+ $this->setExpectedException('Doctrine\Common\Persistence\Mapping\MappingException');
+ $chain->loadMetadataForClass($className, $classMetadata);
+ }
+
+ public function testGatherAllClassNames()
+ {
+ $className = 'Doctrine\Tests\Common\Persistence\Mapping\DriverChainEntity';
+ $classMetadata = $this->getMock('Doctrine\Common\Peristence\ClassMetadata');
+
+ $chain = new MappingDriverChain();
+
+ $driver1 = $this->getMock('Doctrine\Common\Persistence\Mapping\Driver\MappingDriver');
+ $driver1->expects($this->once())
+ ->method('getAllClassNames')
+ ->will($this->returnValue(array('Doctrine\Tests\Models\Company\Foo')));
+
+ $driver2 = $this->getMock('Doctrine\Common\Persistence\Mapping\Driver\MappingDriver');
+ $driver2->expects($this->once())
+ ->method('getAllClassNames')
+ ->will($this->returnValue(array('Doctrine\Tests\ORM\Mapping\Bar', 'Doctrine\Tests\ORM\Mapping\Baz', 'FooBarBaz')));
+
+ $chain->addDriver($driver1, 'Doctrine\Tests\Models\Company');
+ $chain->addDriver($driver2, 'Doctrine\Tests\ORM\Mapping');
+
+ $this->assertEquals(array(
+ 'Doctrine\Tests\Models\Company\Foo',
+ 'Doctrine\Tests\ORM\Mapping\Bar',
+ 'Doctrine\Tests\ORM\Mapping\Baz'
+ ), $chain->getAllClassNames());
+ }
+
+ /**
+ * @group DDC-706
+ */
+ public function testIsTransient()
+ {
+ $driver1 = $this->getMock('Doctrine\Common\Persistence\Mapping\Driver\MappingDriver');
+ $chain = new MappingDriverChain();
+ $chain->addDriver($driver1, 'Doctrine\Tests\Models\CMS');
+
+ $this->assertTrue($chain->isTransient('stdClass'), "stdClass isTransient");
+ }
+}
+
+class DriverChainEntity
+{
+
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/Mapping/ClassMetadataFactoryTest.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/Mapping/ClassMetadataFactoryTest.php
new file mode 100644
index 0000000000000000000000000000000000000000..9fe329944cf1dd0461b5199b28432c47849635a9
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/Mapping/ClassMetadataFactoryTest.php
@@ -0,0 +1,134 @@
+<?php
+
+namespace Doctrine\Tests\Common\Persistence\Mapping;
+
+use Doctrine\Tests\DoctrineTestCase;
+use Doctrine\Common\Persistence\Mapping\Driver\DefaultFileLocator;
+use Doctrine\Common\Persistence\Mapping\ReflectionService;
+use Doctrine\Common\Persistence\Mapping\ClassMetadata;
+use Doctrine\Common\Persistence\Mapping\AbstractClassMetadataFactory;
+use Doctrine\Common\Cache\ArrayCache;
+
+class ClassMetadataFactoryTest extends DoctrineTestCase
+{
+ /**
+ * @var TestClassMetadataFactory
+ */
+ private $cmf;
+
+ public function setUp()
+ {
+ $driver = $this->getMock('Doctrine\Common\Persistence\Mapping\Driver\MappingDriver');
+ $metadata = $this->getMock('Doctrine\Common\Persistence\Mapping\ClassMetadata');
+ $this->cmf = new TestClassMetadataFactory($driver, $metadata);
+ }
+
+ public function testGetCacheDriver()
+ {
+ $this->assertNull($this->cmf->getCacheDriver());
+ $cache = new ArrayCache();
+ $this->cmf->setCacheDriver($cache);
+ $this->assertSame($cache, $this->cmf->getCacheDriver());
+ }
+
+ public function testGetMetadataFor()
+ {
+ $metadata = $this->cmf->getMetadataFor('stdClass');
+
+ $this->assertInstanceOf('Doctrine\Common\Persistence\Mapping\ClassMetadata', $metadata);
+ $this->assertTrue($this->cmf->hasMetadataFor('stdClass'));
+ }
+
+ public function testGetParentMetadata()
+ {
+ $metadata = $this->cmf->getMetadataFor(__NAMESPACE__ . '\ChildEntity');
+
+ $this->assertInstanceOf('Doctrine\Common\Persistence\Mapping\ClassMetadata', $metadata);
+ $this->assertTrue($this->cmf->hasMetadataFor(__NAMESPACE__ . '\ChildEntity'));
+ $this->assertTrue($this->cmf->hasMetadataFor(__NAMESPACE__ . '\RootEntity'));
+ }
+
+ public function testGetCachedMetadata()
+ {
+ $metadata = $this->getMock('Doctrine\Common\Persistence\Mapping\ClassMetadata');
+ $cache = new ArrayCache();
+ $cache->save(__NAMESPACE__. '\ChildEntity$CLASSMETADATA', $metadata);
+
+ $this->cmf->setCacheDriver($cache);
+
+ $loadedMetadata = $this->cmf->getMetadataFor(__NAMESPACE__ . '\ChildEntity');
+ $this->assertSame($loadedMetadata, $metadata);
+ }
+
+ public function testCacheGetMetadataFor()
+ {
+ $cache = new ArrayCache();
+ $this->cmf->setCacheDriver($cache);
+
+ $loadedMetadata = $this->cmf->getMetadataFor(__NAMESPACE__ . '\ChildEntity');
+
+ $this->assertSame($loadedMetadata, $cache->fetch(__NAMESPACE__. '\ChildEntity$CLASSMETADATA'));
+ }
+
+ public function testGetAliasedMetadata()
+ {
+ $loadedMetadata = $this->cmf->getMetadataFor('prefix:ChildEntity');
+
+ $this->assertTrue($this->cmf->hasMetadataFor(__NAMESPACE__ . '\ChildEntity'));
+ $this->assertTrue($this->cmf->hasMetadataFor('prefix:ChildEntity'));
+ }
+}
+
+class TestClassMetadataFactory extends AbstractClassMetadataFactory
+{
+ public $driver;
+ public $metadata;
+
+ public function __construct($driver, $metadata)
+ {
+ $this->driver = $driver;
+ $this->metadata = $metadata;
+ }
+
+ protected function doLoadMetadata($class, $parent, $rootEntityFound)
+ {
+
+ }
+
+ protected function getFqcnFromAlias($namespaceAlias, $simpleClassName)
+ {
+ return __NAMESPACE__ . '\\' . $simpleClassName;
+ }
+
+ protected function initialize()
+ {
+
+ }
+
+ protected function newClassMetadataInstance($className)
+ {
+ return $this->metadata;
+ }
+
+ protected function getDriver()
+ {
+ return $this->driver;
+ }
+ protected function wakeupReflection(ClassMetadata $class, ReflectionService $reflService)
+ {
+ }
+
+ protected function initializeReflection(ClassMetadata $class, ReflectionService $reflService)
+ {
+ }
+}
+
+class RootEntity
+{
+
+}
+
+class ChildEntity extends RootEntity
+{
+
+}
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/Mapping/DefaultFileLocatorTest.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/Mapping/DefaultFileLocatorTest.php
new file mode 100644
index 0000000000000000000000000000000000000000..3c600c406a241ce27676673844dad6fb2e92fb46
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/Mapping/DefaultFileLocatorTest.php
@@ -0,0 +1,90 @@
+<?php
+
+namespace Doctrine\Tests\Common\Persistence\Mapping;
+
+use Doctrine\Tests\DoctrineTestCase;
+use Doctrine\Common\Persistence\Mapping\Driver\DefaultFileLocator;
+
+class DefaultFileLocatorTest extends DoctrineTestCase
+{
+ public function testGetPaths()
+ {
+ $path = __DIR__ . "/_files";
+
+ $locator = new DefaultFileLocator(array($path));
+ $this->assertEquals(array($path), $locator->getPaths());
+
+ $locator = new DefaultFileLocator($path);
+ $this->assertEquals(array($path), $locator->getPaths());
+ }
+
+ public function testGetFileExtension()
+ {
+ $locator = new DefaultFileLocator(array(), ".yml");
+ $this->assertEquals(".yml", $locator->getFileExtension());
+ $locator->setFileExtension(".xml");
+ $this->assertEquals(".xml", $locator->getFileExtension());
+ }
+
+ public function testUniquePaths()
+ {
+ $path = __DIR__ . "/_files";
+
+ $locator = new DefaultFileLocator(array($path, $path));
+ $this->assertEquals(array($path), $locator->getPaths());
+ }
+
+ public function testFindMappingFile()
+ {
+ $path = __DIR__ . "/_files";
+
+ $locator = new DefaultFileLocator(array($path), ".yml");
+
+ $this->assertEquals(__DIR__ . '/_files/stdClass.yml', $locator->findMappingFile('stdClass'));
+ }
+
+ public function testFindMappingFileNotFound()
+ {
+ $path = __DIR__ . "/_files";
+
+ $locator = new DefaultFileLocator(array($path), ".yml");
+
+ $this->setExpectedException(
+ 'Doctrine\Common\Persistence\Mapping\MappingException',
+ "No mapping file found named 'stdClass2.yml' for class 'stdClass2'"
+ );
+ $locator->findMappingFile('stdClass2');
+ }
+
+ public function testGetAllClassNames()
+ {
+ $path = __DIR__ . "/_files";
+
+ $locator = new DefaultFileLocator(array($path), ".yml");
+ $classes = $locator->getAllClassNames(null);
+ sort($classes);
+
+ $this->assertEquals(array('global', 'stdClass'), $classes);
+ $this->assertEquals(array('stdClass'), $locator->getAllClassNames("global"));
+ }
+
+ public function testGetAllClassNamesNonMatchingFileExtension()
+ {
+ $path = __DIR__ . "/_files";
+
+ $locator = new DefaultFileLocator(array($path), ".xml");
+ $this->assertEquals(array(), $locator->getAllClassNames("global"));
+ }
+
+ public function testFileExists()
+ {
+ $path = __DIR__ . "/_files";
+
+ $locator = new DefaultFileLocator(array($path), ".yml");
+
+ $this->assertTrue($locator->fileExists("stdClass"));
+ $this->assertFalse($locator->fileExists("stdClass2"));
+ $this->assertTrue($locator->fileExists("global"));
+ $this->assertFalse($locator->fileExists("global2"));
+ }
+}
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/Mapping/FileDriverTest.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/Mapping/FileDriverTest.php
new file mode 100644
index 0000000000000000000000000000000000000000..020c24247419f03a21730c894ccd8df8e8f79ea2
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/Mapping/FileDriverTest.php
@@ -0,0 +1,142 @@
+<?php
+
+namespace Doctrine\Tests\Common\Persistence\Mapping;
+
+use Doctrine\Tests\DoctrineTestCase;
+use Doctrine\Common\Persistence\Mapping\Driver\FileDriver;
+use Doctrine\Common\Persistence\Mapping\ClassMetadata;
+
+class FileDriverTest extends DoctrineTestCase
+{
+ public function testGlobalBasename()
+ {
+ $driver = new TestFileDriver(array());
+
+ $this->assertNull($driver->getGlobalBasename());
+
+ $driver->setGlobalBasename("global");
+ $this->assertEquals("global", $driver->getGlobalBasename());
+ }
+
+ public function testGetElementFromGlobalFile()
+ {
+ $driver = new TestFileDriver($this->newLocator());
+ $driver->setGlobalBasename("global");
+
+ $element = $driver->getElement('stdGlobal');
+
+ $this->assertEquals('stdGlobal', $element);
+ }
+
+ public function testGetElementFromFile()
+ {
+ $locator = $this->newLocator();
+ $locator->expects($this->once())
+ ->method('findMappingFile')
+ ->with($this->equalTo('stdClass'))
+ ->will($this->returnValue(__DIR__ . '/_files/stdClass.yml'));
+
+ $driver = new TestFileDriver($locator);
+
+ $this->assertEquals('stdClass', $driver->getElement('stdClass'));
+ }
+
+ public function testGetAllClassNamesGlobalBasename()
+ {
+ $driver = new TestFileDriver($this->newLocator());
+ $driver->setGlobalBasename("global");
+
+ $classNames = $driver->getAllClassNames();
+
+ $this->assertEquals(array('stdGlobal', 'stdGlobal2'), $classNames);
+ }
+
+ public function testGetAllClassNamesFromMappingFile()
+ {
+ $locator = $this->newLocator();
+ $locator->expects($this->any())
+ ->method('getAllClassNames')
+ ->with($this->equalTo(null))
+ ->will($this->returnValue(array('stdClass')));
+ $driver = new TestFileDriver($locator);
+
+ $classNames = $driver->getAllClassNames();
+
+ $this->assertEquals(array('stdClass'), $classNames);
+ }
+
+ public function testGetAllClassNamesBothSources()
+ {
+ $locator = $this->newLocator();
+ $locator->expects($this->any())
+ ->method('getAllClassNames')
+ ->with($this->equalTo('global'))
+ ->will($this->returnValue(array('stdClass')));
+ $driver = new TestFileDriver($locator);
+ $driver->setGlobalBasename("global");
+
+ $classNames = $driver->getAllClassNames();
+
+ $this->assertEquals(array('stdGlobal', 'stdGlobal2', 'stdClass'), $classNames);
+ }
+
+ public function testIsNotTransient()
+ {
+ $locator = $this->newLocator();
+ $locator->expects($this->once())
+ ->method('fileExists')
+ ->with($this->equalTo('stdClass'))
+ ->will($this->returnValue( true ));
+
+ $driver = new TestFileDriver($locator);
+ $driver->setGlobalBasename("global");
+
+ $this->assertFalse($driver->isTransient('stdClass'));
+ $this->assertFalse($driver->isTransient('stdGlobal'));
+ $this->assertFalse($driver->isTransient('stdGlobal2'));
+ }
+
+ public function testIsTransient()
+ {
+ $locator = $this->newLocator();
+ $locator->expects($this->once())
+ ->method('fileExists')
+ ->with($this->equalTo('stdClass2'))
+ ->will($this->returnValue( false ));
+
+ $driver = new TestFileDriver($locator);
+
+ $this->assertTrue($driver->isTransient('stdClass2'));
+ }
+
+ public function testNonLocatorFallback()
+ {
+ $driver = new TestFileDriver(__DIR__ . '/_files', '.yml');
+ $this->assertTrue($driver->isTransient('stdClass2'));
+ $this->assertFalse($driver->isTransient('stdClass'));
+ }
+
+ private function newLocator()
+ {
+ $locator = $this->getMock('Doctrine\Common\Persistence\Mapping\Driver\FileLocator');
+ $locator->expects($this->any())->method('getFileExtension')->will($this->returnValue('.yml'));
+ $locator->expects($this->any())->method('getPaths')->will($this->returnValue(array(__DIR__ . "/_files")));
+ return $locator;
+ }
+}
+
+class TestFileDriver extends FileDriver
+{
+ protected function loadMappingFile($file)
+ {
+ if (strpos($file, "global.yml") !== false) {
+ return array('stdGlobal' => 'stdGlobal', 'stdGlobal2' => 'stdGlobal2');
+ }
+ return array('stdClass' => 'stdClass');
+ }
+
+ public function loadMetadataForClass($className, ClassMetadata $metadata)
+ {
+
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/Mapping/PHPDriverTest.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/Mapping/PHPDriverTest.php
new file mode 100644
index 0000000000000000000000000000000000000000..8fc4d80711b99123188119bb89bca6a9c325925b
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/Mapping/PHPDriverTest.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace Doctrine\Tests\Common\Persistence\Mapping;
+
+use Doctrine\Tests\DoctrineTestCase;
+use Doctrine\Common\Persistence\Mapping\Driver\PHPDriver;
+
+class PHPDriverTest extends DoctrineTestCase
+{
+ public function testLoadMetadata()
+ {
+ $metadata = $this->getMock('Doctrine\Common\Persistence\Mapping\ClassMetadata');
+ $metadata->expects($this->once())->method('getFieldNames');
+
+ $driver = new PHPDriver(array(__DIR__ . "/_files"));
+ $driver->loadMetadataForClass('TestEntity', $metadata);
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/Mapping/RuntimeReflectionServiceTest.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/Mapping/RuntimeReflectionServiceTest.php
new file mode 100644
index 0000000000000000000000000000000000000000..5f06cad984a592a757086a33071dbb319c5cf336
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/Mapping/RuntimeReflectionServiceTest.php
@@ -0,0 +1,70 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Tests\Common\Persistence\Mapping;
+
+use Doctrine\Common\Persistence\Mapping\RuntimeReflectionService;
+
+/**
+ * @group DCOM-93
+ */
+class RuntimeReflectionServiceTest extends \PHPUnit_Framework_TestCase
+{
+ private $reflectionService;
+
+ public function setUp()
+ {
+ $this->reflectionService = new RuntimeReflectionService();
+ }
+
+ public function testShortname()
+ {
+ $this->assertEquals("RuntimeReflectionServiceTest", $this->reflectionService->getClassShortName(__CLASS__));
+ }
+
+ public function testClassNamespaceName()
+ {
+ $this->assertEquals("Doctrine\Tests\Common\Persistence\Mapping", $this->reflectionService->getClassNamespace(__CLASS__));
+ }
+
+ public function testGetParentClasses()
+ {
+ $classes = $this->reflectionService->getParentClasses(__CLASS__);
+ $this->assertTrue(count($classes) >= 1, "The test class ".__CLASS__." should have at least one parent.");
+ }
+
+ public function testGetReflectionClass()
+ {
+ $class = $this->reflectionService->getClass(__CLASS__);
+ $this->assertInstanceOf("ReflectionClass", $class);
+ }
+
+ public function testGetMethods()
+ {
+ $this->assertTrue($this->reflectionService->hasPublicMethod(__CLASS__, "testGetMethods"));
+ $this->assertFalse($this->reflectionService->hasPublicMethod(__CLASS__, "testGetMethods2"));
+ }
+
+ public function testGetAccessibleProperty()
+ {
+ $reflProp = $this->reflectionService->getAccessibleProperty(__CLASS__, "reflectionService");
+ $this->assertInstanceOf("ReflectionProperty", $reflProp);
+ }
+}
+
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/Mapping/StaticPHPDriverTest.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/Mapping/StaticPHPDriverTest.php
new file mode 100644
index 0000000000000000000000000000000000000000..9f1c5684e734ca8306e85233b58a32856f59d873
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/Mapping/StaticPHPDriverTest.php
@@ -0,0 +1,35 @@
+<?php
+
+namespace Doctrine\Tests\Common\Persistence\Mapping;
+
+use Doctrine\Tests\DoctrineTestCase;
+use Doctrine\Common\Persistence\Mapping\Driver\StaticPHPDriver;
+
+class StaticPHPDriverTest extends DoctrineTestCase
+{
+ public function testLoadMetadata()
+ {
+ $metadata = $this->getMock('Doctrine\Common\Persistence\Mapping\ClassMetadata');
+ $metadata->expects($this->once())->method('getFieldNames');
+
+ $driver = new StaticPHPDriver(array(__DIR__));
+ $driver->loadMetadataForClass(__NAMESPACE__ . '\\TestEntity', $metadata);
+ }
+
+ public function testGetAllClassNames()
+ {
+ $driver = new StaticPHPDriver(array(__DIR__));
+ $classNames = $driver->getAllClassNames();
+
+ $this->assertContains(
+ 'Doctrine\Tests\Common\Persistence\Mapping\TestEntity', $classNames);
+ }
+}
+
+class TestEntity
+{
+ static public function loadMetadata($metadata)
+ {
+ $metadata->getFieldNames();
+ }
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/Mapping/StaticReflectionServiceTest.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/Mapping/StaticReflectionServiceTest.php
new file mode 100644
index 0000000000000000000000000000000000000000..ffce6d40a1ae81f9c51a3337b03e45f9c77a49b5
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/Mapping/StaticReflectionServiceTest.php
@@ -0,0 +1,70 @@
+<?php
+/*
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Tests\Common\Persistence\Mapping;
+
+use Doctrine\Common\Persistence\Mapping\StaticReflectionService;
+
+/**
+ * @group DCOM-93
+ */
+class StaticReflectionServiceTest extends \PHPUnit_Framework_TestCase
+{
+ private $reflectionService;
+
+ public function setUp()
+ {
+ $this->reflectionService = new StaticReflectionService();
+ }
+
+ public function testShortname()
+ {
+ $this->assertEquals("StaticReflectionServiceTest", $this->reflectionService->getClassShortName(__CLASS__));
+ }
+
+ public function testClassNamespaceName()
+ {
+ $this->assertEquals("Doctrine\Tests\Common\Persistence\Mapping", $this->reflectionService->getClassNamespace(__CLASS__));
+ }
+
+ public function testGetParentClasses()
+ {
+ $classes = $this->reflectionService->getParentClasses(__CLASS__);
+ $this->assertTrue(count($classes) == 0, "The test class ".__CLASS__." should have no parents according to static reflection.");
+ }
+
+ public function testGetReflectionClass()
+ {
+ $class = $this->reflectionService->getClass(__CLASS__);
+ $this->assertNull($class);
+ }
+
+ public function testGetMethods()
+ {
+ $this->assertTrue($this->reflectionService->hasPublicMethod(__CLASS__, "testGetMethods"));
+ $this->assertFalse($this->reflectionService->hasPublicMethod(__CLASS__, "testGetMethods2"));
+ }
+
+ public function testGetAccessibleProperty()
+ {
+ $reflProp = $this->reflectionService->getAccessibleProperty(__CLASS__, "reflectionService");
+ $this->assertNull($reflProp);
+ }
+}
+
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/Mapping/SymfonyFileLocatorTest.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/Mapping/SymfonyFileLocatorTest.php
new file mode 100644
index 0000000000000000000000000000000000000000..b51162e6886aa27d8cac9f3d3e3888cdabca7d7b
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/Mapping/SymfonyFileLocatorTest.php
@@ -0,0 +1,88 @@
+<?php
+
+namespace Doctrine\Tests\Common\Persistence\Mapping;
+
+use Doctrine\Tests\DoctrineTestCase;
+use Doctrine\Common\Persistence\Mapping\Driver\SymfonyFileLocator;
+
+class SymfonyFileLocatorTest extends DoctrineTestCase
+{
+ public function testGetPaths()
+ {
+ $path = __DIR__ . "/_files";
+ $prefix = "Foo";
+
+ $locator = new SymfonyFileLocator(array($path => $prefix));
+ $this->assertEquals(array($path), $locator->getPaths());
+
+ $locator = new SymfonyFileLocator(array($path => $prefix));
+ $this->assertEquals(array($path), $locator->getPaths());
+ }
+
+ public function testGetPrefixes()
+ {
+ $path = __DIR__ . "/_files";
+ $prefix = "Foo";
+
+ $locator = new SymfonyFileLocator(array($path => $prefix));
+ $this->assertEquals(array($path => $prefix), $locator->getNamespacePrefixes());
+ }
+
+ public function testGetFileExtension()
+ {
+ $locator = new SymfonyFileLocator(array(), ".yml");
+ $this->assertEquals(".yml", $locator->getFileExtension());
+ $locator->setFileExtension(".xml");
+ $this->assertEquals(".xml", $locator->getFileExtension());
+ }
+
+ public function testFileExists()
+ {
+ $path = __DIR__ . "/_files";
+ $prefix = "Foo";
+
+ $locator = new SymfonyFileLocator(array($path => $prefix), ".yml");
+
+ $this->assertTrue($locator->fileExists("Foo\stdClass"));
+ $this->assertTrue($locator->fileExists("Foo\global"));
+ $this->assertFalse($locator->fileExists("Foo\stdClass2"));
+ $this->assertFalse($locator->fileExists("Foo\global2"));
+ }
+
+ public function testGetAllClassNames()
+ {
+ $path = __DIR__ . "/_files";
+ $prefix = "Foo";
+
+ $locator = new SymfonyFileLocator(array($path => $prefix), ".yml");
+ $classes = $locator->getAllClassNames(null);
+ sort($classes);
+
+ $this->assertEquals(array("Foo\\global", "Foo\\stdClass"), $classes);
+ $this->assertEquals(array("Foo\\stdClass"), $locator->getAllClassNames("global"));
+ }
+
+ public function testFindMappingFile()
+ {
+ $path = __DIR__ . "/_files";
+ $prefix = "Foo";
+
+ $locator = new SymfonyFileLocator(array($path => $prefix), ".yml");
+
+ $this->assertEquals(__DIR__ . "/_files/stdClass.yml", $locator->findMappingFile("Foo\\stdClass"));
+ }
+
+ public function testFindMappingFileNotFound()
+ {
+ $path = __DIR__ . "/_files";
+ $prefix = "Foo";
+
+ $locator = new SymfonyFileLocator(array($path => $prefix), ".yml");
+
+ $this->setExpectedException(
+ "Doctrine\Common\Persistence\Mapping\MappingException",
+ "No mapping file found named '".__DIR__."/_files/stdClass2.yml' for class 'Foo\stdClass2'."
+ );
+ $locator->findMappingFile("Foo\\stdClass2");
+ }
+}
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/Mapping/_files/TestEntity.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/Mapping/_files/TestEntity.php
new file mode 100644
index 0000000000000000000000000000000000000000..d0e9976ae5b110d675f2622187418d26bf336d6a
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/Mapping/_files/TestEntity.php
@@ -0,0 +1,3 @@
+<?php
+
+$metadata->getFieldNames();
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/Mapping/_files/global.yml b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/Mapping/_files/global.yml
new file mode 100644
index 0000000000000000000000000000000000000000..30d74d258442c7c65512eafab474568dd706c430
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/Mapping/_files/global.yml
@@ -0,0 +1 @@
+test
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/Mapping/_files/stdClass.yml b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/Mapping/_files/stdClass.yml
new file mode 100644
index 0000000000000000000000000000000000000000..30d74d258442c7c65512eafab474568dd706c430
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/Mapping/_files/stdClass.yml
@@ -0,0 +1 @@
+test
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/PersistentObjectTest.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/PersistentObjectTest.php
new file mode 100644
index 0000000000000000000000000000000000000000..a0f77b5068ddf9e5643b91e37f401066acb23f20
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Persistence/PersistentObjectTest.php
@@ -0,0 +1,247 @@
+<?php
+
+namespace Doctrine\Tests\Common\Persistence;
+
+use Doctrine\Common\Persistence\PersistentObject;
+use Doctrine\Common\Persistence\Mapping\ClassMetadata;
+use Doctrine\Common\Persistence\Mapping\ReflectionService;
+
+/**
+ * @group DDC-1448
+ */
+class PersistentObjectTest extends \Doctrine\Tests\DoctrineTestCase
+{
+ private $cm;
+ private $om;
+ private $object;
+
+ public function setUp()
+ {
+ $this->cm = new TestObjectMetadata;
+ $this->om = $this->getMock('Doctrine\Common\Persistence\ObjectManager');
+ $this->om->expects($this->any())->method('getClassMetadata')
+ ->will($this->returnValue($this->cm));
+ $this->object = new TestObject;
+ PersistentObject::setObjectManager($this->om);
+ $this->object->injectObjectManager($this->om, $this->cm);
+ }
+
+ public function testGetObjectManager()
+ {
+ $this->assertSame($this->om, PersistentObject::getObjectManager());
+ }
+
+ public function testNonMatchingObjectManager()
+ {
+ $this->setExpectedException('RuntimeException');
+ $om = $this->getMock('Doctrine\Common\Persistence\ObjectManager');
+ $this->object->injectObjectManager($om, $this->cm);
+ }
+
+ public function testGetField()
+ {
+ $this->assertEquals('beberlei', $this->object->getName());
+ }
+
+ public function testSetField()
+ {
+ $this->object->setName("test");
+ $this->assertEquals("test", $this->object->getName());
+ }
+
+ public function testGetIdentifier()
+ {
+ $this->assertEquals(1, $this->object->getId());
+ }
+
+ public function testSetIdentifier()
+ {
+ $this->setExpectedException('BadMethodCallException');
+ $this->object->setId(2);
+ }
+
+ public function testSetUnknownField()
+ {
+ $this->setExpectedException('BadMethodCallException');
+ $this->object->setUnknown("test");
+ }
+
+ public function testGetUnknownField()
+ {
+ $this->setExpectedException('BadMethodCallException');
+ $this->object->getUnknown();
+ }
+
+ public function testGetToOneAssociation()
+ {
+ $this->assertNull($this->object->getParent());
+ }
+
+ public function testSetToOneAssociation()
+ {
+ $parent = new TestObject();
+ $this->object->setParent($parent);
+ $this->assertSame($parent, $this->object->getParent($parent));
+ }
+
+ public function testSetInvalidToOneAssocation()
+ {
+ $parent = new \stdClass();
+
+ $this->setExpectedException('InvalidArgumentException');
+ $this->object->setParent($parent);
+ }
+
+ public function testSetToOneAssociationNull()
+ {
+ $parent = new TestObject();
+ $this->object->setParent($parent);
+ $this->object->setParent(null);
+ $this->assertNull($this->object->getParent());
+ }
+
+ public function testAddToManyAssocation()
+ {
+ $child = new TestObject();
+ $this->object->addChildren($child);
+
+ $this->assertSame($this->object, $child->getParent());
+ $this->assertEquals(1, count($this->object->getChildren()));
+
+ $child = new TestObject();
+ $this->object->addChildren($child);
+
+ $this->assertEquals(2, count($this->object->getChildren()));
+ }
+
+ public function testAddInvalidToManyAssocation()
+ {
+ $this->setExpectedException('InvalidArgumentException');
+ $this->object->addChildren(new \stdClass());
+ }
+
+ public function testNoObjectManagerSet()
+ {
+ PersistentObject::setObjectManager(null);
+ $child = new TestObject();
+
+ $this->setExpectedException('RuntimeException');
+ $child->setName("test");
+ }
+
+ public function testInvalidMethod()
+ {
+ $this->setExpectedException('BadMethodCallException');
+ $this->object->asdf();
+ }
+
+ public function testAddInvalidCollection()
+ {
+ $this->setExpectedException('BadMethodCallException');
+ $this->object->addAsdf(new \stdClass());
+ }
+}
+
+class TestObject extends PersistentObject
+{
+ protected $id = 1;
+ protected $name = 'beberlei';
+ protected $parent;
+ protected $children;
+}
+
+class TestObjectMetadata implements ClassMetadata
+{
+
+ public function getAssociationMappedByTargetField($assocName)
+ {
+ $assoc = array('children' => 'parent');
+ return $assoc[$assocName];
+ }
+
+ public function getAssociationNames()
+ {
+ return array('parent', 'children');
+ }
+
+ public function getAssociationTargetClass($assocName)
+ {
+ return __NAMESPACE__ . '\TestObject';
+ }
+
+ public function getFieldNames()
+ {
+ return array('id', 'name');
+ }
+
+ public function getIdentifier()
+ {
+ return array('id');
+ }
+
+ public function getName()
+ {
+ return __NAMESPACE__ . '\TestObject';
+ }
+
+ public function getReflectionClass()
+ {
+ return new \ReflectionClass($this->getName());
+ }
+
+ public function getTypeOfField($fieldName)
+ {
+ $types = array('id' => 'integer', 'name' => 'string');
+ return $types[$fieldName];
+ }
+
+ public function hasAssociation($fieldName)
+ {
+ return in_array($fieldName, array('parent', 'children'));
+ }
+
+ public function hasField($fieldName)
+ {
+ return in_array($fieldName, array('id', 'name'));
+ }
+
+ public function isAssociationInverseSide($assocName)
+ {
+ return ($assocName === 'children');
+ }
+
+ public function isCollectionValuedAssociation($fieldName)
+ {
+ return ($fieldName === 'children');
+ }
+
+ public function isIdentifier($fieldName)
+ {
+ return $fieldName === 'id';
+ }
+
+ public function isSingleValuedAssociation($fieldName)
+ {
+ return $fieldName === 'parent';
+ }
+
+ public function getIdentifierValues($entity)
+ {
+
+ }
+
+ public function getIdentifierFieldNames()
+ {
+
+ }
+
+ public function initializeReflection(ReflectionService $reflService)
+ {
+
+ }
+
+ public function wakeupReflection(ReflectionService $reflService)
+ {
+
+ }
+}
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Util/ClassUtilsTest.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Util/ClassUtilsTest.php
new file mode 100644
index 0000000000000000000000000000000000000000..a281450031f183350d00efa9e714187d20cdd501
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Util/ClassUtilsTest.php
@@ -0,0 +1,100 @@
+<?php
+
+namespace Doctrine\Tests\Common\Util
+{
+ use Doctrine\Tests\DoctrineTestCase;
+ use Doctrine\Common\Util\ClassUtils;
+
+ class ClassUtilsTest extends DoctrineTestCase
+ {
+ static public function dataGetClass()
+ {
+ return array(
+ array('stdClass', 'stdClass'),
+ array('Doctrine\Common\Util\ClassUtils', 'Doctrine\Common\Util\ClassUtils'),
+ array( 'MyProject\Proxies\__CG__\stdClass', 'stdClass' ),
+ array( 'MyProject\Proxies\__CG__\OtherProject\Proxies\__CG__\stdClass', 'stdClass' ),
+ array( 'MyProject\Proxies\__CG__\Doctrine\Tests\Common\Util\ChildObject','Doctrine\Tests\Common\Util\ChildObject' )
+ );
+ }
+
+ /**
+ * @dataProvider dataGetClass
+ */
+ public function testGetRealClass($className, $expectedClassName)
+ {
+ $this->assertEquals($expectedClassName, ClassUtils::getRealClass($className));
+ }
+
+ /**
+ * @dataProvider dataGetClass
+ */
+ public function testGetClass( $className, $expectedClassName )
+ {
+ $object = new $className();
+ $this->assertEquals($expectedClassName, ClassUtils::getClass($object));
+ }
+
+ public function testGetParentClass()
+ {
+ $parentClass = ClassUtils::getParentClass( 'MyProject\Proxies\__CG__\OtherProject\Proxies\__CG__\Doctrine\Tests\Common\Util\ChildObject' );
+ $this->assertEquals('stdClass', $parentClass);
+ }
+
+ public function testGenerateProxyClassName()
+ {
+ $this->assertEquals( 'Proxies\__CG__\stdClass', ClassUtils::generateProxyClassName( 'stdClass', 'Proxies' ) );
+ }
+
+ /**
+ * @dataProvider dataGetClass
+ */
+ public function testNewReflectionClass( $className, $expectedClassName )
+ {
+ $reflClass = ClassUtils::newReflectionClass( $className );
+ $this->assertEquals( $expectedClassName, $reflClass->getName() );
+ }
+
+ /**
+ * @dataProvider dataGetClass
+ */
+ public function testNewReflectionObject( $className, $expectedClassName )
+ {
+ $object = new $className;
+ $reflClass = ClassUtils::newReflectionObject( $object );
+ $this->assertEquals( $expectedClassName, $reflClass->getName() );
+ }
+ }
+
+ class ChildObject extends \stdClass
+ {
+ }
+}
+
+namespace MyProject\Proxies\__CG__
+{
+ class stdClass extends \stdClass
+ {
+ }
+}
+
+namespace MyProject\Proxies\__CG__\Doctrine\Tests\Common\Util
+{
+ class ChildObject extends \Doctrine\Tests\Common\Util\ChildObject
+ {
+ }
+}
+
+namespace MyProject\Proxies\__CG__\OtherProject\Proxies\__CG__
+{
+ class stdClass extends \MyProject\Proxies\__CG__\stdClass
+ {
+ }
+}
+
+namespace MyProject\Proxies\__CG__\OtherProject\Proxies\__CG__\Doctrine\Tests\Common\Util
+{
+ class ChildObject extends \MyProject\Proxies\__CG__\Doctrine\Tests\Common\Util\ChildObject
+ {
+ }
+}
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Util/DebugTest.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Util/DebugTest.php
new file mode 100644
index 0000000000000000000000000000000000000000..b4e9eed2cd975c8497627bf51cbde3b8979833cf
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/Common/Util/DebugTest.php
@@ -0,0 +1,27 @@
+<?php
+
+namespace Doctrine\Tests\Common\Util;
+
+use Doctrine\Tests\DoctrineTestCase;
+use Doctrine\Common\Util\Debug;
+
+class DebugTest extends DoctrineTestCase
+{
+ public function testExportObject( )
+ {
+ $obj = new \stdClass;
+ $obj->foo = "bar";
+ $obj->bar = 1234;
+
+ $var = Debug::export($obj, 2);
+ $this->assertEquals( "stdClass", $var->__CLASS__ );
+ }
+
+ public function testExportDateTime()
+ {
+ $obj = new \DateTime( "2010-10-10 10:10:10" );
+
+ $var = Debug::export( $obj, 2 );
+ $this->assertEquals( "DateTime", $var->__CLASS__ );
+ }
+}
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/DoctrineTestCase.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/DoctrineTestCase.php
new file mode 100644
index 0000000000000000000000000000000000000000..e8323d294092a5ed06eb1ff8fca5840f613ae41a
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/DoctrineTestCase.php
@@ -0,0 +1,10 @@
+<?php
+
+namespace Doctrine\Tests;
+
+/**
+ * Base testcase class for all Doctrine testcases.
+ */
+abstract class DoctrineTestCase extends \PHPUnit_Framework_TestCase
+{
+}
\ No newline at end of file
diff --git a/core/vendor/doctrine/common/tests/Doctrine/Tests/TestInit.php b/core/vendor/doctrine/common/tests/Doctrine/Tests/TestInit.php
new file mode 100644
index 0000000000000000000000000000000000000000..e7ab51f3a22cbc9cf83c5fc166c2340b665471ce
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/Doctrine/Tests/TestInit.php
@@ -0,0 +1,31 @@
+<?php
+/*
+ * This file bootstraps the test environment.
+ */
+namespace Doctrine\Tests;
+
+error_reporting(E_ALL | E_STRICT);
+
+// register silently failing autoloader
+spl_autoload_register(function($class)
+{
+ if (0 === strpos($class, 'Doctrine\Tests\\')) {
+ $path = __DIR__.'/../../'.strtr($class, '\\', '/').'.php';
+ if (file_exists($path) && is_readable($path)) {
+ require_once $path;
+
+ return true;
+ }
+ } else if (0 === strpos($class, 'Doctrine\Common\\')) {
+ $path = __DIR__.'/../../../lib/'.($class = strtr($class, '\\', '/')).'.php';
+ if (file_exists($path) && is_readable($path)) {
+ require_once $path;
+
+ return true;
+ }
+ }
+});
+
+\Doctrine\Common\Annotations\AnnotationRegistry::registerAutoloadNamespace(
+ 'Doctrine\Tests\Common\Annotations\Fixtures', __DIR__ . '/../../'
+);
diff --git a/core/vendor/doctrine/common/tests/NativePhpunitTask.php b/core/vendor/doctrine/common/tests/NativePhpunitTask.php
new file mode 100644
index 0000000000000000000000000000000000000000..50fd1c3d424d946c45e1099ecd57573dfc25bef2
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/NativePhpunitTask.php
@@ -0,0 +1,246 @@
+<?php
+/**
+ * Native PHPUnit Task
+ *
+ * LICENSE
+ *
+ * This source file is subject to the new BSD license that is bundled
+ * with this package in the file LICENSE.txt.
+ * If you did not receive a copy of the license and are unable to
+ * obtain it through the world-wide-web, please send an email
+ * to kontakt@beberlei.de so I can send you a copy immediately.
+ */
+
+require_once 'PHPUnit/Autoload.php';
+
+/**
+ * A more flexible and powerful PHPUnit Task than the native Phing one.
+ *
+ * Plus forward compability for PHPUnit 3.5 and later is ensured by using the PHPUnit Test Runner instead of implementing one.
+ *
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ */
+class NativePhpunitTask extends Task
+{
+ private $test;
+ private $testfile;
+ private $testdirectory;
+ private $configuration = null;
+ private $coverageClover = null;
+ private $junitlogfile = null;
+ private $haltonfailure = true;
+ private $haltonerror = true;
+
+ public function setTestdirectory($directory) {
+ $this->testdirectory = $directory;
+ }
+
+ public function setTest($test) {
+ $this->test = $test;
+ }
+
+ public function setTestfile($testfile) {
+ $this->testfile = $testfile;
+ }
+
+ public function setJunitlogfile($junitlogfile) {
+ if (strlen($junitlogfile) == 0) {
+ $junitlogfile = NULL;
+ }
+
+ $this->junitlogfile = $junitlogfile;
+ }
+
+ public function setConfiguration($configuration) {
+ if (strlen($configuration) == 0) {
+ $configuration = NULL;
+ }
+
+ $this->configuration = $configuration;
+ }
+
+ public function setCoverageClover($coverageClover) {
+ if (strlen($coverageClover) == 0) {
+ $coverageClover = NULL;
+ }
+
+ $this->coverageClover = $coverageClover;
+ }
+
+ public function setHaltonfailure($haltonfailures) {
+ $this->haltonfailure = $haltonfailures;
+ }
+
+ public function setHaltonerror($haltonerrors) {
+ $this->haltonerror = $haltonerrors;
+ }
+
+ public function init()
+ {
+ require_once "PHPUnit/Runner/Version.php";
+ $version = PHPUnit_Runner_Version::id();
+
+ if (version_compare($version, '3.4.0') < 0) {
+ throw new BuildException("NativePHPUnitTask requires PHPUnit version >= 3.2.0", $this->getLocation());
+ }
+
+ require_once 'PHPUnit/Util/Filter.php';
+
+ // point PHPUnit_MAIN_METHOD define to non-existing method
+ if (!defined('PHPUnit_MAIN_METHOD')) {
+ define('PHPUnit_MAIN_METHOD', 'PHPUnitTask::undefined');
+ }
+ }
+
+ public function main()
+ {
+ if (!is_dir(realpath($this->testdirectory))) {
+ throw new BuildException("NativePHPUnitTask requires a Test Directory path given, '".$this->testdirectory."' given.");
+ }
+ set_include_path(realpath($this->testdirectory) . PATH_SEPARATOR . get_include_path());
+
+ $printer = new NativePhpunitPrinter();
+
+ $arguments = array(
+ 'configuration' => $this->configuration,
+ 'coverageClover' => $this->coverageClover,
+ 'junitLogfile' => $this->junitlogfile,
+ 'printer' => $printer,
+ );
+
+ $runner = new PHPUnit_TextUI_TestRunner();
+ $suite = $runner->getTest($this->test, $this->testfile, true);
+
+ try {
+ $result = $runner->doRun($suite, $arguments);
+ /* @var $result PHPUnit_Framework_TestResult */
+
+ if ( ($this->haltonfailure && $result->failureCount() > 0) || ($this->haltonerror && $result->errorCount() > 0) ) {
+ throw new BuildException("PHPUnit: ".$result->failureCount()." Failures and ".$result->errorCount()." Errors, ".
+ "last failure message: ".$printer->getMessages());
+ }
+
+ $this->log("PHPUnit Success: ".count($result->passed())." tests passed, no ".
+ "failures (".$result->skippedCount()." skipped, ".$result->notImplementedCount()." not implemented)");
+
+ // Hudson for example doesn't like the backslash in class names
+ if (file_exists($this->coverageClover)) {
+ $this->log("Generated Clover Coverage XML to: ".$this->coverageClover);
+ $content = file_get_contents($this->coverageClover);
+ $content = str_replace("\\", ".", $content);
+ file_put_contents($this->coverageClover, $content);
+ unset($content);
+ }
+
+ } catch(\Exception $e) {
+ throw new BuildException("NativePhpunitTask failed: ".$e->getMessage());
+ }
+ }
+}
+
+class NativePhpunitPrinter extends PHPUnit_Util_Printer implements PHPUnit_Framework_TestListener
+{
+ private $_messages = array();
+
+ public function write($buffer)
+ {
+ // do nothing
+ }
+
+ public function getMessages()
+ {
+ return $this->_messages;
+ }
+
+ /**
+ * An error occurred.
+ *
+ * @param PHPUnit_Framework_Test $test
+ * @param Exception $e
+ * @param float $time
+ */
+ public function addError(PHPUnit_Framework_Test $test, Exception $e, $time)
+ {
+ $this->_messages[] = "Test ERROR: ".$test->getName().": ".$e->getMessage();
+ }
+
+ /**
+ * A failure occurred.
+ *
+ * @param PHPUnit_Framework_Test $test
+ * @param PHPUnit_Framework_AssertionFailedError $e
+ * @param float $time
+ */
+ public function addFailure(PHPUnit_Framework_Test $test, PHPUnit_Framework_AssertionFailedError $e, $time)
+ {
+ $this->_messages[] = "Test FAILED: ".$test->getName().": ".$e->getMessage();
+ }
+
+ /**
+ * Incomplete test.
+ *
+ * @param PHPUnit_Framework_Test $test
+ * @param Exception $e
+ * @param float $time
+ */
+ public function addIncompleteTest(PHPUnit_Framework_Test $test, Exception $e, $time)
+ {
+
+ }
+
+ /**
+ * Skipped test.
+ *
+ * @param PHPUnit_Framework_Test $test
+ * @param Exception $e
+ * @param float $time
+ * @since Method available since Release 3.0.0
+ */
+ public function addSkippedTest(PHPUnit_Framework_Test $test, Exception $e, $time)
+ {
+
+ }
+
+ /**
+ * A test suite started.
+ *
+ * @param PHPUnit_Framework_TestSuite $suite
+ * @since Method available since Release 2.2.0
+ */
+ public function startTestSuite(PHPUnit_Framework_TestSuite $suite)
+ {
+
+ }
+
+ /**
+ * A test suite ended.
+ *
+ * @param PHPUnit_Framework_TestSuite $suite
+ * @since Method available since Release 2.2.0
+ */
+ public function endTestSuite(PHPUnit_Framework_TestSuite $suite)
+ {
+
+ }
+
+ /**
+ * A test started.
+ *
+ * @param PHPUnit_Framework_Test $test
+ */
+ public function startTest(PHPUnit_Framework_Test $test)
+ {
+
+ }
+
+ /**
+ * A test ended.
+ *
+ * @param PHPUnit_Framework_Test $test
+ * @param float $time
+ */
+ public function endTest(PHPUnit_Framework_Test $test, $time)
+ {
+
+ }
+}
diff --git a/core/vendor/doctrine/common/tests/README.markdown b/core/vendor/doctrine/common/tests/README.markdown
new file mode 100644
index 0000000000000000000000000000000000000000..e6f1703de02899853ee91ed603f4c8117f0e98cd
--- /dev/null
+++ b/core/vendor/doctrine/common/tests/README.markdown
@@ -0,0 +1,27 @@
+# Running the Doctrine 2 Testsuite
+
+## Running tests
+
+Execute PHPUnit in the root folder of your doctrine-common clone.
+
+ phpunit
+
+## Testing Lock-Support
+
+The Lock support in Doctrine 2 is tested using Gearman, which allows to run concurrent tasks in parallel.
+Install Gearman with PHP as follows:
+
+1. Go to http://www.gearman.org and download the latest Gearman Server
+2. Compile it and then call ldconfig
+3. Start it up "gearmand -vvvv"
+4. Install pecl/gearman by calling "gearman-beta"
+
+You can then go into tests/ and start up two workers:
+
+ php Doctrine/Tests/ORM/Functional/Locking/LockAgentWorker.php
+
+Then run the locking test-suite:
+
+ phpunit --configuration <myconfig.xml> Doctrine/Tests/ORM/Functional/Locking/GearmanLockTest.php
+
+This can run considerable time, because it is using sleep() to test for the timing ranges of locks.
\ No newline at end of file