Added a folder remotely

Doctrine/Access.php

+<?php
+/**
+ * Doctrine_Access
+ *
+ * the purpose of Doctrine_Access is to provice array access
+ * and property overload interface for subclasses
+ *
+ * @package     Doctrine ORM
+ * @url         www.phpdoctrine.com
+ * @license     LGPL
+ */
+abstract class Doctrine_Access implements ArrayAccess {
+    /**
+     * setArray
+     * @param array $array          an array of key => value pairs
+     */
+    public function setArray(array $array) {
+        foreach($array as $k=>$v):
+            $this->set($k,$v);
+        endforeach;
+    }
+    /**
+     * __set -- an alias of set()
+     * @see set, offsetSet
+     * @param $name
+     * @param $value
+     */
+    public function __set($name,$value) {
+        $this->set($name,$value);
+    }
+    /**
+     * __get -- an alias of get()
+     * @see get,  offsetGet
+     * @param mixed $name
+     * @return mixed
+     */
+    public function __get($name) {
+        return $this->get($name);
+    }
+    /**
+     * @param mixed $offset
+     * @return boolean -- whether or not the data has a field $offset
+     */
+    public function offsetExists($offset) {
+        return (bool) isset($this->data[$offset]);
+    }
+    /**
+     * offsetGet -- an alias of get()
+     * @see get,  __get
+     * @param mixed $offset
+     * @return mixed
+     */
+    public function offsetGet($offset) {
+        return $this->get($offset);
+    }
+    /**
+     * sets $offset to $value
+     * @see set,  __set
+     * @param mixed $offset
+     * @param mixed $value
+     * @return void
+     */
+    public function offsetSet($offset, $value) {
+        if( ! isset($offset)) {
+            $this->add($value);
+        } else
+            $this->set($offset,$value);
+    }
+    /**
+     * unset a given offset
+     * @see set, offsetSet, __set
+     * @param mixed $offset
+     */
+    public function offsetUnset($offset) {
+        if($this instanceof Doctrine_Collection) {
+            return $this->remove($offset);
+        } else {
+            $this->set($offset,null);
+        }
+    }
+}
+?>

Doctrine/Association.php

+<?php
+require_once("Relation.php");
+/**
+ * Doctrine_Association    this class takes care of association mapping
+ *                         (= many-to-many relationships, where the relationship is handled with an additional relational table
+ *                         which holds 2 foreign keys)
+ *
+ *
+ * @package     Doctrine ORM
+ * @url         www.phpdoctrine.com
+ * @license     LGPL
+ */
+class Doctrine_Association extends Doctrine_Relation {
+    /**
+     * @var Doctrine_Table $associationTable
+     */
+    private $associationTable;
+    /**
+     * the constructor
+     * @param Doctrine_Table $table                 foreign factory object
+     * @param Doctrine_Table $associationTable      factory which handles the association
+     * @param string $local                         local field name
+     * @param string $foreign                       foreign field name
+     * @param integer $type                         type of relation
+     * @see Doctrine_Table constants
+     */
+    public function __construct(Doctrine_Table $table, Doctrine_Table $associationTable, $local, $foreign, $type) {
+        parent::__construct($table, $local, $foreign, $type);
+        $this->associationTable = $associationTable;
+    }
+    /**
+     * @return Doctrine_Table
+     */
+    public function getAssociationFactory() {
+        return $this->associationTable;
+    }
+}
+?>

Doctrine/Cache.php

+<?php
+interface iDoctrine_Cache {
+    public function store(Doctrine_Record $record);
+    public function clean();
+    public function delete($id);
+    public function fetch($id);
+    public function exists($id);
+}
+class Doctrine_Cache implements iDoctrine_Cache {
+    /**
+     * implemented by child classes
+     * @param Doctrine_Record $record
+     * @return boolean
+     */
+    public function store(Doctrine_Record $record) {
+        return false;
+    }
+    /**
+     * implemented by child classes
+     * @return boolean
+     */
+    public function clean() {
+        return false;
+    }
+    /**
+     * implemented by child classes
+     * @return boolean
+     */
+    public function delete($id) {
+        return false;
+    }
+    /**
+     * implemented by child classes
+     * @throws InvalidKeyException
+     * @return Doctrine_Record                      found Data Access Object
+     */
+    public function fetch($id) {
+        throw new InvalidKeyException();
+    }
+    /**
+     * implemented by child classes
+     * @param array $keys
+     * @return boolean
+     */
+    public function fetchMultiple($keys) {
+        return false;                                     	
+    }
+    /**
+     * implemented by child classes
+     * @param integer $id
+     * @return boolean
+     */
+    public function exists($id) {
+        return false;
+    }
+    /**
+     * implemented by child classes
+     */
+    public function deleteMultiple($keys) {
+        return 0;
+    }
+    /**
+     * implemented by child classes
+     * @return integer
+     */
+    public function deleteAll() {
+        return 0;
+    }
+
+}
+?>

Doctrine/Configurable.php

+<?php
+/**
+ * Doctrine_Configurable
+ * the base for Doctrine_Table, Doctrine_Manager and Doctrine_Session
+ *
+ *
+ * @package     Doctrine ORM
+ * @url         www.phpdoctrine.com
+ * @license     LGPL
+ */
+abstract class Doctrine_Configurable {
+
+    /**
+     * @var array $attributes               an array of containing all attributes
+     */
+    private $attributes = array();
+    /**
+     * @var $parent                         the parents of this component
+     */
+    private $parent;
+    /**
+     * sets a given attribute
+     *
+     * @throws Doctrine_Exception           if the value is invalid
+     * @param integer $attribute
+     * @param mixed $value
+     * @return void
+     */
+    final public function setAttribute($attribute,$value) {
+        switch($attribute):
+            case Doctrine::ATTR_BATCH_SIZE:
+                if($value < 0)
+                    throw new Doctrine_Exception("Batch size should be greater than or equal to zero");
+            break;
+            case Doctrine::ATTR_CACHE_DIR:
+                if(substr(trim($value),0,6) == "%ROOT%") {
+                    $dir   = dirname(__FILE__);
+                    $value = $dir.substr($value,6);
+                }
+
+                if(! is_dir($value) && ! file_exists($value))
+                    mkdir($value,0777);
+            break;
+            case Doctrine::ATTR_CACHE_TTL:
+                if($value < 1)
+                    throw new Doctrine_Exception("Cache TimeToLive should be greater than or equal to 1");
+            break;
+            case Doctrine::ATTR_CACHE_SIZE:
+                if($value < 1)
+                    throw new Doctrine_Exception("Cache size should be greater than or equal to 1");
+            break;
+            case Doctrine::ATTR_CACHE_SLAM:
+                if($value < 0 || $value > 1) 
+                    throw new Doctrine_Exception("Cache slam defense should be a floating point number between 0 and 1");
+            break;
+            case Doctrine::ATTR_FETCHMODE:
+                 if($value < 0)
+                    throw new Doctrine_Exception("Unknown fetchmode. See Doctrine::FETCH_* constants.");
+            break;
+            case Doctrine::ATTR_LISTENER:
+                $this->setEventListener($value);
+            break;
+            case Doctrine::ATTR_PK_COLUMNS:
+                if( ! is_array($value)) 
+                    throw new Doctrine_Exception("The value of Doctrine::ATTR_PK_COLUMNS attribute must be an array");
+            break;
+            case Doctrine::ATTR_PK_TYPE:
+                if($value != Doctrine::INCREMENT_KEY && $value != Doctrine::UNIQUE_KEY)
+                    throw new Doctrine_Exception("The value of Doctrine::ATTR_PK_TYPE attribute must be either Doctrine::INCREMENT_KEY or Doctrine::UNIQUE_KEY");
+
+            break;
+            case Doctrine::ATTR_LOCKMODE:
+                if($this instanceof Doctrine_Session) {
+                    if($this->getState() != Doctrine_Session::STATE_OPEN)
+                        throw new Doctrine_Exception("Couldn't set lockmode. There are transactions open.");
+
+                } elseif($this instanceof Doctrine_Manager) {
+                    foreach($this as $session) {
+                        if($session->getState() != Doctrine_Session::STATE_OPEN)
+                            throw new Doctrine_Exception("Couldn't set lockmode. There are transactions open.");
+                    }
+                } else {
+                    throw new Doctrine_Exception("Lockmode attribute can only be set at the global or session level.");
+                }
+            break;
+            case Doctrine::ATTR_CREATE_TABLES:
+                $value = (bool) $value;
+            break;
+            case Doctrine::ATTR_COLL_LIMIT:
+                if($value < 1) {
+                    throw new Doctrine_Exception("Collection limit should be a value greater than or equal to 1.");
+                }
+            break;
+            case Doctrine::ATTR_COLL_KEY:
+                if( ! ($this instanceof Doctrine_Table)) 
+                    throw new Doctrine_Exception("This attribute can only be set at table level.");
+
+                if( ! $this->hasColumn($value)) 
+                    throw new Doctrine_Exception("Couldn't set collection key attribute. No such column '$value'");
+                    
+
+            break;
+            case Doctrine::ATTR_VLD:
+            
+            break;
+            case Doctrine::ATTR_CACHE:
+                if($value != Doctrine::CACHE_SQLITE && $value != Doctrine::CACHE_NONE)
+                    throw new Doctrine_Exception("Unknown cache container. See Doctrine::CACHE_* constants for availible containers.");
+            break;
+            default:
+                throw new Doctrine_Exception("Unknown attribute.");
+        endswitch;
+
+        $this->attributes[$attribute] = $value;
+
+    }
+    /**
+     * @param Doctrine_EventListener $listener
+     * @return void
+     */
+    final public function setEventListener(Doctrine_EventListener $listener) {
+        $i = Doctrine::ATTR_LISTENER;
+        $this->attributes[$i] = $listener;
+    }
+    /**
+     * returns the value of an attribute
+     *
+     * @param integer $attribute
+     * @return mixed
+     */
+    final public function getAttribute($attribute) {
+        $attribute = (int) $attribute;
+
+        if($attribute < 1 || $attribute > 16)
+            throw new InvalidKeyException();
+
+        if( ! isset($this->attributes[$attribute])) {
+            if(isset($this->parent))
+                return $this->parent->getAttribute($attribute);
+
+            return null;
+        }
+        return $this->attributes[$attribute];
+    }
+    /**
+     * getAttributes
+     * returns all attributes as an array
+     *
+     * @return array
+     */
+    final public function getAttributes() {
+        return $this->attributes;
+    }
+    /**
+     * sets a parent for this configurable component
+     * the parent must be configurable component itself
+     *
+     * @param Doctrine_Configurable $component
+     * @return void
+     */
+    final public function setParent(Doctrine_Configurable $component) {
+        $this->parent = $component;
+    }
+    /**
+     * getParent
+     * returns the parent of this component
+     *
+     * @return Doctrine_Configurable
+     */
+    final public function getParent() {
+        return $this->parent;
+    }
+}
+?>

