RetailCRM-Mirror/doctrine2
1
0
Fork 0
mirror of synced 2025-04-03 13:23:37 +03:00
Code Issues Projects Releases Wiki Activity

set svn:eol-style property on plain text files

Browse source
This commit is contained in:
piccoloprincipe 2009-06-02 18:05:26 +00:00
parent 9837cd79ff
commit bdd2241fb5
38 changed files with 6172 additions and 6172 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

98
lib/Doctrine/Common/EventArgs.php
View file

@ -1,49 +1,49 @@
<?php <?php
/* /*
* $Id$ * $Id$
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* *
* This software consists of voluntary contributions made by many individuals * This software consists of voluntary contributions made by many individuals
* and is licensed under the LGPL. For more information, see * and is licensed under the LGPL. For more information, see
* <http://www.doctrine-project.org>. * <http://www.doctrine-project.org>.
*/ */
namespace Doctrine\Common; namespace Doctrine\Common;
/** /**
* EventArgs is the base class for classes containing event data. * 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 * 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 * information to an event handler when an event is raised. The single empty EventArgs
* instance can be obtained through {@link getEmptyInstance()}. * instance can be obtained through {@link getEmptyInstance()}.
* *
* @author Konsta Vesterinen <kvesteri@cc.hut.fi> * @author Konsta Vesterinen <kvesteri@cc.hut.fi>
* @author Roman Borschel * @author Roman Borschel
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link www.doctrine-project.org * @link www.doctrine-project.org
* @since 2.0 * @since 2.0
* @version $Revision$ * @version $Revision$
*/ */
class EventArgs class EventArgs
{ {
private static $_emptyEventArgsInstance; private static $_emptyEventArgsInstance;
public static function getEmptyInstance() public static function getEmptyInstance()
{ {
if ( ! self::$_emptyEventArgsInstance) { if ( ! self::$_emptyEventArgsInstance) {
self::$_emptyEventArgsInstance = new EventArgs; self::$_emptyEventArgsInstance = new EventArgs;
} }
return self::$_emptyEventArgsInstance; return self::$_emptyEventArgsInstance;
} }
} }

78
lib/Doctrine/Common/EventSubscriber.php
View file

@ -1,39 +1,39 @@
<?php <?php
/* /*
* $Id: EventListener.php 4653 2008-07-10 17:17:58Z romanb $ * $Id: EventListener.php 4653 2008-07-10 17:17:58Z romanb $
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* *
* This software consists of voluntary contributions made by many individuals * This software consists of voluntary contributions made by many individuals
* and is licensed under the LGPL. For more information, see * and is licensed under the LGPL. For more information, see
* <http://www.phpdoctrine.org>. * <http://www.phpdoctrine.org>.
*/ */
namespace Doctrine\Common; namespace Doctrine\Common;
/** /**
* An EventSubscriber knows himself what events he is interested in. * An EventSubscriber knows himself what events he is interested in.
* If an EventSubscriber is added to an EventManager, the manager invokes * If an EventSubscriber is added to an EventManager, the manager invokes
* getSubscribedEvents() and registers the subscriber as a listener for all * getSubscribedEvents() and registers the subscriber as a listener for all
* returned events. * returned events.
* *
* @author Roman Borschel <roman@code-factory.org> * @author Roman Borschel <roman@code-factory.org>
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link www.phpdoctrine.org * @link www.phpdoctrine.org
* @since 2.0 * @since 2.0
* @version $Revision: 4653 $ * @version $Revision: 4653 $
*/ */
interface EventSubscriber interface EventSubscriber
{ {
public function getSubscribedEvents(); public function getSubscribedEvents();
} }

584
lib/Doctrine/DBAL/Driver/Statement.php
View file

@ -1,293 +1,293 @@
<?php <?php
/* /*
* $Id$ * $Id$
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* *
* This software consists of voluntary contributions made by many individuals * This software consists of voluntary contributions made by many individuals
* and is licensed under the LGPL. For more information, see * and is licensed under the LGPL. For more information, see
* <http://www.doctrine-project.org>. * <http://www.doctrine-project.org>.
*/ */
namespace Doctrine\DBAL\Driver; namespace Doctrine\DBAL\Driver;
/** /**
* Statement interface. * Statement interface.
* Drivers must implement this interface. * Drivers must implement this interface.
* *
* This resembles the PDOStatement interface. * This resembles the PDOStatement interface.
* *
* @author Konsta Vesterinen <kvesteri@cc.hut.fi> * @author Konsta Vesterinen <kvesteri@cc.hut.fi>
* @author Roman Borschel <roman@code-factory.org> * @author Roman Borschel <roman@code-factory.org>
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link www.doctrine-project.org * @link www.doctrine-project.org
* @since 2.0 * @since 2.0
* @version $Revision$ * @version $Revision$
*/ */
interface Statement interface Statement
{ {
/** /**
* Bind a column to a PHP variable * Bind a column to a PHP variable
* *
* @param mixed $column Number of the column (1-indexed) or name of the column in the result set. * @param mixed $column Number of the column (1-indexed) or name of the column in the result set.
* If using the column name, be aware that the name should match * If using the column name, be aware that the name should match
* the case of the column, as returned by the driver. * the case of the column, as returned by the driver.
* @param string $param Name of the PHP variable to which the column will be bound. * @param string $param Name of the PHP variable to which the column will be bound.
* @param integer $type Data type of the parameter, specified by the PDO::PARAM_* constants. * @param integer $type Data type of the parameter, specified by the PDO::PARAM_* constants.
* @return boolean Returns TRUE on success or FALSE on failure * @return boolean Returns TRUE on success or FALSE on failure
*/ */
public function bindColumn($column, &$param, $type = null); public function bindColumn($column, &$param, $type = null);
/** /**
* Binds a value to a corresponding named or positional * Binds a value to a corresponding named or positional
* placeholder in the SQL statement that was used to prepare the statement. * placeholder in the SQL statement that was used to prepare the statement.
* *
* @param mixed $param Parameter identifier. For a prepared statement using named placeholders, * @param mixed $param Parameter identifier. For a prepared statement using named placeholders,
* this will be a parameter name of the form :name. For a prepared statement * this will be a parameter name of the form :name. For a prepared statement
* using question mark placeholders, this will be the 1-indexed position of the parameter * using question mark placeholders, this will be the 1-indexed position of the parameter
* *
* @param mixed $value The value to bind to the parameter. * @param mixed $value The value to bind to the parameter.
* @param integer $type Explicit data type for the parameter using the PDO::PARAM_* constants. * @param integer $type Explicit data type for the parameter using the PDO::PARAM_* constants.
* *
* @return boolean Returns TRUE on success or FALSE on failure. * @return boolean Returns TRUE on success or FALSE on failure.
*/ */
public function bindValue($param, $value, $type = null); public function bindValue($param, $value, $type = null);
/** /**
* Binds a PHP variable to a corresponding named or question mark placeholder in the * Binds a PHP variable to a corresponding named or question mark placeholder in the
* SQL statement that was use to prepare the statement. Unlike PDOStatement->bindValue(), * SQL statement that was use to prepare the statement. Unlike PDOStatement->bindValue(),
* the variable is bound as a reference and will only be evaluated at the time * the variable is bound as a reference and will only be evaluated at the time
* that PDOStatement->execute() is called. * that PDOStatement->execute() is called.
* *
* Most parameters are input parameters, that is, parameters that are * Most parameters are input parameters, that is, parameters that are
* used in a read-only fashion to build up the query. Some drivers support the invocation * used in a read-only fashion to build up the query. Some drivers support the invocation
* of stored procedures that return data as output parameters, and some also as input/output * of stored procedures that return data as output parameters, and some also as input/output
* parameters that both send in data and are updated to receive it. * parameters that both send in data and are updated to receive it.
* *
* @param mixed $param Parameter identifier. For a prepared statement using named placeholders, * @param mixed $param Parameter identifier. For a prepared statement using named placeholders,
* this will be a parameter name of the form :name. For a prepared statement * this will be a parameter name of the form :name. For a prepared statement
* using question mark placeholders, this will be the 1-indexed position of the parameter * using question mark placeholders, this will be the 1-indexed position of the parameter
* *
* @param mixed $variable Name of the PHP variable to bind to the SQL statement parameter. * @param mixed $variable Name of the PHP variable to bind to the SQL statement parameter.
* *
* @param integer $type Explicit data type for the parameter using the PDO::PARAM_* constants. To return * @param integer $type Explicit data type for the parameter using the PDO::PARAM_* constants. To return
* an INOUT parameter from a stored procedure, use the bitwise OR operator to set the * an INOUT parameter from a stored procedure, use the bitwise OR operator to set the
* PDO::PARAM_INPUT_OUTPUT bits for the data_type parameter. * PDO::PARAM_INPUT_OUTPUT bits for the data_type parameter.
* *
* @param integer $length Length of the data type. To indicate that a parameter is an OUT parameter * @param integer $length Length of the data type. To indicate that a parameter is an OUT parameter
* from a stored procedure, you must explicitly set the length. * from a stored procedure, you must explicitly set the length.
* @param mixed $driverOptions * @param mixed $driverOptions
* @return boolean Returns TRUE on success or FALSE on failure. * @return boolean Returns TRUE on success or FALSE on failure.
*/ */
public function bindParam($column, &$variable, $type = null, $length = null, $driverOptions = array()); public function bindParam($column, &$variable, $type = null, $length = null, $driverOptions = array());
/** /**
* closeCursor * closeCursor
* Closes the cursor, enabling the statement to be executed again. * Closes the cursor, enabling the statement to be executed again.
* *
* @return boolean Returns TRUE on success or FALSE on failure. * @return boolean Returns TRUE on success or FALSE on failure.
*/ */
public function closeCursor(); public function closeCursor();
/** /**
* columnCount * columnCount
* Returns the number of columns in the result set * Returns the number of columns in the result set
* *
* @return integer Returns the number of columns in the result set represented * @return integer Returns the number of columns in the result set represented
* by the PDOStatement object. If there is no result set, * by the PDOStatement object. If there is no result set,
* this method should return 0. * this method should return 0.
*/ */
public function columnCount(); public function columnCount();
/** /**
* errorCode * errorCode
* Fetch the SQLSTATE associated with the last operation on the statement handle * Fetch the SQLSTATE associated with the last operation on the statement handle
* *
* @see Doctrine_Adapter_Interface::errorCode() * @see Doctrine_Adapter_Interface::errorCode()
* @return string error code string * @return string error code string
*/ */
public function errorCode(); public function errorCode();
/** /**
* errorInfo * errorInfo
* Fetch extended error information associated with the last operation on the statement handle * Fetch extended error information associated with the last operation on the statement handle
* *
* @see Doctrine_Adapter_Interface::errorInfo() * @see Doctrine_Adapter_Interface::errorInfo()
* @return array error info array * @return array error info array
*/ */
public function errorInfo(); public function errorInfo();
/** /**
* Executes a prepared statement * Executes a prepared statement
* *
* If the prepared statement included parameter markers, you must either: * If the prepared statement included parameter markers, you must either:
* call PDOStatement->bindParam() to bind PHP variables to the parameter markers: * call PDOStatement->bindParam() to bind PHP variables to the parameter markers:
* bound variables pass their value as input and receive the output value, * bound variables pass their value as input and receive the output value,
* if any, of their associated parameter markers or pass an array of input-only * if any, of their associated parameter markers or pass an array of input-only
* parameter values * parameter values
* *
* *
* @param array $params An array of values with as many elements as there are * @param array $params An array of values with as many elements as there are
* bound parameters in the SQL statement being executed. * bound parameters in the SQL statement being executed.
* @return boolean Returns TRUE on success or FALSE on failure. * @return boolean Returns TRUE on success or FALSE on failure.
*/ */
public function execute($params = null); public function execute($params = null);
/** /**
* fetch * fetch
* *
* @see Query::HYDRATE_* constants * @see Query::HYDRATE_* constants
* @param integer $fetchStyle Controls how the next row will be returned to the caller. * @param integer $fetchStyle Controls how the next row will be returned to the caller.
* This value must be one of the Query::HYDRATE_* constants, * This value must be one of the Query::HYDRATE_* constants,
* defaulting to Query::HYDRATE_BOTH * defaulting to Query::HYDRATE_BOTH
* *
* @param integer $cursorOrientation For a PDOStatement object representing a scrollable cursor, * @param integer $cursorOrientation For a PDOStatement object representing a scrollable cursor,
* this value determines which row will be returned to the caller. * this value determines which row will be returned to the caller.
* This value must be one of the Query::HYDRATE_ORI_* constants, defaulting to * This value must be one of the Query::HYDRATE_ORI_* constants, defaulting to
* Query::HYDRATE_ORI_NEXT. To request a scrollable cursor for your * Query::HYDRATE_ORI_NEXT. To request a scrollable cursor for your
* PDOStatement object, * PDOStatement object,
* you must set the PDO::ATTR_CURSOR attribute to Doctrine::CURSOR_SCROLL when you * you must set the PDO::ATTR_CURSOR attribute to Doctrine::CURSOR_SCROLL when you
* prepare the SQL statement with Doctrine_Adapter_Interface->prepare(). * prepare the SQL statement with Doctrine_Adapter_Interface->prepare().
* *
* @param integer $cursorOffset For a PDOStatement object representing a scrollable cursor for which the * @param integer $cursorOffset For a PDOStatement object representing a scrollable cursor for which the
* $cursorOrientation parameter is set to Query::HYDRATE_ORI_ABS, this value specifies * $cursorOrientation parameter is set to Query::HYDRATE_ORI_ABS, this value specifies
* the absolute number of the row in the result set that shall be fetched. * the absolute number of the row in the result set that shall be fetched.
* *
* For a PDOStatement object representing a scrollable cursor for * For a PDOStatement object representing a scrollable cursor for
* which the $cursorOrientation parameter is set to Query::HYDRATE_ORI_REL, this value * which the $cursorOrientation parameter is set to Query::HYDRATE_ORI_REL, this value
* specifies the row to fetch relative to the cursor position before * specifies the row to fetch relative to the cursor position before
* PDOStatement->fetch() was called. * PDOStatement->fetch() was called.
* *
* @return mixed * @return mixed
*/ */
public function fetch($fetchStyle = Query::HYDRATE_BOTH, public function fetch($fetchStyle = Query::HYDRATE_BOTH,
$cursorOrientation = Query::HYDRATE_ORI_NEXT, $cursorOrientation = Query::HYDRATE_ORI_NEXT,
$cursorOffset = null); $cursorOffset = null);
/** /**
* fetchAll * fetchAll
* Returns an array containing all of the result set rows * Returns an array containing all of the result set rows
* *
* @param integer $fetchStyle Controls how the next row will be returned to the caller. * @param integer $fetchStyle Controls how the next row will be returned to the caller.
* This value must be one of the Query::HYDRATE_* constants, * This value must be one of the Query::HYDRATE_* constants,
* defaulting to Query::HYDRATE_BOTH * defaulting to Query::HYDRATE_BOTH
* *
* @param integer $columnIndex Returns the indicated 0-indexed column when the value of $fetchStyle is * @param integer $columnIndex Returns the indicated 0-indexed column when the value of $fetchStyle is
* Query::HYDRATE_COLUMN. Defaults to 0. * Query::HYDRATE_COLUMN. Defaults to 0.
* *
* @return array * @return array
*/ */
public function fetchAll($fetchStyle = Query::HYDRATE_BOTH); public function fetchAll($fetchStyle = Query::HYDRATE_BOTH);
/** /**
* fetchColumn * fetchColumn
* Returns a single column from the next row of a * Returns a single column from the next row of a
* result set or FALSE if there are no more rows. * result set or FALSE if there are no more rows.
* *
* @param integer $columnIndex 0-indexed number of the column you wish to retrieve from the row. If no * @param integer $columnIndex 0-indexed number of the column you wish to retrieve from the row. If no
* value is supplied, PDOStatement->fetchColumn() * value is supplied, PDOStatement->fetchColumn()
* fetches the first column. * fetches the first column.
* *
* @return string returns a single column in the next row of a result set. * @return string returns a single column in the next row of a result set.
*/ */
public function fetchColumn($columnIndex = 0); public function fetchColumn($columnIndex = 0);
/** /**
* fetchObject * fetchObject
* Fetches the next row and returns it as an object. * Fetches the next row and returns it as an object.
* *
* Fetches the next row and returns it as an object. This function is an alternative to * Fetches the next row and returns it as an object. This function is an alternative to
* PDOStatement->fetch() with Query::HYDRATE_CLASS or Query::HYDRATE_OBJ style. * PDOStatement->fetch() with Query::HYDRATE_CLASS or Query::HYDRATE_OBJ style.
* *
* @param string $className Name of the created class, defaults to stdClass. * @param string $className Name of the created class, defaults to stdClass.
* @param array $args Elements of this array are passed to the constructor. * @param array $args Elements of this array are passed to the constructor.
* *
* @return mixed an instance of the required class with property names that correspond * @return mixed an instance of the required class with property names that correspond
* to the column names or FALSE in case of an error. * to the column names or FALSE in case of an error.
*/ */
public function fetchObject($className = 'stdClass', $args = array()); public function fetchObject($className = 'stdClass', $args = array());
/** /**
* getAttribute * getAttribute
* Retrieve a statement attribute * Retrieve a statement attribute
* *
* @param integer $attribute * @param integer $attribute
* @see Doctrine::ATTR_* constants * @see Doctrine::ATTR_* constants
* @return mixed the attribute value * @return mixed the attribute value
*/ */
public function getAttribute($attribute); public function getAttribute($attribute);
/** /**
* getColumnMeta * getColumnMeta
* Returns metadata for a column in a result set * Returns metadata for a column in a result set
* *
* @param integer $column The 0-indexed column in the result set. * @param integer $column The 0-indexed column in the result set.
* *
* @return array Associative meta data array with the following structure: * @return array Associative meta data array with the following structure:
* *
* native_type The PHP native type used to represent the column value. * native_type The PHP native type used to represent the column value.
* driver:decl_ type The SQL type used to represent the column value in the database. If the column in the result set is the result of a function, this value is not returned by PDOStatement->getColumnMeta(). * driver:decl_ type The SQL type used to represent the column value in the database. If the column in the result set is the result of a function, this value is not returned by PDOStatement->getColumnMeta().
* flags Any flags set for this column. * flags Any flags set for this column.
* name The name of this column as returned by the database. * name The name of this column as returned by the database.
* len The length of this column. Normally -1 for types other than floating point decimals. * len The length of this column. Normally -1 for types other than floating point decimals.
* precision The numeric precision of this column. Normally 0 for types other than floating point decimals. * precision The numeric precision of this column. Normally 0 for types other than floating point decimals.
* pdo_type The type of this column as represented by the PDO::PARAM_* constants. * pdo_type The type of this column as represented by the PDO::PARAM_* constants.
*/ */
public function getColumnMeta($column); public function getColumnMeta($column);
/** /**
* nextRowset * nextRowset
* Advances to the next rowset in a multi-rowset statement handle * Advances to the next rowset in a multi-rowset statement handle
* *
* Some database servers support stored procedures that return more than one rowset * Some database servers support stored procedures that return more than one rowset
* (also known as a result set). The nextRowset() method enables you to access the second * (also known as a result set). The nextRowset() method enables you to access the second
* and subsequent rowsets associated with a PDOStatement object. Each rowset can have a * and subsequent rowsets associated with a PDOStatement object. Each rowset can have a
* different set of columns from the preceding rowset. * different set of columns from the preceding rowset.
* *
* @return boolean Returns TRUE on success or FALSE on failure. * @return boolean Returns TRUE on success or FALSE on failure.
*/ */
public function nextRowset(); public function nextRowset();
/** /**
* rowCount * rowCount
* rowCount() returns the number of rows affected by the last DELETE, INSERT, or UPDATE statement * rowCount() returns the number of rows affected by the last DELETE, INSERT, or UPDATE statement
* executed by the corresponding object. * executed by the corresponding object.
* *
* If the last SQL statement executed by the associated Statement object was a SELECT statement, * If the last SQL statement executed by the associated Statement object was a SELECT statement,
* some databases may return the number of rows returned by that statement. However, * some databases may return the number of rows returned by that statement. However,
* this behaviour is not guaranteed for all databases and should not be * this behaviour is not guaranteed for all databases and should not be
* relied on for portable applications. * relied on for portable applications.
* *
* @return integer Returns the number of rows. * @return integer Returns the number of rows.
*/ */
public function rowCount(); public function rowCount();
/** /**
* setAttribute * setAttribute
* Set a statement attribute * Set a statement attribute
* *
* @param integer $attribute * @param integer $attribute
* @param mixed $value the value of given attribute * @param mixed $value the value of given attribute
* @return boolean Returns TRUE on success or FALSE on failure. * @return boolean Returns TRUE on success or FALSE on failure.
*/ */
public function setAttribute($attribute, $value); public function setAttribute($attribute, $value);
/** /**
* setFetchMode * setFetchMode
* Set the default fetch mode for this statement * Set the default fetch mode for this statement
* *
* @param integer $mode The fetch mode must be one of the Query::HYDRATE_* constants. * @param integer $mode The fetch mode must be one of the Query::HYDRATE_* constants.
* @return boolean Returns 1 on success or FALSE on failure. * @return boolean Returns 1 on success or FALSE on failure.
*/ */
public function setFetchMode($mode, $arg1); public function setFetchMode($mode, $arg1);
} }

874
lib/Doctrine/DBAL/Statement.php
View file

