- Update docu

Author: helly25

ext/spl/internal/cachingiterator.inc

@@ -1,8 +1,23 @@
 <?php
 
+/** @file cachingiterator.inc
+ * @ingroup Internal
+ * @brief class CachingIterator
+ * @author  Marcus Boerger
+ * @date    2003 - 2004
+ *
+ * SPL - Standard PHP Library
+ */
+
 define('CIT_CALL_TOSTRING', 1);
 define('CIT_CATCH_GET_CHILD', 2);
 
+/**
+ * @brief   Cached Iteration over another Iterator
+ * @author  Marcus Boerger
+ * @version 1.1
+ *
+ */
 class CachingIterator implements OuterIterator
 {
 	protected $it;
@@ -11,19 +26,29 @@ class CachingIterator implements OuterIterator
 	protected $valid;
 	protected $strValue;
 
+	/** Construct from another iterator
+	 *
+	 * @param it    Iterator to cache
+	 * @param flags Bitmask: 
+	 *              - CIT_CALL_TOSTRING  (whether to call __toString() for every element)
+	 */
 	function __construct(Iterator $it, $flags = CIT_CALL_TOSTRING)
 	{
 		$this->it = $it;
 		$this->flags = $flags & (CIT_CALL_TOSTRING|CIT_CATCH_GET_CHILD);
 		$this->next();
 	}
 
+	/** Rewind the Iterator
+	 */
 	function rewind()
 	{
 		$this->it->rewind();
 		$this->next();
 	}
 
+	/** Forward to the next element
+	 */
 	function next()
 	{
 		if ($this->valid = $this->it->valid()) {
@@ -44,31 +69,45 @@ class CachingIterator implements OuterIterator
 		$this->it->next();
 	}
 
+	/** @return whether teh iterator is valid
+	 */
 	function valid()
 	{
 		return $this->valid;
 	}
 
+	/** @return whether there is one more element
+	 */
 	function hasNext()
 	{
 		return $this->it->valid();
 	}
 
+	/** @return the current element
+	 */
 	function current()
 	{
 		return $this->current;
 	}
 
+	/** @return the current key
+	 */
 	function key()
 	{
 		return $this->key;
 	}
 
+	/** Aggregate the inner iterator
+	 */
 	function __call($func, $params)
 	{
 		return call_user_func_array(array($this->it, $func), $params);
 	}
 
+	/** @return the string represenatation that was generated for the current 
+	 *          element
+	 * @throw exception when CIT_CALL_TOSTRING was not specified in constructor
+	 */
 	function __toString()
 	{
 		if (!$this->flags & CIT_CALL_TOSTRING) {
@@ -77,6 +116,9 @@ class CachingIterator implements OuterIterator
 		return $this->strValue;
 	}
 
+	/**
+	 * @return The inner iterator
+	 */	
 	function getInnerIterator()
 	{
 		return $this->it;

ext/spl/internal/cachingrecursiveiterator.inc

@@ -1,22 +1,48 @@
 <?php
 
+/** @file cachingrecursiveiterator.inc
+ * @ingroup Internal
+ * @brief class CachingRecursiveIterator
+ * @author  Marcus Boerger
+ * @date    2003 - 2004
+ *
+ * SPL - Standard PHP Library
+ */
+
+/**
+ * @brief   
+ * @author  Marcus Boerger
+ * @version 1.1
+ */
 class CachingRecursiveIterator extends CachingIterator implements RecursiveIterator
 {
 	protected $hasChildren;
 	protected $getChildren;
 
+	/** Construct from another iterator
+	 *
+	 * @param it    Iterator to cache
+	 * @param flags Bitmask: 
+	 *              - CIT_CALL_TOSTRING   (whether to call __toString() for every element)
+	 *              - CIT_CATCH_GET_CHILD (whether to catch exceptions when trying to get childs)
+	 */
 	function __construct(RecursiveIterator $it, $flags = CIT_CALL_TOSTRING)
 	{
 		parent::__construct($it, $flags);
 	}
-	
+
+	/** Rewind Iterator
+	 */	
 	function rewind();
 	{
 	   $this->hasChildren = false;
 	   $this->getChildren = NULL;
 	   parent::rewind();
 	}
 
+	/** Forward to next element if necessary then an Iterator for the Children
+	 * will be created.
+	 */
 	function next()
 	{
 		if ($this->hasChildren = $this->it->hasChildren()) {
@@ -39,11 +65,19 @@ class CachingRecursiveIterator extends CachingIterator implements RecursiveItera
 		parent::next();
 	}
 
+	/** @return whether the current element has children
+	 * @note The check whether the Iterator for the children can be created was
+	 *       already executed. Hence when flag CIT_CATCH_GET_CHILD was given in
+	 *       constructor this fucntion returns false so that getChildren does 
+	 *       not try to access those children.
+	 */
 	function hasChildren()
 	{
 		return $this->hasChildren;
 	}
 
+	/** @return An Iterator for the children
+	 */
 	function getChildren()
 	{
 		return $this->getChildren;

ext/spl/internal/filteriterator.inc

@@ -1,9 +1,18 @@
 <?php
 
+/** @file filteriterator.inc
+ * @ingroup Internal
+ * @brief class FilterIterator
+ * @author  Marcus Boerger
+ * @date    2003 - 2004
+ *
+ * SPL - Standard PHP Library
+ */
+
 /**
  * @brief   Regular expression filter for string iterators
  * @author  Marcus Boerger
- * @version 1.0
+ * @version 1.1
  *
  * Instances of this class act as a filter around iterators. In other words 
  * you can put an iterator into the constructor and the instance will only 

ext/spl/internal/limititerator.inc

@@ -1,13 +1,33 @@
 <?php
 
+/** @file limititerator.inc
+ * @ingroup Internal
+ * @brief class LimitIterator
+ * @author  Marcus Boerger
+ * @date    2003 - 2004
+ *
+ * SPL - Standard PHP Library
+ */
+
+/**
+ * @brief   Limited Iteration over another Iterator
+ * @author  Marcus Boerger
+ * @version 1.1
+ *
+ */
 class LimitIterator implements OuterIterator
 {
 	protected $it;
 	protected $offset;
 	protected $count;
 	private $pos;
 
-	// count === NULL means all
+	/** Construct
+	 *
+	 * @param it     Iterator to limit
+	 * @param offset Offset to first element
+	 * @param count  Maximum number of elements to show or NULL for all
+	 */
 	function __construct(Iterator $it, $offset = 0, $count = -1)
 	{
 		if ($offset < 0) {
@@ -22,6 +42,11 @@ class LimitIterator implements OuterIterator
 		$this->pos    = 0;
 	}
 
+	/** Seek to specified position
+	 * @param position offset to seek to (relative to beginning not offset
+	 *                 specified in constructor).
+	 * @throw exception when position is invalid
+	 */
 	function seek($position) {
 		if ($position < $this->offset) {
 			throw new exception('Cannot seek to '.$position.' which is below offset '.$this->offset);
@@ -39,31 +64,44 @@ class LimitIterator implements OuterIterator
 		}
 	}
 
+    /** Rewind to offset specified in constructor
+     */
 	function rewind()
 	{
 		$this->it->rewind();
 		$this->pos = 0;
 		$this->seek($this->offset);
 	}
 
+	/** @return whether iterator is valid
+	 */
 	function valid() {
 		return ($this->count == -1 || $this->pos < $this->offset + $this->count)
 			 && $this->it->valid();
 	}
 
+	/** @return current key
+	 */
 	function key() {
 		return $this->it->key();
 	}
 
+	/** @return current element
+	 */
 	function current() {
 		return $this->it->current();
 	}
 
+	/** Forward to nect element
+	 */
 	function next() {
 		$this->it->next();
 		$this->pos++;
 	}
 
+	/** @return current position relative to zero (not to offset specified in 
+	 *          constructor).
+	 */
 	function getPosition() {
 		return $this->pos;
 	}

ext/spl/internal/outeriterator.inc

@@ -1,11 +1,22 @@
 <?php
 
-/** \ingroup SPL
- * \brief Interface to access inner iterator of iterator wrappers
+/** @file outeriterator.inc
+ * @ingroup Internal
+ * @brief class OuterIterator
+ * @author  Marcus Boerger
+ * @date    2003 - 2004
+ *
+ * SPL - Standard PHP Library
+ */
+
+/**
+ * @brief   Interface to access the current inner iteraor of iterator wrappers
+ * @author  Marcus Boerger
+ * @version 1.0
  */
 interface OuterIterator extends Iterator
 {
-	/** \return inner iterator
+	/** @return inner iterator
 	 */
     function getInnerIterator();
 }

ext/spl/internal/parentiterator.inc

@@ -1,21 +1,48 @@
 <?php
 
+/** @file parentiterator.inc
+ * @ingroup Internal
+ * @brief class FilterIterator
+ * @author  Marcus Boerger
+ * @date    2003 - 2004
+ *
+ * SPL - Standard PHP Library
+ */
+
+/**
+ * @brief   Iterator to filter parents
+ * @author  Marcus Boerger
+ * @version 1.1
+ *
+ * This extended FilterIterator allows a recursive iteration using 
+ * RecursiveIteratorIterator that only shows those elements which have 
+ * children.
+ */
 class ParentIterator extends FilterIterator implements RecursiveIterator
 {
+	/** @param $it the RecursiveIterator to filter
+	 */
 	function __construct(RecursiveIterator $it)
 	{
 		parent::__construct($it);
 	}
+	
+	/** @return whetehr the current element has children
+	 */
 	function accept()
 	{
 		return $this->it->hasChildren();
 	}
 
+	/** @return whether the current element has children
+	 */
 	function hasChildren()
 	{
 		return $this->it->hasChildren();
 	}
 
+	/** @return the ParentIterator for the current elements children
+	 */
 	function getChildren()
 	{
 		return new ParentIterator($this->it->getChildren());

ext/spl/internal/recursiveiterator.inc

@@ -1,8 +1,27 @@
 <?php
 
+/** @file recursiveiterator.inc
+ * @ingroup Internal
+ * @brief class RecursiveIterator
+ * @author  Marcus Boerger
+ * @date    2003 - 2004
+ *
+ * SPL - Standard PHP Library
+ */
+
+/**
+ * @brief   Interface for recursive iteration with RecursiveIteratorIterator
+ * @author  Marcus Boerger
+ * @version 1.0
+ */
 interface RecursiveIterator implements Iterator
 {
+	/** @return whether the current element has children
+	 */
 	function hasChildren();
+	
+	/** @return the sub iterator for the current element
+	 */
 	function getChildren();
 }