Value.php

Go to the documentation of this file.

<?php
 
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4 foldmethod=marker: */
 
// LICENSE AGREEMENT. If folded, press za here to unfold and read license {{{ 
 
// }}}
 
// dependencies {{{
require_once 'XML/RPC2/Exception.php';
require_once 'XML/RPC2/Value.php';
// }}}
 
abstract class XML_RPC2_Backend_Php_Value extends XML_RPC2_Value
{
    // {{{ properties
    
    private $_nativeValue = null;
    
    // }}}
    // {{{ getNativeValue()
    
    public function getNativeValue() 
    {
        return $this->_nativeValue;
    } 
 
    // }}}
    // {{{ setNativeValue()
    
    protected function setNativeValue($value)
    {
        $this->_nativeValue = $value;
    }
    
    // }}}  
    // {{{ createFromNative()
    
    public static function createFromNative($nativeValue, $explicitType = null) 
    {
        if (is_null($explicitType)) {
            switch (gettype($nativeValue)) {
                case 'boolean':
                    $explicitType = 'boolean';
                    break;
                case 'integer':
                    $explicitType = 'int';
                    break;
                case 'double':
                    $explicitType = 'double';
                    break;
                case 'string':
                    $explicitType = 'string';
                    break;
                case 'array':
                    $explicitType = 'array';
                    $keys = array_keys($nativeValue);
                    if (count($keys) > 0) {
                        if ($keys[0] !== 0 && ($keys[0] !== 1)) $explicitType = 'struct';
                        $i=0;
                        do {
                            $previous = $keys[$i];
                            $i++;
                            if (array_key_exists($i, $keys) && ($keys[$i] !== $keys[$i - 1] + 1)) $explicitType = 'struct';
                        } while (array_key_exists($i, $keys) && $explicitType == 'array');
                    }
                    break;
                case 'object':
                    if ((strtolower(get_class($nativeValue)) == 'stdclass') && (isset($nativeValue->xmlrpc_type))) {
                        // In this case, we have a "stdclass native value" (emulate xmlrpcext)
                        // the type 'base64' or 'datetime' is given by xmlrpc_type public property 
                        $explicitType = $nativeValue->xmlrpc_type;
                    } else {
                            $nativeValue = serialize($nativeValue);
                            $explicitType = 'base64';
                    }
                    break;
                case 'resource':
                case 'NULL':
                case 'unknown type':
                    throw new XML_RPC2_InvalidTypeEncodeException(sprintf('Impossible to encode value \'%s\' from type \'%s\'. No analogous type in XML_RPC.', 
                        (string) $nativeValue,
                        gettype($nativeValue)));
                default:
                    throw new XML_RPC2_InvalidTypeEncodeException(sprintf('Unexpected PHP native type returned by gettype: \'%s\', for value \'%s\'',
                        gettype($nativeValue),
                        (string) $nativeValue));
            }
        }        
        $explicitType = ucfirst(strtolower($explicitType));
        switch ($explicitType) {
            case 'I4':
            case 'Int':
            case 'Boolean':
            case 'Double':
            case 'String':
                require_once 'XML/RPC2/Backend/Php/Value/Scalar.php';
                return XML_RPC2_Backend_Php_Value_Scalar::createFromNative($nativeValue);
                break;
            case 'Datetime.iso8601':
            case 'Datetime':    
                require_once 'XML/RPC2/Backend/Php/Value/Datetime.php';
                return new XML_RPC2_Backend_Php_Value_Datetime($nativeValue);
                break;
            case 'Base64':
                require_once 'XML/RPC2/Backend/Php/Value/Base64.php';
                return new XML_RPC2_Backend_Php_Value_Base64($nativeValue);
                break;
            case 'Array':
                require_once 'XML/RPC2/Backend/Php/Value/Array.php';
                return new XML_RPC2_Backend_Php_Value_Array($nativeValue);
                break;
            case 'Struct':
                require_once 'XML/RPC2/Backend/Php/Value/Struct.php';
                return new XML_RPC2_Backend_Php_Value_Struct($nativeValue);
                break;
            default:
                throw new XML_RPC2_InvalidTypeEncodeException(sprintf('Unexpected explicit encoding type \'%s\'', $explicitType));
        }
    }
    
    // }}}
    // {{{ createFromDecode()
    
    public static function createFromDecode($simpleXML) 
    {
        // TODO Remove reparsing of XML fragment, when SimpleXML proves more solid. Currently it segfaults when
        // xpath is used both in an element and in one of its children
        $simpleXML = simplexml_load_string($simpleXML->asXML());
        
        $valueType = $simpleXML->xpath('./*');
        if (count($valueType) == 1) { // Usually we must check the node name
            $nodename = dom_import_simplexml($valueType[0])->nodeName;
            switch ($nodename) {
                case 'i4':
                case 'int':
                    $nativeType = 'Integer';
                    break;
                case 'boolean':
                    $nativeType = 'Boolean';
                    break;
                case 'double':
                    $nativeType = 'Double';
                    break;
                case 'string':
                    $nativeType = 'String';
                    break;
                case 'dateTime.iso8601':
                    $nativeType = 'Datetime';
                    break;
                case 'base64':
                    $nativeType = 'Base64';
                    break;
                case 'array':
                    $nativeType = 'Array';
                    break;
                case 'struct':
                    $nativeType = 'Struct';
                    break;
                default:
                    throw new XML_RPC2_DecodeException(sprintf('Unable to decode XML-RPC value. Value type is not recognized \'%s\'', $nodename));
            }
        } elseif (count($valueType) == 0) { // Default type is string
            $nodename = null;
            $nativeType = 'String';
        } else {
            throw new XML_RPC2_DecodeException(sprintf('Unable to decode XML-RPC value. Value presented %s type nodes: %s.', count($valueType), $simpleXML->asXML()));
        }
        require_once(sprintf('XML/RPC2/Backend/Php/Value/%s.php', $nativeType));
        $nativeType = 'XML_RPC2_Backend_Php_Value_' . $nativeType;
        return self::createFromNative(@call_user_func(array($nativeType, 'decode'), $simpleXML), $nodename);
    }
    
    // }}}
    // {{{ encode()
        
     // Declaration commented because of: http://pear.php.net/bugs/bug.php?id=8499
//    public abstract function encode();
    
    // }}}
    // {{{ decode()
    
     // Declaration commented because of: http://pear.php.net/bugs/bug.php?id=8499
//    public static abstract function decode($xml);
    
    // }}}
}
 
?>