@ -1,438 +1,438 @@
<?php <?php
/* /*
* $Id: Statement.php 1532 2007-05-31 17:45:07Z zYne $ * $Id: Statement.php 1532 2007-05-31 17:45:07Z zYne $
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* *
* This software consists of voluntary contributions made by many individuals * This software consists of voluntary contributions made by many individuals
* and is licensed under the LGPL. For more information, see * and is licensed under the LGPL. For more information, see
* <http://www.phpdoctrine.org>. * <http://www.phpdoctrine.org>.
*/ */
namespace Doctrine\DBAL; namespace Doctrine\DBAL;
/** /**
* A thin wrapper around PDOStatement. * A thin wrapper around PDOStatement.
* *
* @author Konsta Vesterinen <kvesteri@cc.hut.fi> * @author Konsta Vesterinen <kvesteri@cc.hut.fi>
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link www.phpdoctrine.org * @link www.phpdoctrine.org
* @since 1.0 * @since 1.0
* @version $Revision: 1532 $ * @version $Revision: 1532 $
* @todo Do we seriously need this wrapper? * @todo Do we seriously need this wrapper?
*/ */
class Statement class Statement
{ {
/** /**
* @var Doctrine_Connection $conn Doctrine_Connection object, every connection * @var Doctrine_Connection $conn Doctrine_Connection object, every connection
* statement holds an instance of Doctrine_Connection * statement holds an instance of Doctrine_Connection
*/ */
protected $_conn; protected $_conn;
/** /**
* @var Doctrine::DBAL::Driver::Statement * @var Doctrine::DBAL::Driver::Statement
*/ */
protected $_stmt; protected $_stmt;
/** /**
* constructor * constructor
* *
* @param Doctrine_Connection $conn Doctrine_Connection object, every connection * @param Doctrine_Connection $conn Doctrine_Connection object, every connection
* statement holds an instance of Doctrine_Connection * statement holds an instance of Doctrine_Connection
* @param mixed $stmt * @param mixed $stmt
*/ */
public function __construct(Connection $conn, $stmt) public function __construct(Connection $conn, $stmt)
{ {
$this->_conn = $conn; $this->_conn = $conn;
$this->_stmt = $stmt; $this->_stmt = $stmt;
if ($stmt === false) { if ($stmt === false) {
throw \Doctrine\Common\DoctrineException::updateMe('Unknown statement object given.'); throw \Doctrine\Common\DoctrineException::updateMe('Unknown statement object given.');
} }
} }
/** /**
* getConnection * getConnection
* returns the connection object this statement uses * returns the connection object this statement uses
* *
* @return Doctrine_Connection * @return Doctrine_Connection
*/ */
public function getConnection() public function getConnection()
{ {
return $this->_conn; return $this->_conn;
} }
public function getStatement() public function getStatement()
{ {
return $this->_stmt; return $this->_stmt;
} }
public function getQuery() public function getQuery()
{ {
return $this->_stmt->queryString; return $this->_stmt->queryString;
} }
/** /**
* Bind a column to a PHP variable * Bind a column to a PHP variable
* *
* @param mixed $column Number of the column (1-indexed) or name of the column in the result set. * @param mixed $column Number of the column (1-indexed) or name of the column in the result set.
* If using the column name, be aware that the name should match * If using the column name, be aware that the name should match
* the case of the column, as returned by the driver. * the case of the column, as returned by the driver.
* *
* @param string $param Name of the PHP variable to which the column will be bound. * @param string $param Name of the PHP variable to which the column will be bound.
* @param integer $type Data type of the parameter, specified by the PDO::PARAM_* constants. * @param integer $type Data type of the parameter, specified by the PDO::PARAM_* constants.
* @return boolean Returns TRUE on success or FALSE on failure * @return boolean Returns TRUE on success or FALSE on failure
*/ */
public function bindColumn($column, $param, $type = null) public function bindColumn($column, $param, $type = null)
{ {
if ($type === null) { if ($type === null) {
return $this->_stmt->bindColumn($column, $param); return $this->_stmt->bindColumn($column, $param);
} else { } else {
return $this->_stmt->bindColumn($column, $param, $type); return $this->_stmt->bindColumn($column, $param, $type);
} }
} }
/** /**
* bindValue * bindValue
* Binds a value to a corresponding named or question mark * Binds a value to a corresponding named or question mark
* placeholder in the SQL statement that was use to prepare the statement. * placeholder in the SQL statement that was use to prepare the statement.
* *
* @param mixed $param Parameter identifier. For a prepared statement using named placeholders, * @param mixed $param Parameter identifier. For a prepared statement using named placeholders,
* this will be a parameter name of the form :name. For a prepared statement * this will be a parameter name of the form :name. For a prepared statement
* using question mark placeholders, this will be the 1-indexed position of the parameter * using question mark placeholders, this will be the 1-indexed position of the parameter
* *
* @param mixed $value The value to bind to the parameter. * @param mixed $value The value to bind to the parameter.
* @param integer $type Explicit data type for the parameter using the PDO::PARAM_* constants. * @param integer $type Explicit data type for the parameter using the PDO::PARAM_* constants.
* *
* @return boolean Returns TRUE on success or FALSE on failure. * @return boolean Returns TRUE on success or FALSE on failure.
*/ */
public function bindValue($param, $value, $type = null) public function bindValue($param, $value, $type = null)
{ {
if ($type === null) { if ($type === null) {
return $this->_stmt->bindValue($param, $value); return $this->_stmt->bindValue($param, $value);
} else { } else {
return $this->_stmt->bindValue($param, $value, $type); return $this->_stmt->bindValue($param, $value, $type);
} }
} }
/** /**
* Binds a PHP variable to a corresponding named or question mark placeholder in the * Binds a PHP variable to a corresponding named or question mark placeholder in the
* SQL statement that was use to prepare the statement. Unlike PDOStatement->bindValue(), * SQL statement that was use to prepare the statement. Unlike PDOStatement->bindValue(),
* the variable is bound as a reference and will only be evaluated at the time * the variable is bound as a reference and will only be evaluated at the time
* that PDOStatement->execute() is called. * that PDOStatement->execute() is called.
* *
* Most parameters are input parameters, that is, parameters that are * Most parameters are input parameters, that is, parameters that are
* used in a read-only fashion to build up the query. Some drivers support the invocation * used in a read-only fashion to build up the query. Some drivers support the invocation
* of stored procedures that return data as output parameters, and some also as input/output * of stored procedures that return data as output parameters, and some also as input/output
* parameters that both send in data and are updated to receive it. * parameters that both send in data and are updated to receive it.
* *
* @param mixed $param Parameter identifier. For a prepared statement using named placeholders, * @param mixed $param Parameter identifier. For a prepared statement using named placeholders,
* this will be a parameter name of the form :name. For a prepared statement * this will be a parameter name of the form :name. For a prepared statement
* using question mark placeholders, this will be the 1-indexed position of the parameter * using question mark placeholders, this will be the 1-indexed position of the parameter
* *
* @param mixed $variable Name of the PHP variable to bind to the SQL statement parameter. * @param mixed $variable Name of the PHP variable to bind to the SQL statement parameter.
* *
* @param integer $type Explicit data type for the parameter using the PDO::PARAM_* constants. To return * @param integer $type Explicit data type for the parameter using the PDO::PARAM_* constants. To return
* an INOUT parameter from a stored procedure, use the bitwise OR operator to set the * an INOUT parameter from a stored procedure, use the bitwise OR operator to set the
* PDO::PARAM_INPUT_OUTPUT bits for the data_type parameter. * PDO::PARAM_INPUT_OUTPUT bits for the data_type parameter.
* *
* @param integer $length Length of the data type. To indicate that a parameter is an OUT parameter * @param integer $length Length of the data type. To indicate that a parameter is an OUT parameter
* from a stored procedure, you must explicitly set the length. * from a stored procedure, you must explicitly set the length.
* @param mixed $driverOptions * @param mixed $driverOptions
* @return boolean Returns TRUE on success or FALSE on failure. * @return boolean Returns TRUE on success or FALSE on failure.
*/ */
public function bindParam($column, &$variable, $type = null, $length = null, $driverOptions = array()) public function bindParam($column, &$variable, $type = null, $length = null, $driverOptions = array())
{ {
if ($type === null) { if ($type === null) {
return $this->_stmt->bindParam($column, $variable); return $this->_stmt->bindParam($column, $variable);
} else { } else {
return $this->_stmt->bindParam($column, $variable, $type, $length, $driverOptions); return $this->_stmt->bindParam($column, $variable, $type, $length, $driverOptions);
} }
} }
/** /**
* Closes the cursor, enabling the statement to be executed again. * Closes the cursor, enabling the statement to be executed again.
* *
* @return boolean Returns TRUE on success or FALSE on failure. * @return boolean Returns TRUE on success or FALSE on failure.
*/ */
public function closeCursor() public function closeCursor()
{ {
return $this->_stmt->closeCursor(); return $this->_stmt->closeCursor();
} }
/** /**
* Returns the number of columns in the result set * Returns the number of columns in the result set
* *
* @return integer Returns the number of columns in the result set represented * @return integer Returns the number of columns in the result set represented
* by the PDOStatement object. If there is no result set, * by the PDOStatement object. If there is no result set,
* this method should return 0. * this method should return 0.
*/ */
public function columnCount() public function columnCount()
{ {
return $this->_stmt->columnCount(); return $this->_stmt->columnCount();
} }
/** /**
* Fetch the SQLSTATE associated with the last operation on the statement handle * Fetch the SQLSTATE associated with the last operation on the statement handle
* *
* @see Doctrine_Adapter_Interface::errorCode() * @see Doctrine_Adapter_Interface::errorCode()
* @return string error code string * @return string error code string
*/ */
public function errorCode() public function errorCode()
{ {
return $this->_stmt->errorCode(); return $this->_stmt->errorCode();
} }
/** /**
* Fetch extended error information associated with the last operation on the statement handle * Fetch extended error information associated with the last operation on the statement handle
* *
* @see Doctrine_Adapter_Interface::errorInfo() * @see Doctrine_Adapter_Interface::errorInfo()
* @return array error info array * @return array error info array
*/ */
public function errorInfo() public function errorInfo()
{ {
return $this->_stmt->errorInfo(); return $this->_stmt->errorInfo();
} }
/** /**
* Executes a prepared statement * Executes a prepared statement
* *
* If the prepared statement included parameter markers, you must either: * If the prepared statement included parameter markers, you must either:
* call PDOStatement->bindParam() to bind PHP variables to the parameter markers: * call PDOStatement->bindParam() to bind PHP variables to the parameter markers:
* bound variables pass their value as input and receive the output value, * bound variables pass their value as input and receive the output value,
* if any, of their associated parameter markers or pass an array of input-only * if any, of their associated parameter markers or pass an array of input-only
* parameter values * parameter values
* *
* *
* @param array $params An array of values with as many elements as there are * @param array $params An array of values with as many elements as there are
* bound parameters in the SQL statement being executed. * bound parameters in the SQL statement being executed.
* @return boolean Returns TRUE on success or FALSE on failure. * @return boolean Returns TRUE on success or FALSE on failure.
*/ */
public function execute($params = null) public function execute($params = null)
{ {
try { try {
//$event = new Doctrine_Event($this, Doctrine_Event::STMT_EXECUTE, $this->getQuery(), $params); //$event = new Doctrine_Event($this, Doctrine_Event::STMT_EXECUTE, $this->getQuery(), $params);
//$this->_conn->getListener()->preStmtExecute($event); //$this->_conn->getListener()->preStmtExecute($event);
$result = true; $result = true;
//if ( ! $event->skipOperation) { //if ( ! $event->skipOperation) {
$result = $this->_stmt->execute($params); $result = $this->_stmt->execute($params);
//$this->_conn->incrementQueryCount(); //$this->_conn->incrementQueryCount();
//} //}
//$this->_conn->getListener()->postStmtExecute($event); //$this->_conn->getListener()->postStmtExecute($event);
return $result; return $result;
} catch (PDOException $e) { } catch (PDOException $e) {
$this->_conn->rethrowException($e, $this); $this->_conn->rethrowException($e, $this);
} }
return false; return false;
} }
/** /**
* fetch * fetch
* *
* @see Query::HYDRATE_* constants * @see Query::HYDRATE_* constants
* @param integer $fetchStyle Controls how the next row will be returned to the caller. * @param integer $fetchStyle Controls how the next row will be returned to the caller.
* This value must be one of the Query::HYDRATE_* constants, * This value must be one of the Query::HYDRATE_* constants,
* defaulting to Query::HYDRATE_BOTH * defaulting to Query::HYDRATE_BOTH
* *
* @param integer $cursorOrientation For a PDOStatement object representing a scrollable cursor, * @param integer $cursorOrientation For a PDOStatement object representing a scrollable cursor,
* this value determines which row will be returned to the caller. * this value determines which row will be returned to the caller.
* This value must be one of the Query::HYDRATE_ORI_* constants, defaulting to * This value must be one of the Query::HYDRATE_ORI_* constants, defaulting to
* Query::HYDRATE_ORI_NEXT. To request a scrollable cursor for your * Query::HYDRATE_ORI_NEXT. To request a scrollable cursor for your
* PDOStatement object, * PDOStatement object,
* you must set the PDO::ATTR_CURSOR attribute to Doctrine::CURSOR_SCROLL when you * you must set the PDO::ATTR_CURSOR attribute to Doctrine::CURSOR_SCROLL when you
* prepare the SQL statement with Doctrine_Adapter_Interface->prepare(). * prepare the SQL statement with Doctrine_Adapter_Interface->prepare().
* *
* @param integer $cursorOffset For a PDOStatement object representing a scrollable cursor for which the * @param integer $cursorOffset For a PDOStatement object representing a scrollable cursor for which the
* $cursorOrientation parameter is set to Query::HYDRATE_ORI_ABS, this value specifies * $cursorOrientation parameter is set to Query::HYDRATE_ORI_ABS, this value specifies
* the absolute number of the row in the result set that shall be fetched. * the absolute number of the row in the result set that shall be fetched.
* *
* For a PDOStatement object representing a scrollable cursor for * For a PDOStatement object representing a scrollable cursor for
* which the $cursorOrientation parameter is set to Query::HYDRATE_ORI_REL, this value * which the $cursorOrientation parameter is set to Query::HYDRATE_ORI_REL, this value
* specifies the row to fetch relative to the cursor position before * specifies the row to fetch relative to the cursor position before
* PDOStatement->fetch() was called. * PDOStatement->fetch() was called.
* *
* @return mixed * @return mixed
*/ */
public function fetch($fetchMode = Query::HYDRATE_BOTH, public function fetch($fetchMode = Query::HYDRATE_BOTH,
$cursorOrientation = Query::HYDRATE_ORI_NEXT, $cursorOrientation = Query::HYDRATE_ORI_NEXT,
$cursorOffset = null) $cursorOffset = null)
{ {
//$event = new Doctrine_Event($this, Doctrine_Event::STMT_FETCH, $this->getQuery()); //$event = new Doctrine_Event($this, Doctrine_Event::STMT_FETCH, $this->getQuery());
//$event->fetchMode = $fetchMode; //$event->fetchMode = $fetchMode;
//$event->cursorOrientation = $cursorOrientation; //$event->cursorOrientation = $cursorOrientation;
//$event->cursorOffset = $cursorOffset; //$event->cursorOffset = $cursorOffset;
//$data = $this->_conn->getListener()->preFetch($event); //$data = $this->_conn->getListener()->preFetch($event);
//if ( ! $event->skipOperation) { //if ( ! $event->skipOperation) {
$data = $this->_stmt->fetch($fetchMode, $cursorOrientation, $cursorOffset); $data = $this->_stmt->fetch($fetchMode, $cursorOrientation, $cursorOffset);
//} //}
//$this->_conn->getListener()->postFetch($event); //$this->_conn->getListener()->postFetch($event);
return $data; return $data;
} }
/** /**
* Returns an array containing all of the result set rows * Returns an array containing all of the result set rows
* *
* @param integer $fetchMode Controls how the next row will be returned to the caller. * @param integer $fetchMode Controls how the next row will be returned to the caller.
* This value must be one of the Query::HYDRATE_* constants, * This value must be one of the Query::HYDRATE_* constants,
* defaulting to Query::HYDRATE_BOTH * defaulting to Query::HYDRATE_BOTH
* *
* @param integer $columnIndex Returns the indicated 0-indexed column when the value of $fetchStyle is * @param integer $columnIndex Returns the indicated 0-indexed column when the value of $fetchStyle is
* Query::HYDRATE_COLUMN. Defaults to 0. * Query::HYDRATE_COLUMN. Defaults to 0.
* *
* @return array * @return array
*/ */
public function fetchAll($fetchMode = Query::HYDRATE_BOTH, $columnIndex = null) public function fetchAll($fetchMode = Query::HYDRATE_BOTH, $columnIndex = null)
{ {
//$event = new Doctrine_Event($this, Doctrine_Event::STMT_FETCHALL, $this->getQuery()); //$event = new Doctrine_Event($this, Doctrine_Event::STMT_FETCHALL, $this->getQuery());
//$event->fetchMode = $fetchMode; //$event->fetchMode = $fetchMode;
//$event->columnIndex = $columnIndex; //$event->columnIndex = $columnIndex;
//$this->_conn->getListener()->preFetchAll($event); //$this->_conn->getListener()->preFetchAll($event);
//if ( ! $event->skipOperation) { //if ( ! $event->skipOperation) {
if ($columnIndex !== null) { if ($columnIndex !== null) {
$data = $this->_stmt->fetchAll($fetchMode, $columnIndex); $data = $this->_stmt->fetchAll($fetchMode, $columnIndex);
} else { } else {
$data = $this->_stmt->fetchAll($fetchMode); $data = $this->_stmt->fetchAll($fetchMode);
} }
//$event->data = $data; //$event->data = $data;
//} //}
//$this->_conn->getListener()->postFetchAll($event); //$this->_conn->getListener()->postFetchAll($event);
return $data; return $data;
} }
/** /**
* Returns a single column from the next row of a * Returns a single column from the next row of a
* result set or FALSE if there are no more rows. * result set or FALSE if there are no more rows.
* *
* @param integer $columnIndex 0-indexed number of the column you wish to retrieve from the row. If no * @param integer $columnIndex 0-indexed number of the column you wish to retrieve from the row. If no
* value is supplied, PDOStatement->fetchColumn() * value is supplied, PDOStatement->fetchColumn()
* fetches the first column. * fetches the first column.
* *
* @return string returns a single column in the next row of a result set. * @return string returns a single column in the next row of a result set.
*/ */
public function fetchColumn($columnIndex = 0) public function fetchColumn($columnIndex = 0)
{ {
return $this->_stmt->fetchColumn($columnIndex); return $this->_stmt->fetchColumn($columnIndex);
} }
/** /**
* Fetches the next row and returns it as an object. * Fetches the next row and returns it as an object.
* *
* Fetches the next row and returns it as an object. This function is an alternative to * Fetches the next row and returns it as an object. This function is an alternative to
* PDOStatement->fetch() with Query::HYDRATE_CLASS or Query::HYDRATE_OBJ style. * PDOStatement->fetch() with Query::HYDRATE_CLASS or Query::HYDRATE_OBJ style.
* *
* @param string $className Name of the created class, defaults to stdClass. * @param string $className Name of the created class, defaults to stdClass.
* @param array $args Elements of this array are passed to the constructor. * @param array $args Elements of this array are passed to the constructor.
* *
* @return mixed an instance of the required class with property names that correspond * @return mixed an instance of the required class with property names that correspond
* to the column names or FALSE in case of an error. * to the column names or FALSE in case of an error.
*/ */
public function fetchObject($className = 'stdClass', $args = array()) public function fetchObject($className = 'stdClass', $args = array())
{ {
return $this->_stmt->fetchObject($className, $args); return $this->_stmt->fetchObject($className, $args);
} }
/** /**
* Retrieve a statement attribute * Retrieve a statement attribute
* *
* @param integer $attribute * @param integer $attribute
* @see Doctrine::ATTR_* constants * @see Doctrine::ATTR_* constants
* @return mixed the attribute value * @return mixed the attribute value
*/ */
public function getAttribute($attribute) public function getAttribute($attribute)
{ {
return $this->_stmt->getAttribute($attribute); return $this->_stmt->getAttribute($attribute);
} }
/** /**
* Returns metadata for a column in a result set * Returns metadata for a column in a result set
* *
* @param integer $column The 0-indexed column in the result set. * @param integer $column The 0-indexed column in the result set.
* *
* @return array Associative meta data array with the following structure: * @return array Associative meta data array with the following structure:
* *
* native_type The PHP native type used to represent the column value. * native_type The PHP native type used to represent the column value.
* driver:decl_ type The SQL type used to represent the column value in the database. If the column in the result set is the result of a function, this value is not returned by PDOStatement->getColumnMeta(). * driver:decl_ type The SQL type used to represent the column value in the database. If the column in the result set is the result of a function, this value is not returned by PDOStatement->getColumnMeta().
* flags Any flags set for this column. * flags Any flags set for this column.
* name The name of this column as returned by the database. * name The name of this column as returned by the database.
* len The length of this column. Normally -1 for types other than floating point decimals. * len The length of this column. Normally -1 for types other than floating point decimals.
* precision The numeric precision of this column. Normally 0 for types other than floating point decimals. * precision The numeric precision of this column. Normally 0 for types other than floating point decimals.
* pdo_type The type of this column as represented by the PDO::PARAM_* constants. * pdo_type The type of this column as represented by the PDO::PARAM_* constants.
*/ */
public function getColumnMeta($column) public function getColumnMeta($column)
{ {
return $this->_stmt->getColumnMeta($column); return $this->_stmt->getColumnMeta($column);
} }
/** /**
* Advances to the next rowset in a multi-rowset statement handle * Advances to the next rowset in a multi-rowset statement handle
* *
* Some database servers support stored procedures that return more than one rowset * Some database servers support stored procedures that return more than one rowset
* (also known as a result set). The nextRowset() method enables you to access the second * (also known as a result set). The nextRowset() method enables you to access the second
* and subsequent rowsets associated with a PDOStatement object. Each rowset can have a * and subsequent rowsets associated with a PDOStatement object. Each rowset can have a
* different set of columns from the preceding rowset. * different set of columns from the preceding rowset.
* *
* @return boolean Returns TRUE on success or FALSE on failure. * @return boolean Returns TRUE on success or FALSE on failure.
*/ */
public function nextRowset() public function nextRowset()
{ {
return $this->_stmt->nextRowset(); return $this->_stmt->nextRowset();
} }
/** /**
* rowCount() returns the number of rows affected by the last DELETE, INSERT, or UPDATE statement * rowCount() returns the number of rows affected by the last DELETE, INSERT, or UPDATE statement
* executed by the corresponding object. * executed by the corresponding object.
* *
* If the last SQL statement executed by the associated Statement object was a SELECT statement, * If the last SQL statement executed by the associated Statement object was a SELECT statement,
* some databases may return the number of rows returned by that statement. However, * some databases may return the number of rows returned by that statement. However,
* this behaviour is not guaranteed for all databases and should not be * this behaviour is not guaranteed for all databases and should not be
* relied on for portable applications. * relied on for portable applications.
* *
* @return integer Returns the number of rows. * @return integer Returns the number of rows.
*/ */
public function rowCount() public function rowCount()
{ {
return $this->_stmt->rowCount(); return $this->_stmt->rowCount();
} }
/** /**
* Set a statement attribute * Set a statement attribute
* *
* @param integer $attribute * @param integer $attribute
* @param mixed $value the value of given attribute * @param mixed $value the value of given attribute
* @return boolean Returns TRUE on success or FALSE on failure. * @return boolean Returns TRUE on success or FALSE on failure.
*/ */
public function setAttribute($attribute, $value) public function setAttribute($attribute, $value)
{ {
return $this->_stmt->setAttribute($attribute, $value); return $this->_stmt->setAttribute($attribute, $value);
} }
/** /**
* Set the default fetch mode for this statement * Set the default fetch mode for this statement
* *
* @param integer $mode The fetch mode must be one of the Query::HYDRATE_* constants. * @param integer $mode The fetch mode must be one of the Query::HYDRATE_* constants.
* @return boolean Returns 1 on success or FALSE on failure. * @return boolean Returns 1 on success or FALSE on failure.
*/ */
public function setFetchMode($mode, $arg1 = null, $arg2 = null) public function setFetchMode($mode, $arg1 = null, $arg2 = null)
{ {
return $this->_stmt->setFetchMode($mode, $arg1, $arg2); return $this->_stmt->setFetchMode($mode, $arg1, $arg2);
} }
} }

152
lib/Doctrine/ORM/Cache/ApcCache.php
View file

@ -1,77 +1,77 @@
<?php <?php
/* /*
* $Id: Apc.php 4910 2008-09-12 08:51:56Z romanb $ * $Id: Apc.php 4910 2008-09-12 08:51:56Z romanb $
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* *
* This software consists of voluntary contributions made by many individuals * This software consists of voluntary contributions made by many individuals
* and is licensed under the LGPL. For more information, see * and is licensed under the LGPL. For more information, see
* <http://www.doctrine-project.org>. * <http://www.doctrine-project.org>.
*/ */
namespace Doctrine\ORM\Cache; namespace Doctrine\ORM\Cache;
/** /**
* APC cache driver. * APC cache driver.
* *
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link www.doctrine-project.org * @link www.doctrine-project.org
* @since 1.0 * @since 1.0
* @version $Revision: 4910 $ * @version $Revision: 4910 $
* @author Konsta Vesterinen <kvesteri@cc.hut.fi> * @author Konsta Vesterinen <kvesteri@cc.hut.fi>
* @author Roman Borschel <roman@code-factory.org> * @author Roman Borschel <roman@code-factory.org>
*/ */
class ApcCache implements Cache class ApcCache implements Cache
{ {
/** /**
* {@inheritdoc} * {@inheritdoc}
*/ */
public function __construct() public function __construct()
{ {
if ( ! extension_loaded('apc')) { if ( ! extension_loaded('apc')) {
\Doctrine\Common\DoctrineException::updateMe('The apc extension must be loaded in order to use the ApcCache.'); \Doctrine\Common\DoctrineException::updateMe('The apc extension must be loaded in order to use the ApcCache.');
} }
} }
/** /**
* {@inheritdoc} * {@inheritdoc}
*/ */
public function fetch($id) public function fetch($id)
{ {
return apc_fetch($id); return apc_fetch($id);
} }
/** /**
* {@inheritdoc} * {@inheritdoc}
*/ */
public function contains($id) public function contains($id)
{ {
return apc_fetch($id) === false ? false : true; return apc_fetch($id) === false ? false : true;
} }
/** /**
* {@inheritdoc} * {@inheritdoc}
*/ */
public function save($id, $data, $lifeTime = false) public function save($id, $data, $lifeTime = false)
{ {
return (bool) apc_store($id, $data, $lifeTime); return (bool) apc_store($id, $data, $lifeTime);
} }
/** /**
* {@inheritdoc} * {@inheritdoc}
*/ */
public function delete($id) public function delete($id)
{ {
return apc_delete($id); return apc_delete($id);
} }
} }

182
lib/Doctrine/ORM/Cache/ArrayCache.php
View file

@ -1,92 +1,92 @@
<?php <?php
/* /*
* $Id: Array.php 4910 2008-09-12 08:51:56Z romanb $ * $Id: Array.php 4910 2008-09-12 08:51:56Z romanb $
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* *
* This software consists of voluntary contributions made by many individuals * This software consists of voluntary contributions made by many individuals
* and is licensed under the LGPL. For more information, see * and is licensed under the LGPL. For more information, see
* <http://www.doctrine-project.org>. * <http://www.doctrine-project.org>.
*/ */
namespace Doctrine\ORM\Cache; namespace Doctrine\ORM\Cache;
/** /**
* Array cache driver. * Array cache driver.
* *
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link www.doctrine-project.org * @link www.doctrine-project.org
* @since 1.0 * @since 1.0
* @version $Revision: 4910 $ * @version $Revision: 4910 $
* @author Konsta Vesterinen <kvesteri@cc.hut.fi> * @author Konsta Vesterinen <kvesteri@cc.hut.fi>
*/ */
class ArrayCache implements Cache class ArrayCache implements Cache
{ {
/** /**
* @var array $data * @var array $data
*/ */
private $data; private $data;
/** /**
* {@inheritdoc} * {@inheritdoc}
*/ */
public function fetch($id) public function fetch($id)
{ {
if (isset($this->data[$id])) { if (isset($this->data[$id])) {
return $this->data[$id]; return $this->data[$id];
} }
return false; return false;
} }
/** /**
* {@inheritdoc} * {@inheritdoc}
*/ */
public function contains($id) public function contains($id)
{ {
return isset($this->data[$id]); return isset($this->data[$id]);
} }
/** /**
* {@inheritdoc} * {@inheritdoc}
*/ */
public function save($id, $data, $lifeTime = false) public function save($id, $data, $lifeTime = false)
{ {
$this->data[$id] = $data; $this->data[$id] = $data;
} }
/** /**
* {@inheritdoc} * {@inheritdoc}
*/ */
public function delete($id) public function delete($id)
{ {
unset($this->data[$id]); unset($this->data[$id]);
} }
/** /**
* {@inheritdoc} * {@inheritdoc}
*/ */
public function deleteAll() public function deleteAll()
{ {
$this->data = array(); $this->data = array();
} }
/** /**
* count * count
* *
* @return integer * @return integer
*/ */
public function count() public function count()
{ {
return count($this->data); return count($this->data);
} }
} }

140
lib/Doctrine/ORM/Cache/Cache.php
View file

@ -1,71 +1,71 @@
<?php <?php
/* /*
* $Id: Interface.php 3931 2008-03-05 11:24:33Z romanb $ * $Id: Interface.php 3931 2008-03-05 11:24:33Z romanb $
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* *
* This software consists of voluntary contributions made by many individuals * This software consists of voluntary contributions made by many individuals
* and is licensed under the LGPL. For more information, see * and is licensed under the LGPL. For more information, see
* <http://www.doctrine-project.org>. * <http://www.doctrine-project.org>.
*/ */
namespace Doctrine\ORM\Cache; namespace Doctrine\ORM\Cache;
/** /**
* Interface for cache drivers. * Interface for cache drivers.
* *
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link www.doctrine-project.org * @link www.doctrine-project.org
* @since 1.0 * @since 1.0
* @version $Revision: 3931 $ * @version $Revision: 3931 $
* @author Konsta Vesterinen <kvesteri@cc.hut.fi> * @author Konsta Vesterinen <kvesteri@cc.hut.fi>
* @author Roman Borschel <roman@code-factory.org> * @author Roman Borschel <roman@code-factory.org>
*/ */
interface Cache interface Cache
{ {
/** /**
* Test if a cache entry is available for the given id and (if yes) return it (false else). * Test if a cache entry is available for the given id and (if yes) return it (false else).
* *
* Note : return value is always "string" (unserialization is done by the core not by the backend) * Note : return value is always "string" (unserialization is done by the core not by the backend)
* *
* @param string $id cache id * @param string $id cache id
* @return string cached datas (or false) * @return string cached datas (or false)
*/ */
public function fetch($id); public function fetch($id);
/** /**
* Test if a cache is available or not (for the given id) * Test if a cache is available or not (for the given id)
* *
* @param string $id cache id * @param string $id cache id
* @return mixed false (a cache is not available) or "last modified" timestamp (int) of the available cache record * @return mixed false (a cache is not available) or "last modified" timestamp (int) of the available cache record
*/ */
public function contains($id); public function contains($id);
/** /**
* Puts data into the cache. * Puts data into the cache.
* *
* @param string $id cache id * @param string $id cache id
* @param string $data data to cache * @param string $data data to cache
* @param int $lifeTime if != false, set a specific lifetime for this cache record (null => infinite lifeTime) * @param int $lifeTime if != false, set a specific lifetime for this cache record (null => infinite lifeTime)
* @return boolean true if no problem * @return boolean true if no problem
*/ */
public function save($id, $data, $lifeTime = false); public function save($id, $data, $lifeTime = false);
/** /**
* Remove a cache record * Remove a cache record
* *
* @param string $id cache id * @param string $id cache id
* @return boolean true if no problem * @return boolean true if no problem
*/ */
public function delete($id); public function delete($id);
} }

