Innmind\AMQP\Transport\Protocol\Delegate

Complexity

Total Complexity

14

Size/Duplication

Total Lines	91
Duplicated Lines	0 %

Test Coverage

Coverage

70.27%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	transaction()	0	3	1
A	connection()	0	3	1
A	basic()	0	3	1
A	channel()	0	3	1
A	method()	0	3	1
A	readHeader()	0	3	1
A	read()	0	3	1
A	queue()	0	3	1
A	version()	0	3	1
A	exchange()	0	3	1
A	__construct()	0	7	1
A	use()	0	21	3

<?php
declare(strict_types = 1);

namespace Innmind\AMQP\Transport\Protocol;

use Innmind\AMQP\{
    Transport\Protocol,
    Transport\Frame\Method,
    Exception\VersionNotUsable,
};
use Innmind\Stream\Readable;
use Innmind\Immutable\{
    Sequence,
    StreamInterface,
};

final class Delegate implements Protocol
{
    private $protocols;
    private $inUse;

    public function __construct(Protocol $first, Protocol ...$protocols)
    {
        $protocols = Sequence::of($first, ...$protocols)->sort(static function(Protocol $a, Protocol $b): bool {
            return $b->version()->higherThan($a->version());
        });
        $this->inUse = $protocols->first();
        $this->protocols = $protocols;
    }

    public function version(): Version
    {
        return $this->inUse->version();
    }

    public function use(Version $version): Protocol
    {
        $protocols = $this
            ->protocols
            ->filter(static function(Protocol $protocol) use ($version): bool {
                try {
                    $protocol->use($version);

                    return true;
                } catch (VersionNotUsable $e) {
                    return false;
                }
            });

        if ($protocols->size() === 0) {
            throw new VersionNotUsable($version);
        }

        $this->inUse = $protocols->first();

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function read(Method $method, Readable $arguments): StreamInterface
    {
        return $this->inUse->read($method, $arguments);
    }

    /**
     * {@inheritdoc}
     */
    public function readHeader(Readable $arguments): StreamInterface
    {
        return $this->inUse->readHeader($arguments);
    }

    public function method(string $name): Method
    {
        return $this->inUse->method($name);
    }

    public function connection(): Connection
    {
        return $this->inUse->connection();
    }

    public function channel(): Channel
    {
        return $this->inUse->channel();
    }

    public function exchange(): Exchange
    {
        return $this->inUse->exchange();
    }

    public function queue(): Queue
    {
        return $this->inUse->queue();
    }

    public function basic(): Basic
    {
        return $this->inUse->basic();
    }

    public function transaction(): Transaction
    {
        return $this->inUse->transaction();
    }
}