Nested data via DOM

<?php

// Nested.php

include 'Nested/Exception.php';
include 'Nested/Child.php';
include 'Nested/Child/Properties.php';

class Nested {

    /**
     *
     * @var DOMDocument
     */
    protected $doc;

    /**
     * Properties collection
     * @var array
     */
    static public $propertiesCollection = array();

    /**
     * If an element is added, when the parent element isn't already added, the element
     * will stored temporary in this array
     *
     * @var array
     */
    protected $noParentCollection = array();

    /**
     * Create the DOMDocument object
     */
    public function __construct(){
        $this->doc = new DOMDocument();
    }

    /**
     *
     * @param $id
     * @param $parent_id
     * @param $properties
     * @return unknown_type
     */
    public function addChild($id,$parent_id=0,$properties=array()){
        if(!(ctype_digit($id) || is_int($id)) || $id <= 0 || isset(self::$propertiesCollection[$id])){
            throw new Nested_Exception('The ID must be a unique positive integer');
        }

        // Properties
        self::$propertiesCollection[$id] = new Nested_Child_Properties($properties);

        // Create the element
        $newElmt = $this->doc->createElement('child');

        // Add ID attribute
        $idAttr = $this->doc->createAttribute('id');
        $idAttr->appendChild($this->doc->createTextNode('id'.$id));
        $newElmt->appendChild($idAttr);
        $newElmt->setIdAttribute('id',true);

        // Check if the element has a parent
        if($parent_id > 0){
            $parentElmt = (int)$parent_id > 0 ? $this->doc->getElementById('id'.$parent_id) : null;
            if($parentElmt instanceof DOMElement){
                // If there's a parent element found, append this new element to the parent element
                $parentElmt->appendChild($newElmt);
            }else{
                // The parent is not found, store the element and wait till the parent element
                // gets added
                $this->noParentCollection[$parent_id] = $newElmt;
            }
        }else{
            $this->doc->appendChild($newElmt);
        }

        // There is a child element of this element who is already added
        if(isset($this->noParentCollection[$id])){
            $newElmt->appendChild($this->noParentCollection[$id]);
            unset($this->noParentCollection[$id]);
        }
    }

    /**
     *
     * @param int $id
     * @return Nested_Child
     */
    public function getElement($id){
        $elmt = $this->doc->getElementById('id'.$id);
        if($elmt instanceof DOMElement){
            return new Nested_Child($elmt);
        }
        throw new Nested_Exception('This element does not exists');
    }

    /**
     * Get the elements at the 'root' level
     * @return Nested_Children
     */
    public function getElements(){
        $childElmts = $this->doc->childNodes;
        $children = new Nested_Children();
        foreach($childElmts as $elmt){
            print_r($elmt);
            $children->addChild(new Nested_Child($elmt));
        }
        return $children;
    }

    /**
     * Shows the hierarchy in XML
     * @param int $id If you want to view the hierarchy of an element
     * @return void
     */
    public function debug($id=null){
        $this->doc->formatOutput = true;

        $node = null;
        if(!empty($id)){
            $node = $this->getElement($id)->getDOMElement();
        }
        echo '<pre>'.htmlentities($this->doc->saveXML($node),true).'</pre>';
    }

    /**
     * Clear the memory
     * @return void
     */
    public function __destruct(){
        unset($this->doc);
    }

}


// Nested/Child.php

include 'Children.php';

class Nested_Child {

    /**
     *
     * @var DOMElement
     */
    protected $elmt;

    /**
     *
     * @var int
     */
    protected $id;

    /**
     *
     * @param DOMElement $elmt
     */
    public function __construct(DOMElement $elmt){
        $this->elmt = $elmt;
    }

    /**
     * Get the element ID
     * @return int
     */
    public function getId(){
        if(empty($this->id)){
            $this->id = (int) substr($this->elmt->getAttribute('id'),2);
        }
        return $this->id;
    }

    /**
     * Get the parent element
     * @return Nested_Child
     */
    public function getParent(){
        $parent = $this->elmt->parentNode;
        if($parent instanceof DOMElement){
            return new Nested_Child($parent);
        }
        throw new Nested_Exception('This parent element does not exists');
    }

    /**
     * Get the element properties
     * @return Nested_Child_Properties
     */
    public function getProperties(){
        $properties = isset(Nested::$propertiesCollection[$this->getId()]) ?
            Nested::$propertiesCollection[$this->getId()] :
            new Nested_Child_Properties(array());
        return $properties;
    }

    /**
     * Check if the element has child nodes
     * @return bool
     */
    public function hasChildren(){
        return $this->elmt->hasChildNodes();
    }

