JClaveau\Async\DeferredCallChain

Complexity

Total Complexity

13

Size/Duplication

Total Lines	140
Duplicated Lines	0 %

Importance

Changes	4
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	offsetSet()	0	4	1
A	offsetGet()	0	7	1
A	__toString()	0	19	3
A	__invoke()	0	19	4
A	__call()	0	8	1
A	offsetExists()	0	4	1
A	offsetUnset()	0	4	1
A	jsonSerialize()	0	3	1

<?php
/**
 * DeferredCallChain
 *
 * @package php-deferred-callchain
 * @author  Jean Claveau
 */
namespace JClaveau\Async;
use       BadMethodCallException;

/**
 * This class stores an arbitrary stack of calls (methods or array entries access)
 * that will be callable on any future variable.
 */
class DeferredCallChain implements \JsonSerializable, \ArrayAccess
{
    use Jclaveau\Traits\Fluent\New_;

The type JClaveau\Async\Jclaveau\Traits\Fluent\New_ was not found. Did you mean Jclaveau\Traits\Fluent\New_? If so, make sure to prefix the type with \.

    
    /** @var array $stack The stack of deferred calls */
    protected $stack = [];

    /**
     * ArrayAccess interface
     *
     * @param string $key The entry to acces
     */
    public function &offsetGet($key)
    {
        $this->stack[] = [
            'entry' => $key,
        ];

        return $this;
    }

    /**
     * Stores any call in the the stack.
     *
     * @param  string $method
     * @param  array  $arguments
     *
     * @return $this
     */
    public final function __call($method, array $arguments)
    {
        $this->stack[] = [
            'method'    => $method,
            'arguments' => $arguments,
        ];

        return $this;
    }

    /**
     * For implementing JsonSerializable interface.
     *
     * @see https://secure.php.net/manual/en/jsonserializable.jsonserialize.php
     */
    public function jsonSerialize()
    {
        return $this->stack;
    }

    /**
     * Outputs the PHP code producing the current call chain while it's casted
     * as a string.
     *
     * @return string The PHP code corresponding to this call chain
     */
    public function __toString()
    {
        $string = '(new ' . get_called_class() . ')';

        foreach ($this->stack as $i => $call) {
            if (isset($call['method'])) {
                $string .= '->';
                $string .= $call['method'].'(';
                $string .= implode(', ', array_map(function($argument) {
                    return var_export($argument, true);
                }, $call['arguments']));
                $string .= ')';
            }
            else {
                $string .= '[' . var_export($call['entry'], true) . ']';
            }
        }

        return $string;
    }

    /**
     * Invoking the instance produces the call of the stack
     *
     * @param  $target The target to apply the callchain on

The type JClaveau\Async\The was not found. Maybe you did not declare it correctly or list all dependencies?

     * @return The value returned once the call chain is called uppon $target
     */
    public function __invoke($target)
    {
        $out = $target;
        foreach ($this->stack as $i => $call) {
            try {
                if (isset($call['method'])) {
                    $out = call_user_func_array([$out, $call['method']], $call['arguments']);
                }
                else {
                    $out = $out[ $call['entry'] ];
                }
            }
            catch (\Exception $e) {
                // Throw $e with the good stack (usage exception)
                throw $e;
            }
        }

        return $out;
    }

    /**
     * Unused part of the ArrayAccess interface
     *
     * @param  $offset
     * @param  $value
     * @throws \BadMethodCallException
     */
    public function offsetSet($offset, $value)
    {
        throw new BadMethodCallException(
            "not implemented"
        );
    }

    /**
     * Unused part of the ArrayAccess interface
     *
     * @param  $offset
     * @throws \BadMethodCallException
     */
    public function offsetExists($offset)
    {
        throw new BadMethodCallException(
            "not implemented"
        );
    }

    /**
     * Unused part of the ArrayAccess interface
     *
     * @param  $offset
     * @throws \BadMethodCallException
     */
    public function offsetUnset($offset)
    {
        throw new BadMethodCallException(
            "not implemented"
        );
    }

    /**/
}