360
lib/Doctrine/ORM/Cache/DbCache.php
View file

@ -1,181 +1,181 @@
<?php <?php
/* /*
* $Id: Db.php 3931 2008-03-05 11:24:33Z romanb $ * $Id: Db.php 3931 2008-03-05 11:24:33Z romanb $
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* *
* This software consists of voluntary contributions made by many individuals * This software consists of voluntary contributions made by many individuals
* and is licensed under the LGPL. For more information, see * and is licensed under the LGPL. For more information, see
* <http://www.doctrine-project.org>. * <http://www.doctrine-project.org>.
*/ */
namespace Doctrine\ORM\Cache; namespace Doctrine\ORM\Cache;
/** /**
* Doctrine_Cache_Db * Doctrine_Cache_Db
* *
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link www.doctrine-project.org * @link www.doctrine-project.org
* @since 1.0 * @since 1.0
* @version $Revision: 3931 $ * @version $Revision: 3931 $
* @author Konsta Vesterinen <kvesteri@cc.hut.fi> * @author Konsta Vesterinen <kvesteri@cc.hut.fi>
* @todo Needs some maintenance. Any takers? * @todo Needs some maintenance. Any takers?
*/ */
class DbCache implements Cache, \Countable class DbCache implements Cache, \Countable
{ {
private $_options = array(); private $_options = array();
/** /**
* {@inheritdoc} * {@inheritdoc}
*/ */
public function __construct($options) public function __construct($options)
{ {
if ( ! isset($options['connection']) || if ( ! isset($options['connection']) ||
! ($options['connection'] instanceof Doctrine_DBAL_Connection)) { ! ($options['connection'] instanceof Doctrine_DBAL_Connection)) {
throw \Doctrine\Common\DoctrineException::updateMe('Connection option not set.'); throw \Doctrine\Common\DoctrineException::updateMe('Connection option not set.');
} }
if ( ! isset($options['tableName']) || if ( ! isset($options['tableName']) ||
! is_string($options['tableName'])) { ! is_string($options['tableName'])) {
throw \Doctrine\Common\DoctrineException::updateMe('Table name option not set.'); throw \Doctrine\Common\DoctrineException::updateMe('Table name option not set.');
} }
$this->_options = $options; $this->_options = $options;
} }
/** /**
* getConnection * getConnection
* returns the connection object associated with this cache driver * returns the connection object associated with this cache driver
* *
* @return Doctrine_Connection connection object * @return Doctrine_Connection connection object
*/ */
public function getConnection() public function getConnection()
{ {
return $this->_options['connection']; return $this->_options['connection'];
} }
/** /**
* {@inheritdoc} * {@inheritdoc}
*/ */
public function fetch($id) public function fetch($id)
{ {
$sql = 'SELECT data, expire FROM ' . $this->_options['tableName'] $sql = 'SELECT data, expire FROM ' . $this->_options['tableName']
. ' WHERE id = ?'; . ' WHERE id = ?';
if ($testCacheValidity) { if ($testCacheValidity) {
$sql .= ' AND (expire=0 OR expire > ' . time() . ')'; $sql .= ' AND (expire=0 OR expire > ' . time() . ')';
} }
$result = $this->getConnection()->fetchAssoc($sql, array($id)); $result = $this->getConnection()->fetchAssoc($sql, array($id));
if ( ! isset($result[0])) { if ( ! isset($result[0])) {
return false; return false;
} }
return unserialize($result[0]['data']); return unserialize($result[0]['data']);
} }
/** /**
* {@inheritdoc} * {@inheritdoc}
*/ */
public function contains($id) public function contains($id)
{ {
$sql = 'SELECT expire FROM ' . $this->_options['tableName'] $sql = 'SELECT expire FROM ' . $this->_options['tableName']
. ' WHERE id = ? AND (expire=0 OR expire > ' . time() . ')'; . ' WHERE id = ? AND (expire=0 OR expire > ' . time() . ')';
return $this->getConnection()->fetchOne($sql, array($id)); return $this->getConnection()->fetchOne($sql, array($id));
} }
/** /**
* {@inheritdoc} * {@inheritdoc}
*/ */
public function save($data, $id, $lifeTime = false) public function save($data, $id, $lifeTime = false)
{ {
$sql = 'INSERT INTO ' . $this->_options['tableName'] $sql = 'INSERT INTO ' . $this->_options['tableName']
. ' (id, data, expire) VALUES (?, ?, ?)'; . ' (id, data, expire) VALUES (?, ?, ?)';
if ($lifeTime) { if ($lifeTime) {
$expire = time() + $lifeTime; $expire = time() + $lifeTime;
} else { } else {
$expire = 0; $expire = 0;
} }
$params = array($id, serialize($data), $expire); $params = array($id, serialize($data), $expire);
return (bool) $this->getConnection()->exec($sql, $params); return (bool) $this->getConnection()->exec($sql, $params);
} }
/** /**
* {@inheritdoc} * {@inheritdoc}
*/ */
public function delete($id) public function delete($id)
{ {
$sql = 'DELETE FROM ' . $this->_options['tableName'] . ' WHERE id = ?'; $sql = 'DELETE FROM ' . $this->_options['tableName'] . ' WHERE id = ?';
return (bool) $this->getConnection()->exec($sql, array($id)); return (bool) $this->getConnection()->exec($sql, array($id));
} }
/** /**
* Removes all cache records * Removes all cache records
* *
* $return bool true on success, false on failure * $return bool true on success, false on failure
*/ */
public function deleteAll() public function deleteAll()
{ {
$sql = 'DELETE FROM ' . $this->_options['tableName']; $sql = 'DELETE FROM ' . $this->_options['tableName'];
return (bool) $this->getConnection()->exec($sql); return (bool) $this->getConnection()->exec($sql);
} }
/** /**
* count * count
* returns the number of cached elements * returns the number of cached elements
* *
* @return integer * @return integer
*/ */
public function count() public function count()
{ {
$sql = 'SELECT COUNT(*) FROM ' . $this->_options['tableName']; $sql = 'SELECT COUNT(*) FROM ' . $this->_options['tableName'];
return (int) $this->getConnection()->fetchOne($sql); return (int) $this->getConnection()->fetchOne($sql);
} }
/** /**
* Creates the cache table. * Creates the cache table.
*/ */
public function createTable() public function createTable()
{ {
$name = $this->_options['tableName']; $name = $this->_options['tableName'];
$fields = array( $fields = array(
'id' => array( 'id' => array(
'type' => 'string', 'type' => 'string',
'length' => 255 'length' => 255
), ),
'data' => array( 'data' => array(
'type' => 'blob' 'type' => 'blob'
), ),
'expire' => array( 'expire' => array(
'type' => 'timestamp' 'type' => 'timestamp'
) )
); );
$options = array( $options = array(
'primary' => array('id') 'primary' => array('id')
); );
$this->getConnection()->export->createTable($name, $fields, $options); $this->getConnection()->export->createTable($name, $fields, $options);
} }
} }

200
lib/Doctrine/ORM/Cache/MemcacheCache.php
View file

@ -1,101 +1,101 @@
<?php <?php
/* /*
* $Id: Memcache.php 4910 2008-09-12 08:51:56Z romanb $ * $Id: Memcache.php 4910 2008-09-12 08:51:56Z romanb $
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* *
* This software consists of voluntary contributions made by many individuals * This software consists of voluntary contributions made by many individuals
* and is licensed under the LGPL. For more information, see * and is licensed under the LGPL. For more information, see
* <http://www.doctrine-project.org>. * <http://www.doctrine-project.org>.
*/ */
namespace Doctrine\ORM\Cache; namespace Doctrine\ORM\Cache;
/** /**
* Memcache cache driver. * Memcache cache driver.
* *
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link www.phpdoctrine.org * @link www.phpdoctrine.org
* @since 1.0 * @since 1.0
* @version $Revision: 4910 $ * @version $Revision: 4910 $
* @author Konsta Vesterinen <kvesteri@cc.hut.fi> * @author Konsta Vesterinen <kvesteri@cc.hut.fi>
*/ */
class MemcacheCache implements Cache class MemcacheCache implements Cache
{ {
/** /**
* @var Memcache $_memcache memcache object * @var Memcache $_memcache memcache object
*/ */
private $_memcache; private $_memcache;
/** /**
* {@inheritdoc} * {@inheritdoc}
*/ */
public function __construct() public function __construct()
{ {
if ( ! extension_loaded('memcache')) { if ( ! extension_loaded('memcache')) {
throw \Doctrine\Common\DoctrineException::updateMe('In order to use Memcache driver, the memcache extension must be loaded.'); throw \Doctrine\Common\DoctrineException::updateMe('In order to use Memcache driver, the memcache extension must be loaded.');
} }
} }
/** /**
* Sets the memcache instance to use. * Sets the memcache instance to use.
* *
* @param Memcache $memcache * @param Memcache $memcache
*/ */
public function setMemcache(Memcache $memcache) public function setMemcache(Memcache $memcache)
{ {
$this->_memcache = $memcache; $this->_memcache = $memcache;
} }
/** /**
* Gets the memcache instance used by the cache. * Gets the memcache instance used by the cache.
* *
* @return Memcache * @return Memcache
*/ */
public function getMemcache() public function getMemcache()
{ {
return $this->_memcache; return $this->_memcache;
} }
/** /**
* {@inheritdoc} * {@inheritdoc}
*/ */
public function fetch($id) public function fetch($id)
{ {
return $this->_memcache->get($id); return $this->_memcache->get($id);
} }
/** /**
* {@inheritdoc} * {@inheritdoc}
*/ */
public function contains($id) public function contains($id)
{ {
return (bool) $this->_memcache->get($id); return (bool) $this->_memcache->get($id);
} }
/** /**
* {@inheritdoc} * {@inheritdoc}
*/ */
public function save($id, $data, $lifeTime = false) public function save($id, $data, $lifeTime = false)
{ {
return $this->_memcache->set($id, $data, 0, $lifeTime); return $this->_memcache->set($id, $data, 0, $lifeTime);
} }
/** /**
* {@inheritdoc} * {@inheritdoc}
*/ */
public function delete($id) public function delete($id)
{ {
return $this->_memcache->delete($id); return $this->_memcache->delete($id);
} }
} }

122
lib/Doctrine/ORM/Query/AST/DeleteStatement.php
View file

@ -1,62 +1,62 @@
<?php <?php
/* /*
* $Id$ * $Id$
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* *
* This software consists of voluntary contributions made by many individuals * This software consists of voluntary contributions made by many individuals
* and is licensed under the LGPL. For more information, see * and is licensed under the LGPL. For more information, see
* <http://www.phpdoctrine.org>. * <http://www.phpdoctrine.org>.
*/ */
namespace Doctrine\ORM\Query\AST; namespace Doctrine\ORM\Query\AST;
/** /**
* DeleteStatement = DeleteClause [WhereClause] * DeleteStatement = DeleteClause [WhereClause]
* *
* @author Guilherme Blanco <guilhermeblanco@hotmail.com> * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link http://www.phpdoctrine.org * @link http://www.phpdoctrine.org
* @since 2.0 * @since 2.0
* @version $Revision$ * @version $Revision$
*/ */
class DeleteStatement extends Node class DeleteStatement extends Node
{ {
private $_deleteClause; private $_deleteClause;
private $_whereClause; private $_whereClause;
public function __construct($deleteClause) public function __construct($deleteClause)
{ {
$this->_deleteClause = $deleteClause; $this->_deleteClause = $deleteClause;
} }
public function setWhereClause($whereClause) public function setWhereClause($whereClause)
{ {
$this->_whereClause = $whereClause; $this->_whereClause = $whereClause;
} }
public function getDeleteClause() public function getDeleteClause()
{ {
return $this->_deleteClause; return $this->_deleteClause;
} }
public function getWhereClause() public function getWhereClause()
{ {
return $this->_whereClause; return $this->_whereClause;
} }
public function dispatch($sqlWalker) public function dispatch($sqlWalker)
{ {
return $sqlWalker->walkDeleteStatement($this); return $sqlWalker->walkDeleteStatement($this);
} }
} }

102
lib/Doctrine/ORM/Query/AST/FromClause.php
View file

@ -1,52 +1,52 @@
<?php <?php
/* /*
* $Id$ * $Id$
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* *
* This software consists of voluntary contributions made by many individuals * This software consists of voluntary contributions made by many individuals
* and is licensed under the LGPL. For more information, see * and is licensed under the LGPL. For more information, see
* <http://www.phpdoctrine.org>. * <http://www.phpdoctrine.org>.
*/ */
namespace Doctrine\ORM\Query\AST; namespace Doctrine\ORM\Query\AST;
/** /**
* FromClause ::= "FROM" IdentificationVariableDeclaration {"," IdentificationVariableDeclaration} * FromClause ::= "FROM" IdentificationVariableDeclaration {"," IdentificationVariableDeclaration}
* *
* @author Guilherme Blanco <guilhermeblanco@hotmail.com> * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link http://www.phpdoctrine.org * @link http://www.phpdoctrine.org
* @since 2.0 * @since 2.0
* @version $Revision$ * @version $Revision$
*/ */
class FromClause extends Node class FromClause extends Node
{ {
protected $_identificationVariableDeclarations = array(); protected $_identificationVariableDeclarations = array();
public function __construct(array $identificationVariableDeclarations) public function __construct(array $identificationVariableDeclarations)
{ {
$this->_identificationVariableDeclarations = $identificationVariableDeclarations; $this->_identificationVariableDeclarations = $identificationVariableDeclarations;
} }
/* Getters */ /* Getters */
public function getIdentificationVariableDeclarations() public function getIdentificationVariableDeclarations()
{ {
return $this->_identificationVariableDeclarations; return $this->_identificationVariableDeclarations;
} }
public function dispatch($sqlWalker) public function dispatch($sqlWalker)
{ {
return $sqlWalker->walkFromClause($this); return $sqlWalker->walkFromClause($this);
} }
} }

138
lib/Doctrine/ORM/Query/AST/IdentificationVariableDeclaration.php
View file

@ -1,70 +1,70 @@
<?php <?php
/* /*
* $Id$ * $Id$
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* *
* This software consists of voluntary contributions made by many individuals * This software consists of voluntary contributions made by many individuals
* and is licensed under the LGPL. For more information, see * and is licensed under the LGPL. For more information, see
* <http://www.doctrine-project.org>. * <http://www.doctrine-project.org>.
*/ */
namespace Doctrine\ORM\Query\AST; namespace Doctrine\ORM\Query\AST;
/** /**
* IdentificationVariableDeclaration ::= RangeVariableDeclaration [IndexBy] {JoinVariableDeclaration}* * IdentificationVariableDeclaration ::= RangeVariableDeclaration [IndexBy] {JoinVariableDeclaration}*
* *
* @author Guilherme Blanco <guilhermeblanco@hotmail.com> * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link http://www.doctrine-project.org * @link http://www.doctrine-project.org
* @since 2.0 * @since 2.0
* @version $Revision$ * @version $Revision$
*/ */
class IdentificationVariableDeclaration extends Node class IdentificationVariableDeclaration extends Node
{ {
protected $_rangeVariableDeclaration = null; protected $_rangeVariableDeclaration = null;
protected $_indexBy = null; protected $_indexBy = null;
protected $_joinVariableDeclarations = array(); protected $_joinVariableDeclarations = array();
public function __construct($rangeVariableDecl, $indexBy, array $joinVariableDecls) public function __construct($rangeVariableDecl, $indexBy, array $joinVariableDecls)
{ {
$this->_rangeVariableDeclaration = $rangeVariableDecl; $this->_rangeVariableDeclaration = $rangeVariableDecl;
$this->_indexBy = $indexBy; $this->_indexBy = $indexBy;
$this->_joinVariableDeclarations = $joinVariableDecls; $this->_joinVariableDeclarations = $joinVariableDecls;
} }
/* Getters */ /* Getters */
public function getRangeVariableDeclaration() public function getRangeVariableDeclaration()
{ {
return $this->_rangeVariableDeclaration; return $this->_rangeVariableDeclaration;
} }
public function getIndexBy() public function getIndexBy()
{ {
return $this->_indexBy; return $this->_indexBy;
} }
public function getJoinVariableDeclarations() public function getJoinVariableDeclarations()
{ {
return $this->_joinVariableDeclarations; return $this->_joinVariableDeclarations;
} }
public function dispatch($sqlWalker) public function dispatch($sqlWalker)
{ {
return $sqlWalker->walkIdentificationVariableDeclaration($this); return $sqlWalker->walkIdentificationVariableDeclaration($this);
} }
} }

102
lib/Doctrine/ORM/Query/AST/IndexBy.php
View file

@ -1,52 +1,52 @@
<?php <?php
/* /*
* $Id$ * $Id$
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* *
* This software consists of voluntary contributions made by many individuals * This software consists of voluntary contributions made by many individuals
* and is licensed under the LGPL. For more information, see * and is licensed under the LGPL. For more information, see
* <http://www.doctrine-project.org>. * <http://www.doctrine-project.org>.
*/ */
namespace Doctrine\ORM\Query\AST; namespace Doctrine\ORM\Query\AST;
/** /**
* IndexBy ::= "INDEX" "BY" SimpleStateFieldPathExpression * IndexBy ::= "INDEX" "BY" SimpleStateFieldPathExpression
* *
* @author Guilherme Blanco <guilhermeblanco@hotmail.com> * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link http://www.doctrine-project.org * @link http://www.doctrine-project.org
* @since 2.0 * @since 2.0
* @version $Revision$ * @version $Revision$
*/ */
class IndexBy extends Node class IndexBy extends Node
{ {
protected $_simpleStateFieldPathExpression = null; protected $_simpleStateFieldPathExpression = null;
public function __construct($simpleStateFieldPathExpression) public function __construct($simpleStateFieldPathExpression)
{ {
$this->_simpleStateFieldPathExpression = $simpleStateFieldPathExpression; $this->_simpleStateFieldPathExpression = $simpleStateFieldPathExpression;
} }
/* Getters */ /* Getters */
public function getSimpleStateFieldPathExpression() public function getSimpleStateFieldPathExpression()
{ {
return $this->_simpleStateFieldPathExpression; return $this->_simpleStateFieldPathExpression;
} }
public function dispatch($sqlWalker) public function dispatch($sqlWalker)
{ {
return $sqlWalker->walkIndexBy($this); return $sqlWalker->walkIndexBy($this);
} }
} }

192
lib/Doctrine/ORM/Query/AST/Join.php
View file

@ -1,97 +1,97 @@
<?php <?php
/* /*
* $Id$ * $Id$
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* *
* This software consists of voluntary contributions made by many individuals * This software consists of voluntary contributions made by many individuals
* and is licensed under the LGPL. For more information, see * and is licensed under the LGPL. For more information, see
* <http://www.phpdoctrine.org>. * <http://www.phpdoctrine.org>.
*/ */
namespace Doctrine\ORM\Query\AST; namespace Doctrine\ORM\Query\AST;
/** /**
* Join ::= ["LEFT" ["OUTER"] | "INNER"] "JOIN" JoinAssociationPathExpression * Join ::= ["LEFT" ["OUTER"] | "INNER"] "JOIN" JoinAssociationPathExpression
* ["AS"] AliasIdentificationVariable [("ON" | "WITH") ConditionalExpression] * ["AS"] AliasIdentificationVariable [("ON" | "WITH") ConditionalExpression]
* *
* @author Guilherme Blanco <guilhermeblanco@hotmail.com> * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link http://www.phpdoctrine.org * @link http://www.phpdoctrine.org
* @since 2.0 * @since 2.0
* @version $Revision$ * @version $Revision$
*/ */
class Join extends Node class Join extends Node
{ {
const JOIN_TYPE_LEFT = 1; const JOIN_TYPE_LEFT = 1;
const JOIN_TYPE_LEFTOUTER = 2; const JOIN_TYPE_LEFTOUTER = 2;
const JOIN_TYPE_INNER = 3; const JOIN_TYPE_INNER = 3;
const JOIN_WHERE_ON = 1; const JOIN_WHERE_ON = 1;
const JOIN_WHERE_WITH = 2; const JOIN_WHERE_WITH = 2;
protected $_joinType = self::JOIN_TYPE_INNER; protected $_joinType = self::JOIN_TYPE_INNER;
protected $_joinAssociationPathExpression = null; protected $_joinAssociationPathExpression = null;
protected $_aliasIdentificationVariable = null; protected $_aliasIdentificationVariable = null;
protected $_whereType = self::JOIN_WHERE_WITH; protected $_whereType = self::JOIN_WHERE_WITH;
protected $_conditionalExpression = null; protected $_conditionalExpression = null;
public function __construct($joinType, $joinAssocPathExpr, $aliasIdentVar) public function __construct($joinType, $joinAssocPathExpr, $aliasIdentVar)
{ {
$this->_joinType = $joinType; $this->_joinType = $joinType;
$this->_joinAssociationPathExpression = $joinAssocPathExpr; $this->_joinAssociationPathExpression = $joinAssocPathExpr;
$this->_aliasIdentificationVariable = $aliasIdentVar; $this->_aliasIdentificationVariable = $aliasIdentVar;
} }
/* Setters */ /* Setters */
public function setWhereType($whereType) public function setWhereType($whereType)
{ {
$this->_whereType = $whereType; $this->_whereType = $whereType;
} }
public function setConditionalExpression($conditionalExpression) public function setConditionalExpression($conditionalExpression)
{ {
$this->_conditionalExpression = $conditionalExpression; $this->_conditionalExpression = $conditionalExpression;
} }
/* Getters */ /* Getters */
public function getJoinType() public function getJoinType()
{ {
return $this->_joinType; return $this->_joinType;
} }
public function getJoinAssociationPathExpression() public function getJoinAssociationPathExpression()
{ {
return $this->_joinAssociationPathExpression; return $this->_joinAssociationPathExpression;
} }
public function getAliasIdentificationVariable() public function getAliasIdentificationVariable()
{ {
return $this->_aliasIdentificationVariable; return $this->_aliasIdentificationVariable;
} }
public function getWhereType() public function getWhereType()
{ {
return $this->_whereType; return $this->_whereType;
} }
public function getConditionalExpression() public function getConditionalExpression()
{ {
return $this->_conditionalExpression; return $this->_conditionalExpression;
} }
public function dispatch($sqlWalker) public function dispatch($sqlWalker)
{ {
return $sqlWalker->walkJoin($this); return $sqlWalker->walkJoin($this);
} }
} }

116
lib/Doctrine/ORM/Query/AST/JoinVariableDeclaration.php
View file

@ -1,59 +1,59 @@
<?php <?php
/* /*
* $Id$ * $Id$
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* *
* This software consists of voluntary contributions made by many individuals * This software consists of voluntary contributions made by many individuals
* and is licensed under the LGPL. For more information, see * and is licensed under the LGPL. For more information, see
* <http://www.phpdoctrine.org>. * <http://www.phpdoctrine.org>.
*/ */
namespace Doctrine\ORM\Query\AST; namespace Doctrine\ORM\Query\AST;
/** /**
* JoinVariableDeclaration ::= Join [IndexBy] * JoinVariableDeclaration ::= Join [IndexBy]
* *
* @author Guilherme Blanco <guilhermeblanco@hotmail.com> * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link http://www.phpdoctrine.org * @link http://www.phpdoctrine.org
* @since 2.0 * @since 2.0
* @version $Revision$ * @version $Revision$
*/ */
class JoinVariableDeclaration extends Node class JoinVariableDeclaration extends Node
{ {
protected $_join = null; protected $_join = null;
protected $_indexBy = null; protected $_indexBy = null;
public function __construct($join, $indexBy) public function __construct($join, $indexBy)
{ {
$this->_join = $join; $this->_join = $join;
$this->_indexBy = $indexBy; $this->_indexBy = $indexBy;
} }
/* Getters */ /* Getters */
public function getJoin() public function getJoin()
{ {
return $this->_join; return $this->_join;
} }
public function getIndexBy() public function getIndexBy()
{ {
return $this->_indexBy; return $this->_indexBy;
} }
public function dispatch($sqlWalker) public function dispatch($sqlWalker)
{ {
return $sqlWalker->walkJoinVariableDeclaration($this); return $sqlWalker->walkJoinVariableDeclaration($this);
} }
} }

74
lib/Doctrine/ORM/Query/AST/Node.php
View file

@ -1,38 +1,38 @@
<?php <?php
/* /*
* $Id$ * $Id$
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* *
* This software consists of voluntary contributions made by many individuals * This software consists of voluntary contributions made by many individuals
* and is licensed under the LGPL. For more information, see * and is licensed under the LGPL. For more information, see
* <http://www.doctrine-project.org>. * <http://www.doctrine-project.org>.
*/ */
namespace Doctrine\ORM\Query\AST; namespace Doctrine\ORM\Query\AST;
/** /**
* Abstract class of an AST node * Abstract class of an AST node
* *
* @author Guilherme Blanco <guilhermeblanco@hotmail.com> * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
* @author Janne Vanhala <jpvanhal@cc.hut.fi> * @author Janne Vanhala <jpvanhal@cc.hut.fi>
* @author Roman Borschel <roman@code-factory.org> * @author Roman Borschel <roman@code-factory.org>
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link http://www.doctrine-project.org * @link http://www.doctrine-project.org
* @since 2.0 * @since 2.0
* @version $Revision$ * @version $Revision$
*/ */
abstract class Node abstract class Node
{ {
abstract public function dispatch($sqlWalker); abstract public function dispatch($sqlWalker);
} }

130
lib/Doctrine/ORM/Query/AST/RangeVariableDeclaration.php
View file

