Innmind\AMQP\Transport\Protocol\v091\Queue

Complexity

Total Complexity

8

Size/Duplication

Total Lines	98
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	declare()	0	21	2
A	delete()	0	11	1
A	unbind()	0	10	1
A	purge()	0	8	1
A	bind()	0	11	1
A	translate()	0	9	1

<?php
declare(strict_types = 1);

namespace Innmind\AMQP\Transport\Protocol\v091;

use Innmind\AMQP\{
    Model\Queue\Declaration,
    Model\Queue\Deletion,
    Model\Queue\Binding,
    Model\Queue\Unbinding,
    Model\Queue\Purge,
    Transport\Frame,
    Transport\Frame\Channel as FrameChannel,
    Transport\Frame\Type,
    Transport\Frame\Value,
    Transport\Frame\Value\UnsignedShortInteger,
    Transport\Frame\Value\ShortString,
    Transport\Frame\Value\Bits,
    Transport\Frame\Value\Table,
    Transport\Protocol\Queue as QueueInterface,
    Transport\Protocol\ArgumentTranslator,
};
use Innmind\Math\Algebra\Integer;
use Innmind\Immutable\{
    Str,
    MapInterface,
    Map,
};

final class Queue implements QueueInterface
{
    private $translate;

    public function __construct(ArgumentTranslator $translator)
    {
        $this->translate = $translator;
    }

    public function declare(FrameChannel $channel, Declaration $command): Frame
    {
        $name = '';

        if (!$command->shouldAutoGenerateName()) {
            $name = $command->name();
        }

        return Frame::method(
            $channel,
            Methods::get('queue.declare'),
            new UnsignedShortInteger(new Integer(0)), //ticket (reserved)
            ShortString::of(new Str($name)),
            new Bits(
                $command->isPassive(),
                $command->isDurable(),
                $command->isExclusive(),
                $command->isAutoDeleted(),
                !$command->shouldWait()
            ),
            $this->translate($command->arguments())
        );
    }

    public function delete(FrameChannel $channel, Deletion $command): Frame
    {
        return Frame::method(
            $channel,
            Methods::get('queue.delete'),
            new UnsignedShortInteger(new Integer(0)), //ticket (reserved)
            ShortString::of(new Str($command->name())),
            new Bits(
                $command->onlyIfUnused(),
                $command->onlyIfEmpty(),
                !$command->shouldWait()
            )
        );
    }

    public function bind(FrameChannel $channel, Binding $command): Frame
    {
        return Frame::method(
            $channel,
            Methods::get('queue.bind'),
            new UnsignedShortInteger(new Integer(0)), //ticket (reserved)
            ShortString::of(new Str($command->queue())),
            ShortString::of(new Str($command->exchange())),
            ShortString::of(new Str($command->routingKey())),
            new Bits(!$command->shouldWait()),
            $this->translate($command->arguments())
        );
    }

    public function unbind(FrameChannel $channel, Unbinding $command): Frame
    {
        return Frame::method(
            $channel,
            Methods::get('queue.unbind'),
            new UnsignedShortInteger(new Integer(0)), //ticket (reserved)
            ShortString::of(new Str($command->queue())),
            ShortString::of(new Str($command->exchange())),
            ShortString::of(new Str($command->routingKey())),
            $this->translate($command->arguments())
        );
    }

    public function purge(FrameChannel $channel, Purge $command): Frame
    {
        return Frame::method(
            $channel,
            Methods::get('queue.purge'),
            new UnsignedShortInteger(new Integer(0)), //ticket (reserved)
            ShortString::of(new Str($command->name())),
            new Bits(!$command->shouldWait())
        );
    }

    /**
     * @param MapInterface<string, mixed> $arguments
     */
    private function translate(MapInterface $arguments): Table
    {
        return new Table(
            $arguments->reduce(
                new Map('string', Value::class),
                function(Map $carry, string $key, $value): Map {
                    return $carry->put(
                        $key,
                        ($this->translate)($value)
                    );
                }
            )
        );
    }
}