1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
|
<?php
/** @file iteratoriterator.inc
* @ingroup SPL
* @brief class IteratorIterator
* @author Marcus Boerger
* @date 2003 - 2009
*
* SPL - Standard PHP Library
*/
/** @ingroup SPL
* @brief Basic Iterator wrapper
* @since PHP 5.1
*
* This iterator wrapper allows to convert anything that is traversable into
* an Iterator. It is very important to understand that most classes that do
* not implement Iterator have their reasone to. Most likely they do not allow
* the full Iterator feature set. If so you need to provide techniques to
* prevent missuse. If you do not you must expect exceptions or fatal errors.
*
* It is also possible to derive the class and implement IteratorAggregate by
* downcasting the instances returned in getIterator. See the following
* example (assuming BaseClass implements Traversable):
\code
class SomeClass extends BaseClass implements IteratorAggregate
{
function getIterator()
{
return new IteratorIterator($this, 'BaseClass');
}
}
\endcode
*
* As you can see in the example this approach requires that the class to
* downcast to is actually a base class of the specified iterator to wrap.
* Omitting the downcast in the above example would result in an endless loop
* since IteratorIterator::__construct() would call SomeClass::getIterator().
*/
class IteratorIterator implements OuterIterator
{
/** Construct an IteratorIterator from an Iterator or an IteratorAggregate.
*
* @param iterator inner iterator
* @param classname optional class the iterator has to be downcasted to
*/
function __construct(Traversable $iterator, $classname = null)
{
if ($iterator instanceof IteratorAggregate)
{
$iterator = $iterator->getIterator();
}
if ($iterator instanceof Iterator)
{
$this->iterator = $iterator;
}
else
{
throw new Exception("Classes that only implement Traversable can be wrapped only after converting class IteratorIterator into c code");
}
}
/** \return the inner iterator as passed to the constructor
*/
function getInnerIterator()
{
return $this->iterator;
}
/** \return whether the iterator is valid
*/
function valid()
{
return $this->iterator->valid();
}
/** \return current key
*/
function key()
{
return $this->iterator->key();
}
/** \return current value
*/
function current()
{
return $this->iterator->current();
}
/** forward to next element
*/
function next()
{
return $this->iterator->next();
}
/** rewind to the first element
*/
function rewind()
{
return $this->iterator->rewind();
}
/** Aggregate the inner iterator
*
* @param func Name of method to invoke
* @param params Array of parameters to pass to method
*/
function __call($func, $params)
{
return call_user_func_array(array($this->iterator, $func), $params);
}
/** The inner iterator must be private because when this class will be
* converted to c code it won't no longer be available.
*/
private $iterator;
}
?>
|