@ -1,66 +1,66 @@
<?php <?php
/* /*
* $Id$ * $Id$
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* *
* This software consists of voluntary contributions made by many individuals * This software consists of voluntary contributions made by many individuals
* and is licensed under the LGPL. For more information, see * and is licensed under the LGPL. For more information, see
* <http://www.doctrine-project.org>. * <http://www.doctrine-project.org>.
*/ */
namespace Doctrine\ORM\Query\AST; namespace Doctrine\ORM\Query\AST;
/** /**
* RangeVariableDeclaration ::= AbstractSchemaName ["AS"] AliasIdentificationVariable * RangeVariableDeclaration ::= AbstractSchemaName ["AS"] AliasIdentificationVariable
* *
* @author Guilherme Blanco <guilhermeblanco@hotmail.com> * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link http://www.doctrine-project.org * @link http://www.doctrine-project.org
* @since 2.0 * @since 2.0
* @version $Revision$ * @version $Revision$
*/ */
class RangeVariableDeclaration extends Node class RangeVariableDeclaration extends Node
{ {
private $_classMetadata; private $_classMetadata;
private $_abstractSchemaName; private $_abstractSchemaName;
private $_aliasIdentificationVariable; private $_aliasIdentificationVariable;
public function __construct($classMetadata, $aliasIdentificationVar) public function __construct($classMetadata, $aliasIdentificationVar)
{ {
$this->_classMetadata = $classMetadata; $this->_classMetadata = $classMetadata;
$this->_abstractSchemaName = $classMetadata->name; $this->_abstractSchemaName = $classMetadata->name;
$this->_aliasIdentificationVariable = $aliasIdentificationVar; $this->_aliasIdentificationVariable = $aliasIdentificationVar;
} }
/* Getters */ /* Getters */
public function getAbstractSchemaName() public function getAbstractSchemaName()
{ {
return $this->_abstractSchemaName; return $this->_abstractSchemaName;
} }
public function getAliasIdentificationVariable() public function getAliasIdentificationVariable()
{ {
return $this->_aliasIdentificationVariable; return $this->_aliasIdentificationVariable;
} }
public function getClassMetadata() public function getClassMetadata()
{ {
return $this->_classMetadata; return $this->_classMetadata;
} }
public function dispatch($sqlWalker) public function dispatch($sqlWalker)
{ {
return $sqlWalker->walkRangeVariableDeclaration($this); return $sqlWalker->walkRangeVariableDeclaration($this);
} }
} }

152
lib/Doctrine/ORM/Query/AST/SelectClause.php
View file

@ -1,77 +1,77 @@
<?php <?php
/* /*
* $Id$ * $Id$
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* *
* This software consists of voluntary contributions made by many individuals * This software consists of voluntary contributions made by many individuals
* and is licensed under the LGPL. For more information, see * and is licensed under the LGPL. For more information, see
* <http://www.doctrine-project.org>. * <http://www.doctrine-project.org>.
*/ */
namespace Doctrine\ORM\Query\AST; namespace Doctrine\ORM\Query\AST;
/** /**
* SelectClause = "SELECT" ["DISTINCT"] SelectExpression {"," SelectExpression} * SelectClause = "SELECT" ["DISTINCT"] SelectExpression {"," SelectExpression}
* *
* @author Guilherme Blanco <guilhermeblanco@hotmail.com> * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link http://www.doctrine-project.org * @link http://www.doctrine-project.org
* @since 2.0 * @since 2.0
* @version $Revision$ * @version $Revision$
*/ */
class SelectClause extends Node class SelectClause extends Node
{ {
protected $_isDistinct; protected $_isDistinct;
protected $_selectExpressions = array(); protected $_selectExpressions = array();
public function __construct(array $selectExpressions, $isDistinct) public function __construct(array $selectExpressions, $isDistinct)
{ {
$this->_isDistinct = $isDistinct; $this->_isDistinct = $isDistinct;
$this->_selectExpressions = $selectExpressions; $this->_selectExpressions = $selectExpressions;
} }
/* Getters */ /* Getters */
public function isDistinct() public function isDistinct()
{ {
return $this->_isDistinct; return $this->_isDistinct;
} }
public function getSelectExpressions() public function getSelectExpressions()
{ {
return $this->_selectExpressions; return $this->_selectExpressions;
} }
/* REMOVE ME LATER. COPIED METHODS FROM SPLIT OF PRODUCTION INTO "AST" AND "PARSER" */ /* REMOVE ME LATER. COPIED METHODS FROM SPLIT OF PRODUCTION INTO "AST" AND "PARSER" */
public function buildSql() public function buildSql()
{ {
return 'SELECT ' . (($this->_isDistinct) ? 'DISTINCT ' : '') return 'SELECT ' . (($this->_isDistinct) ? 'DISTINCT ' : '')
. implode(', ', $this->_mapSelectExpressions()); . implode(', ', $this->_mapSelectExpressions());
} }
protected function _mapSelectExpressions() protected function _mapSelectExpressions()
{ {
return array_map(array(&$this, '_mapSelectExpression'), $this->_selectExpressions); return array_map(array(&$this, '_mapSelectExpression'), $this->_selectExpressions);
} }
protected function _mapSelectExpression($value) protected function _mapSelectExpression($value)
{ {
return is_object($value) ? $value->buildSql() : $value; return is_object($value) ? $value->buildSql() : $value;
} }
public function dispatch($sqlWalker) public function dispatch($sqlWalker)
{ {
return $sqlWalker->walkSelectClause($this); return $sqlWalker->walkSelectClause($this);
} }
} }

118
lib/Doctrine/ORM/Query/AST/SelectExpression.php
View file

@ -1,60 +1,60 @@
<?php <?php
/* /*
* $Id$ * $Id$
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* *
* This software consists of voluntary contributions made by many individuals * This software consists of voluntary contributions made by many individuals
* and is licensed under the LGPL. For more information, see * and is licensed under the LGPL. For more information, see
* <http://www.phpdoctrine.org>. * <http://www.phpdoctrine.org>.
*/ */
namespace Doctrine\ORM\Query\AST; namespace Doctrine\ORM\Query\AST;
/** /**
* SelectExpression ::= IdentificationVariable ["." "*"] | StateFieldPathExpression | * SelectExpression ::= IdentificationVariable ["." "*"] | StateFieldPathExpression |
* (AggregateExpression | "(" Subselect ")") [["AS"] FieldAliasIdentificationVariable] * (AggregateExpression | "(" Subselect ")") [["AS"] FieldAliasIdentificationVariable]
* *
* @author Guilherme Blanco <guilhermeblanco@hotmail.com> * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link http://www.phpdoctrine.org * @link http://www.phpdoctrine.org
* @since 2.0 * @since 2.0
* @version $Revision$ * @version $Revision$
*/ */
class SelectExpression extends Node class SelectExpression extends Node
{ {
protected $_expression; protected $_expression;
protected $_fieldIdentificationVariable; protected $_fieldIdentificationVariable;
public function __construct($expression, $fieldIdentificationVariable) public function __construct($expression, $fieldIdentificationVariable)
{ {
$this->_expression = $expression; $this->_expression = $expression;
$this->_fieldIdentificationVariable = $fieldIdentificationVariable; $this->_fieldIdentificationVariable = $fieldIdentificationVariable;
} }
/* Getters */ /* Getters */
public function getExpression() public function getExpression()
{ {
return $this->_expression; return $this->_expression;
} }
public function getFieldIdentificationVariable() public function getFieldIdentificationVariable()
{ {
return $this->_fieldIdentificationVariable; return $this->_fieldIdentificationVariable;
} }
public function dispatch($sqlWalker) public function dispatch($sqlWalker)
{ {
return $sqlWalker->walkSelectExpression($this); return $sqlWalker->walkSelectExpression($this);
} }
} }

172
lib/Doctrine/ORM/Query/AST/SelectStatement.php
View file

@ -1,87 +1,87 @@
<?php <?php
/* /*
* $Id$ * $Id$
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* *
* This software consists of voluntary contributions made by many individuals * This software consists of voluntary contributions made by many individuals
* and is licensed under the LGPL. For more information, see * and is licensed under the LGPL. For more information, see
* <http://www.phpdoctrine.org>. * <http://www.phpdoctrine.org>.
*/ */
namespace Doctrine\ORM\Query\AST; namespace Doctrine\ORM\Query\AST;
/** /**
* SelectStatement = SelectClause FromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause] * SelectStatement = SelectClause FromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause]
* *
* @author Guilherme Blanco <guilhermeblanco@hotmail.com> * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link http://www.phpdoctrine.org * @link http://www.phpdoctrine.org
* @since 2.0 * @since 2.0
* @version $Revision$ * @version $Revision$
*/ */
class SelectStatement extends Node class SelectStatement extends Node
{ {
protected $_selectClause; protected $_selectClause;
protected $_fromClause; protected $_fromClause;
protected $_whereClause; protected $_whereClause;
protected $_groupByClause; protected $_groupByClause;
protected $_havingClause; protected $_havingClause;
protected $_orderByClause; protected $_orderByClause;
public function __construct($selectClause, $fromClause, $whereClause, $groupByClause, public function __construct($selectClause, $fromClause, $whereClause, $groupByClause,
$havingClause, $orderByClause) { $havingClause, $orderByClause) {
$this->_selectClause = $selectClause; $this->_selectClause = $selectClause;
$this->_fromClause = $fromClause; $this->_fromClause = $fromClause;
$this->_whereClause = $whereClause; $this->_whereClause = $whereClause;
$this->_groupByClause = $groupByClause; $this->_groupByClause = $groupByClause;
$this->_havingClause = $havingClause; $this->_havingClause = $havingClause;
$this->_orderByClause = $orderByClause; $this->_orderByClause = $orderByClause;
} }
/* Getters */ /* Getters */
public function getSelectClause() public function getSelectClause()
{ {
return $this->_selectClause; return $this->_selectClause;
} }
public function getFromClause() public function getFromClause()
{ {
return $this->_fromClause; return $this->_fromClause;
} }
public function getWhereClause() public function getWhereClause()
{ {
return $this->_whereClause; return $this->_whereClause;
} }
public function getGroupByClause() public function getGroupByClause()
{ {
return $this->_groupByClause; return $this->_groupByClause;
} }
public function getHavingClause() public function getHavingClause()
{ {
return $this->_havingClause; return $this->_havingClause;
} }
public function getOrderByClause() public function getOrderByClause()
{ {
return $this->_orderByClause; return $this->_orderByClause;
} }
public function dispatch($sqlWalker) public function dispatch($sqlWalker)
{ {
return $sqlWalker->walkSelectStatement($this); return $sqlWalker->walkSelectStatement($this);
} }
} }

124
lib/Doctrine/ORM/Query/AST/SimpleSelectClause.php
View file

@ -1,63 +1,63 @@
<?php <?php
/* /*
* $Id$ * $Id$
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* *
* This software consists of voluntary contributions made by many individuals * This software consists of voluntary contributions made by many individuals
* and is licensed under the LGPL. For more information, see * and is licensed under the LGPL. For more information, see
* <http://www.doctrine-project.org>. * <http://www.doctrine-project.org>.
*/ */
namespace Doctrine\ORM\Query\AST; namespace Doctrine\ORM\Query\AST;
/** /**
* SimpleSelectClause ::= "SELECT" ["DISTINCT"] SimpleSelectExpression * SimpleSelectClause ::= "SELECT" ["DISTINCT"] SimpleSelectExpression
* *
* @author Guilherme Blanco <guilhermeblanco@hotmail.com> * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link http://www.doctrine-project.org * @link http://www.doctrine-project.org
* @since 2.0 * @since 2.0
* @version $Revision$ * @version $Revision$
*/ */
class SimpleSelectClause extends Node class SimpleSelectClause extends Node
{ {
private $_isDistinct = false; private $_isDistinct = false;
private $_simpleSelectExpression; private $_simpleSelectExpression;
public function __construct($simpleSelectExpression) public function __construct($simpleSelectExpression)
{ {
$this->_simpleSelectExpression = $simpleSelectExpression; $this->_simpleSelectExpression = $simpleSelectExpression;
} }
/* Getters */ /* Getters */
public function isDistinct() public function isDistinct()
{ {
return $this->_isDistinct; return $this->_isDistinct;
} }
public function setDistinct($bool) public function setDistinct($bool)
{ {
$this->_isDistinct = $bool; $this->_isDistinct = $bool;
} }
public function getSimpleSelectExpression() public function getSimpleSelectExpression()
{ {
return $this->_simpleSelectExpression; return $this->_simpleSelectExpression;
} }
public function dispatch($sqlWalker) public function dispatch($sqlWalker)
{ {
return $sqlWalker->walkSimpleSelectClause($this); return $sqlWalker->walkSimpleSelectClause($this);
} }
} }

124
lib/Doctrine/ORM/Query/AST/SimpleSelectExpression.php
View file

@ -1,63 +1,63 @@
<?php <?php
/* /*
* $Id$ * $Id$
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* *
* This software consists of voluntary contributions made by many individuals * This software consists of voluntary contributions made by many individuals
* and is licensed under the LGPL. For more information, see * and is licensed under the LGPL. For more information, see
* <http://www.doctrine-project.org>. * <http://www.doctrine-project.org>.
*/ */
namespace Doctrine\ORM\Query\AST; namespace Doctrine\ORM\Query\AST;
/** /**
* SimpleSelectExpression ::= StateFieldPathExpression | IdentificationVariable * SimpleSelectExpression ::= StateFieldPathExpression | IdentificationVariable
* | (AggregateExpression [["AS"] FieldAliasIdentificationVariable]) * | (AggregateExpression [["AS"] FieldAliasIdentificationVariable])
* *
* @author Guilherme Blanco <guilhermeblanco@hotmail.com> * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link http://www.doctrine-project.org * @link http://www.doctrine-project.org
* @since 2.0 * @since 2.0
* @version $Revision$ * @version $Revision$
*/ */
class SimpleSelectExpression extends Node class SimpleSelectExpression extends Node
{ {
private $_expression; private $_expression;
private $_fieldIdentificationVariable; private $_fieldIdentificationVariable;
public function __construct($expression) public function __construct($expression)
{ {
$this->_expression = $expression; $this->_expression = $expression;
} }
public function getExpression() public function getExpression()
{ {
return $this->_expression; return $this->_expression;
} }
public function getFieldIdentificationVariable() public function getFieldIdentificationVariable()
{ {
return $this->_fieldIdentificationVariable; return $this->_fieldIdentificationVariable;
} }
public function setFieldIdentificationVariable($fieldAlias) public function setFieldIdentificationVariable($fieldAlias)
{ {
$this->_fieldIdentificationVariable = $fieldAlias; $this->_fieldIdentificationVariable = $fieldAlias;
} }
public function dispatch($sqlWalker) public function dispatch($sqlWalker)
{ {
return $sqlWalker->walkSimpleSelectExpression($this); return $sqlWalker->walkSimpleSelectExpression($this);
} }
} }

116
lib/Doctrine/ORM/Query/AST/SimpleStateFieldPathExpression.php
View file

@ -1,59 +1,59 @@
<?php <?php
/* /*
* $Id$ * $Id$
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* *
* This software consists of voluntary contributions made by many individuals * This software consists of voluntary contributions made by many individuals
* and is licensed under the LGPL. For more information, see * and is licensed under the LGPL. For more information, see
* <http://www.doctrine-project.org>. * <http://www.doctrine-project.org>.
*/ */
namespace Doctrine\ORM\Query\AST; namespace Doctrine\ORM\Query\AST;
/** /**
* SimpleStateFieldPathExpression ::= IdentificationVariable "." SimpleStateField * SimpleStateFieldPathExpression ::= IdentificationVariable "." SimpleStateField
* *
* @author Guilherme Blanco <guilhermeblanco@hotmail.com> * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link http://www.doctrine-project.org * @link http://www.doctrine-project.org
* @since 2.0 * @since 2.0
* @version $Revision$ * @version $Revision$
*/ */
class SimpleStateFieldPathExpression extends Node class SimpleStateFieldPathExpression extends Node
{ {
private $_identificationVariable = null; private $_identificationVariable = null;
private $_simpleStateField = null; private $_simpleStateField = null;
public function __construct($identificationVariable, $simpleStateField) public function __construct($identificationVariable, $simpleStateField)
{ {
$this->_identificationVariable = $identificationVariable; $this->_identificationVariable = $identificationVariable;
$this->_simpleStateField = $simpleStateField; $this->_simpleStateField = $simpleStateField;
} }
/* Getters */ /* Getters */
public function getIdentificationVariable() public function getIdentificationVariable()
{ {
return $this->_identificationVariable; return $this->_identificationVariable;
} }
public function getSimpleStateField() public function getSimpleStateField()
{ {
return $this->_simpleStateField; return $this->_simpleStateField;
} }
public function dispatch($sqlWalker) public function dispatch($sqlWalker)
{ {
return $sqlWalker->walkSimpleStateFieldPathExpression($this); return $sqlWalker->walkSimpleStateFieldPathExpression($this);
} }
} }

204
lib/Doctrine/ORM/Query/AST/Subselect.php
View file

@ -1,103 +1,103 @@
<?php <?php
/* /*
* $Id$ * $Id$
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* *
* This software consists of voluntary contributions made by many individuals * This software consists of voluntary contributions made by many individuals
* and is licensed under the LGPL. For more information, see * and is licensed under the LGPL. For more information, see
* <http://www.doctrine-project.org>. * <http://www.doctrine-project.org>.
*/ */
namespace Doctrine\ORM\Query\AST; namespace Doctrine\ORM\Query\AST;
/** /**
* Subselect ::= SimpleSelectClause SubselectFromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause] * Subselect ::= SimpleSelectClause SubselectFromClause [WhereClause] [GroupByClause] [HavingClause] [OrderByClause]
* *
* @author Guilherme Blanco <guilhermeblanco@hotmail.com> * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link http://www.doctrine-project.org * @link http://www.doctrine-project.org
* @since 2.0 * @since 2.0
* @version $Revision$ * @version $Revision$
*/ */
class Subselect extends Node class Subselect extends Node
{ {
private $_simpleSelectClause; private $_simpleSelectClause;
private $_subselectFromClause; private $_subselectFromClause;
private $_whereClause; private $_whereClause;
private $_groupByClause; private $_groupByClause;
private $_havingClause; private $_havingClause;
private $_orderByClause; private $_orderByClause;
public function __construct($simpleSelectClause, $subselectFromClause) public function __construct($simpleSelectClause, $subselectFromClause)
{ {
$this->_simpleSelectClause = $simpleSelectClause; $this->_simpleSelectClause = $simpleSelectClause;
$this->_subselectFromClause = $subselectFromClause; $this->_subselectFromClause = $subselectFromClause;
} }
/* Getters */ /* Getters */
public function getSimpleSelectClause() public function getSimpleSelectClause()
{ {
return $this->_simpleSelectClause; return $this->_simpleSelectClause;
} }
public function getSubselectFromClause() public function getSubselectFromClause()
{ {
return $this->_subselectFromClause; return $this->_subselectFromClause;
} }
public function getWhereClause() public function getWhereClause()
{ {
return $this->_whereClause; return $this->_whereClause;
} }
public function setWhereClause($whereClause) public function setWhereClause($whereClause)
{ {
$this->_whereClause = $whereClause; $this->_whereClause = $whereClause;
} }
public function getGroupByClause() public function getGroupByClause()
{ {
return $this->_groupByClause; return $this->_groupByClause;
} }
public function setGroupByClause($groupByClause) public function setGroupByClause($groupByClause)
{ {
$this->_groupByClause = $groupByClause; $this->_groupByClause = $groupByClause;
} }
public function getHavingClause() public function getHavingClause()
{ {
return $this->_havingClause; return $this->_havingClause;
} }
public function setHavingClause($havingClause) public function setHavingClause($havingClause)
{ {
$this->_havingClause = $havingClause; $this->_havingClause = $havingClause;
} }
public function getOrderByClause() public function getOrderByClause()
{ {
return $this->_orderByClause; return $this->_orderByClause;
} }
public function setOrderByClause($orderByClause) public function setOrderByClause($orderByClause)
{ {
$this->_orderByClause = $orderByClause; $this->_orderByClause = $orderByClause;
} }
public function dispatch($sqlWalker) public function dispatch($sqlWalker)
{ {
return $sqlWalker->walkSubselect($this); return $sqlWalker->walkSubselect($this);
} }
} }

102
lib/Doctrine/ORM/Query/AST/SubselectFromClause.php
View file

@ -1,52 +1,52 @@
<?php <?php
/* /*
* $Id$ * $Id$
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* *
* This software consists of voluntary contributions made by many individuals * This software consists of voluntary contributions made by many individuals
* and is licensed under the LGPL. For more information, see * and is licensed under the LGPL. For more information, see
* <http://www.doctrine-project.org>. * <http://www.doctrine-project.org>.
*/ */
namespace Doctrine\ORM\Query\AST; namespace Doctrine\ORM\Query\AST;
/** /**
* SubselectFromClause ::= "FROM" SubselectIdentificationVariableDeclaration {"," SubselectIdentificationVariableDeclaration}* * SubselectFromClause ::= "FROM" SubselectIdentificationVariableDeclaration {"," SubselectIdentificationVariableDeclaration}*
* *
* @author Guilherme Blanco <guilhermeblanco@hotmail.com> * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link http://www.doctrine-project.org * @link http://www.doctrine-project.org
* @since 2.0 * @since 2.0
* @version $Revision$ * @version $Revision$
*/ */
class SubselectFromClause extends Node class SubselectFromClause extends Node
{ {
private $_identificationVariableDeclarations = array(); private $_identificationVariableDeclarations = array();
public function __construct(array $identificationVariableDeclarations) public function __construct(array $identificationVariableDeclarations)
{ {
$this->_identificationVariableDeclarations = $identificationVariableDeclarations; $this->_identificationVariableDeclarations = $identificationVariableDeclarations;
} }
/* Getters */ /* Getters */
public function getSubselectIdentificationVariableDeclarations() public function getSubselectIdentificationVariableDeclarations()
{ {
return $this->_identificationVariableDeclarations; return $this->_identificationVariableDeclarations;
} }
public function dispatch($sqlWalker) public function dispatch($sqlWalker)
{ {
return $sqlWalker->walkSubselectFromClause($this); return $sqlWalker->walkSubselectFromClause($this);
} }
} }

122
lib/Doctrine/ORM/Query/AST/UpdateStatement.php
View file

@ -1,62 +1,62 @@
<?php <?php
/* /*
* $Id$ * $Id$
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* *
* This software consists of voluntary contributions made by many individuals * This software consists of voluntary contributions made by many individuals
* and is licensed under the LGPL. For more information, see * and is licensed under the LGPL. For more information, see
* <http://www.doctrine-project.org>. * <http://www.doctrine-project.org>.
*/ */
namespace Doctrine\ORM\Query\AST; namespace Doctrine\ORM\Query\AST;
/** /**
* UpdateStatement = UpdateClause [WhereClause] * UpdateStatement = UpdateClause [WhereClause]
* *
* @author Guilherme Blanco <guilhermeblanco@hotmail.com> * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link http://www.doctrine-project.org * @link http://www.doctrine-project.org
* @since 2.0 * @since 2.0
* @version $Revision$ * @version $Revision$
*/ */
class UpdateStatement extends Node class UpdateStatement extends Node
{ {
private $_updateClause; private $_updateClause;
private $_whereClause; private $_whereClause;
public function __construct($updateClause) public function __construct($updateClause)
{ {
$this->_updateClause = $updateClause; $this->_updateClause = $updateClause;
} }
public function setWhereClause($whereClause) public function setWhereClause($whereClause)
{ {
$this->_whereClause = $whereClause; $this->_whereClause = $whereClause;
} }
public function getUpdateClause() public function getUpdateClause()
{ {
return $this->_updateClause; return $this->_updateClause;
} }
public function getWhereClause() public function getWhereClause()
{ {
return $this->_whereClause; return $this->_whereClause;
} }
public function dispatch($sqlWalker) public function dispatch($sqlWalker)
{ {
return $sqlWalker->walkUpdateStatement($this); return $sqlWalker->walkUpdateStatement($this);
} }
} }

290
lib/Doctrine/ORM/Query/CacheHandler.php
View file