Doctrine/DB.php

+<?php
+class Doctrine_DB extends PDO implements Countable, IteratorAggregate {
+    /**
+     * default DSN
+     */
+    const DSN = "mysql://root:dc34@localhost/test";
+    /**
+     * executed queries
+     */
+    private $queries    = array();
+    /**
+     * execution times of the executed queries
+     */
+    private $exectimes  = array();
+
+    /**
+     * constructor
+     * @param string $dsn
+     * @param string $username
+     * @param string $password
+     */
+    public function __construct($dsn,$username,$password) {
+        parent::__construct($dsn,$username,$password);
+        $this->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
+        $this->setAttribute(PDO::ATTR_STATEMENT_CLASS, array("Doctrine_DBStatement",array($this)));
+    }
+    
+    
+    public static function getConn($dsn,$username = null, $password = null) {
+        static $instance;
+        
+        if( ! isset($instance)) {
+            $instance = new Doctrine_DB($dsn,$username,$password);
+        }
+        return $instance;
+    }
+
+    /**
+     * @param string $dsn           PEAR::DB like DSN
+     * format:                      schema://user:password@address/dbname
+     */
+    public static function getConnection($dsn = null) {
+        static $instance = array();
+        $md5 = md5($dsn);
+
+        if( ! isset($instance[$md5])) {
+            if( ! isset($dsn)) {
+                $a = parse_url(self::DSN);
+            } else {
+                $a = parse_url($dsn);
+            }
+            $e = array();
+
+            $e[0] = $a["scheme"].":host=".$a["host"].";dbname=".substr($a["path"],1);
+            $e[1] = $a["user"];
+            $e[2] = $a["pass"];
+
+            $instance[$md5] = new Doctrine_DB($e[0],$e[1],$e[2]);
+        }
+        return $instance[$md5];
+    }
+    /**
+     * @param string $query         query to be executed
+     */
+    public function query($query) {
+        try {
+            $this->queries[] = $query;
+            $time = microtime();
+
+            $stmt = parent::query($query);
+
+            $this->exectimes[] = (microtime() - $time);
+            return $stmt;
+        } catch(PDOException $e) {
+            throw $e;
+        }
+    }
+    /**
+     * @param string $query         query to be prepared
+     */
+    public function prepare($query) {
+        $this->queries[] = $query;
+        return parent::prepare($query);
+    }
+    /**
+     * @param string $time          exectime of the last executed query
+     * @return void
+     */
+    public function addExecTime($time) {
+        $this->exectimes[] = $time;
+    }
+    
+    public function getExecTimes() {
+        return $this->exectimes;
+    }
+    /**
+     * @return array                an array of executed queries
+     */
+    public function getQueries() {
+        return $this->queries;
+    }
+    /**
+     * @return ArrayIterator
+     */
+    public function getIterator() {
+        return new ArrayIterator($this->queries);
+    }
+    /**
+     * returns the number of executed queries
+     * @return integer
+     */
+    public function count() {
+        return count($this->queries);
+    }
+
+}
+class Doctrine_DBStatement extends PDOStatement {
+    /**
+     * @param Doctrine_DB $dbh        Doctrine Database Handler
+     */
+    private $dbh;
+    /**
+     * @param Doctrine_DB $dbh
+     */
+    private function __construct(Doctrine_DB $dbh) {
+        $this->dbh = $dbh;
+    }
+    /**
+     * @param array $params
+     */
+    public function execute(array $params = null) {
+        $time     = microtime();
+        $result   = parent::execute($params);
+
+        $exectime = (microtime() - $time);
+        $this->dbh->addExecTime($exectime);
+        return $result;
+    }
+}
+?>

Doctrine/DataDict.php

+<?php
+class Doctrine_DataDict {
+    private $dbh;
+    public function __construct(PDO $dbh) {
+        $manager = Doctrine_Manager::getInstance();
+        require_once($manager->getRoot()."/adodb-hack/adodb.inc.php");
+
+        $this->dbh  = $dbh;
+        $this->dict = NewDataDictionary($dbh);
+    }
+
+    public function metaColumns(Doctrine_Table $table) {
+        return $this->dict->metaColumns($table->getTableName());
+    }
+
+
+    public function createTable($tablename, $columns) {
+        foreach($columns as $name => $args) {
+            $r[] = $name." ".$this->getADOType($args[0],$args[1])." ".str_replace("|"," ",$args[2]);
+        }
+
+
+        $r = implode(", ",$r);
+        $a = $this->dict->createTableSQL($tablename,$r);
+
+        $return = true;
+        foreach($a as $sql) {
+            try {
+                $this->dbh->query($sql);
+            } catch(PDOException $e) {
+                if($this->dbh->getAttribute(PDO::ATTR_DRIVER_NAME) == "sqlite")
+                    throw $e;
+                $return = false;
+            }
+        }
+
+        return $return;
+    }
+    /**
+     * converts doctrine type to adodb type
+     *
+     * @param string $type              column type
+     * @param integer $length           column length
+     */
+    public function getADOType($type,$length) {
+        switch($type):
+            case "string":
+            case "s":
+                if($length < 255)
+                    return "C($length)";
+                elseif($length < 4000) 
+                    return "X";
+                else
+                    return "X2";
+            break;
+            case "mbstring":
+                if($length < 255) 
+                    return "C2($length)";
+                
+                return "X2";
+            case "clob":
+                return "XL";
+            break;
+            case "d":
+            case "date":
+                return "D";
+            break;
+            case "float":
+            case "f":
+            case "double":
+                return "F";
+            break;
+            case "timestamp":
+            case "t":
+                return "T";
+            break;
+            case "boolean":
+            case "bool":
+                return "L";
+            break;
+            case "integer":
+            case "int":
+            case "i":
+                if(empty($length))
+                    return "I8";
+                elseif($length < 4)
+                    return "I1";
+                elseif($length < 6)
+                    return "I2";
+                elseif($length < 10)
+                    return "I4";
+                elseif($length <= 20)
+                    return "I8";
+                else
+                    throw new Doctrine_Exception("Too long integer (max length is 20).");
+
+            break;
+        endswitch;
+    }
+}
+?>

