Extending the DirectoryIterator

function valid(){
  if(parent::valid())
    {
    if (!parent::isDir())
        {
        parent::next();
        return $this->valid();
        }
    return TRUE;
    }
  return FALSE;
}

Filter Iterator

• Takes another iterator as its argument
• All iterations are performed on the inner iterator
• For every iteration the Accept() method is called
• You only need to implement Accept

$it = new DirectoryIterator($path);

class my_filter extends FilterIterator($it){
 ...
}

Filter Iterator

$animals = array('koala', 'kangaroo', 'wombat', 'wallaby', 'emu', 'NZ'=>'kiwi', 'kookaburra', 'platypus');

class CullingIterator extends FilterIterator{

public function __construct( Iterator $it ){
  parent::__construct( $it );
}

function accept(){
  return is_numeric($this->key());
}
}
$cull = new CullingIterator(new ArrayIterator($animals));

foreach($cull as $key=>$value){
    echo $key.' == '.$value.'<br />';
    }

Another Filter

function accept(){
if($this->current() % 2 != 1){
    return false;
    }
$d = 3;
$x = sqrt($this->current());
while ($this->current() % $d != 0 && $d < $x){
    $d += 2;
    }
 return (($this->current() % $d == 0 && $this->current() != $d) * 1) == 0 ? true : false;
}

To further demonstrate how a filter iterator works, we can simply change the Accept() method to whatever we wish to filter out. Here we will change the Accept method to accept only prime numbers. If anybody has a better prime checker, please feel free to submit.

A moment to review

• The directory iterator takes a path as an arg to the construct
• The filter iterator takes another iterator as its arg
• The only method you need to implement in the filter iterator is Accept()
• A recursiveFilterIterator is also implemented
• Any iterator that wraps another is called an "outer iterator"
• The iterator that gets wrapped is called an "inner iterator"

Limit Iterator

• Limit amount of results
• Similar functionality to SQL LIMIT clause
• Offset can also be set
• Is an outer iterator

<?xml version = "1.0" encoding="UTF-8" standalone="yes"?>
<document>
  <animal>koala</animal>
  <animal>kangaroo</animal>
  <animal>wombat</animal>
  <animal>wallaby</animal>
  <animal>emu</animal>
  <animal>kiwi</animal>
  <animal>kookaburra</animal>
  <animal>platypus</animal>
</document>

try{
$it = new LimitIterator(new SimpleXMLIterator($xmlstring), 3, 2);
foreach($it as $r)
    {
    // output the key and current array value
    echo $it->key().' -- '.$it->current().'<br />';
    }
}
catch(Exception $e)
    {
    echo $e->getMessage();
    }

animal -- wallaby
animal -- emu

$offset = 3;

$limit = 2;

$array = array('koala', 'kangaroo', 'wombat', 'wallaby', 'emu', 'kiwi', 'kookaburra', 'platypus');

$it = new LimitIterator(new ArrayIterator($array), $offset, $limit);

foreach($it as $k=>$v)
    {
    echo $it->getPosition().'<br />';
    }

Seeking

$array = array('koala', 'kangaroo', 'wombat', 'wallaby', 'emu', 'kiwi', 'kookaburra', 'platypus');

$it = new LimitIterator(new ArrayIterator($array));

try
    {
    $it->seek(5);
    echo $it->current();
    }
catch(OutOfBoundsException $e)
    {
    echo $e->getMessage() . "<br />";
    }

$offset = 2;

$array = array('koala', 'kangaroo', 'wombat', 'wallaby', 'emu', 'kiwi', 'kookaburra', 'platypus');

$it = new LimitIterator(new ArrayIterator($array), $offset);

$it->getInnerIterator()->offsetUnset(5);

try {
    foreach($it as $value){
        echo $value.'<br />';
        }
    }
catch(OutOfBoundsException $e){
    echo $e->getMessage() . "<br />";
    }

LimitIterator Revision

• Similar access to SQL with offset and limit
• Seekable using the seek() method
• Access current position with getPosition() method
• Access to the inner iterator using getInnerIterator

Array Object

• Allows external traversal of arrays
• Creates an instance of ArrayIterator
• Both implement SeekableIterator
To clarify internal and external iterators an traversal.. An internal iterator modifies the object itself, and an external iterator points to another object without modifying it. At the engine level, PHP uses external iterators. By implementing the seekableIterator direct access to any array position is possible.

Array Object

$array = array('koala', 'kangaroo', 'wombat', 'wallaby', 'emu', 'kiwi', 'kookaburra', 'platypus');

$arrayObj = new ArrayObject($array);

for($iterator = $arrayObj->getIterator();
   $iterator->valid();
   $iterator->next())
    {
    echo $iterator->key() . ' => ' . $iterator->current() . '<br />';
    }

Append to the object

$arrayObj = new ArrayObject($array);

$arrayObj->append('dingo');

Sorting

• asort
• ksort
• uasort
• uksort
• natsort
• natcasesort

