Server.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 Server implements \Countable, \IteratorAggregate, \ArrayAccess
{
    protected $XRLFunctions;

    protected $XRLEncoder;

    protected $XRLDecoder;


    public function __construct(
        \fpoirotte\XRL\EncoderInterface $encoder = null,
        \fpoirotte\XRL\DecoderInterface $decoder = null
    ) {
        if ($encoder === null) {
            $encoder = new \fpoirotte\XRL\NativeEncoder(
                new \fpoirotte\XRL\Encoder(null, false, true)
            );
        }

        if ($decoder === null) {
            $decoder = new \fpoirotte\XRL\NativeDecoder(
                new \fpoirotte\XRL\Decoder(null, true)
            );
        }

        $this->XRLEncoder   = $encoder;
        $this->XRLDecoder   = $decoder;
        $this->XRLFunctions = array();
    }

    public function __set($func, $callback)
    {
        $this->XRLFunctions[$func] = new \fpoirotte\XRL\CallableObject($callback);
    }

    public function offsetSet($func, $callback)
    {
        $this->XRLFunctions[$func] = new \fpoirotte\XRL\CallableObject($callback);
    }

    public function __get($func)
    {
        return $this->XRLFunctions[$func];
    }

    public function offsetGet($func)
    {
        return $this->XRLFunctions[$func];
    }

    public function __isset($func)
    {
        return isset($this->XRLFunctions[$func]);
    }

    public function offsetExists($func)
    {
        return isset($this->XRLFunctions[$func]);
    }

    public function __unset($func)
    {
        unset($this->XRLFunctions[$func]);
    }

    public function offsetUnset($func)
    {
        unset($this->XRLFunctions[$func]);
    }

    public function count()
    {
        return count($this->XRLFunctions);
    }

    public function getIterator()
    {
        return new \ArrayIterator($this->XRLFunctions);
    }

    public function expose($other, $prefix = '')
    {
        if (!is_string($other) && !is_object($other)) {
            throw new \InvalidArgumentException('Invalid adoption');
        }

        if (!is_string($prefix)) {
            throw new \InvalidArgumentException('Invalid prefix');
        }

        $prefix = rtrim($prefix, '.');
        if ($prefix !== '') {
            $prefix .= '.';
        }

        if (is_object($other)) {
            // An object was passed.
            $class = get_class($other);
            foreach (get_class_methods($class) as $method) {
                // Only adopt public methods of the object,
                // excluding the constructor and static methods.
                // To also register static methods, call this method
                // a second time with get_class($other).
                $reflector = new \ReflectionMethod($class, $method);
                if ($reflector->isPublic() && !$reflector->isConstructor() &&
                    !$reflector->isStatic()) {
                    $this[$prefix . $method] = array($other, $method);
                }
            }
        } else {
            // A class was passed.
            foreach (get_class_methods($other) as $method) {
                // Only adopt methods which are both public and static.
                $reflector = new \ReflectionMethod($other, $method);
                if ($reflector->isPublic() && $reflector->isStatic()) {
                    $this[$prefix . $method] = array($other, $method);
                }
            }
        }
    }

    public function handle($URI = null)
    {
        if ($URI === null) {
            $URI = 'php://input';
        }

        try {
            $request    = $this->XRLDecoder->decodeRequest($URI);
            $procedure  = $request->getProcedure();
            // Necessary to keep references.
            $params     = $request->getParams();

            $result     = $this->call($procedure, $params);
            $response   = $this->XRLEncoder->encodeResponse($result);
        } catch (\Exception $result) {
            $response   = $this->XRLEncoder->encodeError($result);
        }

        return new \fpoirotte\XRL\Response($response);
    }

    public function call($procedure, array $params)
    {
        if (!is_string($procedure)) {
            throw new \BadFunctionCallException('Expected a string');
        }

        if (!isset($this->XRLFunctions[$procedure])) {
            throw \fpoirotte\XRL\Faults::get(\fpoirotte\XRL\Faults::METHOD_NOT_FOUND);
        }

        $callable = $this->XRLFunctions[$procedure];
        return $callable->invokeArgs($params);
    }
}