Doctrine/Debugger.php

+<?php
+require_once("EventListener.php");
+
+class Doctrine_DebugMessage {
+    private $code;
+    private $object;
+    public function __construct($object, $code) {
+        $this->object = $object;
+        $this->code   = $code;
+    }
+    final public function getCode() {
+        return $this->code;
+    }
+    final public function getObject() {
+        return $this->object;
+    }
+}
+class Doctrine_Debugger extends Doctrine_EventListener {
+    const EVENT_LOAD            = 1;
+    const EVENT_PRELOAD         = 2;
+    const EVENT_SLEEP           = 3;
+    const EVENT_WAKEUP          = 4;
+    const EVENT_UPDATE          = 5;
+    const EVENT_PREUPDATE       = 6;
+    const EVENT_CREATE          = 7;
+    const EVENT_PRECREATE       = 8;
+
+    const EVENT_SAVE            = 9;
+    const EVENT_PRESAVE         = 10;
+    const EVENT_INSERT          = 11;
+    const EVENT_PREINSERT       = 12;
+    const EVENT_DELETE          = 13;
+    const EVENT_PREDELETE       = 14;
+    const EVENT_EVICT           = 15;
+    const EVENT_PREEVICT        = 16;
+    const EVENT_CLOSE           = 17;
+    const EVENT_PRECLOSE        = 18;
+
+    const EVENT_OPEN            = 19;
+    const EVENT_COMMIT          = 20;
+    const EVENT_PRECOMMIT       = 21;
+    const EVENT_ROLLBACK        = 22;
+    const EVENT_PREROLLBACK     = 23;
+    const EVENT_BEGIN           = 24;
+    const EVENT_PREBEGIN        = 25;
+    const EVENT_COLLDELETE      = 26;
+    const EVENT_PRECOLLDELETE   = 27;
+    private $debug;
+    
+    public function getMessages() {
+        return $this->debug;                              	
+    }
+
+
+    public function onLoad(Doctrine_Record $record) {
+        $this->debug[] = new Doctrine_DebugMessage($record,self::EVENT_LOAD);
+    }
+    public function onPreLoad(Doctrine_Record $record) {
+        $this->debug[] = new Doctrine_DebugMessage($record,self::EVENT_PRELOAD);
+    }
+
+    public function onSleep(Doctrine_Record $record) { 
+        $this->debug[] = new Doctrine_DebugMessage($record,self::EVENT_SLEEP);
+    }
+
+    public function onWakeUp(Doctrine_Record $record) { 
+        $this->debug[] = new Doctrine_DebugMessage($record,self::EVENT_WAKEUP);
+    }
+
+    public function onUpdate(Doctrine_Record $record) { 
+        $this->debug[] = new Doctrine_DebugMessage($record,self::EVENT_UPDATE);
+    }
+    public function onPreUpdate(Doctrine_Record $record) { 
+        $this->debug[] = new Doctrine_DebugMessage($record,self::EVENT_PREUPDATE);
+    }
+
+    public function onCreate(Doctrine_Record $record) {
+        $this->debug[] = new Doctrine_DebugMessage($record,self::EVENT_CREATE);
+    }
+    public function onPreCreate(Doctrine_Record $record) {
+        $this->debug[] = new Doctrine_DebugMessage($record,self::EVENT_PRECREATE);
+    }
+
+    public function onSave(Doctrine_Record $record) {
+        $this->debug[] = new Doctrine_DebugMessage($record,self::EVENT_SAVE);
+    }
+    public function onPreSave(Doctrine_Record $record) {
+        $this->debug[] = new Doctrine_DebugMessage($record,self::EVENT_PRESAVE);
+    }
+
+    public function onInsert(Doctrine_Record $record) { 
+        $this->debug[] = new Doctrine_DebugMessage($record,self::EVENT_INSERT);
+    }
+    public function onPreInsert(Doctrine_Record $record) { 
+        $this->debug[] = new Doctrine_DebugMessage($record,self::EVENT_PREINSERT);
+    }
+
+    public function onDelete(Doctrine_Record $record) { 
+        $this->debug[] = new Doctrine_DebugMessage($record,self::EVENT_DELETE);
+    }
+    public function onPreDelete(Doctrine_Record $record) { 
+        $this->debug[] = new Doctrine_DebugMessage($record,self::EVENT_PREDELETE);
+    }
+
+    public function onEvict(Doctrine_Record $record) { 
+        $this->debug[] = new Doctrine_DebugMessage($record,self::EVENT_EVICT);
+    }
+    public function onPreEvict(Doctrine_Record $record) { 
+        $this->debug[] = new Doctrine_DebugMessage($record,self::EVENT_PREEVICT);
+    }
+
+    public function onClose(Doctrine_Session $session) { 
+         $this->debug[] = new Doctrine_DebugMessage($session,self::EVENT_CLOSE);
+    }
+    public function onPreClose(Doctrine_Session $session) { 
+         $this->debug[] = new Doctrine_DebugMessage($session,self::EVENT_PRECLOSE);
+    }
+
+    public function onOpen(Doctrine_Session $session) { 
+         $this->debug[] = new Doctrine_DebugMessage($session,self::EVENT_OPEN);
+    }
+
+    public function onTransactionCommit(Doctrine_Session $session) { 
+         $this->debug[] = new Doctrine_DebugMessage($session,self::EVENT_COMMIT);
+    }
+    public function onPreTransactionCommit(Doctrine_Session $session) { 
+        $this->debug[] = new Doctrine_DebugMessage($session,self::EVENT_PRECOMMIT);
+    }
+
+    public function onTransactionRollback(Doctrine_Session $session) {
+        $this->debug[] = new Doctrine_DebugMessage($session,self::EVENT_ROLLBACK);
+    }
+    public function onPreTransactionRollback(Doctrine_Session $session) {
+        $this->debug[] = new Doctrine_DebugMessage($session,self::EVENT_PREROLLBACK);
+    }
+
+    public function onTransactionBegin(Doctrine_Session $session) {
+        $this->debug[] = new Doctrine_DebugMessage($session,self::EVENT_BEGIN);
+    }
+    public function onPreTransactionBegin(Doctrine_Session $session) {
+        $this->debug[] = new Doctrine_DebugMessage($session,self::EVENT_PREBEGIN);
+    }
+    
+    public function onCollectionDelete(Doctrine_Collection $collection) { 
+        $this->debug[] = new Doctrine_DebugMessage($collection,self::EVENT_COLLDELETE);
+    }
+    public function onPreCollectionDelete(Doctrine_Collection $collection) {
+        $this->debug[] = new Doctrine_DebugMessage($collection,self::EVENT_PRECOLLDELETE);
+    }
+}
+?>

Doctrine/EventListener.php