$arrayObj = new ArrayObject($array);

$arrayObj->natcasesort();

Count

$array = array(koala, kangaroo, wombat, wallaby, emu, kiwi, kookaburra, platypus);

$arrayObj = new ArrayObject($array);

echo $arrayObj->count();

And what array access class would be complete without a method to count them. Within arrayOject we use the count method. Genius!

Unset

$arrayObj = new ArrayObject($array);

$arrayObj->offsetUnset(5);

offsetSet

$array = array('koala', 'kangaroo', 'wombat', 'wallaby', 'emu', 'kiwi', 'kookaburra', 'platypus');

$arrayObj = new ArrayObject($array);

$arrayObj->offsetSet(5, "galah");

Caching Iterator

<pre>
<?php

  Reflection::export(new ReflectionClass('cachingIterator'));

?>
</pre>

class CachingIterator extends IteratorIterator implements OuterIterator, Traversable, Iterator, ArrayAccess, Countable ]

hasNext()

$array = array('koala', 'kangaroo', 'wombat', 'wallaby', 'emu', 'kiwi', 'kookaburra', 'platypus');

try {
    $object = new CachingIterator(new ArrayIterator($array));
    foreach($object as $value){
        echo $value;
        echo $object->hasNext() ? ',' : null;
            }
        }
    }
catch (Exception $e)
    {
    echo $e->getMessage();
    }

SimpleXML Iterator

<pre>
<?php

  Reflection::export(new ReflectionClass('SimpleXMLIterator'));

?>
</pre>

SimpleXML Iterator

try    {
       $sxi = simplexml_load_string($xmlstring, 'SimpleXMLIterator');
       foreach(new RecursiveIteratorIterator($sxi, 1) as $name => $data)
          {
          echo $name.' -- '.$data.'<br />';
          }
    }
catch(Exception $e)
    {
    echo $e->getMessage();
    }

SimpleXML Iterator

try {
    $sxi =  new SimpleXMLIterator($xmlstring);

    foreach ( $sxi as $node )
        {
        foreach($node as $k=>$v)
            {
            echo $v->node_name.'<br />';
            }
        }
    }
catch(Exception $e)
    {
    echo $e->getMessage();
    }

SimpleXML Iterator

try {
$sxi = simplexml_load_string($xmlstring, 'SimpleXMLIterator');

for ($sxi->rewind(); $sxi->valid(); $sxi->next())
    {
    if($sxi->hasChildren())
        {
        foreach($sxi->getChildren() as $element=>$value)
          {
          echo $value->node_name.'<br />';
          }
        }
     }
   }
catch(Exception $e)
   {
   echo $e->getMessage();
   }

SimpleXML Iterator xPath

path/to/node_name

SimpleXML Iterator xPath

try {
    $sxi =  new SimpleXMLIterator($xmlstring);

    /*** set the xpath ***/
    $foo = $sxi->xpath('path/to/node_name');

    foreach ($foo as $k=>$v){
        echo $v.'<br />';
        }
    }
catch(Exception $e)
    {
    echo $e->getMessage();
    }

<?xml version = "1.0" encoding="UTF-8" standalone="yes"?>
<document>
    <ignorance>
    I dont want to know
        <discovery>
        Whats this then?
            <awareness>
            This could be useful
                <acceptance>
                I must use this
                    <enlightenment>
                    SPL
                    </enlightenment>
                </acceptance>
            </awareness>
        </discovery>
    </ignorance>
</document>

SimpleXML Iterator xPath

try {
    $sxi =  new SimpleXMLIterator($xmlstring);

    $foo = $sxi->xpath('ignorance/discovery/awareness/acceptance/enlightenment');

    foreach ($foo as $k=>$v){
        echo $v.'<br />';
        }
    }
catch(Exception $e)
    {
    echo $e->getMessage();
    }

SimpleXML Iterator Revision

• Is a recursive Iterator
• Supports xPath
• Add/Remove nodes

try{
        $file = new SplFileObject("/usr/local/apache/logs/access_log");

        while($file->valid()){
                echo $file->current().'<br />';
                $file->next();
                }
        }
catch (Exception $e)
        {
        echo $e->getMessage();
        }

try{
    $file = new SplFileObject("/usr/local/apache/logs/access_log");

    $file->seek( 3 );

    echo $file->current();
        }
catch (Exception $e)
    {
    echo $e->getMessage();
    }

SPL and PDO

$db = new PDO($dsn);

foreach($db->query("SELECT * FROM table")){
    // do stuff here
}

The PDO extension implements the traversable iterator internally. This gives amazing memory benifits when you need to iterate over large SQL result sets. The new image magick extension also makes use of SPL for iteration of pixels etc.

Summary

• A new way of programming
• Better memory utilization
• Promote code re-use
• • Filtering
  • Recursion
  • Limiting

Thank You, Questions?

• Iterators offer much more
• http://www.phpro.org/tutorials/
• Questions?