Subversion-Projekte lars-tiefland.prado

Revision

Details | Letzte Änderung | Log anzeigen | RSS feed

Revision Autor Zeilennr. Zeile
1 lars 1 
<?php
2 
/**
3 
 * TStack, TStackIterator classes
4 
 *
5 
 * @author Qiang Xue <qiang.xue@gmail.com>
6 
 * @link http://www.pradosoft.com/
7 
 * @copyright Copyright &copy; 2005-2008 PradoSoft
8 
 * @license http://www.pradosoft.com/license/
9 
 * @version $Id: TStack.php 2541 2008-10-21 15:05:13Z qiang.xue $
10 
 * @package System.Collections
11 
 */
12 
 
13 
/**
14 
 * TStack class
15 
 *
16 
 * TStack implements a stack.
17 
 *
18 
 * The typical stack operations are implemented, which include
19 
 * {@link push()}, {@link pop()} and {@link peek()}. In addition,
20 
 * {@link contains()} can be used to check if an item is contained
21 
 * in the stack. To obtain the number of the items in the stack,
22 
 * check the {@link getCount Count} property.
23 
 *
24 
 * Items in the stack may be traversed using foreach as follows,
25 
 * <code>
26 
 * foreach($stack as $item) ...
27 
 * </code>
28 
 *
29 
 * @author Qiang Xue <qiang.xue@gmail.com>
30 
 * @version $Id: TStack.php 2541 2008-10-21 15:05:13Z qiang.xue $
31 
 * @package System.Collections
32 
 * @since 3.0
33 
 */
34 
class TStack extends TComponent implements IteratorAggregate,Countable
35 
{
36 
	/**
37 
	 * internal data storage
38 
	 * @var array
39 
	 */
40 
	private $_d=array();
41 
	/**
42 
	 * number of items
43 
	 * @var integer
44 
	 */
45 
	private $_c=0;
46 
 
47 
	/**
48 
	 * Constructor.
49 
	 * Initializes the stack with an array or an iterable object.
50 
	 * @param array|Iterator the initial data. Default is null, meaning no initialization.
51 
	 * @throws TInvalidDataTypeException If data is not null and neither an array nor an iterator.
52 
	 */
53 
	public function __construct($data=null)
54 
	{
55 
		if($data!==null)
56 
			$this->copyFrom($data);
57 
	}
58 
 
59 
	/**
60 
	 * @return array the list of items in stack
61 
	 */
62 
	public function toArray()
63 
	{
64 
		return $this->_d;
65 
	}
66 
 
67 
	/**
68 
	 * Copies iterable data into the stack.
69 
	 * Note, existing data in the list will be cleared first.
70 
	 * @param mixed the data to be copied from, must be an array or object implementing Traversable
71 
	 * @throws TInvalidDataTypeException If data is neither an array nor a Traversable.
72 
	 */
73 
	public function copyFrom($data)
74 
	{
75 
		if(is_array($data) || ($data instanceof Traversable))
76 
		{
77 
			$this->clear();
78 
			foreach($data as $item)
79 
			{
80 
				$this->_d[]=$item;
81 
				++$this->_c;
82 
			}
83 
		}
84 
		else if($data!==null)
85 
			throw new TInvalidDataTypeException('stack_data_not_iterable');
86 
	}
87 
 
88 
	/**
89 
	 * Removes all items in the stack.
90 
	 */
91 
	public function clear()
92 
	{
93 
		$this->_c=0;
94 
		$this->_d=array();
95 
	}
96 
 
97 
	/**
98 
	 * @param mixed the item
99 
	 * @return boolean whether the stack contains the item
100 
	 */
101 
	public function contains($item)
102 
	{
103 
		return array_search($item,$this->_d,true)!==false;
104 
	}
105 
 
106 
	/**
107 
	 * Returns the item at the top of the stack.
108 
	 * Unlike {@link pop()}, this method does not remove the item from the stack.
109 
	 * @return mixed item at the top of the stack
110 
	 * @throws TInvalidOperationException if the stack is empty
111 
	 */
112 
	public function peek()
113 
	{
114 
		if($this->_c===0)
115 
			throw new TInvalidOperationException('stack_empty');
116 
		else
117 
			return $this->_d[$this->_c-1];
118 
	}
119 
 
120 
	/**
121 
	 * Pops up the item at the top of the stack.
122 
	 * @return mixed the item at the top of the stack
123 
	 * @throws TInvalidOperationException if the stack is empty
124 
	 */
125 
	public function pop()
126 
	{
127 
		if($this->_c===0)
128 
			throw new TInvalidOperationException('stack_empty');
129 
		else
130 
		{
131 
			--$this->_c;
132 
			return array_pop($this->_d);
133 
		}
134 
	}
135 
 
136 
	/**
137 
	 * Pushes an item into the stack.
138 
	 * @param mixed the item to be pushed into the stack
139 
	 */
140 
	public function push($item)
141 
	{
142 
		++$this->_c;
143 
		array_push($this->_d,$item);
144 
	}
145 
 
146 
	/**
147 
	 * Returns an iterator for traversing the items in the stack.
148 
	 * This method is required by the interface IteratorAggregate.
149 
	 * @return Iterator an iterator for traversing the items in the stack.
150 
	 */
151 
	public function getIterator()
152 
	{
153 
		return new TStackIterator($this->_d);
154 
	}
155 
 
156 
	/**
157 
	 * @return integer the number of items in the stack
158 
	 */
159 
	public function getCount()
160 
	{
161 
		return $this->_c;
162 
	}
163 
 
164 
	/**
165 
	 * Returns the number of items in the stack.
166 
	 * This method is required by Countable interface.
167 
	 * @return integer number of items in the stack.
168 
	 */
169 
	public function count()
170 
	{
171 
		return $this->getCount();
172 
	}
173 
}
174 
 
