<?php /** * TStack, TStackIterator classes * * @author Qiang Xue <qiang.xue@gmail.com> * @link http://www.pradosoft.com/ * @copyright Copyright © 2005-2010 PradoSoft * @license http://www.pradosoft.com/license/ * @version $Id$ * @package System.Collections */ /** * TStack class * * TStack implements a stack. * * The typical stack operations are implemented, which include * {@link push()}, {@link pop()} and {@link peek()}. In addition, * {@link contains()} can be used to check if an item is contained * in the stack. To obtain the number of the items in the stack, * check the {@link getCount Count} property. * * Items in the stack may be traversed using foreach as follows, * <code> * foreach($stack as $item) ... * </code> * * @author Qiang Xue <qiang.xue@gmail.com> * @version $Id$ * @package System.Collections * @since 3.0 */ class TStack extends TComponent implements IteratorAggregate,Countable { /** * internal data storage * @var array */ private $_d=array(); /** * number of items * @var integer */ private $_c=0; /** * Constructor. * Initializes the stack with an array or an iterable object. * @param array|Iterator the initial data. Default is null, meaning no initialization. * @throws TInvalidDataTypeException If data is not null and neither an array nor an iterator. */ public function __construct($data=null) { parent::__construct(); if($data!==null) $this->copyFrom($data); } /** * @return array the list of items in stack */ public function toArray() { return $this->_d; } /** * Copies iterable data into the stack. * Note, existing data in the list will be cleared first. * @param mixed the data to be copied from, must be an array or object implementing Traversable * @throws TInvalidDataTypeException If data is neither an array nor a Traversable. */ public function copyFrom($data) { if(is_array($data) || ($data instanceof Traversable)) { $this->clear(); foreach($data as $item) { $this->_d[]=$item; ++$this->_c; } } else if($data!==null) throw new TInvalidDataTypeException('stack_data_not_iterable'); } /** * Removes all items in the stack. */ public function clear() { $this->_c=0; $this->_d=array(); } /** * @param mixed the item * @return boolean whether the stack contains the item */ public function contains($item) { return array_search($item,$this->_d,true)!==false; } /** * Returns the item at the top of the stack. * Unlike {@link pop()}, this method does not remove the item from the stack. * @return mixed item at the top of the stack * @throws TInvalidOperationException if the stack is empty */ public function peek() { if($this->_c===0) throw new TInvalidOperationException('stack_empty'); else return $this->_d[$this->_c-1]; } /** * Pops up the item at the top of the stack. * @return mixed the item at the top of the stack * @throws TInvalidOperationException if the stack is empty */ public function pop() { if($this->_c===0) throw new TInvalidOperationException('stack_empty'); else { --$this->_c; return array_pop($this->_d); } } /** * Pushes an item into the stack. * @param mixed the item to be pushed into the stack */ public function push($item) { ++$this->_c; $this->_d[] = $item; } /** * Returns an iterator for traversing the items in the stack. * This method is required by the interface IteratorAggregate. * @return Iterator an iterator for traversing the items in the stack. */ public function getIterator() { return new ArrayIterator( $this->_d ); } /** * @return integer the number of items in the stack */ public function getCount() { return $this->_c; } /** * Returns the number of items in the stack. * This method is required by Countable interface. * @return integer number of items in the stack. */ public function count() { return $this->getCount(); } } /** * TStackIterator class * * TStackIterator implements Iterator interface. * * TStackIterator is used by TStack. It allows TStack to return a new iterator * for traversing the items in the list. * * @deprecated Issue 264 : ArrayIterator should be used instead * @author Qiang Xue <qiang.xue@gmail.com> * @version $Id$ * @package System.Collections * @since 3.0 */ class TStackIterator implements Iterator { /** * @var array the data to be iterated through */ private $_d; /** * @var integer index of the current item */ private $_i; /** * @var integer count of the data items */ private $_c; /** * Constructor. * @param array the data to be iterated through */ public function __construct(&$data) { $this->_d=&$data; $this->_i=0; $this->_c=count($this->_d); } /** * Rewinds internal array pointer. * This method is required by the interface Iterator. */ public function rewind() { $this->_i=0; } /** * Returns the key of the current array item. * This method is required by the interface Iterator. * @return integer the key of the current array item */ public function key() { return $this->_i; } /** * Returns the current array item. * This method is required by the interface Iterator. * @return mixed the current array item */ public function current() { return $this->_d[$this->_i]; } /** * Moves the internal pointer to the next array item. * This method is required by the interface Iterator. */ public function next() { $this->_i++; } /** * Returns whether there is an item at current position. * This method is required by the interface Iterator. * @return boolean */ public function valid() { return $this->_i<$this->_c; } }