Return to dualiterator.inc CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / spl / examples

Annotation of embedaddon/php/ext/spl/examples/dualiterator.inc, revision 1.1

1.1     ! misho       1: <?php
        !             2: 
        !             3: /** @file dualiterator.inc
        !             4:  * @ingroup Examples
        !             5:  * @brief class DualIterator
        !             6:  * @author  Marcus Boerger
        !             7:  * @date    2003 - 2006
        !             8:  *
        !             9:  * SPL - Standard PHP Library
        !            10:  */
        !            11: 
        !            12: /** @ingroup Examples
        !            13:  * @brief   Synchronous iteration over two iterators
        !            14:  * @author  Marcus Boerger
        !            15:  * @version 1.3
        !            16:  */
        !            17: class DualIterator implements Iterator
        !            18: {
        !            19:        const CURRENT_LHS   = 0x01;
        !            20:        const CURRENT_RHS   = 0x02;
        !            21:        const CURRENT_ARRAY = 0x03;
        !            22:        const CURRENT_0     = 0x00;
        !            23: 
        !            24:        const KEY_LHS   = 0x10;
        !            25:        const KEY_RHS   = 0x20;
        !            26:        const KEY_0     = 0x00;
        !            27:        
        !            28:        const DEFAULT_FLAGS = 0x13;
        !            29:        
        !            30:        private $lhs;
        !            31:        private $rhs;
        !            32:        private $flags;
        !            33: 
        !            34:        /** construct iterator from two iterators
        !            35:         *
        !            36:         * @param lhs   Left  Hand Side Iterator
        !            37:         * @param rhs   Right Hand Side Iterator
        !            38:         * @param flags iteration flags
        !            39:         */
        !            40:        function __construct(Iterator $lhs, Iterator $rhs, 
        !            41:                                        $flags = 0x13 /*DualIterator::DEFAULT_FLAGS*/)
        !            42:        {
        !            43:                $this->lhs   = $lhs;
        !            44:                $this->rhs   = $rhs;
        !            45:                $this->flags = $flags;
        !            46:        }
        !            47: 
        !            48:        /** @return Left Hand Side Iterator
        !            49:         */
        !            50:        function getLHS()
        !            51:        {
        !            52:                return $this->lhs;
        !            53:        }
        !            54: 
        !            55:        /** @return Right Hand Side Iterator
        !            56:         */
        !            57:        function getRHS()
        !            58:        {
        !            59:                return $this->rhs;
        !            60:        }
        !            61: 
        !            62:        /** @param flags new flags
        !            63:         */
        !            64:        function setFlags($flags)
        !            65:        {
        !            66:                $this->flags = $flags;
        !            67:        }
        !            68: 
        !            69:        /** @return current flags
        !            70:         */
        !            71:        function getFlags()
        !            72:        {
        !            73:                return $this->flags;
        !            74:        }
        !            75: 
        !            76:        /** rewind both inner iterators
        !            77:         */     
        !            78:        function rewind()
        !            79:        {
        !            80:                $this->lhs->rewind();
        !            81:                $this->rhs->rewind();   
        !            82:        }
        !            83: 
        !            84:        /** @return whether both inner iterators are valid
        !            85:         */     
        !            86:        function valid()
        !            87:        {
        !            88:                return $this->lhs->valid() && $this->rhs->valid();      
        !            89:        }
        !            90: 
        !            91:        /** @return current value depending on CURRENT_* flags
        !            92:         */     
        !            93:        function current()
        !            94:        {
        !            95:                switch($this->flags & 0x0F)
        !            96:                {
        !            97:                default:
        !            98:                case self::CURRENT_ARRAY:
        !            99:                        return array($this->lhs->current(), $this->rhs->current());
        !           100:                case self::CURRENT_LHS:
        !           101:                        return $this->lhs->current();
        !           102:                case self::CURRENT_RHS:
        !           103:                        return $this->rhs->current();
        !           104:                case self::CURRENT_0:
        !           105:                        return NULL;
        !           106:                }
        !           107:        }
        !           108: 
        !           109:        /** @return key value depending on KEY_* flags
        !           110:         */     
        !           111:        function key()
        !           112:        {
        !           113:                switch($this->flags & 0xF0)
        !           114:                {
        !           115:                default:
        !           116:                case self::KEY_LHS:
        !           117:                        return $this->lhs->key();
        !           118:                case self::KEY_RHS:
        !           119:                        return $this->rhs->key();
        !           120:                case self::KEY_0:
        !           121:                        return NULL;
        !           122:                }
        !           123:        }
        !           124: 
        !           125:        /** move both inner iterators forward
        !           126:         */     
        !           127:        function next()
        !           128:        {
        !           129:                $this->lhs->next();
        !           130:                $this->rhs->next();
        !           131:        }
        !           132: 
        !           133:        /** @return whether both inner iterators are valid and have identical 
        !           134:         * current and key values or both are non valid.
        !           135:         */
        !           136:        function areIdentical()
        !           137:        {
        !           138:                return $this->valid()
        !           139:                     ? $this->lhs->current() === $this->rhs->current()
        !           140:                        && $this->lhs->key()     === $this->rhs->key()
        !           141:                         : $this->lhs->valid()   ==  $this->rhs->valid();
        !           142:        }
        !           143: 
        !           144:        /** @return whether both inner iterators are valid and have equal current 
        !           145:         * and key values or both are non valid.
        !           146:         */
        !           147:        function areEqual()
        !           148:        {
        !           149:                return $this->valid()
        !           150:                     ? $this->lhs->current() ==  $this->rhs->current()
        !           151:                        && $this->lhs->key()     ==  $this->rhs->key()
        !           152:                         : $this->lhs->valid()   ==  $this->rhs->valid();
        !           153:        }
        !           154: 
        !           155:        /** Compare two iterators
        !           156:         *
        !           157:         * @param lhs   Left  Hand Side Iterator
        !           158:         * @param rhs   Right Hand Side Iterator
        !           159:         * @param identical whether to use areEqual() or areIdentical()
        !           160:         * @return whether both iterators are equal/identical
        !           161:         *
        !           162:         * @note If one implements RecursiveIterator the other must do as well.
        !           163:         *       And if both do then a recursive comparison is being used.
        !           164:         */
        !           165:        static function compareIterators(Iterator $lhs, Iterator $rhs, 
        !           166:                                         $identical = false)
        !           167:        {
        !           168:                if ($lhs instanceof RecursiveIterator)
        !           169:                {
        !           170:                        if ($rhs instanceof RecursiveIterator)
        !           171:                        {
        !           172:                                $it = new RecursiveDualIterator($lhs, $rhs, 
        !           173:                                                                self::CURRENT_0 | self::KEY_0);
        !           174:                                $it = new RecursiveCompareDualIterator($it);
        !           175:                        }
        !           176:                        else
        !           177:                        {
        !           178:                                return false;
        !           179:                        }
        !           180:                }
        !           181:                else
        !           182:                {
        !           183:                        $it = new DualIterator($lhs, $rhs, self::CURRENT_0 | self::KEY_0);
        !           184:                }
        !           185: 
        !           186:                if ($identical)
        !           187:                {
        !           188:                        foreach($it as $n)
        !           189:                        {
        !           190:                                if (!$it->areIdentical())
        !           191:                                {
        !           192:                                        return false;
        !           193:                                }
        !           194:                        }
        !           195:                }
        !           196:                else
        !           197:                {
        !           198:                        foreach($it as $n)
        !           199:                        {
        !           200:                                if (!$it->areEqual())
        !           201:                                {
        !           202:                                        return false;
        !           203:                                }
        !           204:                        }
        !           205:                }
        !           206:                return $identical ? $it->areIdentical() : $it->areEqual();
        !           207:        }
        !           208: }
        !           209: 
        !           210: ?>