175 
/**
176 
 * TStackIterator class
177 
 *
178 
 * TStackIterator implements Iterator interface.
179 
 *
180 
 * TStackIterator is used by TStack. It allows TStack to return a new iterator
181 
 * for traversing the items in the list.
182 
 *
183 
 * @author Qiang Xue <qiang.xue@gmail.com>
184 
 * @version $Id: TStack.php 2541 2008-10-21 15:05:13Z qiang.xue $
185 
 * @package System.Collections
186 
 * @since 3.0
187 
 */
188 
class TStackIterator implements Iterator
189 
{
190 
	/**
191 
	 * @var array the data to be iterated through
192 
	 */
193 
	private $_d;
194 
	/**
195 
	 * @var integer index of the current item
196 
	 */
197 
	private $_i;
198 
	/**
199 
	 * @var integer count of the data items
200 
	 */
201 
	private $_c;
202 
 
203 
	/**
204 
	 * Constructor.
205 
	 * @param array the data to be iterated through
206 
	 */
207 
	public function __construct(&$data)
208 
	{
209 
		$this->_d=&$data;
210 
		$this->_i=0;
211 
		$this->_c=count($this->_d);
212 
	}
213 
 
214 
	/**
215 
	 * Rewinds internal array pointer.
216 
	 * This method is required by the interface Iterator.
217 
	 */
218 
	public function rewind()
219 
	{
220 
		$this->_i=0;
221 
	}
222 
 
223 
	/**
224 
	 * Returns the key of the current array item.
225 
	 * This method is required by the interface Iterator.
226 
	 * @return integer the key of the current array item
227 
	 */
228 
	public function key()
229 
	{
230 
		return $this->_i;
231 
	}
232 
 
233 
	/**
234 
	 * Returns the current array item.
235 
	 * This method is required by the interface Iterator.
236 
	 * @return mixed the current array item
237 
	 */
238 
	public function current()
239 
	{
240 
		return $this->_d[$this->_i];
241 
	}
242 
 
243 
	/**
244 
	 * Moves the internal pointer to the next array item.
245 
	 * This method is required by the interface Iterator.
246 
	 */
247 
	public function next()
248 
	{
249 
		$this->_i++;
250 
	}
251 
 
252 
	/**
253 
	 * Returns whether there is an item at current position.
254 
	 * This method is required by the interface Iterator.
255 
	 * @return boolean
256 
	 */
257 
	public function valid()
258 
	{
259 
		return $this->_i<$this->_c;
260 
	}
261 
}
262