Return to filteriterator.inc CVS log

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

Annotation of embedaddon/php/ext/spl/internal/filteriterator.inc, revision 1.1.1.1

1.1       misho       1: <?php
                      2: 
                      3: /** @file filteriterator.inc
                      4:  * @ingroup SPL
                      5:  * @brief class FilterIterator
                      6:  * @author  Marcus Boerger
                      7:  * @date    2003 - 2009
                      8:  *
                      9:  * SPL - Standard PHP Library
                     10:  */
                     11: 
                     12: /**
                     13:  * @brief   Abstract filter for iterators
                     14:  * @author  Marcus Boerger
                     15:  * @version 1.1
                     16:  * @since PHP 5.0
                     17:  *
                     18:  * Instances of this class act as a filter around iterators. In other words 
                     19:  * you can put an iterator into the constructor and the instance will only 
                     20:  * return selected (accepted) elements.
                     21:  *
                     22:  * The only thing that needs to be done to make this work is implementing 
                     23:  * method accept(). Typically this invloves reading the current element or 
                     24:  * key of the inner Iterator and checking whether it is acceptable.
                     25:  */
                     26: abstract class FilterIterator implements OuterIterator
                     27: {
                     28:        private $it;
                     29: 
                     30:        /**
                     31:         * Constructs a filter around another iterator.
                     32:         *
                     33:         * @param it     Iterator to filter
                     34:         */
                     35:        function __construct(Iterator $it) {
                     36:                $this->it = $it;
                     37:        }
                     38: 
                     39:        /**
                     40:         * Rewind the inner iterator.
                     41:         */
                     42:        function rewind() {     
                     43:                $this->it->rewind();
                     44:                $this->fetch();
                     45:        }
                     46: 
                     47:        /**
                     48:         * Accept function to decide whether an element of the inner iterator
                     49:         * should be accessible through the Filteriterator.
                     50:         *
                     51:         * @return whether or not to expose the current element of the inner
                     52:         *         iterator.
                     53:         */
                     54:        abstract function accept();
                     55: 
                     56:        /**
                     57:         * Fetch next element and store it.
                     58:         *
                     59:         * @return void
                     60:         */
                     61:        protected function fetch() {
                     62:                while ($this->it->valid()) {
                     63:                        if ($this->accept()) {
                     64:                                return;
                     65:                        }
                     66:                        $this->it->next();
                     67:                };
                     68:        }
                     69: 
                     70:        /**
                     71:         * Move to next element
                     72:         *
                     73:         * @return void
                     74:         */
                     75:        function next() {
                     76:                $this->it->next();
                     77:                $this->fetch();
                     78:        }
                     79:        
                     80:        /**
                     81:         * @return Whether more elements are available
                     82:         */
                     83:        function valid() {
                     84:                return $this->it->valid();
                     85:        }
                     86:        
                     87:        /**
                     88:         * @return The current key
                     89:         */
                     90:        function key() {
                     91:                return $this->it->key();
                     92:        }
                     93:        
                     94:        /**
                     95:         * @return The current value
                     96:         */
                     97:        function current() {
                     98:                return $this->it->current();
                     99:        }
                    100:        
                    101:        /**
                    102:         * hidden __clone
                    103:         */
                    104:        protected function __clone() {
                    105:                // disallow clone 
                    106:        }
                    107: 
                    108:        /**
                    109:         * @return The inner iterator
                    110:         */     
                    111:        function getInnerIterator()
                    112:        {
                    113:                return $this->it;
                    114:        }
                    115: 
                    116:        /** Aggregate the inner iterator
                    117:         *
                    118:         * @param func    Name of method to invoke
                    119:         * @param params  Array of parameters to pass to method
                    120:         */
                    121:        function __call($func, $params)
                    122:        {
                    123:                return call_user_func_array(array($this->it, $func), $params);
                    124:        }
                    125: }
                    126: 
                    127: ?>