+<?php
+/**
+ * interface for event listening, forces all classes that extend 
+ * Doctrine_EventListener to have the same method arguments as their parent
+ */
+interface iDoctrine_EventListener {
+
+    public function onLoad(Doctrine_Record $record);
+    public function onPreLoad(Doctrine_Record $record);
+
+    public function onUpdate(Doctrine_Record $record);
+    public function onPreUpdate(Doctrine_Record $record);
+
+    public function onCreate(Doctrine_Record $record);
+    public function onPreCreate(Doctrine_Record $record);
+
+    public function onSave(Doctrine_Record $record);
+    public function onPreSave(Doctrine_Record $record);
+
+    public function onInsert(Doctrine_Record $record);
+    public function onPreInsert(Doctrine_Record $record);
+
+    public function onDelete(Doctrine_Record $record);
+    public function onPreDelete(Doctrine_Record $record);
+
+    public function onEvict(Doctrine_Record $record);
+    public function onPreEvict(Doctrine_Record $record);
+    
+    public function onSaveCascade(Doctrine_Record $record);
+    public function onPreSaveCascade(Doctrine_Record $record);
+    
+    public function onDeleteCascade(Doctrine_Record $record);
+    public function onPreDeleteCascade(Doctrine_Record $record);
+
+    public function onSleep(Doctrine_Record $record);
+    
+    public function onWakeUp(Doctrine_Record $record);
+    
+    public function onClose(Doctrine_Session $session);
+    public function onPreClose(Doctrine_Session $session);
+    
+    public function onOpen(Doctrine_Session $session);
+
+    public function onTransactionCommit(Doctrine_Session $session);
+    public function onPreTransactionCommit(Doctrine_Session $session);
+
+    public function onTransactionRollback(Doctrine_Session $session);
+    public function onPreTransactionRollback(Doctrine_Session $session);
+
+    public function onTransactionBegin(Doctrine_Session $session);
+    public function onPreTransactionBegin(Doctrine_Session $session);
+    
+    public function onCollectionDelete(Doctrine_Collection $collection);
+    public function onPreCollectionDelete(Doctrine_Collection $collection);
+}
+
+/**
+ * Doctrine_EventListener     all event listeners extend this base class
+ *                      the empty methods allow child classes to only implement the methods they need to implement
+ *
+ *
+ * @author      Konsta Vesterinen
+ * @package     Doctrine ORM
+ * @url         www.phpdoctrine.com
+ * @license     LGPL
+ * @version     1.0 alpha
+ *
+ */
+abstract class Doctrine_EventListener implements iDoctrine_EventListener {
+
+    public function onLoad(Doctrine_Record $record) { }
+    public function onPreLoad(Doctrine_Record $record) { }
+
+    public function onSleep(Doctrine_Record $record) { }
+
+    public function onWakeUp(Doctrine_Record $record) { }
+
+    public function onUpdate(Doctrine_Record $record) { }
+    public function onPreUpdate(Doctrine_Record $record) { }
+
+    public function onCreate(Doctrine_Record $record) { }
+    public function onPreCreate(Doctrine_Record $record) { }
+
+    public function onSave(Doctrine_Record $record) { }
+    public function onPreSave(Doctrine_Record $record) { }
+
+    public function onInsert(Doctrine_Record $record) { }
+    public function onPreInsert(Doctrine_Record $record) { }
+
+    public function onDelete(Doctrine_Record $record) { }
+    public function onPreDelete(Doctrine_Record $record) { }
+
+    public function onEvict(Doctrine_Record $record) { }
+    public function onPreEvict(Doctrine_Record $record) { }
+
+    public function onSaveCascade(Doctrine_Record $record) { }
+    public function onPreSaveCascade(Doctrine_Record $record) { }
+
+    public function onDeleteCascade(Doctrine_Record $record) { }
+    public function onPreDeleteCascade(Doctrine_Record $record) { }
+
+    public function onClose(Doctrine_Session $session) { }
+    public function onPreClose(Doctrine_Session $session) { }
+
+    public function onOpen(Doctrine_Session $session) { }
+
+    public function onTransactionCommit(Doctrine_Session $session) { }
+    public function onPreTransactionCommit(Doctrine_Session $session) { }
+
+    public function onTransactionRollback(Doctrine_Session $session) { }
+    public function onPreTransactionRollback(Doctrine_Session $session) { }
+
+    public function onTransactionBegin(Doctrine_Session $session) { }
+    public function onPreTransactionBegin(Doctrine_Session $session) { }
+    
+    public function onCollectionDelete(Doctrine_Collection $collection) { }
+    public function onPreCollectionDelete(Doctrine_Collection $collection) { }
+}
+/**
+ * an emtpy listener all components use this by default
+ */
+class EmptyEventListener extends Doctrine_EventListener { }
+
+?>

Doctrine/Exception.php

+<?php
+class InvalidKeyException extends Exception { }
+class InvalidTypeException extends Exception { }
+class Doctrine_Exception extends Exception { }   
+class DQLException extends Doctrine_Exception { }
+?>

Doctrine/ForeignKey.php

+<?php
+require_once("Relation.php");
+/**
+ * Foreign Key
+ */
+class Doctrine_ForeignKey extends Doctrine_Relation { }
+?>

Doctrine/Form.class.php

+<?php
+class Doctrine_Form implements Iterator {
+    protected $record;
+    protected $elements = array();
+    protected $columns;
+    protected $current;
+    protected $keys;
+    protected $index;
+    protected $count;
+    public function __construct(Doctrine_Record $record) {
+        $this->record = $record;
+        $this->columns = $record->getTable()->getColumns();
+        $this->keys    = array_keys($this->columns);
+        $this->index   = 0;
+        $this->count   = count($this->keys);
+    }
+    public function current() {
+        $i = $this->index;
+        $column = $this->keys[$i];
+
+        $definitions = $this->columns[$column];
+
+        $e    = explode("|",$definitions[2]);
+        $enum = false;
+        foreach($e as $v) {
+            $e2 = explode(":",$v);
+            if($e2[0] == "enum") {
+                $enum = explode("-",$e2[1]);
+                break;
+            }
+        }
+        $length = $definitions[1];
+        if( ! in_array("autoincrement",$e) && ! in_array("protected",$e)) {
+            if($enum) {
+                $elements[$column] = "<select name='data[$column]'>\n";
+                foreach($enum as $k => $v) {
+                    if($this->record->get($column) == $k) {
+                        $str = 'selected';
+                    } else
+                        $str = '';
+
+                    $elements[$column] .= "    <option value='$k' $str>$v</option>\n";
+                }
+                $elements[$column] .= "</select>\n";
+            } else {
+                if($length <= 255) {
+                    $elements[$column] = "<input name='data[$column]' type='text' value='".$this->record->get($column)."' maxlength=$length \>\n";
+                } else {
+                    $elements[$column] = "<textarea name='data[$column]' cols=40 rows=10>".$this->record->get($column)."</textarea>\n";
+                }
+            }
+            return $elements[$column];
+        } else {
+            $this->index++;
+
+            if($this->index < $this->count)
+                return self::current();
+        }
+    }
+    public function key() {
+        $i = $this->index;
+        return $this->keys[$i];
+    }
+    public function next() {
+        $this->index++;
+    }
+    public function rewind() {
+        $this->index = 0;
+    }
+    public function valid() {
+        if($this->index >= $this->count)
+            return false;
+            
+        return true;
+    }
+}
+?>

Doctrine/Identifier.php

+<?php
+class Doctrine_Identifier {
+    /**
+     * constant for unique identifier
+     */
+    const UNIQUE         = 0;
+    /**
+     * constant for auto_increment identifier
+     */
+    const AUTO_INCREMENT = 1;
+    /**
+     * constant for sequence identifier
+     */
+    const SEQUENCE       = 2;
+    /**
+     * constant for normal identifier
+     */
+    const NORMAL         = 3;
+    /**
+     * constant for composite identifier
+     */
+    const COMPOSITE      = 4;
+}
+?>

Doctrine/IdentityMap.class.php

+<?php
+abstract class Doctrine_Creator {
+    protected $_table;
+    /**
+     * constructor
+     *
+     * @param Doctrine_Table $table
+     */
+    public function __construct(Doctrine_Table $table) {
+        $this->_table = $_table;
+    }
+    
+
+    abstract public function get();
+}
+class Doctrine_IdentityMap {
+    private $identityMap = array();
+
+    /**
+     * first checks if record exists in identityMap, if not
+     * returns a new record
+     *
+     * @return Doctrine_Record
+     */
+    public function get() {
+        $key = $this->getIdentifier();
+
+        if( ! is_array($key))
+            $key = array($key);
+
+
+        foreach($key as $k) {
+            if( ! isset($this->data[$k]))
+                throw new Doctrine_Exception("No primary key found");
+
+            $id[] = $this->data[$k];
+        }
+        $id = implode(' ', $id);
+
+        if(isset($this->identityMap[$id]))
+            $record = $this->identityMap[$id];
+        else {
+            $record = new $this->name($this);
+            $this->identityMap[$id] = $record;
+        }
+        $this->data = array();
+
+        return $record;
+    }
+}
+?>

