FilesExpand file tree

 immutable-date

/

iteratoriterator.inc

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

121 lines (110 loc) · 2.93 KB

 immutable-date

/

iteratoriterator.inc

Copy path

Top

File metadata and controls

• Code
• Blame

121 lines (110 loc) · 2.93 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

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 erros.

*

* 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;

}

?>