mxmltree.class

Ir para a documentação deste ficheiro.

<?php
class MXMLTreeElement
{
}
 
class MXMLNode 
{ 
    var $tag = '';
 
    var $value = '';
 
    var $class = '';
 
    var $attrs; 
 
    var $properties = array();
 
} 
 
class MXMLTree
{
   var $stack;
 
   var $top = 0;
 
   var $tree;
 
 
   function __construct($file='')
   {
       $this->tree = null;
       $this->stack = array(); // this keeps track of what tag level you're at
       $doc = new domDocument();
       $doc->preserveWhiteSpace = false;
       $doc->load($file);
       $root = $doc->documentElement;
       $this->Parse($doc);
   }
 
   function Push($node)
   {
        $this->stack[++$this->top] = $node;
   }
 
   function Pop()
   { 
        return $this->stack[$this->top--];
   }
 
   function Top()
   { 
        return $this->stack[$this->top];
   }
 
   function Count()
   {
        return $this->top;
   } 
 
   function AddProperty($index, $value, $key=NULL)
   {
 
       $v = ($key != NULL) ? array($key=>$value) : $value;
       if (isset($this->stack[$this->top]->properties[$index]))
       {
           $p = $this->stack[$this->top]->properties[$index];
           $p = is_array($p) ? $p : array($p);
           $v = is_array($v) ? $v : array($v);
           $this->stack[$this->top]->properties[$index] = array_merge($p,$v);
       }
       else
       {
          $this->stack[$this->top]->properties[$index] = $v;
       }
   }
 
   function AddPropertyArray($index, $value)
   {
       $p = $this->stack[$this->top]->properties[$index];
       if (isset($p))
       {
          if(!is_array($p))
          {
             $p = array($p);
          } 
          $this->stack[$this->top]->properties[$index] = array_merge($p, array($value));
       }
       else
          $this->stack[$this->top]->properties[$index] = array($value);
   }
 
   function AddAttribute($attr,$value)
   {
       $this->stack[$this->top]->$attr = $value;
   }
 
   function SetValue($data)
   {
       $this->stack[$this->top]->value = $data;
   }
 
   function getTree()
   {
       return $this->tree;
   }
 
   function _startElement($name, $attrs) 
   { 
      $node = new MXMLNode; 
      $node->tag = $name;
      $node->attrs = $attrs;
      $this->Push($node);  
   } 
 
   function _endElement($name) 
   { 
      $node = $this->Pop(); 
      // Is there a parent node? 
      if($this->Count()) 
      { 
          $node->class = isset($node->attrs['class']) ? $node->attrs['class'] : $node->class; 
          $name = isset($node->attrs['name']) ? $node->attrs['name'] : $node->tag; 
          $type = isset($node->attrs['type']) ? $node->attrs['type'] : ''; 
          $key  = isset($node->attrs['key'])  ? $node->attrs['key'] : NULL; 
          if ($node->tag == 'class')
             $this->AddAttribute('class', $node->value);
          elseif (!count($node->properties))
          {
             if ($node->value == 'true')
                 $node->value = TRUE;
             elseif ($node->value == 'false') 
                 $node->value = FALSE;
             $this->AddProperty($name, $node->value, $key);
          }
          elseif (($node->class=='array') || ($type == 'array'))
          {
              $this->AddProperty($name, $node->properties['item'], $key);
          }
          elseif ($node->class=='associative')
          { 
             $this->AddProperty($name, $node->properties);
          } 
          else
          {
             $this->AddProperty($name, $node,$key);
          }
      } 
      else $this->tree = $node;
   } 
 
   function _characterData($data) 
   { 
      $this->SetValue($data); 
   } 
 
   function Parse($DomNode)
   {
      $HasTag = null;
      if ($ChildDomNode = $DomNode->firstChild) {
         static $depth = 0;
         while ($ChildDomNode) {
             if ($ChildDomNode->nodeType == XML_TEXT_NODE) {
                 $this->_characterData(utf8_decode(trim($ChildDomNode->nodeValue)));
             } elseif ($ChildDomNode->nodeType == XML_ELEMENT_NODE) {
                 $HasTag = 1;
                 $attrs = array();
                 if ($ChildDomNode->hasAttributes()) {
                     $Array = $ChildDomNode->attributes;
                     foreach ($Array AS $DomAttribute) {
                         $attrs[$DomAttribute->name] = $DomAttribute->value;
                     }
                 }
                 $this->_startElement(utf8_decode($ChildDomNode->nodeName), $attrs);
 
                 if ($ChildDomNode->hasChildNodes()) {
                     $depth++;
                     $this->Parse($ChildDomNode);
                     $depth--;
                 }
                 $this->_endElement(utf8_decode($ChildDomNode->nodeName));
             }
             $ChildDomNode = $ChildDomNode->nextSibling;
         }
         return $HasTag;
      }
   }
 
