--no commit message

--no commit message

lib/Doctrine/ORM/Mapping/ManyToManyMapping.php

+<?php
+
+#namespace Doctrine::ORM::Mapping;
+
+/**
+ * A many-to-many mapping describes the mapping between two collections of
+ * entities.
+ *
+ * @since 2.0
+ * @todo Rename to ManyToManyMapping
+ */
+class Doctrine_ORM_Mapping_ManyToManyMapping extends Doctrine_ORM_Mapping_AssociationMapping
+{    
+    /**
+     * The name of the association class (if an association class is used).
+     *
+     * @var string
+     */
+    private $_associationClass;
+    
+    /** The field in the source table that corresponds to the key in the relation table */
+    protected $_sourceKeyColumns;
+
+    /**  The field in the target table that corresponds to the key in the relation table */
+    protected $_targetKeyColumns;
+
+    /** The field in the intermediate table that corresponds to the key in the source table */
+    protected $_sourceRelationKeyColumns;
+
+    /** The field in the intermediate table that corresponds to the key in the target table */
+    protected $_targetRelationKeyColumns;
+    
+    /**
+     * Constructor.
+     * Creates a new ManyToManyMapping.
+     *
+     * @param array $mapping  The mapping info.
+     */
+    public function __construct(array $mapping)
+    {
+        parent::__construct($mapping);
+    }
+    
+    /**
+     * Validates and completes the mapping.
+     *
+     * @param array $mapping
+     * @override
+     */
+    protected function _validateAndCompleteMapping(array $mapping)
+    {
+        parent::_validateAndCompleteMapping($mapping);
+        
+        if ($this->isOwningSide()) {
+            // many-many owning MUST have a join table
+            if ( ! isset($mapping['joinTable'])) {
+                throw Doctrine_MappingException::joinTableRequired($mapping['fieldName']);
+            }
+        
+            // optional attributes for many-many owning side
+            $this->_associationClass = isset($mapping['associationClass']) ?
+                    $mapping['associationClass'] : null;
+        }
+    }
+    
+    /**
+     * Whether the mapping uses an association class for the intermediary
+     * table.
+     *
+     * @return boolean
+     */
+    public function usesAssociationClass()
+    {
+        return $this->_associationClass !== null;
+    }
+    
+    /**
+     * Gets the name of the association class.
+     *
+     * @return string
+     */
+    public function getAssociationClassName()
+    {
+        return $this->_associationClass;
+    }
+}
+
+?>
\ No newline at end of file

lib/Doctrine/ORM/Mapping/OneToManyMapping.php

+<?php
+/*
+ *  $Id$
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.phpdoctrine.org>.
+ */
+
+#namespace Doctrine::ORM::Mapping;
+
+/**
+ * Represents a one-to-many mapping.
+ * 
+ * NOTE: One-to-many mappings can currently not be uni-directional (one -> many).
+ * They must either be bidirectional (one <-> many) or unidirectional (many -> one).
+ * In other words, the many-side MUST be the owning side and the one-side MUST be
+ * the inverse side.
+ *
+ * @author Roman Borschel <roman@code-factory.org>
+ * @since 2.0
+ * @todo Rename to OneToManyMapping
+ */
+class Doctrine_ORM_Mapping_OneToManyMapping extends Doctrine_ORM_Mapping_AssociationMapping
+{
+    /** The target foreign key columns that reference the sourceKeyColumns. */
+    /* NOTE: Currently not used because uni-directional one-many not supported atm.  */
+    //protected $_targetForeignKeyColumns;
+
+    /** The (typically primary) source key columns that are referenced by the targetForeignKeyColumns. */
+    /* NOTE: Currently not used because uni-directional one-many not supported atm.  */
+    //protected $_sourceKeyColumns;
+
+    /** This maps the target foreign key columns to the corresponding (primary) source key columns. */
+    /* NOTE: Currently not used because uni-directional one-many not supported atm.  */
+    //protected $_targetForeignKeysToSourceKeys;
+    
+    /** This maps the (primary) source key columns to the corresponding target foreign key columns. */
+    /* NOTE: Currently not used because uni-directional one-many not supported atm.  */
+    //protected $_sourceKeysToTargetForeignKeys;
+    
+    /** Whether to delete orphaned elements (removed from the collection) */
+    protected $_deleteOrphans = false;
+    
+    /**
+     * Constructor.
+     * Creates a new OneToManyMapping.
+     *
+     * @param array $mapping  The mapping info.
+     */
+    public function __construct(array $mapping)
+    {
+        parent::__construct($mapping);
+    }
+    
+    /**
+     * Validates and completed the mapping.
+     *
+     * @param array $mapping The mapping to validate and complete.
+     * @return array The validated and completed mapping.
+     * @override
+     */
+    protected function _validateAndCompleteMapping(array $mapping)
+    {
+        parent::_validateAndCompleteMapping($mapping);
+        
+        // one-side MUST be inverse (must have mappedBy)
+        if ( ! isset($mapping['mappedBy'])) {
+            throw Doctrine_MappingException::oneToManyRequiresMappedBy($mapping['fieldName']);
+        }
+        
+        $this->_deleteOrphans = isset($mapping['deleteOrphans']) ?
+                (bool)$mapping['deleteOrphans'] : false;
+    }
+    
+    /**
+     * Whether orphaned elements (removed from the collection) should be deleted.
+     *
+     * @return boolean TRUE if orphaned elements should be deleted, FALSE otherwise.
+     */
+    public function shouldDeleteOrphans()
+    {
+        return $this->_deleteOrphans;
+    }
+    
+    /**
+     * Whether the association is one-to-many.
+     *
+     * @return boolean TRUE if the association is one-to-many, FALSE otherwise.
+     * @override
+     */
+    public function isOneToMany()
+    {
+        return true;
+    }
+    
+    
+}
+
+?>
\ No newline at end of file

