import re
regex = re.compile(r"\s+\w+\s+implements\s+(.*)\s+\{", flags=re.MULTILINE)
test_str = ("<?php \n"
"namespace Zend\\Db\\Table\\Row;\n"
"/**\n"
" * Zend Framework\n"
" *\n"
" * LICENSE\n"
" *\n"
" * This source file is subject to the new BSD license that is bundled\n"
" * with this package in the file LICENSE.txt.\n"
" * It is also available through the world-wide-web at this URL:\n"
" * http://framework.zend.com/license/new-bsd\n"
" * If you did not receive a copy of the license and are unable to\n"
" * obtain it through the world-wide-web, please send an email\n"
" * to license@zend.com so we can send you a copy immediately.\n"
" *\n"
" * @category Zend\n"
" * @package Zend_Db\n"
" * @subpackage Table\n"
" * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)\n"
" * @license http://framework.zend.com/license/new-bsd New BSD License\n"
" * @version $Id$\n"
" */\n\n"
"/**\n"
" * @see Zend_Db\n"
" */\n"
"require_once 'Zend/Db.php';\n\n"
"/**\n"
" * @category Zend\n"
" * @package Zend_Db\n"
" * @subpackage Table\n"
" * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)\n"
" * @license http://framework.zend.com/license/new-bsd New BSD License\n"
" */\n"
"abstract class RowAbstract implements \\ArrayAccess, IteratorAggregate\n"
"{\n\n"
" /**\n"
" * The data for each column in the row (column_name => value).\n"
" * The keys must match the physical names of columns in the\n"
" * table for which this row is defined.\n"
" *\n"
" * @var array\n"
" */\n"
" protected $_data = array();\n\n"
" /**\n"
" * This is set to a copy of $_data when the data is fetched from\n"
" * a database, specified as a new tuple in the constructor, or\n"
" * when dirty data is posted to the database with save().\n"
" *\n"
" * @var array\n"
" */\n"
" protected $_cleanData = array();\n\n"
" /**\n"
" * Tracks columns where data has been updated. Allows more specific insert and\n"
" * update operations.\n"
" *\n"
" * @var array\n"
" */\n"
" protected $_modifiedFields = array();\n\n"
" /**\n"
" * \\Zend\\Db\\Table\\TableAbstract parent class or instance.\n"
" *\n"
" * @var \\Zend\\Db\\Table\\TableAbstract\n"
" */\n"
" protected $_table = null;\n\n"
" /**\n"
" * Connected is true if we have a reference to a live\n"
" * \\Zend\\Db\\Table\\TableAbstract object.\n"
" * This is false after the Rowset has been deserialized.\n"
" *\n"
" * @var boolean\n"
" */\n"
" protected $_connected = true;\n\n"
" /**\n"
" * A row is marked read only if it contains columns that are not physically represented within\n"
" * the database schema (e.g. evaluated columns/Zend_Db_Expr columns). This can also be passed\n"
" * as a run-time config options as a means of protecting row data.\n"
" *\n"
" * @var boolean\n"
" */\n"
" protected $_readOnly = false;\n\n"
" /**\n"
" * Name of the class of the \\Zend\\Db\\Table\\TableAbstract object.\n"
" *\n"
" * @var string\n"
" */\n"
" protected $_tableClass = null;\n\n"
" /**\n"
" * Primary row key(s).\n"
" *\n"
" * @var array\n"
" */\n"
" protected $_primary;\n\n"
" /**\n"
" * Constructor.\n"
" *\n"
" * Supported params for $config are:-\n"
" * - table = class name or object of type \\Zend\\Db\\Table\\TableAbstract\n"
" * - data = values of columns in this row.\n"
" *\n"
" * @param array $config OPTIONAL Array of user-specified config options.\n"
" * @return void\n"
" * @throws Zend_Db_Table_Row_Exception\n"
" */\n"
" public function __construct(array $config = array())\n"
" {\n"
" if (isset($config['table']) && $config['table'] instanceof \\Zend\\Db\\Table\\TableAbstract) {\n"
" $this->_table = $config['table'];\n"
" $this->_tableClass = get_class($this->_table);\n"
" } elseif ($this->_tableClass !== null) {\n"
" $this->_table = $this->_getTableFromString($this->_tableClass);\n"
" }\n\n"
" if (isset($config['data'])) {\n"
" if (!is_array($config['data'])) {\n"
" require_once 'Zend/Db/Table/Row/Exception.php';\n"
" throw new \\Zend\\Db\\Table\\Row\\RowException('Data must be an array');\n"
" }\n"
" $this->_data = $config['data'];\n"
" }\n"
" if (isset($config['stored']) && $config['stored'] === true) {\n"
" $this->_cleanData = $this->_data;\n"
" }\n\n"
" if (isset($config['readOnly']) && $config['readOnly'] === true) {\n"
" $this->setReadOnly(true);\n"
" }\n\n"
" // Retrieve primary keys from table schema\n"
" if (($table = $this->_getTable())) {\n"
" $info = $table->info();\n"
" $this->_primary = (array) $info['primary'];\n"
" }\n\n"
" $this->init();\n"
" }\n\n"
" /**\n"
" * Transform a column name from the user-specified form\n"
" * to the physical form used in the database.\n"
" * You can override this method in a custom Row class\n"
" * to implement column name mappings, for example inflection.\n"
" *\n"
" * @param string $columnName Column name given.\n"
" * @return string The column name after transformation applied (none by default).\n"
" * @throws Zend_Db_Table_Row_Exception if the $columnName is not a string.\n"
" */\n"
" protected function _transformColumn($columnName)\n"
" {\n"
" if (!is_string($columnName)) {\n"
" require_once 'Zend/Db/Table/Row/Exception.php';\n"
" throw new \\Zend\\Db\\Table\\Row\\RowException('Specified column is not a string');\n"
" }\n"
" // Perform no transformation by default\n"
" return $columnName;\n"
" }\n\n"
" /**\n"
" * Retrieve row field value\n"
" *\n"
" * @param string $columnName The user-specified column name.\n"
" * @return string The corresponding column value.\n"
" * @throws Zend_Db_Table_Row_Exception if the $columnName is not a column in the row.\n"
" */\n"
" public function __get($columnName)\n"
" {\n"
" $columnName = $this->_transformColumn($columnName);\n"
" if (!array_key_exists($columnName, $this->_data)) {\n"
" require_once 'Zend/Db/Table/Row/Exception.php';\n"
" throw new \\Zend\\Db\\Table\\Row\\RowException(\"Specified column \\\"$columnName\\\" is not in the row\");\n"
" }\n"
" return $this->_data[$columnName];\n"
" }\n\n"
" /**\n"
" * Set row field value\n"
" *\n"
" * @param string $columnName The column key.\n"
" * @param mixed $value The value for the property.\n"
" * @return void\n"
" * @throws Zend_Db_Table_Row_Exception\n"
" */\n"
" public function __set($columnName, $value)\n"
" {\n"
" $columnName = $this->_transformColumn($columnName);\n"
" if (!array_key_exists($columnName, $this->_data)) {\n"
" require_once 'Zend/Db/Table/Row/Exception.php';\n"
" throw new \\Zend\\Db\\Table\\Row\\RowException(\"Specified column \\\"$columnName\\\" is not in the row\");\n"
" }\n"
" $this->_data[$columnName] = $value;\n"
" $this->_modifiedFields[$columnName] = true;\n"
" }\n\n"
" /**\n"
" * Unset row field value\n"
" *\n"
" * @param string $columnName The column key.\n"
" * @return Zend_Db_Table_Row_Abstract\n"
" * @throws Zend_Db_Table_Row_Exception\n"
" */\n"
" public function __unset($columnName)\n"
" {\n"
" $columnName = $this->_transformColumn($columnName);\n"
" if (!array_key_exists($columnName, $this->_data)) {\n"
" require_once 'Zend/Db/Table/Row/Exception.php';\n"
" throw new \\Zend\\Db\\Table\\Row\\RowException(\"Specified column \\\"$columnName\\\" is not in the row\");\n"
" }\n"
" if ($this->isConnected() && in_array($columnName, $this->_table->info('primary'))) {\n"
" require_once 'Zend/Db/Table/Row/Exception.php';\n"
" throw new \\Zend\\Db\\Table\\Row\\RowException(\"Specified column \\\"$columnName\\\" is a primary key and should not be unset\");\n"
" }\n"
" unset($this->_data[$columnName]);\n"
" return $this;\n"
" }\n\n"
" /**\n"
" * Test existence of row field\n"
" *\n"
" * @param string $columnName The column key.\n"
" * @return boolean\n"
" */\n"
" public function __isset($columnName)\n"
" {\n"
" $columnName = $this->_transformColumn($columnName);\n"
" return array_key_exists($columnName, $this->_data);\n"
" }\n\n"
" /**\n"
" * Store table, primary key and data in serialized object\n"
" *\n"
" * @return array\n"
" */\n"
" public function __sleep()\n"
" {\n"
" return array('_tableClass', '_primary', '_data', '_cleanData', '_readOnly' ,'_modifiedFields');\n"
" }\n\n"
" /**\n"
" * Setup to do on wakeup.\n"
" * A de-serialized Row should not be assumed to have access to a live\n"
" * database connection, so set _connected = false.\n"
" *\n"
" * @return void\n"
" */\n"
" public function __wakeup()\n"
" {\n"
" $this->_connected = false;\n"
" }\n\n"
" /**\n"
" * Proxy to __isset\n"
" * Required by the ArrayAccess implementation\n"
" *\n"
" * @param string $offset\n"
" * @return boolean\n"
" */\n"
" public function offsetExists($offset)\n"
" {\n"
" return $this->__isset($offset);\n"
" }\n\n"
" /**\n"
" * Proxy to __get\n"
" * Required by the ArrayAccess implementation\n"
" *\n"
" * @param string $offset\n"
" * @return string\n"
" */\n"
" public function offsetGet($offset)\n"
" {\n"
" return $this->__get($offset);\n"
" }\n\n"
" /**\n"
" * Proxy to __set\n"
" * Required by the ArrayAccess implementation\n"
" *\n"
" * @param string $offset\n"
" * @param mixed $value\n"
" */\n"
" public function offsetSet($offset, $value)\n"
" {\n"
" $this->__set($offset, $value);\n"
" }\n\n"
" /**\n"
" * Proxy to __unset\n"
" * Required by the ArrayAccess implementation\n"
" *\n"
" * @param string $offset\n"
" */\n"
" public function offsetUnset($offset)\n"
" {\n"
" return $this->__unset($offset);\n"
" }\n\n"
" /**\n"
" * Initialize object\n"
" *\n"
" * Called from {@link __construct()} as final step of object instantiation.\n"
" *\n"
" * @return void\n"
" */\n"
" public function init()\n"
" {\n"
" }\n\n"
" /**\n"
" * Returns the table object, or null if this is disconnected row\n"
" *\n"
" * @return \\Zend\\Db\\Table\\TableAbstract|null\n"
" */\n"
" public function getTable()\n"
" {\n"
" return $this->_table;\n"
" }\n\n"
" /**\n"
" * Set the table object, to re-establish a live connection\n"
" * to the database for a Row that has been de-serialized.\n"
" *\n"
" * @param \\Zend\\Db\\Table\\TableAbstract $table\n"
" * @return boolean\n"
" * @throws Zend_Db_Table_Row_Exception\n"
" */\n"
" public function setTable(\\Zend\\Db\\Table\\TableAbstract $table = null)\n"
" {\n"
" if ($table == null) {\n"
" $this->_table = null;\n"
" $this->_connected = false;\n"
" return false;\n"
" }\n\n"
" $tableClass = get_class($table);\n"
" if (! $table instanceof $this->_tableClass) {\n"
" require_once 'Zend/Db/Table/Row/Exception.php';\n"
" throw new \\Zend\\Db\\Table\\Row\\RowException(\"The specified Table is of class $tableClass, expecting class to be instance of $this->_tableClass\");\n"
" }\n\n"
" $this->_table = $table;\n"
" $this->_tableClass = $tableClass;\n\n"
" $info = $this->_table->info();\n\n"
" if ($info['cols'] != array_keys($this->_data)) {\n"
" require_once 'Zend/Db/Table/Row/Exception.php';\n"
" throw new \\Zend\\Db\\Table\\Row\\RowException('The specified Table does not have the same columns as the Row');\n"
" }\n\n"
" if (! array_intersect((array) $this->_primary, $info['primary']) == (array) $this->_primary) {\n\n"
" require_once 'Zend/Db/Table/Row/Exception.php';\n"
" throw new \\Zend\\Db\\Table\\Row\\RowException(\"The specified Table '$tableClass' does not have the same primary key as the Row\");\n"
" }\n\n"
" $this->_connected = true;\n"
" return true;\n"
" }\n\n"
" /**\n"
" * Query the class name of the Table object for which this\n"
" * Row was created.\n"
" *\n"
" * @return string\n"
" */\n"
" public function getTableClass()\n"
" {\n"
" return $this->_tableClass;\n"
" }\n\n"
" /**\n"
" * Test the connected status of the row.\n"
" *\n"
" * @return boolean\n"
" */\n"
" public function isConnected()\n"
" {\n"
" return $this->_connected;\n"
" }\n\n"
" /**\n"
" * Test the read-only status of the row.\n"
" *\n"
" * @return boolean\n"
" */\n"
" public function isReadOnly()\n"
" {\n"
" return $this->_readOnly;\n"
" }\n\n"
" /**\n"
" * Set the read-only status of the row.\n"
" *\n"
" * @param boolean $flag\n"
" * @return boolean\n"
" */\n"
" public function setReadOnly($flag)\n"
" {\n"
" $this->_readOnly = (bool) $flag;\n"
" }\n\n"
" /**\n"
" * Returns an instance of the parent table's \\Zend\\Db\\Table\\Select object.\n"
" *\n"
" * @return \\Zend\\Db\\Table\\Select\n"
" */\n"
" public function select()\n"
" {\n"
" return $this->getTable()->select();\n"
" }\n\n"
" /**\n"
" * Saves the properties to the database.\n"
" *\n"
" * This performs an intelligent insert/update, and reloads the\n"
" * properties with fresh data from the table on success.\n"
" *\n"
" * @return mixed The primary key value(s), as an associative array if the\n"
" * key is compound, or a scalar if the key is single-column.\n"
" */\n"
" public function save()\n"
" {\n"
" /**\n"
" * If the _cleanData array is empty,\n"
" * this is an INSERT of a new row.\n"
" * Otherwise it is an UPDATE.\n"
" */\n"
" if (empty($this->_cleanData)) {\n"
" return $this->_doInsert();\n"
" } else {\n"
" return $this->_doUpdate();\n"
" }\n"
" }\n\n"
" /**\n"
" * @return mixed The primary key value(s), as an associative array if the\n"
" * key is compound, or a scalar if the key is single-column.\n"
" */\n"
" protected function _doInsert()\n"
" {\n"
" /**\n"
" * A read-only row cannot be saved.\n"
" */\n"
" if ($this->_readOnly === true) {\n"
" require_once 'Zend/Db/Table/Row/Exception.php';\n"
" throw new \\Zend\\Db\\Table\\Row\\RowException('This row has been marked read-only');\n"
" }\n\n"
" /**\n"
" * Run pre-INSERT logic\n"
" */\n"
" $this->_insert();\n\n"
" /**\n"
" * Execute the INSERT (this may throw an exception)\n"
" */\n"
" $data = array_intersect_key($this->_data, $this->_modifiedFields);\n"
" $primaryKey = $this->_getTable()->insert($data);\n\n"
" /**\n"
" * Normalize the result to an array indexed by primary key column(s).\n"
" * The table insert() method may return a scalar.\n"
" */\n"
" if (is_array($primaryKey)) {\n"
" $newPrimaryKey = $primaryKey;\n"
" } else {\n"
" //ZF-6167 Use tempPrimaryKey temporary to avoid that zend encoding fails.\n"
" $tempPrimaryKey = (array) $this->_primary;\n"
" $newPrimaryKey = array(current($tempPrimaryKey) => $primaryKey);\n"
" }\n\n"
" /**\n"
" * Save the new primary key value in _data. The primary key may have\n"
" * been generated by a sequence or auto-increment mechanism, and this\n"
" * merge should be done before the _postInsert() method is run, so the\n"
" * new values are available for logging, etc.\n"
" */\n"
" $this->_data = array_merge($this->_data, $newPrimaryKey);\n\n"
" /**\n"
" * Run post-INSERT logic\n"
" */\n"
" $this->_postInsert();\n\n"
" /**\n"
" * Update the _cleanData to reflect that the data has been inserted.\n"
" */\n"
" $this->_refresh();\n\n"
" return $primaryKey;\n"
" }\n\n"
" /**\n"
" * @return mixed The primary key value(s), as an associative array if the\n"
" * key is compound, or a scalar if the key is single-column.\n"
" */\n"
" protected function _doUpdate()\n"
" {\n"
" /**\n"
" * A read-only row cannot be saved.\n"
" */\n"
" if ($this->_readOnly === true) {\n"
" require_once 'Zend/Db/Table/Row/Exception.php';\n"
" throw new \\Zend\\Db\\Table\\Row\\RowException('This row has been marked read-only');\n"
" }\n\n"
" /**\n"
" * Get expressions for a WHERE clause\n"
" * based on the primary key value(s).\n"
" */\n"
" $where = $this->_getWhereQuery(false);\n\n"
" /**\n"
" * Run pre-UPDATE logic\n"
" */\n"
" $this->_update();\n\n"
" /**\n"
" * Compare the data to the modified fields array to discover\n"
" * which columns have been changed.\n"
" */\n"
" $diffData = array_intersect_key($this->_data, $this->_modifiedFields);\n\n"
" /**\n"
" * Were any of the changed columns part of the primary key?\n"
" */\n"
" $pkDiffData = array_intersect_key($diffData, array_flip((array)$this->_primary));\n\n"
" /**\n"
" * Execute cascading updates against dependent tables.\n"
" * Do this only if primary key value(s) were changed.\n"
" */\n"
" if (count($pkDiffData) > 0) {\n"
" $depTables = $this->_getTable()->getDependentTables();\n"
" if (!empty($depTables)) {\n"
" $pkNew = $this->_getPrimaryKey(true);\n"
" $pkOld = $this->_getPrimaryKey(false);\n"
" foreach ($depTables as $tableClass) {\n"
" $t = $this->_getTableFromString($tableClass);\n"
" $t->_cascadeUpdate($this->getTableClass(), $pkOld, $pkNew);\n"
" }\n"
" }\n"
" }\n\n"
" /**\n"
" * Execute the UPDATE (this may throw an exception)\n"
" * Do this only if data values were changed.\n"
" * Use the $diffData variable, so the UPDATE statement\n"
" * includes SET terms only for data values that changed.\n"
" */\n"
" if (count($diffData) > 0) {\n"
" $this->_getTable()->update($diffData, $where);\n"
" }\n\n"
" /**\n"
" * Run post-UPDATE logic. Do this before the _refresh()\n"
" * so the _postUpdate() function can tell the difference\n"
" * between changed data and clean (pre-changed) data.\n"
" */\n"
" $this->_postUpdate();\n\n"
" /**\n"
" * Refresh the data just in case triggers in the RDBMS changed\n"
" * any columns. Also this resets the _cleanData.\n"
" */\n"
" $this->_refresh();\n\n"
" /**\n"
" * Return the primary key value(s) as an array\n"
" * if the key is compound or a scalar if the key\n"
" * is a scalar.\n"
" */\n"
" $primaryKey = $this->_getPrimaryKey(true);\n"
" if (count($primaryKey) == 1) {\n"
" return current($primaryKey);\n"
" }\n\n"
" return $primaryKey;\n"
" }\n\n"
" /**\n"
" * Deletes existing rows.\n"
" *\n"
" * @return int The number of rows deleted.\n"
" */\n"
" public function delete()\n"
" {\n"
" /**\n"
" * A read-only row cannot be deleted.\n"
" */\n"
" if ($this->_readOnly === true) {\n"
" require_once 'Zend/Db/Table/Row/Exception.php';\n"
" throw new \\Zend\\Db\\Table\\Row\\RowException('This row has been marked read-only');\n"
" }\n\n"
" $where = $this->_getWhereQuery();\n\n"
" /**\n"
" * Execute pre-DELETE logic\n"
" */\n"
" $this->_delete();\n\n"
" /**\n"
" * Execute cascading deletes against dependent tables\n"
" */\n"
" $depTables = $this->_getTable()->getDependentTables();\n"
" if (!empty($depTables)) {\n"
" $pk = $this->_getPrimaryKey();\n"
" foreach ($depTables as $tableClass) {\n"
" $t = $this->_getTableFromString($tableClass);\n"
" $t->_cascadeDelete($this->getTableClass(), $pk);\n"
" }\n"
" }\n\n"
" /**\n"
" * Execute the DELETE (this may throw an exception)\n"
" */\n"
" $result = $this->_getTable()->delete($where);\n\n"
" /**\n"
" * Execute post-DELETE logic\n"
" */\n"
" $this->_postDelete();\n\n"
" /**\n"
" * Reset all fields to null to indicate that the row is not there\n"
" */\n"
" $this->_data = array_combine(\n"
" array_keys($this->_data),\n"
" array_fill(0, count($this->_data), null)\n"
" );\n\n"
" return $result;\n"
" }\n\n"
" public function getIterator()\n"
" {\n"
" return new \\ArrayIterator((array) $this->_data);\n"
" }\n\n"
" /**\n"
" * Returns the column/value data as an array.\n"
" *\n"
" * @return array\n"
" */\n"
" public function toArray()\n"
" {\n"
" return (array)$this->_data;\n"
" }\n\n"
" /**\n"
" * Sets all data in the row from an array.\n"
" *\n"
" * @param array $data\n"
" * @return Zend_Db_Table_Row_Abstract Provides a fluent interface\n"
" */\n"
" public function setFromArray(array $data)\n"
" {\n"
" $data = array_intersect_key($data, $this->_data);\n\n"
" foreach ($data as $columnName => $value) {\n"
" $this->__set($columnName, $value);\n"
" }\n\n"
" return $this;\n"
" }\n\n"
" /**\n"
" * Refreshes properties from the database.\n"
" *\n"
" * @return void\n"
" */\n"
" public function refresh()\n"
" {\n"
" return $this->_refresh();\n"
" }\n\n"
" /**\n"
" * Retrieves an instance of the parent table.\n"
" *\n"
" * @return \\Zend\\Db\\Table\\TableAbstract\n"
" */\n"
" protected function _getTable()\n"
" {\n"
" if (!$this->_connected) {\n"
" require_once 'Zend/Db/Table/Row/Exception.php';\n"
" throw new \\Zend\\Db\\Table\\Row\\RowException('Cannot save a Row unless it is connected');\n"
" }\n"
" return $this->_table;\n"
" }\n\n"
" /**\n"
" * Retrieves an associative array of primary keys.\n"
" *\n"
" * @param bool $useDirty\n"
" * @return array\n"
" */\n"
" protected function _getPrimaryKey($useDirty = true)\n"
" {\n"
" if (!is_array($this->_primary)) {\n"
" require_once 'Zend/Db/Table/Row/Exception.php';\n"
" throw new \\Zend\\Db\\Table\\Row\\RowException(\"The primary key must be set as an array\");\n"
" }\n\n"
" $primary = array_flip($this->_primary);\n"
" if ($useDirty) {\n"
" $array = array_intersect_key($this->_data, $primary);\n"
" } else {\n"
" $array = array_intersect_key($this->_cleanData, $primary);\n"
" }\n"
" if (count($primary) != count($array)) {\n"
" require_once 'Zend/Db/Table/Row/Exception.php';\n"
" throw new \\Zend\\Db\\Table\\Row\\RowException(\"The specified Table '$this->_tableClass' does not have the same primary key as the Row\");\n"
" }\n"
" return $array;\n"
" }\n\n"
" /**\n"
" * Retrieves an associative array of primary keys.\n"
" *\n"
" * @param bool $useDirty\n"
" * @return array\n"
" */\n"
" public function getPrimaryKey($useDirty = true)\n"
" {\n"
" return $this->_getPrimaryKey($useDirty);\n"
" }\n\n"
" /**\n"
" * Constructs where statement for retrieving row(s).\n"
" *\n"
" * @param bool $useDirty\n"
" * @return array\n"
" */\n"
" protected function _getWhereQuery($useDirty = true)\n"
" {\n"
" $where = array();\n"
" $db = $this->_getTable()->getAdapter();\n"
" $primaryKey = $this->_getPrimaryKey($useDirty);\n"
" $info = $this->_getTable()->info();\n"
" $metadata = $info[\\Zend\\Db\\Table\\TableAbstract::METADATA];\n\n"
" // retrieve recently updated row using primary keys\n"
" $where = array();\n"
" foreach ($primaryKey as $column => $value) {\n"
" $tableName = $db->quoteIdentifier($info[\\Zend\\Db\\Table\\TableAbstract::NAME], true);\n"
" $type = $metadata[$column]['DATA_TYPE'];\n"
" $columnName = $db->quoteIdentifier($column, true);\n"
" $where[] = $db->quoteInto(\"{$tableName}.{$columnName} = ?\", $value, $type);\n"
" }\n"
" return $where;\n"
" }\n\n"
" /**\n"
" * Refreshes properties from the database.\n"
" *\n"
" * @return void\n"
" */\n"
" protected function _refresh()\n"
" {\n"
" $where = $this->_getWhereQuery();\n"
" $row = $this->_getTable()->fetchRow($where);\n\n"
" if (null === $row) {\n"
" require_once 'Zend/Db/Table/Row/Exception.php';\n"
" throw new \\Zend\\Db\\Table\\Row\\RowException('Cannot refresh row as parent is missing');\n"
" }\n\n"
" $this->_data = $row->toArray();\n"
" $this->_cleanData = $this->_data;\n"
" $this->_modifiedFields = array();\n"
" }\n\n"
" /**\n"
" * Allows pre-insert logic to be applied to row.\n"
" * Subclasses may override this method.\n"
" *\n"
" * @return void\n"
" */\n"
" protected function _insert()\n"
" {\n"
" }\n\n"
" /**\n"
" * Allows post-insert logic to be applied to row.\n"
" * Subclasses may override this method.\n"
" *\n"
" * @return void\n"
" */\n"
" protected function _postInsert()\n"
" {\n"
" }\n\n"
" /**\n"
" * Allows pre-update logic to be applied to row.\n"
" * Subclasses may override this method.\n"
" *\n"
" * @return void\n"
" */\n"
" protected function _update()\n"
" {\n"
" }\n\n"
" /**\n"
" * Allows post-update logic to be applied to row.\n"
" * Subclasses may override this method.\n"
" *\n"
" * @return void\n"
" */\n"
" protected function _postUpdate()\n"
" {\n"
" }\n\n"
" /**\n"
" * Allows pre-delete logic to be applied to row.\n"
" * Subclasses may override this method.\n"
" *\n"
" * @return void\n"
" */\n"
" protected function _delete()\n"
" {\n"
" }\n\n"
" /**\n"
" * Allows post-delete logic to be applied to row.\n"
" * Subclasses may override this method.\n"
" *\n"
" * @return void\n"
" */\n"
" protected function _postDelete()\n"
" {\n"
" }\n\n"
" /**\n"
" * Prepares a table reference for lookup.\n"
" *\n"
" * Ensures all reference keys are set and properly formatted.\n"
" *\n"
" * @param \\Zend\\Db\\Table\\TableAbstract $dependentTable\n"
" * @param \\Zend\\Db\\Table\\TableAbstract $parentTable\n"
" * @param string $ruleKey\n"
" * @return array\n"
" */\n"
" protected function _prepareReference(\\Zend\\Db\\Table\\TableAbstract $dependentTable, \\Zend\\Db\\Table\\TableAbstract $parentTable, $ruleKey)\n"
" {\n"
" $parentTableName = (get_class($parentTable) === 'Zend_Db_Table') ? $parentTable->getDefinitionConfigName() : get_class($parentTable);\n"
" $map = $dependentTable->getReference($parentTableName, $ruleKey);\n\n"
" if (!isset($map[\\Zend\\Db\\Table\\TableAbstract::REF_COLUMNS])) {\n"
" $parentInfo = $parentTable->info();\n"
" $map[\\Zend\\Db\\Table\\TableAbstract::REF_COLUMNS] = array_values((array) $parentInfo['primary']);\n"
" }\n\n"
" $map[\\Zend\\Db\\Table\\TableAbstract::COLUMNS] = (array) $map[\\Zend\\Db\\Table\\TableAbstract::COLUMNS];\n"
" $map[\\Zend\\Db\\Table\\TableAbstract::REF_COLUMNS] = (array) $map[\\Zend\\Db\\Table\\TableAbstract::REF_COLUMNS];\n\n"
" return $map;\n"
" }\n\n"
" /**\n"
" * Query a dependent table to retrieve rows matching the current row.\n"
" *\n"
" * @param string|\\Zend\\Db\\Table\\TableAbstract $dependentTable\n"
" * @param string OPTIONAL $ruleKey\n"
" * @param \\Zend\\Db\\Table\\Select OPTIONAL $select\n"
" * @return Zend_Db_Table_Rowset_Abstract Query result from $dependentTable\n"
" * @throws Zend_Db_Table_Row_Exception If $dependentTable is not a table or is not loadable.\n"
" */\n"
" public function findDependentRowset($dependentTable, $ruleKey = null, \\Zend\\Db\\Table\\Select $select = null)\n"
" {\n"
" $db = $this->_getTable()->getAdapter();\n\n"
" if (is_string($dependentTable)) {\n"
" $dependentTable = $this->_getTableFromString($dependentTable);\n"
" }\n\n"
" if (!$dependentTable instanceof \\Zend\\Db\\Table\\TableAbstract) {\n"
" $type = gettype($dependentTable);\n"
" if ($type == 'object') {\n"
" $type = get_class($dependentTable);\n"
" }\n"
" require_once 'Zend/Db/Table/Row/Exception.php';\n"
" throw new \\Zend\\Db\\Table\\Row\\RowException(\"Dependent table must be a \\Zend\\Db\\Table\\TableAbstract, but it is $type\");\n"
" }\n\n"
" // even if we are interacting between a table defined in a class and a\n"
" // table via extension, ensure to persist the definition\n"
" if (($tableDefinition = $this->_table->getDefinition()) !== null\n"
" && ($dependentTable->getDefinition() == null)) {\n"
" $dependentTable->setOptions(array(\\Zend\\Db\\Table\\TableAbstract::DEFINITION => $tableDefinition));\n"
" }\n\n"
" if ($select === null) {\n"
" $select = $dependentTable->select();\n"
" } else {\n"
" $select->setTable($dependentTable);\n"
" }\n\n"
" $map = $this->_prepareReference($dependentTable, $this->_getTable(), $ruleKey);\n\n"
" for ($i = 0; $i < count($map[\\Zend\\Db\\Table\\TableAbstract::COLUMNS]); ++$i) {\n"
" $parentColumnName = $db->foldCase($map[\\Zend\\Db\\Table\\TableAbstract::REF_COLUMNS][$i]);\n"
" $value = $this->_data[$parentColumnName];\n"
" // Use adapter from dependent table to ensure correct query construction\n"
" $dependentDb = $dependentTable->getAdapter();\n"
" $dependentColumnName = $dependentDb->foldCase($map[\\Zend\\Db\\Table\\TableAbstract::COLUMNS][$i]);\n"
" $dependentColumn = $dependentDb->quoteIdentifier($dependentColumnName, true);\n"
" $dependentInfo = $dependentTable->info();\n"
" $type = $dependentInfo[\\Zend\\Db\\Table\\TableAbstract::METADATA][$dependentColumnName]['DATA_TYPE'];\n"
" $select->where(\"$dependentColumn = ?\", $value, $type);\n"
" }\n\n"
" return $dependentTable->fetchAll($select);\n"
" }\n\n"
" /**\n"
" * Query a parent table to retrieve the single row matching the current row.\n"
" *\n"
" * @param string|\\Zend\\Db\\Table\\TableAbstract $parentTable\n"
" * @param string OPTIONAL $ruleKey\n"
" * @param \\Zend\\Db\\Table\\Select OPTIONAL $select\n"
" * @return Zend_Db_Table_Row_Abstract Query result from $parentTable\n"
" * @throws Zend_Db_Table_Row_Exception If $parentTable is not a table or is not loadable.\n"
" */\n"
" public function findParentRow($parentTable, $ruleKey = null, \\Zend\\Db\\Table\\Select $select = null)\n"
" {\n"
" $db = $this->_getTable()->getAdapter();\n\n"
" if (is_string($parentTable)) {\n"
" $parentTable = $this->_getTableFromString($parentTable);\n"
" }\n\n"
" if (!$parentTable instanceof \\Zend\\Db\\Table\\TableAbstract) {\n"
" $type = gettype($parentTable);\n"
" if ($type == 'object') {\n"
" $type = get_class($parentTable);\n"
" }\n"
" require_once 'Zend/Db/Table/Row/Exception.php';\n"
" throw new \\Zend\\Db\\Table\\Row\\RowException(\"Parent table must be a \\Zend\\Db\\Table\\TableAbstract, but it is $type\");\n"
" }\n\n"
" // even if we are interacting between a table defined in a class and a\n"
" // table via extension, ensure to persist the definition\n"
" if (($tableDefinition = $this->_table->getDefinition()) !== null\n"
" && ($parentTable->getDefinition() == null)) {\n"
" $parentTable->setOptions(array(\\Zend\\Db\\Table\\TableAbstract::DEFINITION => $tableDefinition));\n"
" }\n\n"
" if ($select === null) {\n"
" $select = $parentTable->select();\n"
" } else {\n"
" $select->setTable($parentTable);\n"
" }\n\n"
" $map = $this->_prepareReference($this->_getTable(), $parentTable, $ruleKey);\n\n"
" // iterate the map, creating the proper wheres\n"
" for ($i = 0; $i < count($map[\\Zend\\Db\\Table\\TableAbstract::COLUMNS]); ++$i) {\n"
" $dependentColumnName = $db->foldCase($map[\\Zend\\Db\\Table\\TableAbstract::COLUMNS][$i]);\n"
" $value = $this->_data[$dependentColumnName];\n"
" // Use adapter from parent table to ensure correct query construction\n"
" $parentDb = $parentTable->getAdapter();\n"
" $parentColumnName = $parentDb->foldCase($map[\\Zend\\Db\\Table\\TableAbstract::REF_COLUMNS][$i]);\n"
" $parentColumn = $parentDb->quoteIdentifier($parentColumnName, true);\n"
" $parentInfo = $parentTable->info();\n\n"
" // determine where part\n"
" $type = $parentInfo[\\Zend\\Db\\Table\\TableAbstract::METADATA][$parentColumnName]['DATA_TYPE'];\n"
" $nullable = $parentInfo[\\Zend\\Db\\Table\\TableAbstract::METADATA][$parentColumnName]['NULLABLE'];\n"
" if ($value === null && $nullable == true) {\n"
" $select->where(\"$parentColumn IS NULL\");\n"
" } elseif ($value === null && $nullable == false) {\n"
" return null;\n"
" } else {\n"
" $select->where(\"$parentColumn = ?\", $value, $type);\n"
" }\n\n"
" }\n\n"
" return $parentTable->fetchRow($select);\n"
" }\n\n"
" /**\n"
" * @param string|\\Zend\\Db\\Table\\TableAbstract $matchTable\n"
" * @param string|\\Zend\\Db\\Table\\TableAbstract $intersectionTable\n"
" * @param string OPTIONAL $callerRefRule\n"
" * @param string OPTIONAL $matchRefRule\n"
" * @param \\Zend\\Db\\Table\\Select OPTIONAL $select\n"
" * @return Zend_Db_Table_Rowset_Abstract Query result from $matchTable\n"
" * @throws Zend_Db_Table_Row_Exception If $matchTable or $intersectionTable is not a table class or is not loadable.\n"
" */\n"
" public function findManyToManyRowset($matchTable, $intersectionTable, $callerRefRule = null,\n"
" $matchRefRule = null, \\Zend\\Db\\Table\\Select $select = null)\n"
" {\n"
" $db = $this->_getTable()->getAdapter();\n\n"
" if (is_string($intersectionTable)) {\n"
" $intersectionTable = $this->_getTableFromString($intersectionTable);\n"
" }\n\n"
" if (!$intersectionTable instanceof \\Zend\\Db\\Table\\TableAbstract) {\n"
" $type = gettype($intersectionTable);\n"
" if ($type == 'object') {\n"
" $type = get_class($intersectionTable);\n"
" }\n"
" require_once 'Zend/Db/Table/Row/Exception.php';\n"
" throw new \\Zend\\Db\\Table\\Row\\RowException(\"Intersection table must be a \\Zend\\Db\\Table\\TableAbstract, but it is $type\");\n"
" }\n\n"
" // even if we are interacting between a table defined in a class and a\n"
" // table via extension, ensure to persist the definition\n"
" if (($tableDefinition = $this->_table->getDefinition()) !== null\n"
" && ($intersectionTable->getDefinition() == null)) {\n"
" $intersectionTable->setOptions(array(\\Zend\\Db\\Table\\TableAbstract::DEFINITION => $tableDefinition));\n"
" }\n\n"
" if (is_string($matchTable)) {\n"
" $matchTable = $this->_getTableFromString($matchTable);\n"
" }\n\n"
" if (! $matchTable instanceof \\Zend\\Db\\Table\\TableAbstract) {\n"
" $type = gettype($matchTable);\n"
" if ($type == 'object') {\n"
" $type = get_class($matchTable);\n"
" }\n"
" require_once 'Zend/Db/Table/Row/Exception.php';\n"
" throw new \\Zend\\Db\\Table\\Row\\RowException(\"Match table must be a \\Zend\\Db\\Table\\TableAbstract, but it is $type\");\n"
" }\n\n"
" // even if we are interacting between a table defined in a class and a\n"
" // table via extension, ensure to persist the definition\n"
" if (($tableDefinition = $this->_table->getDefinition()) !== null\n"
" && ($matchTable->getDefinition() == null)) {\n"
" $matchTable->setOptions(array(\\Zend\\Db\\Table\\TableAbstract::DEFINITION => $tableDefinition));\n"
" }\n\n"
" if ($select === null) {\n"
" $select = $matchTable->select();\n"
" } else {\n"
" $select->setTable($matchTable);\n"
" }\n\n"
" // Use adapter from intersection table to ensure correct query construction\n"
" $interInfo = $intersectionTable->info();\n"
" $interDb = $intersectionTable->getAdapter();\n"
" $interName = $interInfo['name'];\n"
" $interSchema = isset($interInfo['schema']) ? $interInfo['schema'] : null;\n"
" $matchInfo = $matchTable->info();\n"
" $matchName = $matchInfo['name'];\n"
" $matchSchema = isset($matchInfo['schema']) ? $matchInfo['schema'] : null;\n\n"
" $matchMap = $this->_prepareReference($intersectionTable, $matchTable, $matchRefRule);\n\n"
" for ($i = 0; $i < count($matchMap[\\Zend\\Db\\Table\\TableAbstract::COLUMNS]); ++$i) {\n"
" $interCol = $interDb->quoteIdentifier('i' . '.' . $matchMap[\\Zend\\Db\\Table\\TableAbstract::COLUMNS][$i], true);\n"
" $matchCol = $interDb->quoteIdentifier('m' . '.' . $matchMap[\\Zend\\Db\\Table\\TableAbstract::REF_COLUMNS][$i], true);\n"
" $joinCond[] = \"$interCol = $matchCol\";\n"
" }\n"
" $joinCond = implode(' AND ', $joinCond);\n\n"
" $select->from(array('i' => $interName), array(), $interSchema)\n"
" ->joinInner(array('m' => $matchName), $joinCond, \\Zend\\Db\\Select::SQL_WILDCARD, $matchSchema)\n"
" ->setIntegrityCheck(false);\n\n"
" $callerMap = $this->_prepareReference($intersectionTable, $this->_getTable(), $callerRefRule);\n\n"
" for ($i = 0; $i < count($callerMap[\\Zend\\Db\\Table\\TableAbstract::COLUMNS]); ++$i) {\n"
" $callerColumnName = $db->foldCase($callerMap[\\Zend\\Db\\Table\\TableAbstract::REF_COLUMNS][$i]);\n"
" $value = $this->_data[$callerColumnName];\n"
" $interColumnName = $interDb->foldCase($callerMap[\\Zend\\Db\\Table\\TableAbstract::COLUMNS][$i]);\n"
" $interCol = $interDb->quoteIdentifier(\"i.$interColumnName\", true);\n"
" $interInfo = $intersectionTable->info();\n"
" $type = $interInfo[\\Zend\\Db\\Table\\TableAbstract::METADATA][$interColumnName]['DATA_TYPE'];\n"
" $select->where($interDb->quoteInto(\"$interCol = ?\", $value, $type));\n"
" }\n\n"
" $stmt = $select->query();\n\n"
" $config = array(\n"
" 'table' => $matchTable,\n"
" 'data' => $stmt->fetchAll(Zend_Db::FETCH_ASSOC),\n"
" 'rowClass' => $matchTable->getRowClass(),\n"
" 'readOnly' => false,\n"
" 'stored' => true\n"
" );\n\n"
" $rowsetClass = $matchTable->getRowsetClass();\n"
" if (!class_exists($rowsetClass)) {\n"
" try {\n"
" require_once 'Zend/Loader.php';\n"
" Zend_Loader::loadClass($rowsetClass);\n"
" } catch (Zend_Exception $e) {\n"
" require_once 'Zend/Db/Table/Row/Exception.php';\n"
" throw new \\Zend\\Db\\Table\\Row\\RowException($e->getMessage(), $e->getCode(), $e);\n"
" }\n"
" }\n"
" $rowset = new $rowsetClass($config);\n"
" return $rowset;\n"
" }\n\n"
" /**\n"
" * Turn magic function calls into non-magic function calls\n"
" * to the above methods.\n"
" *\n"
" * @param string $method\n"
" * @param array $args OPTIONAL \\Zend\\Db\\Table\\Select query modifier\n"
" * @return Zend_Db_Table_Row_Abstract|Zend_Db_Table_Rowset_Abstract\n"
" * @throws Zend_Db_Table_Row_Exception If an invalid method is called.\n"
" */\n"
" public function __call($method, array $args)\n"
" {\n"
" $matches = array();\n\n"
" if (count($args) && $args[0] instanceof \\Zend\\Db\\Table\\Select) {\n"
" $select = $args[0];\n"
" } else {\n"
" $select = null;\n"
" }\n\n"
" /**\n"
" * Recognize methods for Has-Many cases:\n"
" * findParent<Class>()\n"
" * findParent<Class>By<Rule>()\n"
" * Use the non-greedy pattern repeat modifier e.g. \\w+?\n"
" */\n"
" if (preg_match('/^findParent(\\w+?)(?:By(\\w+))?$/', $method, $matches)) {\n"
" $class = $matches[1];\n"
" $ruleKey1 = isset($matches[2]) ? $matches[2] : null;\n"
" return $this->findParentRow($class, $ruleKey1, $select);\n"
" }\n\n"
" /**\n"
" * Recognize methods for Many-to-Many cases:\n"
" * find<Class1>Via<Class2>()\n"
" * find<Class1>Via<Class2>By<Rule>()\n"
" * find<Class1>Via<Class2>By<Rule1>And<Rule2>()\n"
" * Use the non-greedy pattern repeat modifier e.g. \\w+?\n"
" */\n"
" if (preg_match('/^find(\\w+?)Via(\\w+?)(?:By(\\w+?)(?:And(\\w+))?)?$/', $method, $matches)) {\n"
" $class = $matches[1];\n"
" $viaClass = $matches[2];\n"
" $ruleKey1 = isset($matches[3]) ? $matches[3] : null;\n"
" $ruleKey2 = isset($matches[4]) ? $matches[4] : null;\n"
" return $this->findManyToManyRowset($class, $viaClass, $ruleKey1, $ruleKey2, $select);\n"
" }\n\n"
" /**\n"
" * Recognize methods for Belongs-To cases:\n"
" * find<Class>()\n"
" * find<Class>By<Rule>()\n"
" * Use the non-greedy pattern repeat modifier e.g. \\w+?\n"
" */\n"
" if (preg_match('/^find(\\w+?)(?:By(\\w+))?$/', $method, $matches)) {\n"
" $class = $matches[1];\n"
" $ruleKey1 = isset($matches[2]) ? $matches[2] : null;\n"
" return $this->findDependentRowset($class, $ruleKey1, $select);\n"
" }\n\n"
" require_once 'Zend/Db/Table/Row/Exception.php';\n"
" throw new \\Zend\\Db\\Table\\Row\\RowException(\"Unrecognized method '$method()'\");\n"
" }\n\n\n"
" /**\n"
" * _getTableFromString\n"
" *\n"
" * @param string $tableName\n"
" * @return \\Zend\\Db\\Table\\TableAbstract\n"
" */\n"
" protected function _getTableFromString($tableName)\n"
" {\n"
" return \\Zend\\Db\\Table\\TableAbstract::getTableFromString($tableName, $this->_table);\n"
" }\n\n"
"}\n")
matches = regex.finditer(test_str)
for match_num, match in enumerate(matches, start=1):
print(f"Match {match_num} was found at {match.start()}-{match.end()}: {match.group()}")
for group_num, group in enumerate(match.groups(), start=1):
print(f"Group {group_num} found at {match.start(group_num)}-{match.end(group_num)}: {group}")
Please keep in mind that these code samples are automatically generated and are not guaranteed to work. If you find any syntax errors, feel free to submit a bug report. For a full regex reference for Python, please visit: https://docs.python.org/3/library/re.html