Doctrine/IndexGenerator.php

+<?php
+class Doctrine_IndexGenerator {
+    /**
+     * @var string $name
+     */
+    private $name;
+    /**
+     * @param string $name
+     */
+    public function __construct($name) {
+        $this->name = $name;
+    }
+    /**
+     * @param Doctrine_Record $record
+     * @return mixed
+     */
+    public function getIndex(Doctrine_Record $record) {
+        $value = $record->get($this->name);
+        if($value === null)
+            throw new Doctrine_Exception("Couldn't create collection index. Record field '".$this->name."' was null.");
+
+        return $value;
+    }
+}
+?>

Doctrine/Iterator.php

+<?php
+/**
+ * Doctrine_Iterator
+ * iterates through Doctrine_Collection
+ *
+ * @package     Doctrine ORM
+ * @url         www.phpdoctrine.com
+ * @license     LGPL
+ */
+abstract class Doctrine_Iterator implements Iterator {
+    /**
+     * @var Doctrine_Collection $collection         
+     */
+    protected $collection;
+    /**
+     * @var array $keys
+     */
+    protected $keys;
+    /**
+     * @var mixed $key
+     */
+    protected $key;
+    /**
+     * @var integer $index
+     */
+    protected $index;
+    /**
+     * @var integer $count
+     */
+    protected $count;
+
+    /**
+     * constructor
+     * @var Doctrine_Collection $collection
+     */
+    public function __construct(Doctrine_Collection $collection) {
+        $this->collection = $collection;
+        $this->keys       = $this->collection->getKeys();
+        $this->count      = $this->collection->count();
+    }
+    /**
+     * rewinds the iterator
+     *
+     * @return void
+     */
+    public function rewind() {
+        $this->index = 0;
+        $i = $this->index;
+        if(isset($this->keys[$i]))
+            $this->key   = $this->keys[$i];
+    }
+
+    /**
+     * returns the current key
+     *
+     * @return integer
+     */
+    public function key() {
+        return $this->key;
+    }
+    /**
+     * returns the current record
+     *
+     * @return Doctrine_Record
+     */
+    public function current() {
+        return $this->collection->get($this->key);
+    }
+    /**
+     * advances the internal pointer
+     *
+     * @return void
+     */
+    public function next() {
+        $this->index++;
+        $i = $this->index;
+        if(isset($this->keys[$i]))
+            $this->key   = $this->keys[$i];
+    }
+}
+
+
+?>

Doctrine/Lib.php

+<?php
+class Doctrine_Lib {
+    /**
+     * @param integer $state                the state of record
+     * @see Doctrine_Record::STATE_* constants
+     * @return string                       string representation of given state
+     */
+    public static function getRecordStateAsString($state) {
+        switch($state):
+            case Doctrine_Record::STATE_PROXY:
+                return "proxy";
+            break;
+            case Doctrine_Record::STATE_CLEAN:
+                return "persistent clean";
+            break;
+            case Doctrine_Record::STATE_DIRTY:
+                return "persistent dirty";
+            break;
+            case Doctrine_Record::STATE_TDIRTY:
+                return "transient dirty";
+            break;
+            case Doctrine_Record::STATE_TCLEAN:
+                return "transient clean";
+            break;
+        endswitch;
+    }
+    /**
+     * returns a string representation of Doctrine_Record object
+     * @param Doctrine_Record $record
+     * @return string
+     */
+    public function getRecordAsString(Doctrine_Record $record) {
+        $r[] = "<pre>";
+        $r[] = "Component  : ".$record->getTable()->getComponentName();
+        $r[] = "ID         : ".$record->getID();
+        $r[] = "References : ".count($record->getReferences());
+        $r[] = "State      : ".Doctrine_Lib::getRecordStateAsString($record->getState());
+        $r[] = "OID        : ".$record->getOID();
+        $r[] = "</pre>";
+        return implode("\n",$r)."<br />";
+    }
+    /**
+     * getStateAsString
+     * returns a given session state as string
+     * @param integer $state        session state
+     */
+    public static function getSessionStateAsString($state) {
+        switch($state):
+            case Doctrine_Session::STATE_OPEN:
+                return "open";
+            break;
+            case Doctrine_Session::STATE_CLOSED:
+                return "closed";
+            break;
+            case Doctrine_Session::STATE_BUSY:
+                return "busy";
+            break;
+            case Doctrine_Session::STATE_ACTIVE:
+                return "active";
+            break;
+        endswitch;
+    }
+    /**
+     * returns a string representation of Doctrine_Session object
+     * @param Doctrine_Session $session
+     * @return string
+     */
+    public function getSessionAsString(Doctrine_Session $session) {
+        $r[] = "<pre>";
+        $r[] = "Doctrine_Session object";
+        $r[] = "State               : ".Doctrine_Lib::getSessionStateAsString($session->getState());
+        $r[] = "Open Transactions   : ".$session->getTransactionLevel();
+        $r[] = "Open Factories      : ".$session->count();
+        $sum = 0;
+        $rsum = 0;
+        $csum = 0;
+        foreach($session->getTables() as $objTable) {
+            if($objTable->getCache() instanceof Doctrine_Cache_File) {
+                $sum += array_sum($objTable->getCache()->getStats());
+                $rsum += $objTable->getRepository()->count();
+                $csum += $objTable->getCache()->count();
+            }
+        }
+        $r[] = "Cache Hits          : ".$sum." hits ";
+        $r[] = "Cache               : ".$csum." objects ";
+
+        $r[] = "Repositories        : ".$rsum." objects ";
+        $queries = false;
+        if($session->getDBH() instanceof Doctrine_DB) {
+            $handler = "Doctrine Database Handler";
+            $queries = count($session->getDBH()->getQueries());
+            $sum     = array_sum($session->getDBH()->getExecTimes());
+        } elseif($session->getDBH() instanceof PDO) {
+            $handler = "PHP Native PDO Driver";
+        } else
+            $handler = "Unknown Database Handler";
+
+        $r[] = "DB Handler          : ".$handler;
+        if($queries) {
+            $r[] = "Executed Queries    : ".$queries;
+            $r[] = "Sum of Exec Times   : ".$sum;
+        }
+
+        $r[] = "</pre>";
+        return implode("\n",$r)."<br>";
+    }
+    /**
+     * returns a string representation of Doctrine_Table object
+     * @param Doctrine_Table $table
+     * @return string
+     */
+    public function getTableAsString(Doctrine_Table $table) {
+        $r[] = "<pre>";
+        $r[] = "Component   : ".$this->getComponentName();
+        $r[] = "Table       : ".$this->getTableName();
+        $r[] = "Repository  : ".$this->getRepository()->count()." objects";
+        if($table->getCache() instanceof Doctrine_Cache_File) {
+            $r[] = "Cache       : ".$this->getCache()->count()." objects";
+            $r[] = "Cache hits  : ".array_sum($this->getCache()->getStats())." hits";
+        }
+        $r[] = "</pre>";
+        return implode("\n",$r)."<br>";
+    }
+    /**
+     * returns a string representation of Doctrine_Collection object
+     * @param Doctrine_Collection $collection
+     * @return string
+     */
+    public function getCollectionAsString(Doctrine_Collection $collection) {
+        $r[] = "<pre>";
+        $r[] = get_class($collection);
+
+        foreach($collection as $key => $record) {
+            $r[] = "Key : ".$key." ID : ".$record->getID();
+        }
+        $r[] = "</pre>";
+        return implode("\n",$r);
+    }
+}
+?>

Doctrine/LocalKey.php

+<?php
+require_once("Relation.php");
+/**
+ * Local Key
+ */
+class Doctrine_LocalKey extends Doctrine_Relation { }
+?>