    /**
     * Get the element children
     * @return Nested_Children
     */
    public function getChildren(){
        $childElmts = $this->elmt->childNodes;
        $children = new Nested_Children();
        foreach($childElmts as $elmt){
            $children->addChild(new Nested_Child($elmt));
        }
        return $children;
    }

    /**
     *
     * @return DOMElement
     */
    public function getDOMElement(){
        return $this->elmt;
    }

}

// Nested/Children.php


class Nested_Children implements Iterator, Countable {

    /**
     * The children
     *
     * @var array
     */
    protected $children = array();

    /**
     * Add a child
     *
     * @param Nested_Child $child
     */
    public function addChild(Nested_Child $child){
        $this->children[$child->getId()] = $child;
    }

    /**
     * Get a child
     *
     * @param string $key The ID of the child
     * @return Nested_Child
     */
    public function __get($key){
        if(isset($this->children[$key])){
            return $this->children[$key];
        }
        return false;
    }

    /**
     * If the Child is already added to the children
     *
     * @param string $key The ID of the child
     * @return bool true if the child isset, otherwise false
     */
    public function __isset($key){
        return isset($this->children[$key]);
    }

    /**
     * Count the children
     *
     * @return int
     */
    public function count(){
        return count($this->children);
    }


    /**
     *
     * @return bool
     */
    public function rewind() {
        reset($this->children);
    }

    /**
     *
     * @return Nested_Child
     */
    public function current() {
        return current($this->children);
    }

    /**
    * @var string|int
     */
    public function key() {
        return key($this->children);
    }

    /**
     *
     * @return Nested_Child|false
     */
    public function next() {
        return next($this->children);
    }

    /**
     *
     * @return bool
     */
    public function valid() {
        return $this->current() !== false;
    }
}


// Nested/Child/Properties.php


class Nested_Child_Properties implements Iterator, Countable {

    /**
     * The properties of a element
     *
     * @var array
     */
    protected $properties = array();

    /**
     * Create a properties instance
     *
     * @param array $properties
     */
    public function __construct(array $properties){
        $this->properties = $properties;
    }

    /**
     * Return a property
     *
     * @param string $key Property Key
     * @return mixed The property value, if the property does not exists, it returns false
     */
    public function __get($key){
        if(isset($this->properties[$key])){
            return $this->properties[$key];
        }
        return false;
    }

    /**
     * Set a property
     *
     * @param string $key
     * @param mixed $value
     */
    public function __set($key,$value){
        $this->properties[$key] = $value;
    }

    /**
     * Checks if the property isset
     *
     * @param string $key
     * @return bool True if the property isset, otherwise false
     */
    public function __isset($key){
        return isset($this->properties[(string)$key]);
    }

    public function count(){
        return count($this->properties);
    }

    /**
     * Make the properties iteratable
     */

    public function rewind() {
        reset($this->properties);
    }

    public function current() {
        return current($this->properties);
    }

    public function key() {
        return key($this->properties);
    }

    public function next() {
        return next($this->properties);
    }

    public function valid() {
        return $this->properties() !== false;
    }

}

// Nested/Exception.php

class Nested_Exception extends Exception {
        
}


// Voorbeeld

$i = 1;

$nested = new Nested();

// Elementen toevoegen
$nested->addChild($i,0,array('id'=>$i++,'naam'=>'bar','tekst'=>'foo'));
$nested->addChild($i,0,array('id'=>$i++,'naam'=>'bar','tekst'=>'foo'));

// Zoals je ziet, heeft dit element de parent met id=5. Deze is helaas nog 
//niet toegevoegd. Daarom zal dit element even tijdelijk worden opgeslagen 
//en wordt alsnog toegevoegd als child van id=5 als het element met id=5 
//toegevoegd wordt.
$nested->addChild($i,5,array('id'=>$i++,'naam'=>'bar','tekst'=>'foo'));

$nested->addChild($i,1,array('id'=>$i++,'naam'=>'bar','tekst'=>'foo'));

// Nu wordt dus het element met ID=3 toegevoegd aan dit element
$nested->addChild($i,2,array('id'=>$i++,'naam'=>'bar','tekst'=>'foo'));
$nested->addChild($i,2,array('id'=>$i++,'naam'=>'bar','tekst'=>'foo'));

$children = $nested->getElement(1)->getChildren();
foreach($children as $child){
    echo $child->getProperties()->tekst.'<br />';
}

echo $nested->getElement(4)->getParent()->getProperties()->naam;

$nested->debug();

?>