   function getObject($node=NULL)
   {
      if ($node == NULL)
      {
          $node = $this->tree;
      }   
      if (is_object($node))
      {
         $class = $node->class;
         $obj = new $class;
         foreach($node->properties as $k=>$v)
         {
            $obj->$k = $this->getObject($v);
         }
      }
      elseif (is_array($node))
      {
         foreach($node as $k=>$v)
         {
            $obj[] = $this->getObject($v);
         }
      }
      else
      {
         $obj = $node;
      }
      return $obj;
   }
 
   function getObjectTree($node=NULL,$prefixClass='')
   {
      if ($node == NULL)
      {
          $node = $this->tree;
      }   
      if (is_object($node))
      {
         $class = $prefixClass . ($node->class != '' ? $node->class : $node->tag);
         $obj = new $class;
         foreach($node->attrs as $k=>$v)
         {
            $obj->$k = $v;
         }
         foreach($node->properties as $k=>$v)
         {
            $obj->$k = $this->getObjectTree($v, $prefixClass);
         }
      }
      elseif (is_array($node))
      {
         foreach($node as $k=>$v)
         {
            $obj[] = $this->getObjectTree($v, $prefixClass);
         }
      }
      else
      {
         $obj = $node;
      }
      return $obj;
   }
 
   function getInterfaceTree($node=NULL,$prefixClass='')
   {
      if ($node == NULL)
      {
          $node = $this->tree;
      }   
      if (is_object($node))
      {
         $class = $prefixClass . ($node->class != '' ? $node->class : $node->tag);
         $obj = new $class;
         foreach($node->attrs as $k=>$v)
         {
            $obj->$k = $v;
         }
         foreach($node->properties as $k=>$v)
         {
            if (is_object($v))
            {
               $obj->{$k}[] = $this->getInterfaceTree($v, $prefixClass);
            }
            else
            {
               $obj->$k = $this->getInterfaceTree($v, $prefixClass);
            }
 
         }
      }
      elseif (is_array($node))
      {
         foreach($node as $k=>$v)
         {
            $obj[] = $this->getInterfaceTree($v, $prefixClass);
         }
      }
      else
      {
         $obj = $node;
      }
      return $obj;
   }
 
   function getXMLTreeElement($node=null)
   {
      if (is_object($node))
      {
         $obj = new MXMLTreeElement;
         foreach($node->properties as $k=>$v)
         {
            $obj->$k = $this->getXMLTreeElement($v);
         }
      }
      elseif (is_array($node))
      {
         foreach($node as $k=>$v)
         {
            $obj[] = $this->getXMLTreeElement($v);
         }
      }
      else
      {
         $obj = $node;
      }
      return $obj;
   }
 
   function getXMLTreeAsTreeArray($node=null)
   {
      if (is_object($node))
      {
         $obj = array();
         foreach($node->properties as $k=>$v)
         {
            $obj[$k] = $this->getXMLTreeAsTreeArray($v);
         }
      }
      elseif (is_array($node))
      {
         foreach($node as $k=>$v)
         {
            $obj[$k][] = $this->getXMLTreeAsTreeArray($v);
         }
      }
      else
      {
         $obj = $node;
      }
      return $obj;
   }
 
   function getXMLTreeAsFlatArray($node=null, $array=array(), $key='')
   {
      if (is_object($node))
      {
         foreach($node->properties as $k=>$v)
         {
            $kk = $key . ($key != '' ? '.' : '') . $k;
            $this->getXMLTreeAsFlatArray($v, $array, $kk);
         }
      }
      elseif (is_array($node))
      {
         foreach($node as $k=>$v)
         {
            $kk = $key . ($key != '' ? '.' : '') . $k;
            $this->getXMLTreeAsFlatArray($v, $array, $kk);
         }
      }
      else
      {
         $array[$key] = $node;
      }
      return $array;
   }
 
   function getXMLTreeAsArray()
   {
        $array = array();
        $xml = $this->getXMLTreeElement($this->tree);
        $one = true;
        foreach($xml as $attribute)
        {
            if (is_array($attribute) && $one)
            { 
                $i = 0;
                foreach($attribute as $element)    
                {  
                    $j = 0;
                    foreach($element as $value) 
                    {
                        $array[$i][$j++] = $value;
                    }
                    $i++;
                }
            }
        }
        return $array; 
   }
 
   function getXMLTreeAsAssocArray()
   {
        $array = array();
        $xml = $this->getXMLTreeElement($this->tree);
        $one = true;
        foreach($xml as $attribute)
        {
            if (is_array($attribute) && $one)
            { 
                $i = 0;
                foreach($attribute as $element)    
                {  
                    foreach($element as $a=>$value) 
                    {
                        $array[$i][$a] = $value;
                    }
                    $i++;
                }
            }
        }
        return $array; 
   }
 
   function getXMLTreeAsValueArray($index,$value)
   {
        $array = array();
        $xml = $this->getXMLTreeElement($this->tree);
        $one = true;
        foreach($xml as $attribute)
        {
            if (is_array($attribute) && $one)
            { 
                foreach($attribute as $element)    
                {  
                    $array[$element->$index] = $element->$value;
                }
            }
        }
        return $array; 
   }
} 
?>