Doctrine/Manager.php

+<?php
+require_once("Configurable.php");
+require_once("EventListener.php");
+/**
+ * @package     Doctrine ORM
+ * @url         www.phpdoctrine.com
+ * @license     LGPL
+ * 
+ * Doctrine_Manager is the base component of all doctrine based projects. 
+ * It opens and keeps track of all sessions (database connections).
+ */
+class Doctrine_Manager extends Doctrine_Configurable implements Countable, IteratorAggregate {
+    /**
+     * @var array $session          an array containing all the opened sessions
+     */
+    private $sessions   = array();
+    /**
+     * @var integer $index          the incremented index
+     */
+    private $index      = 0;
+    /**
+     * @var integer $currIndex      the current session index
+     */
+    private $currIndex  = 0;
+    /**
+     * @var string $root            root directory
+     */
+    private $root; 
+    /**
+     * @var Doctrine_Null $null     Doctrine_Null object, used for extremely fast null value checking
+     */
+    private $null;
+
+    /**
+     * constructor
+     */
+    private function __construct() {
+        $this->root = dirname(__FILE__);
+        $this->null = new Doctrine_Null;
+
+        Doctrine_Record::initNullObject($this->null);
+        Doctrine_Collection::initNullObject($this->null);
+    }
+    /**
+     * @return Doctrine_Null
+     */
+    final public function getNullObject() {
+        return $this->null;
+    }
+    /**
+     * setDefaultAttributes
+     * sets default attributes
+     *
+     * @return boolean
+     */
+    final public function setDefaultAttributes() {
+        static $init = false;
+        if( ! $init) {
+            $init = true;
+            $attributes = array(
+                        Doctrine::ATTR_CACHE_DIR        => "%ROOT%".DIRECTORY_SEPARATOR."cachedir",
+                        Doctrine::ATTR_FETCHMODE        => Doctrine::FETCH_LAZY,
+                        Doctrine::ATTR_CACHE_TTL        => 100,
+                        Doctrine::ATTR_CACHE_SIZE       => 100,
+                        Doctrine::ATTR_CACHE            => Doctrine::CACHE_NONE,
+                        Doctrine::ATTR_BATCH_SIZE       => 5,
+                        Doctrine::ATTR_COLL_LIMIT       => 5,
+                        Doctrine::ATTR_LISTENER         => new EmptyEventListener(),
+                        Doctrine::ATTR_PK_COLUMNS       => array("id"),
+                        Doctrine::ATTR_PK_TYPE          => Doctrine::INCREMENT_KEY,
+                        Doctrine::ATTR_LOCKMODE         => 1,
+                        Doctrine::ATTR_VLD              => false,
+                        Doctrine::ATTR_CREATE_TABLES    => true
+                        );
+            foreach($attributes as $attribute => $value) {
+                $old = $this->getAttribute($attribute);
+                if($old === null)
+                    $this->setAttribute($attribute,$value);
+            }
+            return true;
+        }
+        return false;
+    }
+    /**
+     * returns the root directory of Doctrine
+     *
+     * @return string
+     */
+    final public function getRoot() {
+        return $this->root;
+    }
+    /**
+     * getInstance                  
+     * returns an instance of this class
+     * (this class uses the singleton pattern)
+     *
+     * @return Doctrine_Manager
+     */
+    final public static function getInstance() {
+        static $instance;
+        if( ! isset($instance))
+            $instance = new self();
+
+        return $instance;
+    }
+
+    /**
+     * openSession                          
+     * opens a new session and saves it to Doctrine_Manager->sessions
+     *
+     * @param PDO $pdo                      PDO database driver
+     * @param string $name                  name of the session, if empty numeric key is used
+     * @return Doctrine_Session
+     */
+    final public function openSession(PDO $pdo, $name = null) {
+        // initialize the default attributes
+        $this->setDefaultAttributes();
+
+        if($name !== null) {
+            $name = (string) $name;
+            if(isset($this->sessions[$name]))
+                throw new InvalidKeyException();
+        
+        } else {
+            $name = $this->index;
+            $this->index++;
+        }
+        switch($pdo->getAttribute(PDO::ATTR_DRIVER_NAME)):
+            case "mysql":
+                $this->sessions[$name] = new Doctrine_Session_Mysql($this,$pdo);
+            break;
+            case "sqlite":
+                $this->sessions[$name] = new Doctrine_Session_Sqlite($this,$pdo);
+            break;
+            case "pgsql":
+                $this->sessions[$name] = new Doctrine_Session_Pgsql($this,$pdo);
+            break;
+            case "oci":
+                $this->sessions[$name] = new Doctrine_Session_Oracle($this,$pdo);
+            break;
+            case "mssql":
+                $this->sessions[$name] = new Doctrine_Session_Mssql($this,$pdo);
+            break;
+            case "firebird":
+                $this->sessions[$name] = new Doctrine_Session_Firebird($this,$pdo);
+            break;
+            case "informix":
+                $this->sessions[$name] = new Doctrine_Session_Informix($this,$pdo);
+            break;
+        endswitch;
+
+
+        $this->currIndex = $name;
+        return $this->sessions[$name];
+    }
+    /**
+     * getSession
+     * @param integer $index
+     * @return object Doctrine_Session
+     * @throws InvalidKeyException
+     */
+    final public function getSession($index) {
+        if( ! isset($this->sessions[$index]))
+            throw new InvalidKeyException();
+
+        $this->currIndex = $index;
+        return $this->sessions[$index];
+    }
+    /**
+     * closes the session
+     *
+     * @param Doctrine_Session $session
+     * @return void
+     */
+    final public function closeSession(Doctrine_Session $session) {
+        $session->close();
+        unset($session);
+    }
+    /**
+     * getSessions
+     * returns all opened sessions
+     *
+     * @return array
+     */
+    final public function getSessions() {
+        return $this->sessions;
+    }
+    /**
+     * setCurrentSession
+     * sets the current session to $key
+     *
+     * @param mixed $key                        the session key
+     * @throws InvalidKeyException
+     * @return void
+     */
+    final public function setCurrentSession($key) {
+        $key = (string) $key;
+        if( ! isset($this->sessions[$key]))
+            throw new InvalidKeyException();
+        
+        $this->currIndex = $key;
+    }
+    /**
+     * count
+     * returns the number of opened sessions
+     *
+     * @return integer
+     */
+    public function count() {
+        return count($this->sessions);
+    }
+    /**
+     * getIterator
+     * returns an ArrayIterator that iterates through all sessions
+     *
+     * @return ArrayIterator
+     */
+    public function getIterator() {
+        return new ArrayIterator($this->sessions);
+    }
+    /**
+     * getCurrentSession
+     * returns the current session
+     *
+     * @throws Doctrine_Session_Exception       if there are no open sessions
+     * @return Doctrine_Session
+     */
+    final public function getCurrentSession() {
+        $i = $this->currIndex;
+        if( ! isset($this->sessions[$i]))
+            throw new Doctrine_Session_Exception();
+
+        return $this->sessions[$i];
+    }
+    /**
+     * __toString
+     * returns a string representation of this object
+     *
+     * @return string
+     */
+    public function __toString() {
+        $r[] = "<pre>";
+        $r[] = "Doctrine_Manager";
+        $r[] = "Sessions : ".count($this->sessions);
+        $r[] = "</pre>";
+        return implode("\n",$r);
+    }
+}
+?>

Doctrine/Module.class.php

+<?php
+class Doctrine_Module implements IteratorAggregate, Countable {
+    /**
+     * @var array $components   an array containing all the components in this module
+     */
+    private $components = array();
+    /**
+     * @var string $name        the name of this module
+     */
+    private $name;
+    /**
+     * constructor
+     *
+     * @param string $name      the name of this module
+     */
+    public function __construct($name) {
+        $this->name = $name;
+    }
+    /**
+     * returns the name of this module
+     *
+     * @return string
+     */
+    public function getName() {
+        return $this->name;
+    }
+    /**
+     * flush
+     * saves all components
+     *
+     * @return void
+     */
+    public function flush() {
+        $session = Doctrine_Manager::getInstance()->getCurrentSession();
+        
+        $tree = $session->buildFlushTree($this->components);
+    }
+    /**
+     * getIterator
+     * this class implements IteratorAggregate interface
+     * returns an iterator that iterates through the components
+     * in this module
+     *
+     * @return ArrayIterator
+     */
+    public function getIterator() {
+        return new ArrayIterator($this->components);
+    }
+    /**
+     * count
+     * this class implements Countable interface
+     * returns the number of components in this module
+     *
+     * @return integer
+     */
+    public function count() {
+        return count($this->components);
+    }
+}
+?>

