Loading...
Helix SwarmHelix Swarm
Loading...

AbstractValue.php

  • //
  • guest/
  • thomas_gray/
  • jambox/
  • main/
  • swarm/
  • library/
  • Zend/
  • XmlRpc/
  • AbstractValue.php #1
  • View
  • Commits
  • Open Download .zip Download (15 KB) 
  1. <?php
  2. /**
  3.  * Zend Framework (http://framework.zend.com/)
  4.  *
  5.  * @link      http://github.com/zendframework/zf2 for the canonical source repository
  6.  * @copyright Copyright (c) 2005-2014 Zend Technologies USA Inc. (http://www.zend.com)
  7.  * @license   http://framework.zend.com/license/new-bsd New BSD License
  8.  */
  9.  
  10. namespace Zend\XmlRpc;
  11.  
  12. use DateTime;
  13.  
  14. /**
  15.  * Represent a native XML-RPC value entity, used as parameters for the methods
  16.  * called by the Zend\XmlRpc\Client object and as the return value for those calls.
  17.  *
  18.  * This object as a very important static function Zend\XmlRpc\Value::getXmlRpcValue, this
  19.  * function acts likes a factory for the Zend\XmlRpc\Value objects
  20.  *
  21.  * Using this function, users/Zend\XmlRpc\Client object can create the Zend\XmlRpc\Value objects
  22.  * from PHP variables, XML string or by specifying the exact XML-RPC native type
  23.  */
  24. abstract class AbstractValue
  25. {
  26.     /**
  27.      * The native XML-RPC representation of this object's value
  28.      *
  29.      * If the native type of this object is array or struct, this will be an array
  30.      * of Value objects
  31.      */
  32.     protected $value;
  33.  
  34.     /**
  35.      * The native XML-RPC type of this object
  36.      * One of the XMLRPC_TYPE_* constants
  37.      */
  38.     protected $type;
  39.  
  40.     /**
  41.      * XML code representation of this object (will be calculated only once)
  42.      */
  43.     protected $xml;
  44.  
  45.     /**
  46.      * @var \Zend\XmlRpc\Generator\GeneratorInterface
  47.      */
  48.     protected static $generator;
  49.  
  50.     /**
  51.      * Specify that the XML-RPC native type will be auto detected from a PHP variable type
  52.      */
  53.     const AUTO_DETECT_TYPE = 'auto_detect';
  54.  
  55.     /**
  56.      * Specify that the XML-RPC value will be parsed out from a given XML code
  57.      */
  58.     const XML_STRING = 'xml';
  59.  
  60.     /**
  61.      * All the XML-RPC native types
  62.      */
  63.     const XMLRPC_TYPE_I4        = 'i4';
  64.     const XMLRPC_TYPE_INTEGER   = 'int';
  65.     const XMLRPC_TYPE_I8        = 'i8';
  66.     const XMLRPC_TYPE_APACHEI8  = 'ex:i8';
  67.     const XMLRPC_TYPE_DOUBLE    = 'double';
  68.     const XMLRPC_TYPE_BOOLEAN   = 'boolean';
  69.     const XMLRPC_TYPE_STRING    = 'string';
  70.     const XMLRPC_TYPE_DATETIME  = 'dateTime.iso8601';
  71.     const XMLRPC_TYPE_BASE64    = 'base64';
  72.     const XMLRPC_TYPE_ARRAY     = 'array';
  73.     const XMLRPC_TYPE_STRUCT    = 'struct';
  74.     const XMLRPC_TYPE_NIL       = 'nil';
  75.     const XMLRPC_TYPE_APACHENIL = 'ex:nil';
  76.  
  77.     /**
  78.      * Get the native XML-RPC type (the type is one of the Value::XMLRPC_TYPE_* constants)
  79.      *
  80.      * @return string
  81.      */
  82.     public function getType()
  83.     {
  84.         return $this->type;
  85.     }
  86.  
  87.     /**
  88.      * Get XML generator instance
  89.      *
  90.      * @return \Zend\XmlRpc\Generator\GeneratorInterface
  91.      */
  92.     public static function getGenerator()
  93.     {
  94.         if (!static::$generator) {
  95.             if (extension_loaded('xmlwriter')) {
  96.                 static::$generator = new Generator\XmlWriter();
  97.             } else {
  98.                 static::$generator = new Generator\DomDocument();
  99.             }
  100.         }
  101.  
  102.         return static::$generator;
  103.     }
  104.  
  105.     /**
  106.      * Sets XML generator instance
  107.      *
  108.      * @param  null|Generator\GeneratorInterface $generator
  109.      * @return void
  110.      */
  111.     public static function setGenerator(Generator\GeneratorInterface $generator = null)
  112.     {
  113.         static::$generator = $generator;
  114.     }
  115.  
  116.     /**
  117.      * Changes the encoding of the generator
  118.      *
  119.      * @param string $encoding
  120.      * @return void
  121.      */
  122.     public static function setEncoding($encoding)
  123.     {
  124.         $generator    = static::getGenerator();
  125.         $newGenerator = new $generator($encoding);
  126.         static::setGenerator($newGenerator);
  127.     }
  128.  
  129.     /**
  130.      * Return the value of this object, convert the XML-RPC native value into a PHP variable
  131.      *
  132.      * @return mixed
  133.      */
  134.     abstract public function getValue();
  135.  
  136.  
  137.     /**
  138.      * Return the XML code that represent a native MXL-RPC value
  139.      *
  140.      * @return string
  141.      */
  142.     public function saveXml()
  143.     {
  144.         if (!$this->xml) {
  145.             $this->generateXml();
  146.             $this->xml = (string) $this->getGenerator();
  147.         }
  148.         return $this->xml;
  149.     }
  150.  
  151.     /**
  152.      * Generate XML code that represent a native XML/RPC value
  153.      *
  154.      * @return void
  155.      */
  156.     public function generateXml()
  157.     {
  158.         $this->_generateXml();
  159.     }
  160.  
  161.     /**
  162.      * Creates a Value* object, representing a native XML-RPC value
  163.      * A XmlRpcValue object can be created in 3 ways:
  164.      * 1. Autodetecting the native type out of a PHP variable
  165.      *    (if $type is not set or equal to Value::AUTO_DETECT_TYPE)
  166.      * 2. By specifying the native type ($type is one of the Value::XMLRPC_TYPE_* constants)
  167.      * 3. From a XML string ($type is set to Value::XML_STRING)
  168.      *
  169.      * By default the value type is autodetected according to it's PHP type
  170.      *
  171.      * @param  mixed $value
  172.      * @param  Zend\XmlRpc\Value::constant $type
  173.      * @throws Exception\ValueException
  174.      * @return AbstractValue
  175.      */
  176.     public static function getXmlRpcValue($value, $type = self::AUTO_DETECT_TYPE)
  177.     {
  178.         switch ($type) {
  179.             case self::AUTO_DETECT_TYPE:
  180.                 // Auto detect the XML-RPC native type from the PHP type of $value
  181.                 return static::_phpVarToNativeXmlRpc($value);
  182.  
  183.             case self::XML_STRING:
  184.                 // Parse the XML string given in $value and get the XML-RPC value in it
  185.                 return static::_xmlStringToNativeXmlRpc($value);
  186.  
  187.             case self::XMLRPC_TYPE_I4:
  188.                 // fall through to the next case
  189.             case self::XMLRPC_TYPE_INTEGER:
  190.                 return new Value\Integer($value);
  191.  
  192.             case self::XMLRPC_TYPE_I8:
  193.                 // fall through to the next case
  194.             case self::XMLRPC_TYPE_APACHEI8:
  195.                 return new Value\BigInteger($value);
  196.  
  197.             case self::XMLRPC_TYPE_DOUBLE:
  198.                 return new Value\Double($value);
  199.  
  200.             case self::XMLRPC_TYPE_BOOLEAN:
  201.                 return new Value\Boolean($value);
  202.  
  203.             case self::XMLRPC_TYPE_STRING:
  204.                 return new Value\String($value);
  205.  
  206.             case self::XMLRPC_TYPE_BASE64:
  207.                 return new Value\Base64($value);
  208.  
  209.             case self::XMLRPC_TYPE_NIL:
  210.                 // fall through to the next case
  211.             case self::XMLRPC_TYPE_APACHENIL:
  212.                 return new Value\Nil();
  213.  
  214.             case self::XMLRPC_TYPE_DATETIME:
  215.                 return new Value\DateTime($value);
  216.  
  217.             case self::XMLRPC_TYPE_ARRAY:
  218.                 return new Value\ArrayValue($value);
  219.  
  220.             case self::XMLRPC_TYPE_STRUCT:
  221.                 return new Value\Struct($value);
  222.  
  223.             default:
  224.                 throw new Exception\ValueException('Given type is not a '. __CLASS__ .' constant');
  225.         }
  226.     }
  227.  
  228.     /**
  229.      * Get XML-RPC type for a PHP native variable
  230.      *
  231.      * @static
  232.      * @param mixed $value
  233.      * @throws Exception\InvalidArgumentException
  234.      * @return string
  235.      */
  236.     public static function getXmlRpcTypeByValue($value)
  237.     {
  238.         if (is_object($value)) {
  239.             if ($value instanceof AbstractValue) {
  240.                 return $value->getType();
  241.             } elseif ($value instanceof DateTime) {
  242.                 return self::XMLRPC_TYPE_DATETIME;
  243.             }
  244.             return static::getXmlRpcTypeByValue(get_object_vars($value));
  245.         } elseif (is_array($value)) {
  246.             if (!empty($value) && is_array($value) && (array_keys($value) !== range(0, count($value) - 1))) {
  247.                 return self::XMLRPC_TYPE_STRUCT;
  248.             }
  249.             return self::XMLRPC_TYPE_ARRAY;
  250.         } elseif (is_int($value)) {
  251.             return ($value > PHP_INT_MAX) ? self::XMLRPC_TYPE_I8 : self::XMLRPC_TYPE_INTEGER;
  252.         } elseif (is_double($value)) {
  253.             return self::XMLRPC_TYPE_DOUBLE;
  254.         } elseif (is_bool($value)) {
  255.             return self::XMLRPC_TYPE_BOOLEAN;
  256.         } elseif (null === $value) {
  257.             return self::XMLRPC_TYPE_NIL;
  258.         } elseif (is_string($value)) {
  259.             return self::XMLRPC_TYPE_STRING;
  260.         }
  261.         throw new Exception\InvalidArgumentException(sprintf(
  262.             'No matching XMLRPC type found for php type %s.',
  263.             gettype($value)
  264.         ));
  265.     }
  266.  
  267.     /**
  268.      * Transform a PHP native variable into a XML-RPC native value
  269.      *
  270.      * @param mixed $value The PHP variable for conversion
  271.      *
  272.      * @throws Exception\InvalidArgumentException
  273.      * @return AbstractValue
  274.      * @static
  275.      */
  276.     protected static function _phpVarToNativeXmlRpc($value)
  277.     {
  278.         // @see http://framework.zend.com/issues/browse/ZF-8623
  279.         if ($value instanceof AbstractValue) {
  280.             return $value;
  281.         }
  282.  
  283.         switch (static::getXmlRpcTypeByValue($value)) {
  284.             case self::XMLRPC_TYPE_DATETIME:
  285.                 return new Value\DateTime($value);
  286.  
  287.             case self::XMLRPC_TYPE_ARRAY:
  288.                 return new Value\ArrayValue($value);
  289.  
  290.             case self::XMLRPC_TYPE_STRUCT:
  291.                 return new Value\Struct($value);
  292.  
  293.             case self::XMLRPC_TYPE_INTEGER:
  294.                 return new Value\Integer($value);
  295.  
  296.             case self::XMLRPC_TYPE_DOUBLE:
  297.                 return new Value\Double($value);
  298.  
  299.             case self::XMLRPC_TYPE_BOOLEAN:
  300.                 return new Value\Boolean($value);
  301.  
  302.             case self::XMLRPC_TYPE_NIL:
  303.                 return new Value\Nil;
  304.  
  305.             case self::XMLRPC_TYPE_STRING:
  306.                 // Fall through to the next case
  307.             default:
  308.                 // If type isn't identified (or identified as string), it treated as string
  309.                 return new Value\String($value);
  310.         }
  311.     }
  312.  
  313.     /**
  314.      * Transform an XML string into a XML-RPC native value
  315.      *
  316.      * @param string|\SimpleXMLElement $xml A SimpleXMLElement object represent the XML string
  317.      * It can be also a valid XML string for conversion
  318.      *
  319.      * @throws Exception\ValueException
  320.      * @return \Zend\XmlRpc\AbstractValue
  321.      * @static
  322.      */
  323.     protected static function _xmlStringToNativeXmlRpc($xml)
  324.     {
  325.         static::_createSimpleXMLElement($xml);
  326.  
  327.         static::_extractTypeAndValue($xml, $type, $value);
  328.  
  329.         switch ($type) {
  330.             // All valid and known XML-RPC native values
  331.             case self::XMLRPC_TYPE_I4:
  332.                 // Fall through to the next case
  333.             case self::XMLRPC_TYPE_INTEGER:
  334.                 $xmlrpcValue = new Value\Integer($value);
  335.                 break;
  336.             case self::XMLRPC_TYPE_APACHEI8:
  337.                 // Fall through to the next case
  338.             case self::XMLRPC_TYPE_I8:
  339.                 $xmlrpcValue = new Value\BigInteger($value);
  340.                 break;
  341.             case self::XMLRPC_TYPE_DOUBLE:
  342.                 $xmlrpcValue = new Value\Double($value);
  343.                 break;
  344.             case self::XMLRPC_TYPE_BOOLEAN:
  345.                 $xmlrpcValue = new Value\Boolean($value);
  346.                 break;
  347.             case self::XMLRPC_TYPE_STRING:
  348.                 $xmlrpcValue = new Value\String($value);
  349.                 break;
  350.             case self::XMLRPC_TYPE_DATETIME:  // The value should already be in a iso8601 format
  351.                 $xmlrpcValue = new Value\DateTime($value);
  352.                 break;
  353.             case self::XMLRPC_TYPE_BASE64:    // The value should already be base64 encoded
  354.                 $xmlrpcValue = new Value\Base64($value, true);
  355.                 break;
  356.             case self::XMLRPC_TYPE_NIL:
  357.                 // Fall through to the next case
  358.             case self::XMLRPC_TYPE_APACHENIL:
  359.                 // The value should always be NULL
  360.                 $xmlrpcValue = new Value\Nil();
  361.                 break;
  362.             case self::XMLRPC_TYPE_ARRAY:
  363.                 // PHP 5.2.4 introduced a regression in how empty($xml->value)
  364.                 // returns; need to look for the item specifically
  365.                 $data = null;
  366.                 foreach ($value->children() as $key => $value) {
  367.                     if ('data' == $key) {
  368.                         $data = $value;
  369.                         break;
  370.                     }
  371.                 }
  372.  
  373.                 if (null === $data) {
  374.                     throw new Exception\ValueException('Invalid XML for XML-RPC native '. self::XMLRPC_TYPE_ARRAY .' type: ARRAY tag must contain DATA tag');
  375.                 }
  376.                 $values = array();
  377.                 // Parse all the elements of the array from the XML string
  378.                 // (simple xml element) to Value objects
  379.                 foreach ($data->value as $element) {
  380.                     $values[] = static::_xmlStringToNativeXmlRpc($element);
  381.                 }
  382.                 $xmlrpcValue = new Value\ArrayValue($values);
  383.                 break;
  384.             case self::XMLRPC_TYPE_STRUCT:
  385.                 $values = array();
  386.                 // Parse all the members of the struct from the XML string
  387.                 // (simple xml element) to Value objects
  388.                 foreach ($value->member as $member) {
  389.                     // @todo? If a member doesn't have a <value> tag, we don't add it to the struct
  390.                     // Maybe we want to throw an exception here ?
  391.                     if (!isset($member->value) or !isset($member->name)) {
  392.                         continue;
  393.                         //throw new Value_Exception('Member of the '. self::XMLRPC_TYPE_STRUCT .' XML-RPC native type must contain a VALUE tag');
  394.                     }
  395.                     $values[(string) $member->name] = static::_xmlStringToNativeXmlRpc($member->value);
  396.                 }
  397.                 $xmlrpcValue = new Value\Struct($values);
  398.                 break;
  399.             default:
  400.                 throw new Exception\ValueException('Value type \''. $type .'\' parsed from the XML string is not a known XML-RPC native type');
  401.                 break;
  402.         }
  403.         $xmlrpcValue->_setXML($xml->asXML());
  404.  
  405.         return $xmlrpcValue;
  406.     }
  407.  
  408.     protected static function _createSimpleXMLElement(&$xml)
  409.     {
  410.         if ($xml instanceof \SimpleXMLElement) {
  411.             return;
  412.         }
  413.  
  414.         try {
  415.             $xml = new \SimpleXMLElement($xml);
  416.         } catch (\Exception $e) {
  417.             // The given string is not a valid XML
  418.             throw new Exception\ValueException('Failed to create XML-RPC value from XML string: ' . $e->getMessage(), $e->getCode(), $e);
  419.         }
  420.     }
  421.  
  422.     /**
  423.      * Extract XML/RPC type and value from SimpleXMLElement object
  424.      *
  425.      * @param \SimpleXMLElement $xml
  426.      * @param string &$type Type bind variable
  427.      * @param string &$value Value bind variable
  428.      * @return void
  429.      */
  430.     protected static function _extractTypeAndValue(\SimpleXMLElement $xml, &$type, &$value)
  431.     {
  432.         list($type, $value) = each($xml);
  433.         if (!$type and $value === null) {
  434.             $namespaces = array('ex' => 'http://ws.apache.org/xmlrpc/namespaces/extensions');
  435.             foreach ($namespaces as $namespaceName => $namespaceUri) {
  436.                 $namespaceXml = $xml->children($namespaceUri);
  437.                 list($type, $value) = each($namespaceXml);
  438.                 if ($type !== null) {
  439.                     $type = $namespaceName . ':' . $type;
  440.                     break;
  441.                 }
  442.             }
  443.         }
  444.  
  445.         // If no type was specified, the default is string
  446.         if (!$type) {
  447.             $type = self::XMLRPC_TYPE_STRING;
  448.             if (empty($value) and preg_match('#^<value>.*</value>$#', $xml->asXML())) {
  449.                 $value = str_replace(array('<value>', '</value>'), '', $xml->asXML());
  450.             }
  451.         }
  452.     }
  453.  
  454.     /**
  455.      * @param $xml
  456.      * @return void
  457.      */
  458.     protected function _setXML($xml)
  459.     {
  460.         $this->xml = $this->getGenerator()->stripDeclaration($xml);
  461.     }
  462. }
# Change User Description Committed
#1 18334 Liz Lam initial add of jambox 9 years ago