lib/Doctrine/ORM/Mapping/OneToOneMapping.php

+<?php
+/*
+ *  $Id$
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.phpdoctrine.org>.
+ */
+
+#namespace Doctrine::ORM::Mappings;
+
+#use Doctrine::ORM::Entity;
+
+/**
+ * A one-to-one mapping describes a uni-directional mapping from one entity 
+ * to another entity.
+ *
+ * @since 2.0
+ * @author Roman Borschel <roman@code-factory.org>
+ * @todo Rename to OneToOneMapping
+ */
+class Doctrine_ORM_Mapping_OneToOneMapping extends Doctrine_ORM_Mapping_AssociationMapping
+{
+    /**
+     * Maps the source foreign/primary key columns to the target primary/foreign key columns.
+     * i.e. source.id (pk) => target.user_id (fk).
+     * Reverse mapping of _targetToSourceKeyColumns.
+     */
+    protected $_sourceToTargetKeyColumns = array();
+
+    /**
+     * Maps the target primary/foreign key columns to the source foreign/primary key columns.
+     * i.e. target.user_id (fk) => source.id (pk).
+     * Reverse mapping of _sourceToTargetKeyColumns.
+     */
+    protected $_targetToSourceKeyColumns = array();
+    
+    /**
+     * Whether to delete orphaned elements (when nulled out, i.e. $foo->other = null)
+     * 
+     * @var boolean
+     */
+    protected $_deleteOrphans = false;
+    
+    /**
+     * Constructor.
+     * Creates a new OneToOneMapping.
+     *
+     * @param array $mapping  The mapping info.
+     */
+    public function __construct(array $mapping)
+    {
+        parent::__construct($mapping);
+    }
+    
+    protected function _initMappingArray()
+    {
+        parent::_initMappingArray();
+        $this->_mapping['deleteOrphans'] = false;
+    }
+    
+    /**
+     * Validates & completes the mapping. Mapping defaults are applied here.
+     *
+     * @param array $mapping  The mapping to validate & complete.
+     * @return array  The validated & completed mapping.
+     * @override
+     */
+    protected function _validateAndCompleteMapping(array $mapping)
+    {
+        parent::_validateAndCompleteMapping($mapping);
+        
+        if ($this->isOwningSide()) {
+            if ( ! isset($mapping['joinColumns'])) {
+                throw Doctrine_MappingException::invalidMapping($this->_sourceFieldName);
+            }
+            $this->_sourceToTargetKeyColumns = $mapping['joinColumns'];
+            $this->_targetToSourceKeyColumns = array_flip($this->_sourceToTargetKeyColumns);
+        }
+        
+        $this->_deleteOrphans = isset($mapping['deleteOrphans']) ?
+                (bool)$mapping['deleteOrphans'] : false;
+        
+        return $mapping;
+    }
+    
+    /**
+     * Gets the source-to-target key column mapping.
+     *
+     * @return unknown
+     */
+    public function getSourceToTargetKeyColumns()
+    {
+        return $this->_sourceToTargetKeyColumns;
+    }
+    
+    /**
+     * Gets the target-to-source key column mapping.
+     *
+     * @return unknown
+     */
+    public function getTargetToSourceKeyColumns()
+    {
+        return $this->_targetToSourceKeyColumns;
+    }
+    
+    /**
+     * Whether the association is one-to-one.
+     *
+     * @return boolean
+     * @override
+     */
+    public function isOneToOne()
+    {
+        return true;
+    }
+    
+    /**
+     * Lazy-loads the associated entity for a given entity.
+     *
+     * @param Doctrine::ORM::Entity $entity
+     * @return void
+     */
+    public function lazyLoadFor(Doctrine_Entity $entity)
+    {
+        if ($entity->getClassName() != $this->_sourceClass->getClassName()) {
+            //error?
+        }
+        
+        $dql = 'SELECT t.* FROM ' . $this->_targetClass->getClassName() . ' t WHERE ';
+        $params = array();
+        foreach ($this->_sourceToTargetKeyFields as $sourceKeyField => $targetKeyField) {
+            if ($params) {
+                $dql .= " AND ";
+            }
+            $dql .= "t.$targetKeyField = ?";
+            $params[] = $entity->_rawGetField($sourceKeyField);
+        }
+        
+        $otherEntity = $this->_targetClass->getEntityManager()
+                ->query($dql, $params)
+                ->getFirst();
+            
+        if ( ! $otherEntity) {
+            $otherEntity = Doctrine_Null::$INSTANCE;
+        }
+        $entity->_internalSetReference($this->_sourceFieldName, $otherEntity);
+    }
+    
+}
+
+?>
\ No newline at end of file