Source for file Xml.class.php

Documentation is available at Xml.class.php

  1. <?php
  2. /**
  3.  * Gumbo Library Framework
  4.  *
  5.  * LICENSE
  6.  * This library is being released under the terms of the New BSD License.  A
  7.  * copy of the license is packaged with the software (LICENSE.txt).  If no
  8.  * copy is found, a copy of the license template can be found at:
  9.  * http://www.opensource.org/licenses/bsd-license.php
  10.  * 
  11.  * @category Gumbo
  12.  * @package Converter
  13.  * @copyright Copyright (c) 2007, iBayou, Michael Luster
  14.  * @license http://www.opensource.org/licenses/bsd-license.php New BSD License
  15.  * @author Michael Luster <mluster79@yahoo.com>
  16.  * @link http://sourceforge.net/projects/phpgumbo
  17.  * @version 0.0.1
  18.  */
  19.  
  20. /**
  21.  * XML Converter Class
  22.  *
  23.  * @category Gumbo
  24.  * @package Converter
  25.  * @copyright Copyright (c) 2007, iBayou, Michael Luster
  26.  * @license http://www.opensource.org/licenses/bsd-license.php New BSD License
  27.  * @author Michael Luster <mluster79@yahoo.com>
  28.  * @link http://sourceforge.net/projects/phpgumbo
  29.  * @desc XML Converter Class
  30.  * @version 0.0.1
  31.  */
  32.  
  33. gumbo_load ("Converter_Abstract");
  34.  
  35. class Gumbo_Converter_Xml extends Gumbo_Converter_Abstract {
  36.     
  37.     /** @var string $_class SimpleXMLElement Class Name */
  38.     private $_class;
  39.     /** @var int $_options LibXML Options */
  40.     private $_options;
  41.     /** @var string $_ns Namespace */
  42.     private $_ns;
  43.     /** @var bool $_prefix is Prefix option */
  44.     private $_prefix;
  45.     
  46.     
  47.     
  48.     /**
  49.      * Constructor
  50.      * @param string $class_name SimpleXMLElement Class Name
  51.      * @param int $options LibXML Parameters
  52.      * @param string $ns XML Namespace
  53.      * @param bool $is_prefix 
  54.      */
  55.     public function __construct ($class_name=null, $options=null, $ns=null, $is_prefix=null) {
  56.         if (!is_null ($class_name)) { $this->setClassName ($class_name); }
  57.         if (!is_null ($options)) { $this->setOptions ($options); }
  58.         if (!is_null ($ns)) { $this->setNamespace ($ns); }
  59.         if (!is_null ($is_prefix)) { $this->setPrefix ($is_prefix); }
  60.     }
  61.     
  62.     
  63.     
  64.     /** ACTION METHODS **/
  65.     /**
  66.      * Returns a Composite
  67.      * @param string|SimpleXMLElement$data array data
  68.      * @return Gumbo_Interface_Composite 
  69.      * @throws Gumbo_Exception
  70.      * @uses Gumbo_Branch
  71.      */
  72.     public function toComposite ($data) {
  73.         try {
  74.             // verify precondition
  75.             if (!is_string ($data) && !is_object ($data)) {
  76.                 throw new Gumbo_Exception ("Invalid Argument 'data:str|SimpleXMLElement' => {$data}:" . gettype ($data));
  77.             }
  78.             if (is_object ($data) && !($data instanceof SimpleXMLElement)) {
  79.                 throw new Gumbo_Exception ("Invalid Argument 'data:SimpleXMLElement' => {$data}:" . gettype ($data));
  80.             }
  81.             
  82.             // converts into a SimpleXMLElement object
  83.             if (is_string ($data)) {
  84.                 $func = "simplexml_load_string";
  85.                 if (file_exists ($data)) {
  86.                     $func = "simplexml_load_file";
  87.                 }
  88.                 $data = call_user_func ($func, $data, $this->getClassName (), $this->getOptions (), $this->getNamespace (), $this->isPrefix ());
  89.             }
  90.             
  91.             return $this->_getComposite ($data);
  92.         } catch (Gumbo_Exception $e) {
  93.             $e->setFunction (__METHOD__);
  94.             gumbo_trigger ($e);
  95.         }
  96.         return new Gumbo_Branch ();
  97.     }
  98.     
  99.     
  100.     
  101.     /** MUTATOR METHODS **/
  102.     /**
  103.      * Sets the Class Name (must be subclass of SimpleXMLElement)
  104.      * @param string $name 
  105.      * @throws Gumbo_Exception
  106.      */
  107.     public function setClassName ($name) {
  108.         try {
  109.             // verify precondition
  110.             if (!is_string ($name)) {
  111.                 throw new Gumbo_Exception ("Invalid Argument 'name:str' => {$name}:" . gettype ($name));
  112.             }
  113.             if (!is_subclass_of ("SimpleXMLElement", $name)) {
  114.                 throw new Gumbo_Exception ("Invalid SubClass to SimpleXMLElement: {$name}");
  115.             }
  116.             
  117.             $this->_class = $name;
  118.         } catch (Gumbo_Exception $e) {
  119.             $e->setFunction (__METHOD__);
  120.             gumbo_trigger ($e);
  121.         }
  122.     }
  123.     
  124.     /**
  125.      * Sets the Options from LibXML
  126.      * @param int $options 
  127.      * @throws Gumbo_Exception
  128.      */
  129.     public function setOptions ($options) {
  130.         try {
  131.             // verify precondition
  132.             if (!is_int ($options)) {
  133.                 throw new Gumbo_Exception ("Invalid Argument 'options:int' => {$options}:" . gettype ($options));
  134.             }
  135.             
  136.             $this->_options = $options;
  137.         } catch (Gumbo_Exception $e) {
  138.             $e->setFunction (__METHOD__);
  139.             gumbo_trigger ($e);
  140.         }
  141.     }
  142.     
  143.     /**
  144.      * Sets the Namespace
  145.      * @param string $ns 
  146.      * @throws Gumbo_Exception
  147.      */
  148.     public function setNamespace ($ns) {
  149.         try {
  150.             // verify precondition
  151.             if (!is_string ($ns)) {
  152.                 throw new Gumbo_Exception ("Invalid Argument 'ns:str' => {$ns}:" . gettype ($ns));
  153.             }
  154.             
  155.             $this->_ns = $ns;
  156.         } catch (Gumbo_Exception $e) {
  157.             $e->setFunction (__METHOD__);
  158.             gumbo_trigger ($e);
  159.         }
  160.     }
  161.     
  162.     /**
  163.      * Sets the Prefix option
  164.      * @param bool $val 
  165.      * @throws Gumbo_Exception
  166.      */
  167.     public function setPrefix ($val) {
  168.         try {
  169.             // verify precondition
  170.             if (!is_bool ($val)) {
  171.                 throw new Gumbo_Exception ("Invalid Argument 'val:bool' => {$val}:" . gettype ($val));
  172.             }
  173.             
  174.             $this->_prefix = $val;
  175.         } catch (Gumbo_Exception $e) {
  176.             $e->setFunction (__METHOD__);
  177.             gumbo_trigger ($e);
  178.         }
  179.     }
  180.     
  181.     
  182.     
  183.     /** ACCESSOR METHODS **/
  184.     /**
  185.      * Returns the Class Name
  186.      * @return string 
  187.      */
  188.     public function getClassName () {
  189.         return $this->_class;
  190.     }
  191.     
  192.     /**
  193.      * Returns the Options
  194.      * @return int 
  195.      */
  196.     public function getOptions () {
  197.         return $this->_options;
  198.     }
  199.     
  200.     /**
  201.      * Returns the Namespace
  202.      * @return string 
  203.      */
  204.     public function getNamespace () {
  205.         return $this->_ns;
  206.     }
  207.     
  208.     /**
  209.      * Returns the Prefix
  210.      * @return bool 
  211.      */
  212.     public function isPrefix () {
  213.         return $this->_prefix;
  214.     }
  215.     
  216.     
  217.     
  218.     /**
  219.      * Returns a single Composite object from an array
  220.      * This is a recusive method
  221.      * @param SimpleXMLElement $data 
  222.      * @return Gumbo_Interface_Composite 
  223.      * @throws Gumbo_Exception
  224.      * @uses Gumbo_Interface_Composite
  225.      */
  226.     private function _getComposite ($data) {
  227.         try {
  228.             // verify precondition
  229.             if (!($data instanceof SimpleXMLElement)) {
  230.                 throw new Gumbo_Exception ("Invalid Argument 'data:SimpleXMLElement' => {$data}:" . gettype ($data));
  231.             }
  232.             $tree = new Gumbo_Branch ($data->getName ());
  233.             
  234.             // set the attributes
  235.             foreach ($data->attributes () as $key=>$val) {
  236.                 $tree->addAttribute ($key, (string) $val);
  237.             }
  238.             
  239.             // set the child elements
  240.             if ($data->children ()) {
  241.                 foreach ($data->children () as $child) {
  242.                     $tmp = $this->_getTree ($child);
  243.                     if ($tmp instanceof Gumbo_Interface_Composite) {
  244.                         $tree->add ($tmp);
  245.                     }
  246.                 }
  247.             } else {
  248.                 $name = $data->getName ();
  249.                 $tree->setValue ((string) $data->$name);
  250.             }
  251.             
  252.             return $tree;
  253.         } catch (Gumbo_Exception $e) {
  254.             $e->setFunction (__METHOD__);
  255.             gumbo_trigger ($e);
  256.         }
  257.         return null;
  258.     }
  259.     
  260. }
  261.  
  262. ?>