@ -1,146 +1,146 @@
<?php <?php
/* /*
* $Id: Cache.php 3938 2008-03-06 19:36:50Z romanb $ * $Id: Cache.php 3938 2008-03-06 19:36:50Z romanb $
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* *
* This software consists of voluntary contributions made by many individuals * This software consists of voluntary contributions made by many individuals
* and is licensed under the LGPL. For more information, see * and is licensed under the LGPL. For more information, see
* <http://www.doctrine-project.org>. * <http://www.doctrine-project.org>.
*/ */
namespace Doctrine\ORM\Query; namespace Doctrine\ORM\Query;
/** /**
* Doctrine\ORM\Query\CacheHandler * Doctrine\ORM\Query\CacheHandler
* *
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link www.doctrine-project.com * @link www.doctrine-project.com
* @since 2.0 * @since 2.0
* @version $Revision: 1393 $ * @version $Revision: 1393 $
* @author Guilherme Blanco <guilhermeblanco@hotmail.com> * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
* @author Konsta Vesterinen <kvesteri@cc.hut.fi> * @author Konsta Vesterinen <kvesteri@cc.hut.fi>
* *
* @todo Re-document this class * @todo Re-document this class
*/ */
abstract class CacheHandler abstract class CacheHandler
{ {
/** /**
* Static factory method. Receives a Doctrine_ORM_Query object and generates * Static factory method. Receives a Doctrine_ORM_Query object and generates
* the object after processing queryComponents. Table aliases are retrieved * the object after processing queryComponents. Table aliases are retrieved
* directly from Doctrine_ORM_Query_Parser. * directly from Doctrine_ORM_Query_Parser.
* *
* @param mixed $result Data to be stored. * @param mixed $result Data to be stored.
* @param Doctrine_ORM_Query_ParserResult $parserResult Parser results that enables to have important data retrieved. * @param Doctrine_ORM_Query_ParserResult $parserResult Parser results that enables to have important data retrieved.
*/ */
public static function fromResultSet($result, $parserResult) public static function fromResultSet($result, $parserResult)
{ {
$queryComponents = array(); $queryComponents = array();
foreach ($parserResult->getQueryComponents() as $alias => $components) { foreach ($parserResult->getQueryComponents() as $alias => $components) {
if ( ! isset($components['parent'])) { if ( ! isset($components['parent'])) {
$queryComponents[$alias][] = $components['mapper']->getComponentName(); $queryComponents[$alias][] = $components['mapper']->getComponentName();
//$queryComponents[$alias][] = $components['mapper']->getComponentName(); //$queryComponents[$alias][] = $components['mapper']->getComponentName();
} else { } else {
$queryComponents[$alias][] = $components['parent'] . '.' . $components['relation']->getAlias(); $queryComponents[$alias][] = $components['parent'] . '.' . $components['relation']->getAlias();
} }
if (isset($components['agg'])) { if (isset($components['agg'])) {
$queryComponents[$alias][] = $components['agg']; $queryComponents[$alias][] = $components['agg'];
} }
if (isset($components['map'])) { if (isset($components['map'])) {
$queryComponents[$alias][] = $components['map']; $queryComponents[$alias][] = $components['map'];
} }
} }
return new QueryResult( return new QueryResult(
$result, $result,
$queryComponents, $queryComponents,
$parserResult->getTableAliasMap(), $parserResult->getTableAliasMap(),
$parserResult->getEnumParams() $parserResult->getEnumParams()
); );
} }
/** /**
* Static factory method. Receives a Doctrine_ORM_Query object and a cached data. * Static factory method. Receives a Doctrine_ORM_Query object and a cached data.
* It handles the cache and generates the object after processing queryComponents. * It handles the cache and generates the object after processing queryComponents.
* Table aliases are retrieved from cache. * Table aliases are retrieved from cache.
* *
* @param Doctrine_ORM_Query $query Doctrine_ORM_Query_Object related to this cache item. * @param Doctrine_ORM_Query $query Doctrine_ORM_Query_Object related to this cache item.
* @param mixed $cached Cached data. * @param mixed $cached Cached data.
*/ */
public static function fromCachedResult($query, $cached = false) public static function fromCachedResult($query, $cached = false)
{ {
$cached = unserialize($cached); $cached = unserialize($cached);
return new QueryResult( return new QueryResult(
$cached[0], $cached[0],
self::_getQueryComponents($cached[1]), self::_getQueryComponents($cached[1]),
$cached[2], $cached[2],
$cached[3] $cached[3]
); );
} }
/** /**
* Static factory method. Receives a Doctrine_ORM_Query object and a cached data. * Static factory method. Receives a Doctrine_ORM_Query object and a cached data.
* It handles the cache and generates the object after processing queryComponents. * It handles the cache and generates the object after processing queryComponents.
* Table aliases are retrieved from cache. * Table aliases are retrieved from cache.
* *
* @param Doctrine_ORM_Query $query Doctrine_ORM_Query_Object related to this cache item. * @param Doctrine_ORM_Query $query Doctrine_ORM_Query_Object related to this cache item.
* @param mixed $cached Cached data. * @param mixed $cached Cached data.
*/ */
public static function fromCachedQuery($query, $cached = false) public static function fromCachedQuery($query, $cached = false)
{ {
$cached = unserialize($cached); $cached = unserialize($cached);
return new ParserResult( return new ParserResult(
$cached[0], $cached[0],
self::_getQueryComponents($cached[1]), self::_getQueryComponents($cached[1]),
$cached[2], $cached[2],
$cached[3] $cached[3]
); );
} }
/** /**
* @nodoc * @nodoc
*/ */
protected static function _getQueryComponents($query, $cachedQueryComponents) protected static function _getQueryComponents($query, $cachedQueryComponents)
{ {
$queryComponents = array(); $queryComponents = array();
foreach ($cachedQueryComponents as $alias => $components) { foreach ($cachedQueryComponents as $alias => $components) {
$e = explode('.', $components[0]); $e = explode('.', $components[0]);
if (count($e) === 1) { if (count($e) === 1) {
$queryComponents[$alias]['mapper'] = $query->getConnection()->getMapper($e[0]); $queryComponents[$alias]['mapper'] = $query->getConnection()->getMapper($e[0]);
$queryComponents[$alias]['table'] = $queryComponents[$alias]['mapper']->getTable(); $queryComponents[$alias]['table'] = $queryComponents[$alias]['mapper']->getTable();
} else { } else {
$queryComponents[$alias]['parent'] = $e[0]; $queryComponents[$alias]['parent'] = $e[0];
$queryComponents[$alias]['relation'] = $queryComponents[$e[0]]['table']->getAssociation($e[1]); $queryComponents[$alias]['relation'] = $queryComponents[$e[0]]['table']->getAssociation($e[1]);
$queryComponents[$alias]['mapper'] = $query->getConnection()->getMapper($queryComponents[$alias]['relation']->getTargetEntityName()); $queryComponents[$alias]['mapper'] = $query->getConnection()->getMapper($queryComponents[$alias]['relation']->getTargetEntityName());
$queryComponents[$alias]['table'] = $queryComponents[$alias]['mapper']->getTable(); $queryComponents[$alias]['table'] = $queryComponents[$alias]['mapper']->getTable();
} }
if (isset($v[1])) { if (isset($v[1])) {
$queryComponents[$alias]['agg'] = $components[1]; $queryComponents[$alias]['agg'] = $components[1];
} }
if (isset($v[2])) { if (isset($v[2])) {
$queryComponents[$alias]['map'] = $components[2]; $queryComponents[$alias]['map'] = $components[2];
} }
} }
return $queryComponents; return $queryComponents;
} }
} }

3780
lib/Doctrine/ORM/Query/Parser.php
View file

File diff suppressed because it is too large Load diff

682
lib/vendor/addendum/annotations.php vendored
View file

@ -1,341 +1,341 @@
<?php <?php
/** /**
* Addendum PHP Reflection Annotations * Addendum PHP Reflection Annotations
* http://code.google.com/p/addendum/ * http://code.google.com/p/addendum/
* *
* Copyright (C) 2006 Jan "johno Suchal <johno@jsmf.net> * Copyright (C) 2006 Jan "johno Suchal <johno@jsmf.net>
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public * modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either * License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version. * 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, * This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details. * Lesser General Public License for more details.
* You should have received a copy of the GNU Lesser General Public * You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software * License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
**/ **/
require_once(dirname(__FILE__).'/annotations/annotation_parser.php'); require_once(dirname(__FILE__).'/annotations/annotation_parser.php');
class Annotation { class Annotation {
public $value; public $value;
public final function __construct($data, $target) { public final function __construct($data, $target) {
$reflection = new ReflectionClass($this); $reflection = new ReflectionClass($this);
foreach($data as $key => $value) { foreach($data as $key => $value) {
if($reflection->hasProperty($key)) { if($reflection->hasProperty($key)) {
$this->$key = $value; $this->$key = $value;
} else { } else {
$class = $reflection->getName(); $class = $reflection->getName();
trigger_error("Property '$key' not defined for annotation '$class'"); trigger_error("Property '$key' not defined for annotation '$class'");
} }
} }
$this->checkTargetConstraints($target); $this->checkTargetConstraints($target);
$this->checkConstraints($target); $this->checkConstraints($target);
} }
private function checkTargetConstraints($target) { private function checkTargetConstraints($target) {
$reflection = new ReflectionAnnotatedClass($this); $reflection = new ReflectionAnnotatedClass($this);
if($reflection->hasAnnotation('Target')) { if($reflection->hasAnnotation('Target')) {
$value = $reflection->getAnnotation('Target')->value; $value = $reflection->getAnnotation('Target')->value;
$values = is_array($value) ? $value : array($value); $values = is_array($value) ? $value : array($value);
foreach($values as $value) { foreach($values as $value) {
if($value == 'class' && $target instanceof ReflectionClass) return; if($value == 'class' && $target instanceof ReflectionClass) return;
if($value == 'method' && $target instanceof ReflectionMethod) return; if($value == 'method' && $target instanceof ReflectionMethod) return;
if($value == 'property' && $target instanceof ReflectionProperty) return; if($value == 'property' && $target instanceof ReflectionProperty) return;
} }
trigger_error("Annotation '".get_class($this)."' not allowed on ".$this->createName($target), E_USER_ERROR); trigger_error("Annotation '".get_class($this)."' not allowed on ".$this->createName($target), E_USER_ERROR);
} }
} }
private function createName($target) { private function createName($target) {
if($target instanceof ReflectionMethod) { if($target instanceof ReflectionMethod) {
return $target->getDeclaringClass()->getName().'::'.$target->getName(); return $target->getDeclaringClass()->getName().'::'.$target->getName();
} elseif($target instanceof ReflectionProperty) { } elseif($target instanceof ReflectionProperty) {
return $target->getDeclaringClass()->getName().'::$'.$target->getName(); return $target->getDeclaringClass()->getName().'::$'.$target->getName();
} else { } else {
return $target->getName(); return $target->getName();
} }
} }
protected function checkConstraints($target) {} protected function checkConstraints($target) {}
} }
class Target extends Annotation {} class Target extends Annotation {}
class AnnotationsBuilder { class AnnotationsBuilder {
private static $cache = array(); private static $cache = array();
public function build($targetReflection) { public function build($targetReflection) {
$data = $this->parse($targetReflection); $data = $this->parse($targetReflection);
$annotations = array(); $annotations = array();
foreach($data as $class => $parameters) { foreach($data as $class => $parameters) {
if(!Addendum::ignores($class)) { if(!Addendum::ignores($class)) {
foreach($parameters as $params) { foreach($parameters as $params) {
$annotationReflection = new ReflectionClass($class); $annotationReflection = new ReflectionClass($class);
$annotations[$class][] = $annotationReflection->newInstance($params, $targetReflection); $annotations[$class][] = $annotationReflection->newInstance($params, $targetReflection);
} }
} }
} }
return $annotations; return $annotations;
} }
private function parse($reflection) { private function parse($reflection) {
$key = $this->createName($reflection); $key = $this->createName($reflection);
if(!isset(self::$cache[$key])) { if(!isset(self::$cache[$key])) {
$parser = new AnnotationsMatcher; $parser = new AnnotationsMatcher;
$parser->matches($this->getDocComment($reflection), $data); $parser->matches($this->getDocComment($reflection), $data);
self::$cache[$key] = $data; self::$cache[$key] = $data;
} }
return self::$cache[$key]; return self::$cache[$key];
} }
private function createName($target) { private function createName($target) {
if($target instanceof ReflectionMethod) { if($target instanceof ReflectionMethod) {
return $target->getDeclaringClass()->getName().'::'.$target->getName(); return $target->getDeclaringClass()->getName().'::'.$target->getName();
} elseif($target instanceof ReflectionProperty) { } elseif($target instanceof ReflectionProperty) {
return $target->getDeclaringClass()->getName().'::$'.$target->getName(); return $target->getDeclaringClass()->getName().'::$'.$target->getName();
} else { } else {
return $target->getName(); return $target->getName();
} }
} }
protected function getDocComment($reflection) { protected function getDocComment($reflection) {
return Addendum::getDocComment($reflection); return Addendum::getDocComment($reflection);
} }
public static function clearCache() { public static function clearCache() {
self::$cache = array(); self::$cache = array();
} }
} }
class ReflectionAnnotatedClass extends ReflectionClass { class ReflectionAnnotatedClass extends ReflectionClass {
private $annotations; private $annotations;
public function __construct($class) { public function __construct($class) {
parent::__construct($class); parent::__construct($class);
$this->annotations = $this->createAnnotationBuilder()->build($this); $this->annotations = $this->createAnnotationBuilder()->build($this);
} }
public function hasAnnotation($annotation) { public function hasAnnotation($annotation) {
return isset($this->annotations[$annotation]); return isset($this->annotations[$annotation]);
} }
public function getAnnotation($annotation) { public function getAnnotation($annotation) {
return $this->hasAnnotation($annotation) ? end($this->annotations[$annotation]) : false; return $this->hasAnnotation($annotation) ? end($this->annotations[$annotation]) : false;
} }
public function getAnnotations() { public function getAnnotations() {
$result = array(); $result = array();
foreach($this->annotations as $instances) { foreach($this->annotations as $instances) {
$result[] = end($instances); $result[] = end($instances);
} }
return $result; return $result;
} }
public function getAllAnnotations($restriction = false) { public function getAllAnnotations($restriction = false) {
$result = array(); $result = array();
foreach($this->annotations as $class => $instances) { foreach($this->annotations as $class => $instances) {
if(!$restriction || $restriction == $class) { if(!$restriction || $restriction == $class) {
$result = array_merge($result, $instances); $result = array_merge($result, $instances);
} }
} }
return $result; return $result;
} }
public function getConstructor() { public function getConstructor() {
return $this->createReflectionAnnotatedMethod(parent::getConstructor()); return $this->createReflectionAnnotatedMethod(parent::getConstructor());
} }
public function getMethod($name) { public function getMethod($name) {
return $this->createReflectionAnnotatedMethod(parent::getMethod($name)); return $this->createReflectionAnnotatedMethod(parent::getMethod($name));
} }
public function getMethods($filter = -1) { public function getMethods($filter = -1) {
$result = array(); $result = array();
foreach(parent::getMethods($filter) as $method) { foreach(parent::getMethods($filter) as $method) {
$result[] = $this->createReflectionAnnotatedMethod($method); $result[] = $this->createReflectionAnnotatedMethod($method);
} }
return $result; return $result;
} }
public function getProperty($name) { public function getProperty($name) {
return $this->createReflectionAnnotatedProperty(parent::getProperty($name)); return $this->createReflectionAnnotatedProperty(parent::getProperty($name));
} }
public function getProperties($filter = -1) { public function getProperties($filter = -1) {
$result = array(); $result = array();
foreach(parent::getProperties($filter) as $property) { foreach(parent::getProperties($filter) as $property) {
$result[] = $this->createReflectionAnnotatedProperty($property); $result[] = $this->createReflectionAnnotatedProperty($property);
} }
return $result; return $result;
} }
public function getInterfaces() { public function getInterfaces() {
$result = array(); $result = array();
foreach(parent::getInterfaces() as $interface) { foreach(parent::getInterfaces() as $interface) {
$result[] = $this->createReflectionAnnotatedClass($interface); $result[] = $this->createReflectionAnnotatedClass($interface);
} }
return $result; return $result;
} }
public function getParentClass() { public function getParentClass() {
$class = parent::getParentClass(); $class = parent::getParentClass();
return $this->createReflectionAnnotatedClass($class); return $this->createReflectionAnnotatedClass($class);
} }
protected function createAnnotationBuilder() { protected function createAnnotationBuilder() {
return new AnnotationsBuilder(); return new AnnotationsBuilder();
} }
private function createReflectionAnnotatedClass($class) { private function createReflectionAnnotatedClass($class) {
return ($class !== false) ? new ReflectionAnnotatedClass($class->getName()) : false; return ($class !== false) ? new ReflectionAnnotatedClass($class->getName()) : false;
} }
private function createReflectionAnnotatedMethod($method) { private function createReflectionAnnotatedMethod($method) {
return ($method !== null) ? new ReflectionAnnotatedMethod($this->getName(), $method->getName()) : null; return ($method !== null) ? new ReflectionAnnotatedMethod($this->getName(), $method->getName()) : null;
} }
private function createReflectionAnnotatedProperty($property) { private function createReflectionAnnotatedProperty($property) {
return ($property !== null) ? new ReflectionAnnotatedProperty($this->getName(), $property->getName()) : null; return ($property !== null) ? new ReflectionAnnotatedProperty($this->getName(), $property->getName()) : null;
} }
} }
class ReflectionAnnotatedMethod extends ReflectionMethod { class ReflectionAnnotatedMethod extends ReflectionMethod {
private $annotations; private $annotations;
public function __construct($class, $name) { public function __construct($class, $name) {
parent::__construct($class, $name); parent::__construct($class, $name);
$this->annotations = $this->createAnnotationBuilder()->build($this); $this->annotations = $this->createAnnotationBuilder()->build($this);
} }
public function hasAnnotation($annotation) { public function hasAnnotation($annotation) {
return isset($this->annotations[$annotation]); return isset($this->annotations[$annotation]);
} }
public function getAnnotation($annotation) { public function getAnnotation($annotation) {
return ($this->hasAnnotation($annotation)) ? end($this->annotations[$annotation]) : false; return ($this->hasAnnotation($annotation)) ? end($this->annotations[$annotation]) : false;
} }
public function getAnnotations() { public function getAnnotations() {
$result = array(); $result = array();
foreach($this->annotations as $instances) { foreach($this->annotations as $instances) {
$result[] = end($instances); $result[] = end($instances);
} }
return $result; return $result;
} }
public function getAllAnnotations($restriction = false) { public function getAllAnnotations($restriction = false) {
$result = array(); $result = array();
foreach($this->annotations as $class => $instances) { foreach($this->annotations as $class => $instances) {
if(!$restriction || $restriction == $class) { if(!$restriction || $restriction == $class) {
$result = array_merge($result, $instances); $result = array_merge($result, $instances);
} }
} }
return $result; return $result;
} }
public function getDeclaringClass() { public function getDeclaringClass() {
$class = parent::getDeclaringClass(); $class = parent::getDeclaringClass();
return new ReflectionAnnotatedClass($class->getName()); return new ReflectionAnnotatedClass($class->getName());
} }
protected function createAnnotationBuilder() { protected function createAnnotationBuilder() {
return new AnnotationsBuilder(); return new AnnotationsBuilder();
} }
} }
class ReflectionAnnotatedProperty extends ReflectionProperty { class ReflectionAnnotatedProperty extends ReflectionProperty {
private $annotations; private $annotations;
public function __construct($class, $name) { public function __construct($class, $name) {
parent::__construct($class, $name); parent::__construct($class, $name);
$this->annotations = $this->createAnnotationBuilder()->build($this); $this->annotations = $this->createAnnotationBuilder()->build($this);
} }
public function hasAnnotation($annotation) { public function hasAnnotation($annotation) {
return isset($this->annotations[$annotation]); return isset($this->annotations[$annotation]);
} }
public function getAnnotation($annotation) { public function getAnnotation($annotation) {
return ($this->hasAnnotation($annotation)) ? end($this->annotations[$annotation]) : false; return ($this->hasAnnotation($annotation)) ? end($this->annotations[$annotation]) : false;
} }
public function getAnnotations() { public function getAnnotations() {
$result = array(); $result = array();
foreach($this->annotations as $instances) { foreach($this->annotations as $instances) {
$result[] = end($instances); $result[] = end($instances);
} }
return $result; return $result;
} }
public function getAllAnnotations($restriction = false) { public function getAllAnnotations($restriction = false) {
$result = array(); $result = array();
foreach($this->annotations as $class => $instances) { foreach($this->annotations as $class => $instances) {
if(!$restriction || $restriction == $class) { if(!$restriction || $restriction == $class) {
$result = array_merge($result, $instances); $result = array_merge($result, $instances);
} }
} }
return $result; return $result;
} }
public function getDeclaringClass() { public function getDeclaringClass() {
$class = parent::getDeclaringClass(); $class = parent::getDeclaringClass();
return new ReflectionAnnotatedClass($class->getName()); return new ReflectionAnnotatedClass($class->getName());
} }
protected function createAnnotationBuilder() { protected function createAnnotationBuilder() {
return new AnnotationsBuilder(); return new AnnotationsBuilder();
} }
} }
class Addendum { class Addendum {
private static $rawMode; private static $rawMode;
private static $ignore; private static $ignore;
public static function getDocComment($reflection) { public static function getDocComment($reflection) {
if(self::checkRawDocCommentParsingNeeded()) { if(self::checkRawDocCommentParsingNeeded()) {
$docComment = new DocComment(); $docComment = new DocComment();
return $docComment->get($reflection); return $docComment->get($reflection);
} else { } else {
return $reflection->getDocComment(); return $reflection->getDocComment();
} }
} }
/** Raw mode test */ /** Raw mode test */
private static function checkRawDocCommentParsingNeeded() { private static function checkRawDocCommentParsingNeeded() {
if(self::$rawMode === null) { if(self::$rawMode === null) {
$reflection = new ReflectionClass('Addendum'); $reflection = new ReflectionClass('Addendum');
$method = $reflection->getMethod('checkRawDocCommentParsingNeeded'); $method = $reflection->getMethod('checkRawDocCommentParsingNeeded');
self::setRawMode($method->getDocComment() === false); self::setRawMode($method->getDocComment() === false);
} }
return self::$rawMode; return self::$rawMode;
} }
public static function setRawMode($enabled = true) { public static function setRawMode($enabled = true) {
if($enabled) { if($enabled) {
require_once(dirname(__FILE__).'/annotations/doc_comment.php'); require_once(dirname(__FILE__).'/annotations/doc_comment.php');
} }
self::$rawMode = $enabled; self::$rawMode = $enabled;
} }
public static function resetIgnoredAnnotations() { public static function resetIgnoredAnnotations() {
self::$ignore = array(); self::$ignore = array();
} }
public static function ignores($class) { public static function ignores($class) {
return isset(self::$ignore[$class]); return isset(self::$ignore[$class]);
} }
public static function ignore() { public static function ignore() {
foreach(func_get_args() as $class) { foreach(func_get_args() as $class) {
self::$ignore[$class] = true; self::$ignore[$class] = true;
} }
} }
} }
?> ?>

670
lib/vendor/addendum/annotations/annotation_parser.php vendored
View file

