Dazzle\Channel\Router\RouterRule

Complexity

Total Complexity

12

Size/Duplication

Total Lines	142
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	0

Test Coverage

Coverage

86.84%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	1
A	__destruct()	0	9	1
A	getRouter()	0	4	1
A	match()	0	5	1
A	handle()	0	16	3
A	cancel()	0	8	4
A	setPointer()	0	4	1

<?php

namespace Dazzle\Channel\Router;

use Dazzle\Channel\Protocol\ProtocolInterface;

class RouterRule
{
    /**
     * @var RouterInterface
     */
    protected $router;

    /**
     * @var callable
     */
    protected $matcher;

    /**
     * @var callable
     */
    protected $handler;

    /**
     * @var bool
     */
    protected $propagate;

    /**
     * @var int
     */
    protected $limit;

    /**
     * @var array|null
     */
    protected $pointer;

    /**
     * @var bool
     */
    protected $cancelled;

    /**
     * @param RouterInterface $router
     * @param callable $matcher
     * @param callable $handler
     * @param bool $propagate
     * @param int $limit
     */
    public function __construct(RouterInterface $router, callable $matcher, callable $handler, $propagate = false, $limit = 0)
    {
        $this->router = $router;
        $this->matcher = $matcher;
        $this->handler = $handler;
        $this->propagate = $propagate;
        $this->limit = $limit;
        $this->pointer = null;
        $this->cancelled = false;
    }

    /**
     *
     */
    public function __destruct()
    {
        unset($this->router);
        unset($this->matcher);
        unset($this->handler);
        unset($this->propagate);
        unset($this->pointer);
        unset($this->cancelled);
    }

    /**
     * Return Router to which handler is attached to.
     *
     * @return RouterInterface
     */
    public function getRouter()
    {
        return $this->router;
    }

    /**
     * Match given message protocol.
     *
     * @param string $sender
     * @param ProtocolInterface $protocol
     * @return bool
     */
    public function match($sender, ProtocolInterface $protocol)
    {
        $callback = $this->matcher;
        return $callback($sender, $protocol);
    }

    /**
     * Handle given message protocol.
     *
     * @param string $sender
     * @param ProtocolInterface $protocol
     * @param int $flags
     * @param callable|null $success
     * @param callable|null $failure
     * @param callable|null $cancel
     * @param float $timeout
     * @return bool
     */
    public function handle($sender, ProtocolInterface $protocol, $flags, callable $success = null, callable $failure = null, callable $cancel = null, $timeout = 0.0)
    {
        $callback = $this->handler;
        $callback($sender, $protocol, $flags, $success, $failure, $cancel, $timeout);

        if ($this->limit > 0)
        {
            $this->limit--;
            if ($this->limit === 0)
            {
                $this->cancel();
            }
        }

        return $this->propagate;
    }

    /**
     * Remove this handler.
     */
    public function cancel()
    {
        if (isset($this->pointer) && isset($this->router) && !$this->cancelled)
        {
            $this->router->removeHandler($this->pointer[0], $this->pointer[1]);

The method removeHandler() does not exist on Dazzle\Channel\Router\RouterInterface. Did you maybe mean handle()?

            $this->cancelled = true;
        }
    }

    /**
     * @internal
     * @param string $stack
     * @param int $pointer
     */
    public function setPointer($stack, $pointer)
    {
        $this->pointer = [ $stack, $pointer ];
    }
}