CallableObject.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 CallableObject implements \fpoirotte\XRL\CallableInterface
{
    protected $callableObj;

    protected $representation;

    private static $patched;

    public function __construct($callable)
    {
        if (!is_callable($callable, false, $representation)) {
            throw new \InvalidArgumentException('Not a valid callable');
        }

        if (!self::$patched) {
            self::$patched = true;
            // @codeCoverageIgnoreStart
            // Adds support for references to invoke() on PHP 5.6.0+.
            if (version_compare(PHP_VERSION, '5.6.0', '>=') &&
                function_exists('runkit_method_redefine')) {
                runkit_method_redefine(
                    __CLASS__,
                    '__invoke',
                    '&...$args',
                    'return call_user_func_array($this->callableObj, $args);'
                );
            }
            // @codeCoverageIgnoreEnd
        }

        // This happens for anonymous functions
        // created with create_function().
        if (is_string($callable) && $representation == "") {
            $representation = $callable;
        }

        $this->callableObj    = $callable;
        $this->representation = $representation;
    }

    public function getCallable()
    {
        return $this->callableObj;
    }

    public function getRepresentation()
    {
        return $this->representation;
    }

    public function invokeArgs(array &$args)
    {
        $newArgs = array();
        foreach ($args as &$arg) {
            $newArgs[] =& $arg;
        }
        return call_user_func_array($this->callableObj, $newArgs);
    }

    public function __invoke()
    {
        return call_user_func_array($this->callableObj, func_get_args());
    }

    public function __toString()
    {
        return $this->representation;
    }

    public function getReflector()
    {
        $parts = explode('::', $this->representation);

        // Did we wrap a function?
        if (count($parts) == 1) {
            return new \ReflectionFunction($this->callableObj);
        }

        // Did we wrap a Closure or some invokable object?
        if (!is_array($this->callableObj)) {
            $callable = array($this->callableObj, $parts[1]);
        } else {
            $callable = $this->callableObj;
        }
        return new \ReflectionMethod($callable[0], $callable[1]);
    }
}