@ -1,335 +1,335 @@
<?php <?php
/** /**
* Addendum PHP Reflection Annotations * Addendum PHP Reflection Annotations
* http://code.google.com/p/addendum/ * http://code.google.com/p/addendum/
* *
* Copyright (C) 2006 Jan "johno Suchal <johno@jsmf.net> * Copyright (C) 2006 Jan "johno Suchal <johno@jsmf.net>
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public * modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either * License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version. * 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, * This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details. * Lesser General Public License for more details.
* You should have received a copy of the GNU Lesser General Public * You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software * License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
**/ **/
class CompositeMatcher { class CompositeMatcher {
protected $matchers = array(); protected $matchers = array();
private $wasConstructed = false; private $wasConstructed = false;
public function add($matcher) { public function add($matcher) {
$this->matchers[] = $matcher; $this->matchers[] = $matcher;
} }
public function matches($string, &$value) { public function matches($string, &$value) {
if(!$this->wasConstructed) { if(!$this->wasConstructed) {
$this->build(); $this->build();
$this->wasConstructed = true; $this->wasConstructed = true;
} }
return $this->match($string, $value); return $this->match($string, $value);
} }
protected function build() {} protected function build() {}
} }
class ParallelMatcher extends CompositeMatcher { class ParallelMatcher extends CompositeMatcher {
protected function match($string, &$value) { protected function match($string, &$value) {
$maxLength = false; $maxLength = false;
$result = null; $result = null;
foreach($this->matchers as $matcher) { foreach($this->matchers as $matcher) {
$length = $matcher->matches($string, $subvalue); $length = $matcher->matches($string, $subvalue);
if($maxLength === false || $length > $maxLength) { if($maxLength === false || $length > $maxLength) {
$maxLength = $length; $maxLength = $length;
$result = $subvalue; $result = $subvalue;
} }
} }
$value = $this->process($result); $value = $this->process($result);
return $maxLength; return $maxLength;
} }
protected function process($value) { protected function process($value) {
return $value; return $value;
} }
} }
class SerialMatcher extends CompositeMatcher { class SerialMatcher extends CompositeMatcher {
protected function match($string, &$value) { protected function match($string, &$value) {
$results = array(); $results = array();
$total_length = 0; $total_length = 0;
foreach($this->matchers as $matcher) { foreach($this->matchers as $matcher) {
if(($length = $matcher->matches($string, $result)) === false) return false; if(($length = $matcher->matches($string, $result)) === false) return false;
$total_length += $length; $total_length += $length;
$results[] = $result; $results[] = $result;
$string = substr($string, $length); $string = substr($string, $length);
} }
$value = $this->process($results); $value = $this->process($results);
return $total_length; return $total_length;
} }
protected function process($results) { protected function process($results) {
return implode('', $results); return implode('', $results);
} }
} }
class SimpleSerialMatcher extends SerialMatcher { class SimpleSerialMatcher extends SerialMatcher {
private $return_part_index; private $return_part_index;
public function __construct($return_part_index = 0) { public function __construct($return_part_index = 0) {
$this->return_part_index = $return_part_index; $this->return_part_index = $return_part_index;
} }
public function process($parts) { public function process($parts) {
return $parts[$this->return_part_index]; return $parts[$this->return_part_index];
} }
} }
class RegexMatcher { class RegexMatcher {
private $regex; private $regex;
public function __construct($regex) { public function __construct($regex) {
$this->regex = $regex; $this->regex = $regex;
} }
public function matches($string, &$value) { public function matches($string, &$value) {
if(preg_match("/^{$this->regex}/", $string, $matches)) { if(preg_match("/^{$this->regex}/", $string, $matches)) {
$value = $this->process($matches); $value = $this->process($matches);
return strlen($matches[0]); return strlen($matches[0]);
} }
$value = false; $value = false;
return false; return false;
} }
protected function process($matches) { protected function process($matches) {
return $matches[0]; return $matches[0];
} }
} }
class AnnotationsMatcher { class AnnotationsMatcher {
public function matches($string, &$annotations) { public function matches($string, &$annotations) {
$annotations = array(); $annotations = array();
$annotation_matcher = new AnnotationMatcher; $annotation_matcher = new AnnotationMatcher;
while(true) { while(true) {
if(preg_match('/\s(?=@)/', $string, $matches, PREG_OFFSET_CAPTURE)) { if(preg_match('/\s(?=@)/', $string, $matches, PREG_OFFSET_CAPTURE)) {
$offset = $matches[0][1] + 1; $offset = $matches[0][1] + 1;
$string = substr($string, $offset); $string = substr($string, $offset);
} else { } else {
return; // no more annotations return; // no more annotations
} }
if(($length = $annotation_matcher->matches($string, $data)) !== false) { if(($length = $annotation_matcher->matches($string, $data)) !== false) {
$string = substr($string, $length); $string = substr($string, $length);
list($name, $params) = $data; list($name, $params) = $data;
$annotations[$name][] = $params; $annotations[$name][] = $params;
} }
} }
} }
} }
class AnnotationMatcher extends SerialMatcher { class AnnotationMatcher extends SerialMatcher {
protected function build() { protected function build() {
$this->add(new RegexMatcher('@')); $this->add(new RegexMatcher('@'));
$this->add(new RegexMatcher('[A-Z][a-zA-Z0-9_]+')); $this->add(new RegexMatcher('[A-Z][a-zA-Z0-9_]+'));
$this->add(new AnnotationParametersMatcher); $this->add(new AnnotationParametersMatcher);
} }
protected function process($results) { protected function process($results) {
return array($results[1], $results[2]); return array($results[1], $results[2]);
} }
} }
class ConstantMatcher extends RegexMatcher { class ConstantMatcher extends RegexMatcher {
private $constant; private $constant;
public function __construct($regex, $constant) { public function __construct($regex, $constant) {
parent::__construct($regex); parent::__construct($regex);
$this->constant = $constant; $this->constant = $constant;
} }
protected function process($matches) { protected function process($matches) {
return $this->constant; return $this->constant;
} }
} }
class AnnotationParametersMatcher extends ParallelMatcher { class AnnotationParametersMatcher extends ParallelMatcher {
protected function build() { protected function build() {
$this->add(new ConstantMatcher('', array())); $this->add(new ConstantMatcher('', array()));
$this->add(new ConstantMatcher('\(\)', array())); $this->add(new ConstantMatcher('\(\)', array()));
$params_matcher = new SimpleSerialMatcher(1); $params_matcher = new SimpleSerialMatcher(1);
$params_matcher->add(new RegexMatcher('\(\s*')); $params_matcher->add(new RegexMatcher('\(\s*'));
$params_matcher->add(new AnnotationValuesMatcher); $params_matcher->add(new AnnotationValuesMatcher);
$params_matcher->add(new RegexMatcher('\s*\)')); $params_matcher->add(new RegexMatcher('\s*\)'));
$this->add($params_matcher); $this->add($params_matcher);
} }
} }
class AnnotationValuesMatcher extends ParallelMatcher { class AnnotationValuesMatcher extends ParallelMatcher {
protected function build() { protected function build() {
$this->add(new AnnotationTopValueMatcher); $this->add(new AnnotationTopValueMatcher);
$this->add(new AnnotationHashMatcher); $this->add(new AnnotationHashMatcher);
} }
} }
class AnnotationTopValueMatcher extends AnnotationValueMatcher { class AnnotationTopValueMatcher extends AnnotationValueMatcher {
protected function process($value) { protected function process($value) {
return array('value' => $value); return array('value' => $value);
} }
} }
class AnnotationValueMatcher extends ParallelMatcher { class AnnotationValueMatcher extends ParallelMatcher {
protected function build() { protected function build() {
$this->add(new ConstantMatcher('true', true)); $this->add(new ConstantMatcher('true', true));
$this->add(new ConstantMatcher('false', false)); $this->add(new ConstantMatcher('false', false));
$this->add(new ConstantMatcher('TRUE', true)); $this->add(new ConstantMatcher('TRUE', true));
$this->add(new ConstantMatcher('FALSE', false)); $this->add(new ConstantMatcher('FALSE', false));
$this->add(new AnnotationStringMatcher); $this->add(new AnnotationStringMatcher);
$this->add(new AnnotationNumberMatcher); $this->add(new AnnotationNumberMatcher);
$this->add(new AnnotationArrayMatcher); $this->add(new AnnotationArrayMatcher);
} }
} }
class AnnotationKeyMatcher extends ParallelMatcher { class AnnotationKeyMatcher extends ParallelMatcher {
protected function build() { protected function build() {
$this->add(new RegexMatcher('[a-zA-Z][a-zA-Z0-9_]*')); $this->add(new RegexMatcher('[a-zA-Z][a-zA-Z0-9_]*'));
$this->add(new AnnotationStringMatcher); $this->add(new AnnotationStringMatcher);
$this->add(new AnnotationIntegerMatcher); $this->add(new AnnotationIntegerMatcher);
} }
} }
class AnnotationPairMatcher extends SerialMatcher { class AnnotationPairMatcher extends SerialMatcher {
protected function build() { protected function build() {
$this->add(new AnnotationKeyMatcher); $this->add(new AnnotationKeyMatcher);
$this->add(new RegexMatcher('\s*=\s*')); $this->add(new RegexMatcher('\s*=\s*'));
$this->add(new AnnotationValueMatcher); $this->add(new AnnotationValueMatcher);
} }
protected function process($parts) { protected function process($parts) {
return array($parts[0] => $parts[2]); return array($parts[0] => $parts[2]);
} }
} }
class AnnotationHashMatcher extends ParallelMatcher { class AnnotationHashMatcher extends ParallelMatcher {
protected function build() { protected function build() {
$this->add(new AnnotationPairMatcher); $this->add(new AnnotationPairMatcher);
$this->add(new AnnotationMorePairsMatcher); $this->add(new AnnotationMorePairsMatcher);
} }
} }
class AnnotationMorePairsMatcher extends SerialMatcher { class AnnotationMorePairsMatcher extends SerialMatcher {
protected function build() { protected function build() {
$this->add(new AnnotationPairMatcher); $this->add(new AnnotationPairMatcher);
$this->add(new RegexMatcher('\s*,\s*')); $this->add(new RegexMatcher('\s*,\s*'));
$this->add(new AnnotationHashMatcher); $this->add(new AnnotationHashMatcher);
} }
protected function match($string, &$value) { protected function match($string, &$value) {
$result = parent::match($string, $value); $result = parent::match($string, $value);
return $result; return $result;
} }
public function process($parts) { public function process($parts) {
return array_merge($parts[0], $parts[2]); return array_merge($parts[0], $parts[2]);
} }
} }
class AnnotationArrayMatcher extends ParallelMatcher { class AnnotationArrayMatcher extends ParallelMatcher {
protected function build() { protected function build() {
$this->add(new ConstantMatcher('{}', array())); $this->add(new ConstantMatcher('{}', array()));
$values_matcher = new SimpleSerialMatcher(1); $values_matcher = new SimpleSerialMatcher(1);
$values_matcher->add(new RegexMatcher('\s*{\s*')); $values_matcher->add(new RegexMatcher('\s*{\s*'));
$values_matcher->add(new AnnotationArrayValuesMatcher); $values_matcher->add(new AnnotationArrayValuesMatcher);
$values_matcher->add(new RegexMatcher('\s*}\s*')); $values_matcher->add(new RegexMatcher('\s*}\s*'));
$this->add($values_matcher); $this->add($values_matcher);
} }
} }
class AnnotationArrayValuesMatcher extends ParallelMatcher { class AnnotationArrayValuesMatcher extends ParallelMatcher {
protected function build() { protected function build() {
$this->add(new AnnotationArrayValueMatcher); $this->add(new AnnotationArrayValueMatcher);
$this->add(new AnnotationMoreValuesMatcher); $this->add(new AnnotationMoreValuesMatcher);
} }
} }
class AnnotationMoreValuesMatcher extends SimpleSerialMatcher { class AnnotationMoreValuesMatcher extends SimpleSerialMatcher {
protected function build() { protected function build() {
$this->add(new AnnotationArrayValueMatcher); $this->add(new AnnotationArrayValueMatcher);
$this->add(new RegexMatcher('\s*,\s*')); $this->add(new RegexMatcher('\s*,\s*'));
$this->add(new AnnotationArrayValuesMatcher); $this->add(new AnnotationArrayValuesMatcher);
} }
protected function match($string, &$value) { protected function match($string, &$value) {
$result = parent::match($string, $value); $result = parent::match($string, $value);
return $result; return $result;
} }
public function process($parts) { public function process($parts) {
return array_merge($parts[0], $parts[2]); return array_merge($parts[0], $parts[2]);
} }
} }
class AnnotationArrayValueMatcher extends ParallelMatcher { class AnnotationArrayValueMatcher extends ParallelMatcher {
protected function build() { protected function build() {
$this->add(new AnnotationValueInArrayMatcher); $this->add(new AnnotationValueInArrayMatcher);
$this->add(new AnnotationPairMatcher); $this->add(new AnnotationPairMatcher);
} }
} }
class AnnotationValueInArrayMatcher extends AnnotationValueMatcher { class AnnotationValueInArrayMatcher extends AnnotationValueMatcher {
public function process($value) { public function process($value) {
return array($value); return array($value);
} }
} }
class AnnotationStringMatcher extends ParallelMatcher { class AnnotationStringMatcher extends ParallelMatcher {
protected function build() { protected function build() {
$this->add(new AnnotationSingleQuotedStringMatcher); $this->add(new AnnotationSingleQuotedStringMatcher);
$this->add(new AnnotationDoubleQuotedStringMatcher); $this->add(new AnnotationDoubleQuotedStringMatcher);
} }
} }
class AnnotationNumberMatcher extends RegexMatcher { class AnnotationNumberMatcher extends RegexMatcher {
public function __construct() { public function __construct() {
parent::__construct("-?[0-9]*\.?[0-9]*"); parent::__construct("-?[0-9]*\.?[0-9]*");
} }
protected function process($matches) { protected function process($matches) {
$isFloat = strpos($matches[0], '.') !== false; $isFloat = strpos($matches[0], '.') !== false;
return $isFloat ? (float) $matches[0] : (int) $matches[0]; return $isFloat ? (float) $matches[0] : (int) $matches[0];
} }
} }
class AnnotationIntegerMatcher extends RegexMatcher { class AnnotationIntegerMatcher extends RegexMatcher {
public function __construct() { public function __construct() {
parent::__construct("-?[0-9]*"); parent::__construct("-?[0-9]*");
} }
protected function process($matches) { protected function process($matches) {
return (int) $matches[0]; return (int) $matches[0];
} }
} }
class AnnotationSingleQuotedStringMatcher extends RegexMatcher { class AnnotationSingleQuotedStringMatcher extends RegexMatcher {
public function __construct() { public function __construct() {
parent::__construct("'([^']*)'"); parent::__construct("'([^']*)'");
} }
protected function process($matches) { protected function process($matches) {
return $matches[1]; return $matches[1];
} }
} }
class AnnotationDoubleQuotedStringMatcher extends RegexMatcher { class AnnotationDoubleQuotedStringMatcher extends RegexMatcher {
public function __construct() { public function __construct() {
parent::__construct('"([^"]*)"'); parent::__construct('"([^"]*)"');
} }
protected function process($matches) { protected function process($matches) {
return $matches[1]; return $matches[1];
} }
} }
?> ?>

258
lib/vendor/addendum/annotations/doc_comment.php vendored
View file

@ -1,130 +1,130 @@
<?php <?php
class DocComment { class DocComment {
private static $classes = array(); private static $classes = array();
private static $methods = array(); private static $methods = array();
private static $fields = array(); private static $fields = array();
private static $parsedFiles = array(); private static $parsedFiles = array();
public static function clearCache() { public static function clearCache() {
self::$classes = array(); self::$classes = array();
self::$methods = array(); self::$methods = array();
self::$fields = array(); self::$fields = array();
self::$parsedFiles = array(); self::$parsedFiles = array();
} }
public function get($reflection) { public function get($reflection) {
if($reflection instanceof ReflectionClass) { if($reflection instanceof ReflectionClass) {
return $this->forClass($reflection); return $this->forClass($reflection);
} elseif($reflection instanceof ReflectionMethod) { } elseif($reflection instanceof ReflectionMethod) {
return $this->forMethod($reflection); return $this->forMethod($reflection);
} elseif($reflection instanceof ReflectionProperty) { } elseif($reflection instanceof ReflectionProperty) {
return $this->forProperty($reflection); return $this->forProperty($reflection);
} }
} }
public function forClass($reflection) { public function forClass($reflection) {
$this->process($reflection->getFileName()); $this->process($reflection->getFileName());
$name = $reflection->getName(); $name = $reflection->getName();
return isset(self::$classes[$name]) ? self::$classes[$name] : false; return isset(self::$classes[$name]) ? self::$classes[$name] : false;
} }
public function forMethod($reflection) { public function forMethod($reflection) {
$this->process($reflection->getDeclaringClass()->getFileName()); $this->process($reflection->getDeclaringClass()->getFileName());
$class = $reflection->getDeclaringClass()->getName(); $class = $reflection->getDeclaringClass()->getName();
$method = $reflection->getName(); $method = $reflection->getName();
return isset(self::$methods[$class][$method]) ? self::$methods[$class][$method] : false; return isset(self::$methods[$class][$method]) ? self::$methods[$class][$method] : false;
} }
public function forProperty($reflection) { public function forProperty($reflection) {
$this->process($reflection->getDeclaringClass()->getFileName()); $this->process($reflection->getDeclaringClass()->getFileName());
$class = $reflection->getDeclaringClass()->getName(); $class = $reflection->getDeclaringClass()->getName();
$field = $reflection->getName(); $field = $reflection->getName();
return isset(self::$fields[$class][$field]) ? self::$fields[$class][$field] : false; return isset(self::$fields[$class][$field]) ? self::$fields[$class][$field] : false;
} }
private function process($file) { private function process($file) {
if(!isset(self::$parsedFiles[$file])) { if(!isset(self::$parsedFiles[$file])) {
$this->parse($file); $this->parse($file);
self::$parsedFiles[$file] = true; self::$parsedFiles[$file] = true;
} }
} }
protected function parse($file) { protected function parse($file) {
$tokens = $this->getTokens($file); $tokens = $this->getTokens($file);
$currentClass = false; $currentClass = false;
$currentBlock = false; $currentBlock = false;
$max = count($tokens); $max = count($tokens);
$i = 0; $i = 0;
while($i < $max) { while($i < $max) {
$token = $tokens[$i]; $token = $tokens[$i];
if(is_array($token)) { if(is_array($token)) {
list($code, $value) = $token; list($code, $value) = $token;
switch($code) { switch($code) {
case T_DOC_COMMENT: case T_DOC_COMMENT:
$comment = $value; $comment = $value;
break; break;
case T_CLASS: case T_CLASS:
$class = $this->getString($tokens, $i, $max); $class = $this->getString($tokens, $i, $max);
if($comment !== false) { if($comment !== false) {
self::$classes[$class] = $comment; self::$classes[$class] = $comment;
$comment = false; $comment = false;
} }
break; break;
case T_VARIABLE: case T_VARIABLE:
if($comment !== false) { if($comment !== false) {
$field = substr($token[1], 1); $field = substr($token[1], 1);
self::$fields[$class][$field] = $comment; self::$fields[$class][$field] = $comment;
$comment = false; $comment = false;
} }
break; break;
case T_FUNCTION: case T_FUNCTION:
if($comment !== false) { if($comment !== false) {
$function = $this->getString($tokens, $i, $max); $function = $this->getString($tokens, $i, $max);
self::$methods[$class][$function] = $comment; self::$methods[$class][$function] = $comment;
$comment = false; $comment = false;
} }
break; break;
// ignore // ignore
case T_WHITESPACE: case T_WHITESPACE:
case T_PUBLIC: case T_PUBLIC:
case T_PROTECTED: case T_PROTECTED:
case T_PRIVATE: case T_PRIVATE:
case T_ABSTRACT: case T_ABSTRACT:
case T_FINAL: case T_FINAL:
case T_VAR: case T_VAR:
break; break;
default: default:
$comment = false; $comment = false;
break; break;
} }
} else { } else {
$comment = false; $comment = false;
} }
$i++; $i++;
} }
} }
private function getString($tokens, &$i, $max) { private function getString($tokens, &$i, $max) {
do { do {
$token = $tokens[$i]; $token = $tokens[$i];
$i++; $i++;
if(is_array($token)) { if(is_array($token)) {
if($token[0] == T_STRING) { if($token[0] == T_STRING) {
return $token[1]; return $token[1];
} }
} }
} while($i <= $max); } while($i <= $max);
return false; return false;
} }
private function getTokens($file) { private function getTokens($file) {
return token_get_all(file_get_contents($file)); return token_get_all(file_get_contents($file));
} }
} }
?> ?>

466
lib/vendor/addendum/annotations/tests/acceptance_test.php vendored
View file

@ -1,233 +1,233 @@
<?php <?php
require_once('simpletest/autorun.php'); require_once('simpletest/autorun.php');
require_once('simpletest/mock_objects.php'); require_once('simpletest/mock_objects.php');
require_once(dirname(__FILE__).'/../../annotations.php'); require_once(dirname(__FILE__).'/../../annotations.php');
interface DummyInterface {} interface DummyInterface {}
class ParentExample {} class ParentExample {}
/** @FirstAnnotation @SecondAnnotation */ /** @FirstAnnotation @SecondAnnotation */
class Example extends ParentExample implements DummyInterface { class Example extends ParentExample implements DummyInterface {
/** @SecondAnnotation */ /** @SecondAnnotation */
private $exampleProperty; private $exampleProperty;
public $publicOne; public $publicOne;
public function __construct() {} public function __construct() {}
/** @FirstAnnotation */ /** @FirstAnnotation */
public function exampleMethod() { public function exampleMethod() {
} }
private function justPrivate() {} private function justPrivate() {}
} }
/** @FirstAnnotation(1) @FirstAnnotation(2) @SecondAnnotation(3) */ /** @FirstAnnotation(1) @FirstAnnotation(2) @SecondAnnotation(3) */
class MultiExample { class MultiExample {
/** @FirstAnnotation(1) @FirstAnnotation(2) @SecondAnnotation(3) */ /** @FirstAnnotation(1) @FirstAnnotation(2) @SecondAnnotation(3) */
public $property; public $property;
/** @FirstAnnotation(1) @FirstAnnotation(2) @SecondAnnotation(3) */ /** @FirstAnnotation(1) @FirstAnnotation(2) @SecondAnnotation(3) */
public function aMethod() {} public function aMethod() {}
} }
class FirstAnnotation extends Annotation {} class FirstAnnotation extends Annotation {}
class SecondAnnotation extends Annotation {} class SecondAnnotation extends Annotation {}
class TestOfAnnotations extends UnitTestCase { class TestOfAnnotations extends UnitTestCase {
public function testReflectionAnnotatedClass() { public function testReflectionAnnotatedClass() {
$reflection = new ReflectionAnnotatedClass('Example'); $reflection = new ReflectionAnnotatedClass('Example');
$this->assertTrue($reflection->hasAnnotation('FirstAnnotation')); $this->assertTrue($reflection->hasAnnotation('FirstAnnotation'));
$this->assertTrue($reflection->hasAnnotation('SecondAnnotation')); $this->assertTrue($reflection->hasAnnotation('SecondAnnotation'));
$this->assertFalse($reflection->hasAnnotation('NonExistentAnnotation')); $this->assertFalse($reflection->hasAnnotation('NonExistentAnnotation'));
$this->assertIsA($reflection->getAnnotation('FirstAnnotation'), 'FirstAnnotation'); $this->assertIsA($reflection->getAnnotation('FirstAnnotation'), 'FirstAnnotation');
$this->assertIsA($reflection->getAnnotation('SecondAnnotation'), 'SecondAnnotation'); $this->assertIsA($reflection->getAnnotation('SecondAnnotation'), 'SecondAnnotation');
$annotations = $reflection->getAnnotations(); $annotations = $reflection->getAnnotations();
$this->assertEqual(count($annotations), 2); $this->assertEqual(count($annotations), 2);
$this->assertIsA($annotations[0], 'FirstAnnotation'); $this->assertIsA($annotations[0], 'FirstAnnotation');
$this->assertIsA($annotations[1], 'SecondAnnotation'); $this->assertIsA($annotations[1], 'SecondAnnotation');
$this->assertFalse($reflection->getAnnotation('NonExistentAnnotation')); $this->assertFalse($reflection->getAnnotation('NonExistentAnnotation'));
$this->assertIsA($reflection->getConstructor(), 'ReflectionAnnotatedMethod'); $this->assertIsA($reflection->getConstructor(), 'ReflectionAnnotatedMethod');
$this->assertIsA($reflection->getMethod('exampleMethod'), 'ReflectionAnnotatedMethod'); $this->assertIsA($reflection->getMethod('exampleMethod'), 'ReflectionAnnotatedMethod');
foreach($reflection->getMethods() as $method) { foreach($reflection->getMethods() as $method) {
$this->assertIsA($method, 'ReflectionAnnotatedMethod'); $this->assertIsA($method, 'ReflectionAnnotatedMethod');
} }
$this->assertIsA($reflection->getProperty('exampleProperty'), 'ReflectionAnnotatedProperty'); $this->assertIsA($reflection->getProperty('exampleProperty'), 'ReflectionAnnotatedProperty');
foreach($reflection->getProperties() as $property) { foreach($reflection->getProperties() as $property) {
$this->assertIsA($property, 'ReflectionAnnotatedProperty'); $this->assertIsA($property, 'ReflectionAnnotatedProperty');
} }
foreach($reflection->getInterfaces() as $interface) { foreach($reflection->getInterfaces() as $interface) {
$this->assertIsA($interface, 'ReflectionAnnotatedClass'); $this->assertIsA($interface, 'ReflectionAnnotatedClass');
} }
$this->assertIsA($reflection->getParentClass(), 'ReflectionAnnotatedClass'); $this->assertIsA($reflection->getParentClass(), 'ReflectionAnnotatedClass');
} }
public function testReflectionAnnotatedMethod() { public function testReflectionAnnotatedMethod() {
$reflection = new ReflectionAnnotatedMethod('Example', 'exampleMethod'); $reflection = new ReflectionAnnotatedMethod('Example', 'exampleMethod');
$this->assertTrue($reflection->hasAnnotation('FirstAnnotation')); $this->assertTrue($reflection->hasAnnotation('FirstAnnotation'));
$this->assertFalse($reflection->hasAnnotation('NonExistentAnnotation')); $this->assertFalse($reflection->hasAnnotation('NonExistentAnnotation'));
$this->assertIsA($reflection->getAnnotation('FirstAnnotation'), 'FirstAnnotation'); $this->assertIsA($reflection->getAnnotation('FirstAnnotation'), 'FirstAnnotation');
$this->assertFalse($reflection->getAnnotation('NonExistentAnnotation')); $this->assertFalse($reflection->getAnnotation('NonExistentAnnotation'));
$annotations = $reflection->getAnnotations(); $annotations = $reflection->getAnnotations();
$this->assertEqual(count($annotations), 1); $this->assertEqual(count($annotations), 1);
$this->assertIsA($annotations[0], 'FirstAnnotation'); $this->assertIsA($annotations[0], 'FirstAnnotation');
$this->assertIsA($reflection->getDeclaringClass(), 'ReflectionAnnotatedClass'); $this->assertIsA($reflection->getDeclaringClass(), 'ReflectionAnnotatedClass');
} }
public function testReflectionAnnotatedProperty() { public function testReflectionAnnotatedProperty() {
$reflection = new ReflectionAnnotatedProperty('Example', 'exampleProperty'); $reflection = new ReflectionAnnotatedProperty('Example', 'exampleProperty');
$this->assertTrue($reflection->hasAnnotation('SecondAnnotation')); $this->assertTrue($reflection->hasAnnotation('SecondAnnotation'));
$this->assertFalse($reflection->hasAnnotation('FirstAnnotation')); $this->assertFalse($reflection->hasAnnotation('FirstAnnotation'));
$this->assertIsA($reflection->getAnnotation('SecondAnnotation'), 'SecondAnnotation'); $this->assertIsA($reflection->getAnnotation('SecondAnnotation'), 'SecondAnnotation');
$this->assertFalse($reflection->getAnnotation('NonExistentAnnotation')); $this->assertFalse($reflection->getAnnotation('NonExistentAnnotation'));
$annotations = $reflection->getAnnotations(); $annotations = $reflection->getAnnotations();
$this->assertEqual(count($annotations), 1); $this->assertEqual(count($annotations), 1);
$this->assertIsA($annotations[0], 'SecondAnnotation'); $this->assertIsA($annotations[0], 'SecondAnnotation');
$this->assertIsA($reflection->getDeclaringClass(), 'ReflectionAnnotatedClass'); $this->assertIsA($reflection->getDeclaringClass(), 'ReflectionAnnotatedClass');
} }
public function testReflectionClassCanFilterMethodsByAccess() { public function testReflectionClassCanFilterMethodsByAccess() {
$reflection = new ReflectionAnnotatedClass('Example'); $reflection = new ReflectionAnnotatedClass('Example');
$privateMethods = $reflection->getMethods(ReflectionMethod::IS_PRIVATE); $privateMethods = $reflection->getMethods(ReflectionMethod::IS_PRIVATE);
$this->assertEqual(count($privateMethods), 1); $this->assertEqual(count($privateMethods), 1);
$this->assertEqual($privateMethods[0]->getName(), 'justPrivate'); $this->assertEqual($privateMethods[0]->getName(), 'justPrivate');
} }
public function testReflectionClassCanFilterPropertiesByAccess() { public function testReflectionClassCanFilterPropertiesByAccess() {
$reflection = new ReflectionAnnotatedClass('Example'); $reflection = new ReflectionAnnotatedClass('Example');
$privateProperties = $reflection->getProperties(ReflectionProperty::IS_PUBLIC); $privateProperties = $reflection->getProperties(ReflectionProperty::IS_PUBLIC);
$this->assertEqual(count($privateProperties), 1); $this->assertEqual(count($privateProperties), 1);
$this->assertEqual($privateProperties[0]->getName(), 'publicOne'); $this->assertEqual($privateProperties[0]->getName(), 'publicOne');
} }
public function testReflectionClassShouldReturnAllMethodsWithNoFilter() { public function testReflectionClassShouldReturnAllMethodsWithNoFilter() {
$reflection = new ReflectionAnnotatedClass('Example'); $reflection = new ReflectionAnnotatedClass('Example');
$methods = $reflection->getMethods(); $methods = $reflection->getMethods();
$this->assertEqual(count($methods), 3); $this->assertEqual(count($methods), 3);
} }
public function testReflectionClassShouldReturnAllPropertiesWithNoFilter() { public function testReflectionClassShouldReturnAllPropertiesWithNoFilter() {
$reflection = new ReflectionAnnotatedClass('Example'); $reflection = new ReflectionAnnotatedClass('Example');
$properties = $reflection->getProperties(); $properties = $reflection->getProperties();
$this->assertEqual(count($properties), 2); $this->assertEqual(count($properties), 2);
} }
public function testMultipleAnnotationsOnClass() { public function testMultipleAnnotationsOnClass() {
$reflection = new ReflectionAnnotatedClass('MultiExample'); $reflection = new ReflectionAnnotatedClass('MultiExample');
$annotations = $reflection->getAllAnnotations(); $annotations = $reflection->getAllAnnotations();
$this->assertEqual(count($annotations), 3); $this->assertEqual(count($annotations), 3);
$this->assertEqual($annotations[0]->value, 1); $this->assertEqual($annotations[0]->value, 1);
$this->assertEqual($annotations[1]->value, 2); $this->assertEqual($annotations[1]->value, 2);
$this->assertEqual($annotations[2]->value, 3); $this->assertEqual($annotations[2]->value, 3);
$this->assertIsA($annotations[0], 'FirstAnnotation'); $this->assertIsA($annotations[0], 'FirstAnnotation');
$this->assertIsA($annotations[1], 'FirstAnnotation'); $this->assertIsA($annotations[1], 'FirstAnnotation');
$this->assertIsA($annotations[2], 'SecondAnnotation'); $this->assertIsA($annotations[2], 'SecondAnnotation');
} }
public function testMultipleAnnotationsOnClassWithRestriction() { public function testMultipleAnnotationsOnClassWithRestriction() {
$reflection = new ReflectionAnnotatedClass('MultiExample'); $reflection = new ReflectionAnnotatedClass('MultiExample');
$annotations = $reflection->getAllAnnotations('FirstAnnotation'); $annotations = $reflection->getAllAnnotations('FirstAnnotation');
$this->assertEqual(count($annotations), 2); $this->assertEqual(count($annotations), 2);
$this->assertEqual($annotations[0]->value, 1); $this->assertEqual($annotations[0]->value, 1);
$this->assertEqual($annotations[1]->value, 2); $this->assertEqual($annotations[1]->value, 2);
$this->assertIsA($annotations[0], 'FirstAnnotation'); $this->assertIsA($annotations[0], 'FirstAnnotation');
$this->assertIsA($annotations[1], 'FirstAnnotation'); $this->assertIsA($annotations[1], 'FirstAnnotation');
} }
public function testMultipleAnnotationsOnProperty() { public function testMultipleAnnotationsOnProperty() {
$reflection = new ReflectionAnnotatedClass('MultiExample'); $reflection = new ReflectionAnnotatedClass('MultiExample');
$reflection = $reflection->getProperty('property'); $reflection = $reflection->getProperty('property');
$annotations = $reflection->getAllAnnotations(); $annotations = $reflection->getAllAnnotations();
$this->assertEqual(count($annotations), 3); $this->assertEqual(count($annotations), 3);
$this->assertEqual($annotations[0]->value, 1); $this->assertEqual($annotations[0]->value, 1);
$this->assertEqual($annotations[1]->value, 2); $this->assertEqual($annotations[1]->value, 2);
$this->assertEqual($annotations[2]->value, 3); $this->assertEqual($annotations[2]->value, 3);
$this->assertIsA($annotations[0], 'FirstAnnotation'); $this->assertIsA($annotations[0], 'FirstAnnotation');
$this->assertIsA($annotations[1], 'FirstAnnotation'); $this->assertIsA($annotations[1], 'FirstAnnotation');
$this->assertIsA($annotations[2], 'SecondAnnotation'); $this->assertIsA($annotations[2], 'SecondAnnotation');
} }
public function testMultipleAnnotationsOnPropertyWithRestriction() { public function testMultipleAnnotationsOnPropertyWithRestriction() {
$reflection = new ReflectionAnnotatedClass('MultiExample'); $reflection = new ReflectionAnnotatedClass('MultiExample');
$reflection = $reflection->getProperty('property'); $reflection = $reflection->getProperty('property');
$annotations = $reflection->getAllAnnotations('FirstAnnotation'); $annotations = $reflection->getAllAnnotations('FirstAnnotation');
$this->assertEqual(count($annotations), 2); $this->assertEqual(count($annotations), 2);
$this->assertEqual($annotations[0]->value, 1); $this->assertEqual($annotations[0]->value, 1);
$this->assertEqual($annotations[1]->value, 2); $this->assertEqual($annotations[1]->value, 2);
$this->assertIsA($annotations[0], 'FirstAnnotation'); $this->assertIsA($annotations[0], 'FirstAnnotation');
$this->assertIsA($annotations[1], 'FirstAnnotation'); $this->assertIsA($annotations[1], 'FirstAnnotation');
} }
public function testMultipleAnnotationsOnMethod() { public function testMultipleAnnotationsOnMethod() {
$reflection = new ReflectionAnnotatedClass('MultiExample'); $reflection = new ReflectionAnnotatedClass('MultiExample');
$reflection = $reflection->getMethod('aMethod'); $reflection = $reflection->getMethod('aMethod');
$annotations = $reflection->getAllAnnotations(); $annotations = $reflection->getAllAnnotations();
$this->assertEqual(count($annotations), 3); $this->assertEqual(count($annotations), 3);
$this->assertEqual($annotations[0]->value, 1); $this->assertEqual($annotations[0]->value, 1);
$this->assertEqual($annotations[1]->value, 2); $this->assertEqual($annotations[1]->value, 2);
$this->assertEqual($annotations[2]->value, 3); $this->assertEqual($annotations[2]->value, 3);
$this->assertIsA($annotations[0], 'FirstAnnotation'); $this->assertIsA($annotations[0], 'FirstAnnotation');
$this->assertIsA($annotations[1], 'FirstAnnotation'); $this->assertIsA($annotations[1], 'FirstAnnotation');
$this->assertIsA($annotations[2], 'SecondAnnotation'); $this->assertIsA($annotations[2], 'SecondAnnotation');
} }
public function testMultipleAnnotationsOnMethodWithRestriction() { public function testMultipleAnnotationsOnMethodWithRestriction() {
$reflection = new ReflectionAnnotatedClass('MultiExample'); $reflection = new ReflectionAnnotatedClass('MultiExample');
$reflection = $reflection->getMethod('aMethod'); $reflection = $reflection->getMethod('aMethod');
$annotations = $reflection->getAllAnnotations('FirstAnnotation'); $annotations = $reflection->getAllAnnotations('FirstAnnotation');
$this->assertEqual(count($annotations), 2); $this->assertEqual(count($annotations), 2);
$this->assertEqual($annotations[0]->value, 1); $this->assertEqual($annotations[0]->value, 1);
$this->assertEqual($annotations[1]->value, 2); $this->assertEqual($annotations[1]->value, 2);
$this->assertIsA($annotations[0], 'FirstAnnotation'); $this->assertIsA($annotations[0], 'FirstAnnotation');
$this->assertIsA($annotations[1], 'FirstAnnotation'); $this->assertIsA($annotations[1], 'FirstAnnotation');
} }
} }
Mock::generatePartial('AnnotationsBuilder', 'MockedAnnotationsBuilder', array('getDocComment')); Mock::generatePartial('AnnotationsBuilder', 'MockedAnnotationsBuilder', array('getDocComment'));
class TestOfPerformanceFeatures extends UnitTestCase { class TestOfPerformanceFeatures extends UnitTestCase {
public function setUp() { public function setUp() {
AnnotationsBuilder::clearCache(); AnnotationsBuilder::clearCache();
} }
public function tearDown() { public function tearDown() {
AnnotationsBuilder::clearCache(); AnnotationsBuilder::clearCache();
} }
public function testBuilderShouldCacheResults() { public function testBuilderShouldCacheResults() {
$builder = new MockedAnnotationsBuilder; $builder = new MockedAnnotationsBuilder;
$reflection = new ReflectionClass('Example'); $reflection = new ReflectionClass('Example');
$builder->build($reflection); $builder->build($reflection);
$builder->build($reflection); $builder->build($reflection);
$builder->expectOnce('getDocComment'); $builder->expectOnce('getDocComment');
} }
} }
class TestOfSupportingFeatures extends UnitTestCase { class TestOfSupportingFeatures extends UnitTestCase {
public function setUp() { public function setUp() {
Addendum::resetIgnoredAnnotations(); Addendum::resetIgnoredAnnotations();
} }
public function tearDown() { public function tearDown() {
Addendum::resetIgnoredAnnotations(); Addendum::resetIgnoredAnnotations();
} }
public function testIgnoredAnnotationsAreNotUsed() { public function testIgnoredAnnotationsAreNotUsed() {
Addendum::ignore('FirstAnnotation', 'SecondAnnotation'); Addendum::ignore('FirstAnnotation', 'SecondAnnotation');
$reflection = new ReflectionAnnotatedClass('Example'); $reflection = new ReflectionAnnotatedClass('Example');
$this->assertFalse($reflection->hasAnnotation('FirstAnnotation')); $this->assertFalse($reflection->hasAnnotation('FirstAnnotation'));
$this->assertFalse($reflection->hasAnnotation('SecondAnnotation')); $this->assertFalse($reflection->hasAnnotation('SecondAnnotation'));
} }
} }
?> ?>

