NativeEncoder.php

<?php
/*
 * This file is part of XRL, a simple XML-RPC Library for PHP.
 *
 * Copyright (c) 2012, XRL Team. All rights reserved.
 * XRL is licensed under the 3-clause BSD License.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace fpoirotte\XRL;

class NativeEncoder implements \fpoirotte\XRL\EncoderInterface
{
    protected $encoder;

    public function __construct(\fpoirotte\XRL\EncoderInterface $encoder)
    {
        $this->encoder = $encoder;
    }

    protected static function isUTF8($text)
    {
        // From http://w3.org/International/questions/qa-forms-utf-8.html
        // Pointed out by bitseeker on http://php.net/utf8_encode
        return (bool) preg_match(
            '%^(?:
                  [\x09\x0A\x0D\x20-\x7E]            # ASCII
                | [\xC2-\xDF][\x80-\xBF]             # non-overlong 2-byte
                |  \xE0[\xA0-\xBF][\x80-\xBF]        # excluding overlongs
                | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}  # straight 3-byte
                |  \xED[\x80-\x9F][\x80-\xBF]        # excluding surrogates
                |  \xF0[\x90-\xBF][\x80-\xBF]{2}     # planes 1-3
                | [\xF1-\xF3][\x80-\xBF]{3}          # planes 4-15
                |  \xF4[\x80-\x8F][\x80-\xBF]{2}     # plane 16
            )*$%SDxs',
            $text
        );
    }

    public static function convert($value)
    {
        switch (gettype($value)) {
            case 'NULL':
                // Support for the <nil> extension
                // (http://ontosys.com/xml-rpc/extensions.php)
                return new \fpoirotte\XRL\Types\Nil(null);

            case 'boolean':
                return new \fpoirotte\XRL\Types\Boolean($value);

            case 'integer':
                try {
                    return new \fpoirotte\XRL\Types\I4($value);
                } catch (\InvalidArgumentException $e) {
                }
                return new \fpoirotte\XRL\Types\I8($value);

            case 'double':
                return new \fpoirotte\XRL\Types\Double($value);

            case 'string':
                // Encode as a regular string if possible.
                if (static::isUTF8($value)) {
                    return new \fpoirotte\XRL\Types\StringType($value);
                }
                return new \fpoirotte\XRL\Types\Base64($value);

            case 'array':
                $newValue = array_map("static::convert", $value);
                try {
                    return new \fpoirotte\XRL\Types\ArrayType($newValue);
                } catch (\InvalidArgumentException $e) {
                }
                return new \fpoirotte\XRL\Types\Struct($newValue);

            case 'object':
            case 'resource':
                // A special treatment is applied afterwards.
                break;
        }

        // Only objects & resources remain after this point.
        if ($value instanceof \fpoirotte\XRL\Types\AbstractType) {
            return $value;
        }

        if ($value instanceof \GMP ||
            (is_resource($value) && get_resource_type($value) === 'GMP integer')) {
            $candidates = array(
                '\\fpoirotte\\XRL\\Types\\I4',
                '\\fpoirotte\\XRL\\Types\\I8',
                '\\fpoirotte\\XRL\\Types\\BigInteger',
            );
            foreach ($candidates as $candidate) {
                try {
                    return new $candidate($value);
                } catch (\InvalidArgumentException $e) {
                }
            }
        }

        if ($value instanceof \DateTime) {
            return new \fpoirotte\XRL\Types\DateTimeIso8601($value);
        }

        if (($value instanceof \DOMNode) ||
            ($value instanceof \XMLWriter) ||
            ($value instanceof \SimpleXMLElement)) {
            return new \fpoirotte\XRL\Types\Dom($value);
        }

        if ($value instanceof \Exception) {
            return new \fpoirotte\XRL\Types\Struct(
                array(
                    'faultCode'     => new \fpoirotte\XRL\Types\IntType($value->getCode()),
                    'faultString'   => new \fpoirotte\XRL\Types\StringType(
                        get_class($value).': '.$value->getMessage()
                    ),
                )
            );
        }

        if (is_object($value) && (
            ($value instanceof \Serializable) ||
            method_exists($value, '__sleep'))) {
            $value = serialize($value);

            // Encode as a regular string if possible.
            if (static::isUTF8($value)) {
                return new \fpoirotte\XRL\Types\StringType($value);
            }
            return new \fpoirotte\XRL\Types\Base64($value);
        }

        throw new \InvalidArgumentException('Unconvertible type');
    }

    public function encodeRequest(\fpoirotte\XRL\Request $request)
    {
        $newParams = array_map('static::convert', $request->getParams());
        return $this->encoder->encodeRequest(
            new \fpoirotte\XRL\Request($request->getProcedure(), $newParams)
        );
    }

    public function encodeError(\Exception $error)
    {
        return $this->encoder->encodeError($error);
    }

    public function encodeResponse($response)
    {
        return $this->encoder->encodeResponse(static::convert($response));
    }
}