Doctrine/Null.php

+<?php
+/**
+ * Doctrine_Null
+ */
+class Doctrine_Null { }
+?>

Doctrine/Relation.php

+<?php
+/**
+ * Doctrine_Relation
+ *
+ * @package     Doctrine ORM
+ * @url         www.phpdoctrine.com
+ * @license     LGPL
+ */
+class Doctrine_Relation {
+    /**
+     * RELATION CONSTANTS
+     */
+
+    /**
+     * constant for ONE_TO_ONE and MANY_TO_ONE aggregate relationships
+     */
+    const ONE_AGGREGATE         = 0;
+    /**
+     * constant for ONE_TO_ONE and MANY_TO_ONE composite relationships
+     */
+    const ONE_COMPOSITE         = 1;
+    /**
+     * constant for MANY_TO_MANY and ONE_TO_MANY aggregate relationships
+     */
+    const MANY_AGGREGATE        = 2;
+    /**
+     * constant for MANY_TO_MANY and ONE_TO_MANY composite relationships
+     */
+    const MANY_COMPOSITE        = 3;
+    
+
+    /**
+     * @var Doctrine_Table $table     foreign factory
+     */
+    private $table;
+    /**
+     * @var string $local           local field
+     */
+    private $local;
+    /**
+     * @var string $foreign         foreign field
+     */
+    private $foreign;
+    /**
+     * @var integer $type           bind type
+     */
+    private $type;
+    /**
+     * @param Doctrine_Table $table
+     * @param string $local
+     * @param string $foreign
+     * @param integer $type
+     */
+    public function __construct(Doctrine_Table $table,$local,$foreign,$type) {
+        $this->table    = $table;
+        $this->local    = $local;
+        $this->foreign  = $foreign;
+        $this->type     = $type;
+    }
+    /**
+     * @return integer              bind type 1 or 0
+     */
+    public function getType() {
+        return $this->type;
+    }
+    /**
+     * @return object Doctrine_Table    foreign factory object
+     */
+    public function getTable() {
+        return $this->table;
+    }
+    /**
+     * @return string               the name of the local column
+     */
+    public function getLocal() {
+        return $this->local;
+    }
+    /**
+     * @return string               the name of the foreign column where
+     *                              the local column is pointing at
+     */
+    public function getForeign() {
+        return $this->foreign;
+    }
+    /**
+     * __toString
+     */
+    public function __toString() {
+        $r[] = "<pre>";
+        $r[] = "Class       : ".get_class($this);
+        $r[] = "Component   : ".$this->table->getComponentName();
+        $r[] = "Table       : ".$this->table->getTableName();
+        $r[] = "Local key   : ".$this->local;
+        $r[] = "Foreign key : ".$this->foreign;
+        $r[] = "Type        : ".$this->type;
+        $r[] = "</pre>";
+        return implode("\n", $r);
+    }
+}
+
+?>

Doctrine/Repository.php

+<?php
+/**
+ * Doctrine_Repository
+ * each record is added into Doctrine_Repository at the same time they are created,
+ * loaded from the database or retrieved from the cache
+ *
+ * @author      Konsta Vesterinen
+ * @package     Doctrine ORM
+ * @url         www.phpdoctrine.com
+ * @license     LGPL
+ * @version     1.0 alpha
+ *
+ */
+class Doctrine_Repository implements Countable, IteratorAggregate {
+    /**
+     * @var object Doctrine_Table $table
+     */
+    private $table;
+    /**
+     * @var array $registry
+     * an array of all records
+     * keys representing record object identifiers
+     */
+    private $registry = array();
+    /**
+     * constructor
+     */
+    public function __construct(Doctrine_Table $table) {
+        $this->table = $table;
+    }
+    /** 
+     * @return object Doctrine_Table
+     */
+    public function getTable() {
+        return $this->table;
+    }
+    /**
+     * add
+     * @param Doctrine_Record $record       record to be added into registry
+     */
+    public function add(Doctrine_Record $record) {
+        $oid = $record->getOID();
+
+        if(isset($this->registry[$oid]))
+            return false;
+
+        $this->registry[$oid] = $record;
+
+        return true;
+    }
+    /**
+     * get
+     * @param integer $oid
+     * @throws InvalidKeyException
+     */
+    public function get($oid) {
+        if( ! isset($this->registry[$oid]))
+            throw new InvalidKeyException();
+
+        return $this->registry[$oid];
+    }
+    /**
+     * count
+     * Doctrine_Registry implements interface Countable
+     * @return integer                      the number of records this registry has
+     */
+    public function count() {
+        return count($this->registry);
+    }
+    /**
+     * @param integer $oid                  object identifier
+     * @return boolean                      whether ot not the operation was successful
+     */
+    public function evict($oid) {
+        if( ! isset($this->registry[$oid]))
+            return false;
+            
+        unset($this->registry[$oid]);
+        return true;
+    }
+    /**
+     * @return integer                      number of records evicted
+     */
+    public function evictAll() {
+        $evicted = 0;
+        foreach($this->registry as $oid=>$record) {
+            if($this->evict($oid))
+                $evicted++;
+        }
+        return $evicted;
+    }
+    /**
+     * getIterator
+     * @return ArrayIterator
+     */
+    public function getIterator() {
+        return new ArrayIterator($this->registry);
+    }
+    /**
+     * contains
+     * @param integer $oid                  object identifier
+     */
+    public function contains($oid) {
+        return isset($this->registry[$oid]);
+    }
+    /**
+     * loadAll
+     * @return void
+     */
+    public function loadAll() {
+        $this->table->findAll();
+    }
+}
+?>

Doctrine/Statement.class.php