66
lib/vendor/addendum/annotations/tests/all_tests.php vendored
View file

@ -1,33 +1,33 @@
<?php <?php
require_once('simpletest/unit_tester.php'); require_once('simpletest/unit_tester.php');
require_once('simpletest/reporter.php'); require_once('simpletest/reporter.php');
require_once(dirname(__FILE__).'/acceptance_test.php'); require_once(dirname(__FILE__).'/acceptance_test.php');
require_once(dirname(__FILE__).'/annotation_test.php'); require_once(dirname(__FILE__).'/annotation_test.php');
require_once(dirname(__FILE__).'/constrained_annotation_test.php'); require_once(dirname(__FILE__).'/constrained_annotation_test.php');
require_once(dirname(__FILE__).'/annotation_parser_test.php'); require_once(dirname(__FILE__).'/annotation_parser_test.php');
require_once(dirname(__FILE__).'/doc_comment_test.php'); require_once(dirname(__FILE__).'/doc_comment_test.php');
class AllTests extends GroupTest { class AllTests extends GroupTest {
function __construct($title = false) { function __construct($title = false) {
parent::__construct($title); parent::__construct($title);
$this->addTestClass('TestOfAnnotations'); $this->addTestClass('TestOfAnnotations');
$this->addTestClass('TestOfPerformanceFeatures'); $this->addTestClass('TestOfPerformanceFeatures');
$this->addTestClass('TestOfSupportingFeatures'); $this->addTestClass('TestOfSupportingFeatures');
$this->addTestClass('TestOfAnnotation'); $this->addTestClass('TestOfAnnotation');
$this->addTestClass('TestOfConstrainedAnnotation'); $this->addTestClass('TestOfConstrainedAnnotation');
$this->addTestClass('TestOfMatchers'); $this->addTestClass('TestOfMatchers');
$this->addTestClass('TestOfAnnotationMatchers'); $this->addTestClass('TestOfAnnotationMatchers');
$this->addTestClass('TestOfDocComment'); $this->addTestClass('TestOfDocComment');
} }
} }
Addendum::setRawMode(false); Addendum::setRawMode(false);
$test = new AllTests('All tests in reflection mode'); $test = new AllTests('All tests in reflection mode');
$test->run(new HtmlReporter()); $test->run(new HtmlReporter());
Addendum::setRawMode(true); Addendum::setRawMode(true);
$test = new AllTests('All tests in raw mode'); $test = new AllTests('All tests in raw mode');
$test->run(new HtmlReporter()); $test->run(new HtmlReporter());
?> ?>

622
lib/vendor/addendum/annotations/tests/annotation_parser_test.php vendored
View file

@ -1,312 +1,312 @@
<?php <?php
require_once('simpletest/autorun.php'); require_once('simpletest/autorun.php');
require_once(dirname(__FILE__).'/../annotation_parser.php'); require_once(dirname(__FILE__).'/../annotation_parser.php');
class TestOfMatchers extends UnitTestCase { class TestOfMatchers extends UnitTestCase {
public function testRegexMatcherShouldMatchPatternAndReturnLengthOfMatch() { public function testRegexMatcherShouldMatchPatternAndReturnLengthOfMatch() {
$matcher = new RegexMatcher('[0-9]+'); $matcher = new RegexMatcher('[0-9]+');
$this->assertIdentical($matcher->matches('1234a', $value), 4); $this->assertIdentical($matcher->matches('1234a', $value), 4);
$this->assertIdentical($value, '1234'); $this->assertIdentical($value, '1234');
} }
public function testRegexMatcherShouldReturnFalseOnNoMatch() { public function testRegexMatcherShouldReturnFalseOnNoMatch() {
$matcher = new RegexMatcher('[0-9]+'); $matcher = new RegexMatcher('[0-9]+');
$this->assertFalse($matcher->matches('abc123', $value)); $this->assertFalse($matcher->matches('abc123', $value));
} }
public function testParallelMatcherShouldMatchLongerStringOnColision() { public function testParallelMatcherShouldMatchLongerStringOnColision() {
$matcher = new ParallelMatcher; $matcher = new ParallelMatcher;
$matcher->add(new RegexMatcher('true')); $matcher->add(new RegexMatcher('true'));
$matcher->add(new RegexMatcher('.+')); $matcher->add(new RegexMatcher('.+'));
$this->assertEqual($matcher->matches('truestring', $value), 10); $this->assertEqual($matcher->matches('truestring', $value), 10);
$this->assertEqual($value, 'truestring'); $this->assertEqual($value, 'truestring');
} }
public function testSerialMatcherShouldMatchAllParts() { public function testSerialMatcherShouldMatchAllParts() {
$matcher = new SerialMatcher; $matcher = new SerialMatcher;
$matcher->add(new RegexMatcher('[a-zA-Z0-9_]+')); $matcher->add(new RegexMatcher('[a-zA-Z0-9_]+'));
$matcher->add(new RegexMatcher('=')); $matcher->add(new RegexMatcher('='));
$matcher->add(new RegexMatcher('[0-9]+')); $matcher->add(new RegexMatcher('[0-9]+'));
$this->assertEqual($matcher->matches('key=20', $value), 6); $this->assertEqual($matcher->matches('key=20', $value), 6);
$this->assertEqual($value, 'key=20'); $this->assertEqual($value, 'key=20');
} }
public function testSerialMatcherShouldFailIfAnyPartDoesNotMatch() { public function testSerialMatcherShouldFailIfAnyPartDoesNotMatch() {
$matcher = new SerialMatcher; $matcher = new SerialMatcher;
$matcher->add(new RegexMatcher('[a-zA-Z0-9_]+')); $matcher->add(new RegexMatcher('[a-zA-Z0-9_]+'));
$matcher->add(new RegexMatcher('=')); $matcher->add(new RegexMatcher('='));
$matcher->add(new RegexMatcher('[0-9]+')); $matcher->add(new RegexMatcher('[0-9]+'));
$this->assertFalse($matcher->matches('key=a20', $value)); $this->assertFalse($matcher->matches('key=a20', $value));
} }
public function testSimpleSerialMatcherShouldReturnRequestedPartOnMatch() { public function testSimpleSerialMatcherShouldReturnRequestedPartOnMatch() {
$matcher = new SimpleSerialMatcher(1); $matcher = new SimpleSerialMatcher(1);
$matcher->add(new RegexMatcher('\(')); $matcher->add(new RegexMatcher('\('));
$matcher->add(new RegexMatcher('[0-9]+')); $matcher->add(new RegexMatcher('[0-9]+'));
$matcher->add(new RegexMatcher('\)')); $matcher->add(new RegexMatcher('\)'));
$this->assertEqual($matcher->matches('(1234)', $value), 6); $this->assertEqual($matcher->matches('(1234)', $value), 6);
$this->assertEqual($value, '1234'); $this->assertEqual($value, '1234');
} }
} }
class TestOfAnnotationMatchers extends UnitTestCase { class TestOfAnnotationMatchers extends UnitTestCase {
public function testAnnotationsMatcherShouldMatchAnnotationWithGarbage() { public function testAnnotationsMatcherShouldMatchAnnotationWithGarbage() {
$expected = array('Annotation' => array( $expected = array('Annotation' => array(
array('value' => true), array('value' => true),
)); ));
$matcher = new AnnotationsMatcher; $matcher = new AnnotationsMatcher;
$this->assertMatcherResult($matcher, '/** asd bla bla @Annotation(true) */@', $expected); $this->assertMatcherResult($matcher, '/** asd bla bla @Annotation(true) */@', $expected);
} }
public function testAnnotationsMatcherShouldNotMatchEmail() { public function testAnnotationsMatcherShouldNotMatchEmail() {
$matcher = new AnnotationsMatcher; $matcher = new AnnotationsMatcher;
$this->assertMatcherResult($matcher, 'johno@example.com', array()); $this->assertMatcherResult($matcher, 'johno@example.com', array());
} }
public function testAnnotationsMatcherShouldMatchMultipleAnnotations() { public function testAnnotationsMatcherShouldMatchMultipleAnnotations() {
$expected = array('Annotation' => array( $expected = array('Annotation' => array(
array('value' => true), array('value' => true),
array('value' => false) array('value' => false)
)); ));
$matcher = new AnnotationsMatcher; $matcher = new AnnotationsMatcher;
$this->assertMatcherResult($matcher, ' ss @Annotation(true) @Annotation(false)', $expected); $this->assertMatcherResult($matcher, ' ss @Annotation(true) @Annotation(false)', $expected);
} }
public function testAnnotationsMatcherShouldMatchMultipleAnnotationsOnManyLines() { public function testAnnotationsMatcherShouldMatchMultipleAnnotationsOnManyLines() {
$expected = array('Annotation' => array( $expected = array('Annotation' => array(
array('value' => true), array('value' => true),
array('value' => false) array('value' => false)
)); ));
$block = "/** $block = "/**
@Annotation(true) @Annotation(true)
@Annotation(false) @Annotation(false)
**/"; **/";
$matcher = new AnnotationsMatcher; $matcher = new AnnotationsMatcher;
$this->assertMatcherResult($matcher, $block, $expected); $this->assertMatcherResult($matcher, $block, $expected);
} }
public function testAnnotationMatcherShouldMatchMultilineAnnotations() { public function testAnnotationMatcherShouldMatchMultilineAnnotations() {
$block= '/** $block= '/**
* @Annotation( * @Annotation(
paramOne="value1", paramOne="value1",
paramTwo={ paramTwo={
"value2" , "value2" ,
{"one", "two"} {"one", "two"}
}, },
paramThree="three" paramThree="three"
) )
*/'; */';
$expected = array('Annotation' => array( $expected = array('Annotation' => array(
array( array(
'paramOne' => 'value1', 'paramOne' => 'value1',
'paramTwo' => array('value2', array('one', 'two')), 'paramTwo' => array('value2', array('one', 'two')),
'paramThree' => 'three', 'paramThree' => 'three',
) )
)); ));
$matcher = new AnnotationsMatcher; $matcher = new AnnotationsMatcher;
$this->assertMatcherResult($matcher, $block, $expected); $this->assertMatcherResult($matcher, $block, $expected);
} }
public function testAnnotationMatcherShouldMatchSimpleAnnotation() { public function testAnnotationMatcherShouldMatchSimpleAnnotation() {
$matcher = new AnnotationMatcher; $matcher = new AnnotationMatcher;
$this->assertNotFalse($matcher->matches('@Namespace_Annotation', $value)); $this->assertNotFalse($matcher->matches('@Namespace_Annotation', $value));
$this->assertEqual($value, array('Namespace_Annotation', array())); $this->assertEqual($value, array('Namespace_Annotation', array()));
} }
public function testAnnotationMatcherShouldNotMatchAnnotationWithSmallStartingLetter() { public function testAnnotationMatcherShouldNotMatchAnnotationWithSmallStartingLetter() {
$matcher = new AnnotationMatcher; $matcher = new AnnotationMatcher;
$this->assertFalse($matcher->matches('@annotation', $value)); $this->assertFalse($matcher->matches('@annotation', $value));
} }
public function testAnnotationMatcherShouldMatchAlsoBrackets() { public function testAnnotationMatcherShouldMatchAlsoBrackets() {
$matcher = new AnnotationMatcher; $matcher = new AnnotationMatcher;
$this->assertEqual($matcher->matches('@Annotation()', $value), 13); $this->assertEqual($matcher->matches('@Annotation()', $value), 13);
$this->assertEqual($value, array('Annotation', array())); $this->assertEqual($value, array('Annotation', array()));
} }
public function testAnnotationMatcherShouldMatchValuedAnnotation() { public function testAnnotationMatcherShouldMatchValuedAnnotation() {
$matcher = new AnnotationMatcher; $matcher = new AnnotationMatcher;
$this->assertMatcherResult($matcher, '@Annotation(true)', array('Annotation', array('value' => true))); $this->assertMatcherResult($matcher, '@Annotation(true)', array('Annotation', array('value' => true)));
} }
public function testAnnotationMatcherShouldMatchMultiValuedAnnotation() { public function testAnnotationMatcherShouldMatchMultiValuedAnnotation() {
$matcher = new AnnotationMatcher; $matcher = new AnnotationMatcher;
$this->assertMatcherResult($matcher, '@Annotation(key=true, key2=3.14)', array('Annotation', array('key' => true, 'key2' => 3.14))); $this->assertMatcherResult($matcher, '@Annotation(key=true, key2=3.14)', array('Annotation', array('key' => true, 'key2' => 3.14)));
} }
public function testParametersMatcherShouldMatchEmptyStringAndReturnEmptyArray() { public function testParametersMatcherShouldMatchEmptyStringAndReturnEmptyArray() {
$matcher = new AnnotationParametersMatcher; $matcher = new AnnotationParametersMatcher;
$this->assertIdentical($matcher->matches('', $value), 0); $this->assertIdentical($matcher->matches('', $value), 0);
$this->assertEqual($value, array()); $this->assertEqual($value, array());
} }
public function testParametersMatcherShouldMatchEmptyBracketsAndReturnEmptyArray() { public function testParametersMatcherShouldMatchEmptyBracketsAndReturnEmptyArray() {
$matcher = new AnnotationParametersMatcher; $matcher = new AnnotationParametersMatcher;
$this->assertIdentical($matcher->matches('()', $value), 2); $this->assertIdentical($matcher->matches('()', $value), 2);
$this->assertEqual($value, array()); $this->assertEqual($value, array());
} }
public function testParametersMatcherShouldMatchMultilinedParameters() { public function testParametersMatcherShouldMatchMultilinedParameters() {
$matcher = new AnnotationParametersMatcher; $matcher = new AnnotationParametersMatcher;
$block = "( $block = "(
key = true, key = true,
key2 = false key2 = false
)"; )";
$this->assertMatcherResult($matcher, $block, array('key' => true, 'key2' => false)); $this->assertMatcherResult($matcher, $block, array('key' => true, 'key2' => false));
} }
public function testValuesMatcherShouldMatchSimpleValueOrHash() { public function testValuesMatcherShouldMatchSimpleValueOrHash() {
$matcher = new AnnotationValuesMatcher; $matcher = new AnnotationValuesMatcher;
$this->assertNotFalse($matcher->matches('true', $value)); $this->assertNotFalse($matcher->matches('true', $value));
$this->assertNotFalse($matcher->matches('key=true', $value)); $this->assertNotFalse($matcher->matches('key=true', $value));
} }
public function testValueMatcherShouldMatchConstants() { public function testValueMatcherShouldMatchConstants() {
$matcher = new AnnotationValueMatcher; $matcher = new AnnotationValueMatcher;
$this->assertMatcherResult($matcher, 'true', true); $this->assertMatcherResult($matcher, 'true', true);
$this->assertMatcherResult($matcher, 'false', false); $this->assertMatcherResult($matcher, 'false', false);
$this->assertMatcherResult($matcher, 'TRUE', true); $this->assertMatcherResult($matcher, 'TRUE', true);
$this->assertMatcherResult($matcher, 'FALSE', false); $this->assertMatcherResult($matcher, 'FALSE', false);
} }
public function testValueMatcherShouldMatchStrings() { public function testValueMatcherShouldMatchStrings() {
$matcher = new AnnotationValueMatcher; $matcher = new AnnotationValueMatcher;
$this->assertMatcherResult($matcher, '"string"', 'string'); $this->assertMatcherResult($matcher, '"string"', 'string');
$this->assertMatcherResult($matcher, "'string'", 'string'); $this->assertMatcherResult($matcher, "'string'", 'string');
} }
public function testValueMatcherShouldMatchNumbers() { public function testValueMatcherShouldMatchNumbers() {
$matcher = new AnnotationValueMatcher; $matcher = new AnnotationValueMatcher;
$this->assertMatcherResult($matcher, '-3.14', -3.14); $this->assertMatcherResult($matcher, '-3.14', -3.14);
$this->assertMatcherResult($matcher, '100', 100); $this->assertMatcherResult($matcher, '100', 100);
} }
public function testValueMatcherShouldMatchArray() { public function testValueMatcherShouldMatchArray() {
$matcher = new AnnotationValueMatcher; $matcher = new AnnotationValueMatcher;
$this->assertMatcherResult($matcher, '{1}', array(1)); $this->assertMatcherResult($matcher, '{1}', array(1));
} }
public function testArrayMatcherShouldMatchEmptyArray() { public function testArrayMatcherShouldMatchEmptyArray() {
$matcher = new AnnotationArrayMatcher; $matcher = new AnnotationArrayMatcher;
$this->assertMatcherResult($matcher, '{}', array()); $this->assertMatcherResult($matcher, '{}', array());
} }
public function testValueInArrayMatcherReturnsAValueInArray() { public function testValueInArrayMatcherReturnsAValueInArray() {
$matcher = new AnnotationValueInArrayMatcher; $matcher = new AnnotationValueInArrayMatcher;
$this->assertMatcherResult($matcher, '1', array(1)); $this->assertMatcherResult($matcher, '1', array(1));
} }
public function testArrayMatcherShouldMatchSimpleValueInArray() { public function testArrayMatcherShouldMatchSimpleValueInArray() {
$matcher = new AnnotationArrayMatcher; $matcher = new AnnotationArrayMatcher;
$this->assertMatcherResult($matcher, '{1}', array(1)); $this->assertMatcherResult($matcher, '{1}', array(1));
} }
public function testArrayMatcherShouldMatchSimplePair() { public function testArrayMatcherShouldMatchSimplePair() {
$matcher = new AnnotationArrayMatcher; $matcher = new AnnotationArrayMatcher;
$this->assertMatcherResult($matcher, '{key=5}', array('key' => 5)); $this->assertMatcherResult($matcher, '{key=5}', array('key' => 5));
} }
public function TODO_testArrayMatcherShouldMatchPairWithNumericKeys() { public function TODO_testArrayMatcherShouldMatchPairWithNumericKeys() {
$matcher = new AnnotationArrayMatcher; $matcher = new AnnotationArrayMatcher;
$this->assertMatcherResult($matcher, '{1="one", 2="two"}', array(1 => 'one', 2 => 'two')); $this->assertMatcherResult($matcher, '{1="one", 2="two"}', array(1 => 'one', 2 => 'two'));
} }
public function testArrayMatcherShouldMatchMultiplePairs() { public function testArrayMatcherShouldMatchMultiplePairs() {
$matcher = new AnnotationArrayMatcher; $matcher = new AnnotationArrayMatcher;
$this->assertMatcherResult($matcher, '{key=5, "bla"=false}', array('key' => 5, 'bla' => false)); $this->assertMatcherResult($matcher, '{key=5, "bla"=false}', array('key' => 5, 'bla' => false));
} }
public function testArrayMatcherShouldMatchValuesMixedWithPairs() { public function testArrayMatcherShouldMatchValuesMixedWithPairs() {
$matcher = new AnnotationArrayMatcher; $matcher = new AnnotationArrayMatcher;
$this->assertMatcherResult($matcher, '{key=5, 1, 2, key2="ff"}', array('key' => 5, 1, 2, 'key2' => "ff")); $this->assertMatcherResult($matcher, '{key=5, 1, 2, key2="ff"}', array('key' => 5, 1, 2, 'key2' => "ff"));
} }
public function testArrayMatcherShouldMatchMoreValuesInArrayWithWhiteSpace() { public function testArrayMatcherShouldMatchMoreValuesInArrayWithWhiteSpace() {
$matcher = new AnnotationArrayMatcher; $matcher = new AnnotationArrayMatcher;
$this->assertMatcherResult($matcher, "{1 , 2}", array(1, 2)); $this->assertMatcherResult($matcher, "{1 , 2}", array(1, 2));
} }
public function testArrayMatcherShouldMatchNestedArray() { public function testArrayMatcherShouldMatchNestedArray() {
$matcher = new AnnotationArrayMatcher; $matcher = new AnnotationArrayMatcher;
$this->assertMatcherResult($matcher, "{1 , {2, 3}, 4}", array(1, array(2, 3), 4)); $this->assertMatcherResult($matcher, "{1 , {2, 3}, 4}", array(1, array(2, 3), 4));
} }
public function testArrayMatcherShouldMatchWithMoreWhiteSpace() { public function testArrayMatcherShouldMatchWithMoreWhiteSpace() {
$matcher = new AnnotationArrayMatcher; $matcher = new AnnotationArrayMatcher;
$this->assertMatcherResult($matcher, "{ 1 , 2 , 3 }", array(1, 2, 3)); $this->assertMatcherResult($matcher, "{ 1 , 2 , 3 }", array(1, 2, 3));
} }
public function testArrayMatcherShouldMatchWithMultilineWhiteSpace() { public function testArrayMatcherShouldMatchWithMultilineWhiteSpace() {
$matcher = new AnnotationArrayMatcher; $matcher = new AnnotationArrayMatcher;
$this->assertMatcherResult($matcher, "\n{1, 2, 3\n}", array(1, 2, 3)); $this->assertMatcherResult($matcher, "\n{1, 2, 3\n}", array(1, 2, 3));
} }
public function testNumberMatcherShouldMatchInteger() { public function testNumberMatcherShouldMatchInteger() {
$matcher = new AnnotationNumberMatcher; $matcher = new AnnotationNumberMatcher;
$this->assertMatcherResult($matcher, '-314', -314); $this->assertMatcherResult($matcher, '-314', -314);
} }
public function testNumberMatcherShouldMatchFloat() { public function testNumberMatcherShouldMatchFloat() {
$matcher = new AnnotationNumberMatcher; $matcher = new AnnotationNumberMatcher;
$this->assertMatcherResult($matcher, '-3.14', -3.14); $this->assertMatcherResult($matcher, '-3.14', -3.14);
} }
public function testHashMatcherShouldMatchSimpleHash() { public function testHashMatcherShouldMatchSimpleHash() {
$matcher = new AnnotationHashMatcher; $matcher = new AnnotationHashMatcher;
$this->assertMatcherResult($matcher, 'key=true', array('key' => true)); $this->assertMatcherResult($matcher, 'key=true', array('key' => true));
} }
public function testHashMatcherShouldMatchAlsoMultipleKeys() { public function testHashMatcherShouldMatchAlsoMultipleKeys() {
$matcher = new AnnotationHashMatcher; $matcher = new AnnotationHashMatcher;
$this->assertMatcherResult($matcher, 'key=true,key2=false', array('key' => true, 'key2' => false)); $this->assertMatcherResult($matcher, 'key=true,key2=false', array('key' => true, 'key2' => false));
} }
public function testHashMatcherShouldMatchAlsoMultipleKeysWithWhiteSpace() { public function testHashMatcherShouldMatchAlsoMultipleKeysWithWhiteSpace() {
$matcher = new AnnotationHashMatcher; $matcher = new AnnotationHashMatcher;
$this->assertMatcherResult($matcher, "key=true\n\t\r ,\n\t\r key2=false", array('key' => true, 'key2' => false)); $this->assertMatcherResult($matcher, "key=true\n\t\r ,\n\t\r key2=false", array('key' => true, 'key2' => false));
} }
public function testPairMatcherShouldMatchNumericKey() { public function testPairMatcherShouldMatchNumericKey() {
$matcher = new AnnotationPairMatcher; $matcher = new AnnotationPairMatcher;
$this->assertMatcherResult($matcher, '2 = true', array(2 => true)); $this->assertMatcherResult($matcher, '2 = true', array(2 => true));
} }
public function testPairMatcherShouldMatchAlsoWhitespace() { public function testPairMatcherShouldMatchAlsoWhitespace() {
$matcher = new AnnotationPairMatcher; $matcher = new AnnotationPairMatcher;
$this->assertMatcherResult($matcher, 'key = true', array('key' => true)); $this->assertMatcherResult($matcher, 'key = true', array('key' => true));
} }
public function testKeyMatcherShouldMatchSimpleKeysOrStrings() { public function testKeyMatcherShouldMatchSimpleKeysOrStrings() {
$matcher = new AnnotationKeyMatcher; $matcher = new AnnotationKeyMatcher;
$this->assertNotFalse($matcher->matches('key', $value)); $this->assertNotFalse($matcher->matches('key', $value));
$this->assertNotFalse($matcher->matches('"key"', $value)); $this->assertNotFalse($matcher->matches('"key"', $value));
$this->assertNotFalse($matcher->matches("'key'", $value)); $this->assertNotFalse($matcher->matches("'key'", $value));
} }
public function testKeyMatcherShouldMatchIntegerKeys() { public function testKeyMatcherShouldMatchIntegerKeys() {
$matcher = new AnnotationKeyMatcher; $matcher = new AnnotationKeyMatcher;
$this->assertMatcherResult($matcher, '123', 123); $this->assertMatcherResult($matcher, '123', 123);
} }
public function testStringMatcherShouldMatchDoubleAndSingleQuotedStringsAndHandleEscapes() { public function testStringMatcherShouldMatchDoubleAndSingleQuotedStringsAndHandleEscapes() {
$matcher = new AnnotationStringMatcher; $matcher = new AnnotationStringMatcher;
$this->assertMatcherResult($matcher, '"string string"', 'string string'); $this->assertMatcherResult($matcher, '"string string"', 'string string');
$this->assertMatcherResult($matcher, "'string string'", "string string"); $this->assertMatcherResult($matcher, "'string string'", "string string");
} }
public function TODO_testStringMatcherShouldMatchEscapedStringsCorrectly() { public function TODO_testStringMatcherShouldMatchEscapedStringsCorrectly() {
$matcher = new AnnotationStringMatcher; $matcher = new AnnotationStringMatcher;
$this->assertMatcherResult($matcher, '"string\"string"', 'string"string'); $this->assertMatcherResult($matcher, '"string\"string"', 'string"string');
$this->assertMatcherResult($matcher, "'string\'string'", "string'string"); $this->assertMatcherResult($matcher, "'string\'string'", "string'string");
} }
private function assertNotFalse($value) { private function assertNotFalse($value) {
$this->assertNotIdentical($value, false); $this->assertNotIdentical($value, false);
} }
private function assertMatcherResult($matcher, $string, $expected) { private function assertMatcherResult($matcher, $string, $expected) {
$this->assertNotIdentical($matcher->matches($string, $value), false); $this->assertNotIdentical($matcher->matches($string, $value), false);
$this->assertIdentical($value, $expected); $this->assertIdentical($value, $expected);
} }
} }
?> ?>

54
lib/vendor/addendum/annotations/tests/annotation_test.php vendored
View file

@ -1,27 +1,27 @@
<?php <?php
require_once('simpletest/autorun.php'); require_once('simpletest/autorun.php');
require_once(dirname(__FILE__).'/../../annotations.php'); require_once(dirname(__FILE__).'/../../annotations.php');
class TestingAnnotation extends Annotation { class TestingAnnotation extends Annotation {
public $optional = 'default'; public $optional = 'default';
public $required; public $required;
} }
class TestOfAnnotation extends UnitTestCase { class TestOfAnnotation extends UnitTestCase {
public function testConstructorsFillsParameters() { public function testConstructorsFillsParameters() {
$annotation = new TestingAnnotation(array('optional' => 1, 'required' => 2), $this); $annotation = new TestingAnnotation(array('optional' => 1, 'required' => 2), $this);
$this->assertEqual($annotation->optional, 1); $this->assertEqual($annotation->optional, 1);
$this->assertEqual($annotation->required, 2); $this->assertEqual($annotation->required, 2);
} }
public function testConstructorThrowsErrorOnInvalidParameter() { public function testConstructorThrowsErrorOnInvalidParameter() {
$annotation = new TestingAnnotation(array('unknown' => 1), $this); $annotation = new TestingAnnotation(array('unknown' => 1), $this);
$this->assertError("Property 'unknown' not defined for annotation 'TestingAnnotation'"); $this->assertError("Property 'unknown' not defined for annotation 'TestingAnnotation'");
} }
public function TODO_testConstructorThrowsErrorWithoutSpecifingRequiredParameters() { public function TODO_testConstructorThrowsErrorWithoutSpecifingRequiredParameters() {
$annotation = new TestingAnnotation(); $annotation = new TestingAnnotation();
$this->assertError("Property 'required' in annotation 'TestingAnnotation' is required"); $this->assertError("Property 'required' in annotation 'TestingAnnotation' is required");
} }
} }
?> ?>

144
lib/vendor/addendum/annotations/tests/constrained_annotation_test.php vendored
View file

@ -1,73 +1,73 @@
<?php <?php
require_once('simpletest/autorun.php'); require_once('simpletest/autorun.php');
require_once(dirname(__FILE__).'/../../annotations.php'); require_once(dirname(__FILE__).'/../../annotations.php');
/** @Target("class") */ /** @Target("class") */
class ClassRestrictedAnnotation extends Annotation {} class ClassRestrictedAnnotation extends Annotation {}
/** @Target("method") */ /** @Target("method") */
class MethodRestrictedAnnotation extends Annotation {} class MethodRestrictedAnnotation extends Annotation {}
/** @Target("property") */ /** @Target("property") */
class PropertyRestrictedAnnotation extends Annotation {} class PropertyRestrictedAnnotation extends Annotation {}
/** @Target({"class", "property"}) */ /** @Target({"class", "property"}) */
class ClassOrPropertyRestrictedAnnotation extends Annotation {} class ClassOrPropertyRestrictedAnnotation extends Annotation {}
class BadlyAnnotatedClass { class BadlyAnnotatedClass {
/** @ClassRestrictedAnnotation */ /** @ClassRestrictedAnnotation */
private $property; private $property;
/** @ClassRestrictedAnnotation */ /** @ClassRestrictedAnnotation */
public function method() {} public function method() {}
/** @ClassOrPropertyRestrictedAnnotation */ /** @ClassOrPropertyRestrictedAnnotation */
public function method2() {} public function method2() {}
} }
/** @ClassRestrictedAnnotation */ /** @ClassRestrictedAnnotation */
class SuccesfullyAnnotatedClass { class SuccesfullyAnnotatedClass {
/** @PropertyRestrictedAnnotation */ /** @PropertyRestrictedAnnotation */
private $property; private $property;
/** @ClassOrPropertyRestrictedAnnotation */ /** @ClassOrPropertyRestrictedAnnotation */
private $property2; private $property2;
/** @MethodRestrictedAnnotation */ /** @MethodRestrictedAnnotation */
public function method() {} public function method() {}
} }
class TestOfConstrainedAnnotation extends UnitTestCase { class TestOfConstrainedAnnotation extends UnitTestCase {
public function testClassAnnotationThrowsErrorWhenOnMethod() { public function testClassAnnotationThrowsErrorWhenOnMethod() {
$this->expectError("Annotation 'ClassRestrictedAnnotation' not allowed on BadlyAnnotatedClass::method"); $this->expectError("Annotation 'ClassRestrictedAnnotation' not allowed on BadlyAnnotatedClass::method");
$reflection = new ReflectionAnnotatedClass('BadlyAnnotatedClass'); $reflection = new ReflectionAnnotatedClass('BadlyAnnotatedClass');
$method = $reflection->getMethod('method'); $method = $reflection->getMethod('method');
} }
public function testClassAnnotationThrowsErrorWhenOnProperty() { public function testClassAnnotationThrowsErrorWhenOnProperty() {
$this->expectError("Annotation 'ClassRestrictedAnnotation' not allowed on BadlyAnnotatedClass::\$property"); $this->expectError("Annotation 'ClassRestrictedAnnotation' not allowed on BadlyAnnotatedClass::\$property");
$reflection = new ReflectionAnnotatedClass('BadlyAnnotatedClass'); $reflection = new ReflectionAnnotatedClass('BadlyAnnotatedClass');
$method = $reflection->getProperty('property'); $method = $reflection->getProperty('property');
} }
public function testSingleTargetAnnotationThrowsNoErrorWhenOnRightPlace() { public function testSingleTargetAnnotationThrowsNoErrorWhenOnRightPlace() {
$reflection = new ReflectionAnnotatedClass('SuccesfullyAnnotatedClass'); $reflection = new ReflectionAnnotatedClass('SuccesfullyAnnotatedClass');
$method = $reflection->getMethod('method'); $method = $reflection->getMethod('method');
$property = $reflection->getProperty('property'); $property = $reflection->getProperty('property');
$this->assertNoErrors(); $this->assertNoErrors();
} }
public function testMultiTargetAnnotationThrowsErrorWhenOnWrongPlace() { public function testMultiTargetAnnotationThrowsErrorWhenOnWrongPlace() {
$this->expectError("Annotation 'ClassOrPropertyRestrictedAnnotation' not allowed on BadlyAnnotatedClass::method2"); $this->expectError("Annotation 'ClassOrPropertyRestrictedAnnotation' not allowed on BadlyAnnotatedClass::method2");
$reflection = new ReflectionAnnotatedClass('BadlyAnnotatedClass'); $reflection = new ReflectionAnnotatedClass('BadlyAnnotatedClass');
$method = $reflection->getMethod('method2'); $method = $reflection->getMethod('method2');
} }
public function testMultiTargetAnnotationThrowsNoErrorWhenOnRightPlace() { public function testMultiTargetAnnotationThrowsNoErrorWhenOnRightPlace() {
$reflection = new ReflectionAnnotatedClass('SuccesfullyAnnotatedClass'); $reflection = new ReflectionAnnotatedClass('SuccesfullyAnnotatedClass');
$method = $reflection->getProperty('property2'); $method = $reflection->getProperty('property2');
$this->assertNoErrors(); $this->assertNoErrors();
} }
} }
?> ?>

174
lib/vendor/addendum/annotations/tests/doc_comment_test.php vendored
View file

@ -1,87 +1,87 @@
<?php <?php
require_once('simpletest/autorun.php'); require_once('simpletest/autorun.php');
require_once('simpletest/mock_objects.php'); require_once('simpletest/mock_objects.php');
require_once(dirname(__FILE__).'/../doc_comment.php'); require_once(dirname(__FILE__).'/../doc_comment.php');
Mock::generatePartial('DocComment', 'MockDocComment', array('parse')); Mock::generatePartial('DocComment', 'MockDocComment', array('parse'));
/** class doccomment */ /** class doccomment */
class SomeClass { class SomeClass {
/** field doccomment */ /** field doccomment */
private $field1; private $field1;
private $field2; private $field2;
/** method1 doccomment */ /** method1 doccomment */
public function method1() { public function method1() {
} }
public function method2() {} public function method2() {}
/** bad one */ /** bad one */
} }
class SomeOtherClass { class SomeOtherClass {
/** field doccomment */ /** field doccomment */
private $field1; private $field1;
} }
class TestOfDocComment extends UnitTestCase { class TestOfDocComment extends UnitTestCase {
public function setUp() { public function setUp() {
DocComment::clearCache(); DocComment::clearCache();
} }
public function testFinderFindsClassDocBlock() { public function testFinderFindsClassDocBlock() {
$reflection = new ReflectionClass('SomeClass'); $reflection = new ReflectionClass('SomeClass');
$finder = new DocComment(); $finder = new DocComment();
$this->assertEqual($finder->get($reflection), '/** class doccomment */'); $this->assertEqual($finder->get($reflection), '/** class doccomment */');
} }
public function testFinderFindsFieldDocBlock() { public function testFinderFindsFieldDocBlock() {
$reflection = new ReflectionClass('SomeClass'); $reflection = new ReflectionClass('SomeClass');
$property = $reflection->getProperty('field1'); $property = $reflection->getProperty('field1');
$finder = new DocComment(); $finder = new DocComment();
$this->assertEqual($finder->get($property), '/** field doccomment */'); $this->assertEqual($finder->get($property), '/** field doccomment */');
$property = $reflection->getProperty('field2'); $property = $reflection->getProperty('field2');
$finder = new DocComment(); $finder = new DocComment();
$this->assertFalse($finder->get($property)); $this->assertFalse($finder->get($property));
} }
public function testFinderFindsMethodDocBlock() { public function testFinderFindsMethodDocBlock() {
$reflection = new ReflectionClass('SomeClass'); $reflection = new ReflectionClass('SomeClass');
$method = $reflection->getMethod('method1'); $method = $reflection->getMethod('method1');
$finder = new DocComment(); $finder = new DocComment();
$this->assertEqual($finder->get($method), '/** method1 doccomment */'); $this->assertEqual($finder->get($method), '/** method1 doccomment */');
$method = $reflection->getMethod('method2'); $method = $reflection->getMethod('method2');
$finder = new DocComment(); $finder = new DocComment();
$this->assertFalse($finder->get($method)); $this->assertFalse($finder->get($method));
} }
public function testMisplacedDocCommentDoesNotCausesDisaster() { public function testMisplacedDocCommentDoesNotCausesDisaster() {
$reflection = new ReflectionClass('SomeOtherClass'); $reflection = new ReflectionClass('SomeOtherClass');
$finder = new DocComment(); $finder = new DocComment();
$this->assertEqual($finder->get($reflection), false); $this->assertEqual($finder->get($reflection), false);
} }
public function testUnanotatedClassCanHaveAnotatedField() { public function testUnanotatedClassCanHaveAnotatedField() {
$reflection = new ReflectionClass('SomeOtherClass'); $reflection = new ReflectionClass('SomeOtherClass');
$property = $reflection->getProperty('field1'); $property = $reflection->getProperty('field1');
$finder = new DocComment(); $finder = new DocComment();
$this->assertEqual($finder->get($property), '/** field doccomment */'); $this->assertEqual($finder->get($property), '/** field doccomment */');
} }
public function testParserIsOnlyCalledOncePerFile() { public function testParserIsOnlyCalledOncePerFile() {
$reflection = new ReflectionClass('SomeClass'); $reflection = new ReflectionClass('SomeClass');
$finder = new MockDocComment(); $finder = new MockDocComment();
$finder->expectOnce('parse'); $finder->expectOnce('parse');
$this->assertEqual($finder->get($reflection), false); $this->assertEqual($finder->get($reflection), false);
$this->assertEqual($finder->get($reflection), false); $this->assertEqual($finder->get($reflection), false);
$reflection = new ReflectionClass('SomeClass'); $reflection = new ReflectionClass('SomeClass');
$finder = new MockDocComment(); $finder = new MockDocComment();
$finder->expectNever('parse'); $finder->expectNever('parse');
$this->assertEqual($finder->get($reflection), false); $this->assertEqual($finder->get($reflection), false);
} }
} }
?> ?>

260
tests/Doctrine/Tests/ORM/Query/IdentifierRecognitionTest.php
View file

@ -1,130 +1,130 @@
<?php <?php
/* /*
* $Id$ * $Id$
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* *
* This software consists of voluntary contributions made by many individuals * This software consists of voluntary contributions made by many individuals
* and is licensed under the LGPL. For more information, see * and is licensed under the LGPL. For more information, see
* <http://www.doctrine-project.org>. * <http://www.doctrine-project.org>.
*/ */
namespace Doctrine\Tests\ORM\Query; namespace Doctrine\Tests\ORM\Query;
require_once __DIR__ . '/../../TestInit.php'; require_once __DIR__ . '/../../TestInit.php';
/** /**
* Test case for testing the saving and referencing of query identifiers. * Test case for testing the saving and referencing of query identifiers.
* *
* @author Guilherme Blanco <guilhermeblanco@hotmail.com> * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
* @author Janne Vanhala <jpvanhal@cc.hut.fi> * @author Janne Vanhala <jpvanhal@cc.hut.fi>
* @author Konsta Vesterinen <kvesteri@cc.hut.fi> * @author Konsta Vesterinen <kvesteri@cc.hut.fi>
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL * @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link http://www.phpdoctrine.org * @link http://www.phpdoctrine.org
* @since 2.0 * @since 2.0
* @version $Revision$ * @version $Revision$
*/ */
class IdentifierRecognitionTest extends \Doctrine\Tests\OrmTestCase class IdentifierRecognitionTest extends \Doctrine\Tests\OrmTestCase
{ {
private $_em; private $_em;
protected function setUp() { protected function setUp() {
parent::setUp(); parent::setUp();
$this->_em = $this->_getTestEntityManager(); $this->_em = $this->_getTestEntityManager();
} }
public function testSingleAliasDeclarationIsSupported() public function testSingleAliasDeclarationIsSupported()
{ {
$entityManager = $this->_em; $entityManager = $this->_em;
$query = $entityManager->createQuery('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u'); $query = $entityManager->createQuery('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u');
$parserResult = $query->parse(); $parserResult = $query->parse();
$decl = $parserResult->getQueryComponent('u'); $decl = $parserResult->getQueryComponent('u');
$this->assertTrue($decl['metadata'] instanceof \Doctrine\ORM\Mapping\ClassMetadata); $this->assertTrue($decl['metadata'] instanceof \Doctrine\ORM\Mapping\ClassMetadata);
$this->assertEquals(null, $decl['relation']); $this->assertEquals(null, $decl['relation']);
$this->assertEquals(null, $decl['parent']); $this->assertEquals(null, $decl['parent']);
$this->assertEquals(null, $decl['scalar']); $this->assertEquals(null, $decl['scalar']);
$this->assertEquals(null, $decl['map']); $this->assertEquals(null, $decl['map']);
} }
public function testSingleAliasDeclarationWithIndexByIsSupported() public function testSingleAliasDeclarationWithIndexByIsSupported()
{ {
$entityManager = $this->_em; $entityManager = $this->_em;
$query = $entityManager->createQuery('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u INDEX BY u.id'); $query = $entityManager->createQuery('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u INDEX BY u.id');
$parserResult = $query->parse(); $parserResult = $query->parse();
$decl = $parserResult->getQueryComponent('u'); $decl = $parserResult->getQueryComponent('u');
$this->assertTrue($decl['metadata'] instanceof \Doctrine\ORM\Mapping\ClassMetadata); $this->assertTrue($decl['metadata'] instanceof \Doctrine\ORM\Mapping\ClassMetadata);
$this->assertEquals(null, $decl['relation']); $this->assertEquals(null, $decl['relation']);
$this->assertEquals(null, $decl['parent']); $this->assertEquals(null, $decl['parent']);
$this->assertEquals(null, $decl['scalar']); $this->assertEquals(null, $decl['scalar']);
$this->assertEquals('id', $decl['map']); $this->assertEquals('id', $decl['map']);
} }
public function testQueryParserSupportsMultipleAliasDeclarations() public function testQueryParserSupportsMultipleAliasDeclarations()
{ {
$entityManager = $this->_em; $entityManager = $this->_em;
$query = $entityManager->createQuery('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u INDEX BY u.id LEFT JOIN u.phonenumbers p'); $query = $entityManager->createQuery('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u INDEX BY u.id LEFT JOIN u.phonenumbers p');
$parserResult = $query->parse(); $parserResult = $query->parse();
$decl = $parserResult->getQueryComponent('u'); $decl = $parserResult->getQueryComponent('u');
$this->assertTrue($decl['metadata'] instanceof \Doctrine\ORM\Mapping\ClassMetadata); $this->assertTrue($decl['metadata'] instanceof \Doctrine\ORM\Mapping\ClassMetadata);
$this->assertEquals(null, $decl['relation']); $this->assertEquals(null, $decl['relation']);
$this->assertEquals(null, $decl['parent']); $this->assertEquals(null, $decl['parent']);
$this->assertEquals(null, $decl['scalar']); $this->assertEquals(null, $decl['scalar']);
$this->assertEquals('id', $decl['map']); $this->assertEquals('id', $decl['map']);
$decl = $parserResult->getQueryComponent('p'); $decl = $parserResult->getQueryComponent('p');
$this->assertTrue($decl['metadata'] instanceof \Doctrine\ORM\Mapping\ClassMetadata); $this->assertTrue($decl['metadata'] instanceof \Doctrine\ORM\Mapping\ClassMetadata);
$this->assertTrue($decl['relation'] instanceof \Doctrine\ORM\Mapping\AssociationMapping); $this->assertTrue($decl['relation'] instanceof \Doctrine\ORM\Mapping\AssociationMapping);
$this->assertEquals('u', $decl['parent']); $this->assertEquals('u', $decl['parent']);
$this->assertEquals(null, $decl['scalar']); $this->assertEquals(null, $decl['scalar']);
$this->assertEquals(null, $decl['map']); $this->assertEquals(null, $decl['map']);
} }
public function testQueryParserSupportsMultipleAliasDeclarationsWithIndexBy() public function testQueryParserSupportsMultipleAliasDeclarationsWithIndexBy()
{ {
$entityManager = $this->_em; $entityManager = $this->_em;
$query = $entityManager->createQuery('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u INDEX BY u.id LEFT JOIN u.articles a INNER JOIN u.phonenumbers pn INDEX BY pn.phonenumber'); $query = $entityManager->createQuery('SELECT u FROM Doctrine\Tests\Models\CMS\CmsUser u INDEX BY u.id LEFT JOIN u.articles a INNER JOIN u.phonenumbers pn INDEX BY pn.phonenumber');
$parserResult = $query->parse(); $parserResult = $query->parse();
$decl = $parserResult->getQueryComponent('u'); $decl = $parserResult->getQueryComponent('u');
$this->assertTrue($decl['metadata'] instanceof \Doctrine\ORM\Mapping\ClassMetadata); $this->assertTrue($decl['metadata'] instanceof \Doctrine\ORM\Mapping\ClassMetadata);
$this->assertEquals(null, $decl['relation']); $this->assertEquals(null, $decl['relation']);
$this->assertEquals(null, $decl['parent']); $this->assertEquals(null, $decl['parent']);
$this->assertEquals(null, $decl['scalar']); $this->assertEquals(null, $decl['scalar']);
$this->assertEquals('id', $decl['map']); $this->assertEquals('id', $decl['map']);
$decl = $parserResult->getQueryComponent('a'); $decl = $parserResult->getQueryComponent('a');
$this->assertTrue($decl['metadata'] instanceof \Doctrine\ORM\Mapping\ClassMetadata); $this->assertTrue($decl['metadata'] instanceof \Doctrine\ORM\Mapping\ClassMetadata);
$this->assertTrue($decl['relation'] instanceof \Doctrine\ORM\Mapping\AssociationMapping); $this->assertTrue($decl['relation'] instanceof \Doctrine\ORM\Mapping\AssociationMapping);
$this->assertEquals('u', $decl['parent']); $this->assertEquals('u', $decl['parent']);
$this->assertEquals(null, $decl['scalar']); $this->assertEquals(null, $decl['scalar']);
$this->assertEquals(null, $decl['map']); $this->assertEquals(null, $decl['map']);
$decl = $parserResult->getQueryComponent('pn'); $decl = $parserResult->getQueryComponent('pn');
$this->assertTrue($decl['metadata'] instanceof \Doctrine\ORM\Mapping\ClassMetadata); $this->assertTrue($decl['metadata'] instanceof \Doctrine\ORM\Mapping\ClassMetadata);
$this->assertTrue($decl['relation'] instanceof \Doctrine\ORM\Mapping\AssociationMapping); $this->assertTrue($decl['relation'] instanceof \Doctrine\ORM\Mapping\AssociationMapping);
$this->assertEquals('u', $decl['parent']); $this->assertEquals('u', $decl['parent']);
$this->assertEquals(null, $decl['scalar']); $this->assertEquals(null, $decl['scalar']);
$this->assertEquals('phonenumber', $decl['map']); $this->assertEquals('phonenumber', $decl['map']);
} }
} }