+<?php
+require_once("Access.php");
+/**
+ * Doctrine_Statement
+ *
+ * Doctrine_Statement is a wrapper for PDOStatement with DQL support
+ *
+ * @package     Doctrine ORM
+ * @url         www.phpdoctrine.com
+ * @license     LGPL
+ */
+class Doctrine_Statement extends Doctrine_Access {
+    /**
+     * @var Doctrine_Query $query
+     */
+    private $query;
+    /**
+     * @var PDOStatement $stmt
+     */
+    private $stmt;
+    /**
+     * @var array $reserved
+     */
+    private $reserved = array();
+
+    /**
+     * constructor
+     *
+     * @param Doctrine_Query $query
+     * @param PDOStatement $stmt
+     */
+    public function __construct(Doctrine_Query $query, PDOStatement $stmt) {
+        $this->query = $query;
+        $this->stmt  = $stmt;
+    }
+    public function set($name, $value) { }
+    public function get($name) { }
+    /**
+     * getCollection
+     * returns Doctrine_Collection object
+     *
+     * @parma string $name              component name
+     * @param integer $index
+     * @return Doctrine_Collection
+     */
+    private function getCollection($name) {
+        $table = $this->session->getTable($name);
+        switch($this->fetchModes[$name]):
+            case Doctrine::FETCH_BATCH:
+                $coll = new Doctrine_Collection_Batch($table);
+            break;
+            case Doctrine::FETCH_LAZY:
+                $coll = new Doctrine_Collection_Lazy($table);
+            break;
+            case Doctrine::FETCH_OFFSET:
+                $coll = new Doctrine_Collection_Offset($table);
+            break;
+            case Doctrine::FETCH_IMMEDIATE:
+                $coll = new Doctrine_Collection_Immediate($table);
+            break;
+            case Doctrine::FETCH_LAZY_OFFSET:
+                $coll = new Doctrine_Collection_LazyOffset($table);
+            break;
+        endswitch;
+
+        $coll->populate($this);
+        return $coll;
+    }
+    /**
+     * execute
+     * executes the dql query, populates all collections
+     * and returns the root collection
+     *
+     * @param array $params
+     * @return Doctrine_Collection
+     */
+    public function execute($params = array()) {
+        switch(count($this->tables)):
+            case 0:
+                throw new DQLException();
+            break;
+            case 1:
+                $query = $this->getQuery();
+
+                $keys  = array_keys($this->tables);
+    
+                $name  = $this->tables[$keys[0]]->getComponentName();
+                $stmt  = $this->session->execute($query,$params);
+
+                while($data = $stmt->fetch(PDO::FETCH_ASSOC)):
+                    foreach($data as $key => $value):
+                        $e = explode("__",$key);
+                        if(count($e) > 1) {
+                            $data[$e[1]] = $value;
+                        } else {
+                            $data[$e[0]] = $value;
+                        }
+                        unset($data[$key]);
+                    endforeach;
+                    $this->data[$name][] = $data;
+                endwhile;
+
+                return $this->getCollection($keys[0]);
+            break;
+            default:
+                $query = $this->getQuery();
+
+                $keys  = array_keys($this->tables);
+                $root  = $keys[0];
+                $stmt  = $this->session->execute($query,$params);
+                
+                $previd = array();
+
+                $coll = $this->getCollection($root);
+
+                $array = $this->parseData($stmt);
+
+                foreach($array as $data):
+
+                    /**
+                     * remove duplicated data rows and map data into objects
+                     */
+                    foreach($data as $key => $row):
+                        if(empty($row))
+                            continue;
+
+                        $key  = ucwords($key);
+                        $name = $this->tables[$key]->getComponentName();
+
+                        if( ! isset($previd[$name]))
+                            $previd[$name] = array();
+
+
+                        if($previd[$name] !== $row) {
+                            $this->tables[$name]->setData($row);
+                            $record = $this->tables[$name]->getRecord();
+
+                            if($name == $root) {
+                                $this->tables[$name]->setData($row);
+                                $record = $this->tables[$name]->getRecord();
+                                $coll->add($record);
+                            } else {
+                                $last = $coll->getLast();
+
+                                if( ! $last->hasReference($name)) {
+                                    $last->initReference($this->getCollection($name),$this->connectors[$name]);
+                                }
+                                $last->addReference($record);
+                            }
+                        }
+
+                        $previd[$name] = $row;
+                    endforeach;
+                endforeach;
+
+                return $coll;
+        endswitch;
+    }
+    /**
+     * parseData
+     * parses the data returned by PDOStatement
+     *
+     * @param PDOStatement $stmt
+     * @return array
+     */
+    public function parseData(PDOStatement $stmt) {
+        $array = array();
+        while($data = $stmt->fetch(PDO::FETCH_ASSOC)):
+            /**
+             * parse the data into two-dimensional array
+             */
+            foreach($data as $key => $value):
+                $e = explode("__",$key);
+
+                if(count($e) > 1) {
+                    $data[$e[0]][$e[1]] = $value;
+                } else {
+                    $data[0][$e[0]] = $value;
+                }
+                unset($data[$key]);
+            endforeach;
+            $array[] = $data;
+        endwhile;
+        $stmt->closeCursor();
+        return $array;
+    }
+}
+?>

Doctrine/Validator.php

+<?php
+/**
+ * Doctrine_Validator
+ * Doctrine_Session uses this class for transaction validation
+ *
+ * @package     Doctrine ORM
+ * @url         www.phpdoctrine.com
+ * @license     LGPL
+ */
+class Doctrine_Validator {
+    /**
+     * ERROR CONSTANTS
+     */
+
+    /**
+     * constant for length validation error
+     */
+    const ERR_LENGTH    = 0;
+    /**
+     * constant for type validation error
+     */
+    const ERR_TYPE      = 1;
+    /**
+     * constant for general validation error
+     */
+    const ERR_VALID     = 2;
+    /**
+     * constant for unique validation error
+     */
+    const ERR_UNIQUE    = 3;
+    /**
+     * constant for blank validation error
+     */
+    const ERR_BLANK     = 4;
+    /**
+     * constant for date validation error
+     */
+    const ERR_DATE      = 5;
+    /**
+     * constant for null validation error
+     */
+    const ERR_NULL      = 6;
+    /**
+     * constant for enum validation error
+     */
+    const ERR_ENUM      = 7;
+    /**
+     * constant for range validation error
+     */
+    const ERR_RANGE     = 8;
+
+
+
+    
+    /**
+     * @var array $stack            error stack
+     */
+    private $stack      = array();
+    /**
+     * @var array $validators       an array of validator objects
+     */
+    private static $validators = array();
+    /**
+     * returns a validator object
+     *
+     * @param string $name
+     * @return Doctrine_Validator_Interface
+     */
+    public static function getValidator($name) {
+        if( ! isset(self::$validators[$name])) {
+            $class = "Doctrine_Validator_".ucwords(strtolower($name));
+            if(class_exists($class)) {
+                self::$validators[$name] = new $class;
+            } elseif(class_exists($name."Validator")) {
+                self::$validators[$name] = new $name."Validator";
+            } else 
+                throw new Doctrine_Exception("Validator named '$name' not availible.");
+        }
+        return self::$validators[$name];
+    }
+    /**
+     * validates a given record and saves possible errors
+     * in Doctrine_Validator::$stack
+     *
+     * @param Doctrine_Record $record
+     * @return void
+     */
+    public function validateRecord(Doctrine_Record $record) {
+        $modified = $record->getModified();
+        $columns  = $record->getTable()->getColumns();
+        $name     = $record->getTable()->getComponentName();
+
+        $err      = array();
+        foreach($modified as $key => $value) {
+            $column = $columns[$key];
+
+            if(strlen($value) > $column[1]) {
+                $err[$key] = Doctrine_Validator::ERR_LENGTH;
+                continue;
+            }
+
+            if(self::gettype($value) !== $column[0]) {
+                $err[$key] = Doctrine_Validator::ERR_TYPE;
+                continue;
+            }
+
+            $e = explode("|",$column[2]);
+
+            foreach($e as $k => $arg) {
+                if(empty($arg) || $arg == "primary" || $arg == "protected" || $arg == "autoincrement")
+                    continue;
+
+                $args = explode(":",$arg);
+                if( ! isset($args[1])) 
+                    $args[1] = '';
+
+                $validator = self::getValidator($args[0]);
+                if( ! $validator->validate($record, $key, $value, $args[1])) {
+                    switch(strtolower($args[0])):
+                        case "unique":
+                            $err[$key] = Doctrine_Validator::ERR_UNIQUE;
+                        break;
+                        case "notnull":
+                            $err[$key] = Doctrine_Validator::ERR_NULL;
+                        break;
+                        case "notblank":
+                            $err[$key] = Doctrine_Validator::ERR_BLANK;
+                        break;
+                        case "enum":
+                            $err[$key] = Doctrine_Validator::ERR_VALID;
+                        break;
+                        default:
+                            $err[$key] = Doctrine_Validator::ERR_VALID;
+                        break;
+                    endswitch;
+                }
+                
+                // errors found quit validation looping for this column
+                if(isset($err[$key]))
+                    break;
+            }
+        }
+
+        if( ! empty($err)) {
+            $this->stack[$name][] = $err;
+            return false;
+        }
+        
+        return true;
+    }
+    /**
+     * whether or not this validator has errors
+     *
+     * @return boolean
+     */
+    public function hasErrors() {
+        return (count($this->stack) > 0);
+    }
+    /**
+     * returns the error stack
+     *
+     * @return array
+     */
+    public function getErrorStack() {
+        return $this->stack;
+    }
+    /**
+     * returns the type of loosely typed variable
+     *
+     * @param mixed $var
+     * @return string
+     */
+    public static function gettype($var) {
+        $type = gettype($var);
+        switch($type):
+            case "string":
+                if(preg_match("/^[0-9]+$/",$var)) return "integer";
+                elseif(is_numeric($var)) return "float";
+                else return $type;
+            break;
+            default:
+            return $type;
+        endswitch;
+    }
+}
+?>