Lisachenko\Protocol\FCGI\Record\Params

Complexity

Total Complexity

16

Size/Duplication

Total Lines	102
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

100%

Importance

Changes

0

<?php

use Lisachenko\Protocol\FCGI;
use Lisachenko\Protocol\FCGI\Record;

/**
 * Params request record
 *
 * @author Alexander.Lisachenko
 */
class Params extends Record
{
    /**
     * List of params
     *
     * @var string[]
     * @phpstan-var array<string, string>
     */
    protected array $values = [];

This code did not parse for me. Apparently, there is an error somewhere around this line:

Syntax error, unexpected T_ARRAY, expecting T_FUNCTION or T_CONST

    /**
     * Constructs a param request
     *
     * @phpstan-param array<string, string> $values
     */
    public function __construct(array $values = [])
    {
        $this->type   = FCGI::PARAMS;
        $this->values = $values;
        $this->setContentData($this->packPayload());
    }

    /**
     * Returns an associative list of parameters
     *
     * @phpstan-return array<string, string>
     */
    public function getValues(): array
    {
        return $this->values;
    }

    /**
     * {@inheritdoc}
     */
    protected static function unpackPayload($self, string $binaryData): void
    {
        assert($self instanceof self);
        $currentOffset = 0;
        do {
            /** @phpstan-var false|array{nameLengthHigh: int} */
            $payload = unpack('CnameLengthHigh', $binaryData);
            if ($payload === false) {
                throw new \RuntimeException('Can not unpack data from the binary buffer');
            }
            [$nameLengthHigh] = array_values($payload);
            $isLongName  = ($nameLengthHigh >> 7 == 1);
            $valueOffset = $isLongName ? 4 : 1;

            /** @phpstan-var false|array{valueLengthHigh: int} */
            $payload = unpack('CvalueLengthHigh', substr($binaryData, $valueOffset));
            if ($payload === false) {
                throw new \RuntimeException('Can not unpack data from the binary buffer');
            }
            [$valueLengthHigh] = array_values($payload);
            $isLongValue = ($valueLengthHigh >> 7 == 1);
            $dataOffset  = $valueOffset + ($isLongValue ? 4 : 1);

            $formatParts = [
                $isLongName ? 'NnameLength' : 'CnameLength',
                $isLongValue ? 'NvalueLength' : 'CvalueLength',
            ];
            $format      = join('/', $formatParts);

            /** @phpstan-var false|array{nameLength: int, valueLength: int} */
            $payload = unpack($format, $binaryData);
            if ($payload === false) {
                throw new \RuntimeException('Can not unpack data from the binary buffer');
            }
            [$nameLength, $valueLength] = array_values($payload);

            // Clear top bit for long record
            $nameLength  &= ($isLongName ? 0x7fffffff : 0x7f);
            $valueLength &= ($isLongValue ? 0x7fffffff : 0x7f);

            /** @phpstan-var false|array{nameData: string, valueData: string} */
            $payload = unpack(
                "a{$nameLength}nameData/a{$valueLength}valueData",
                substr($binaryData, $dataOffset)
            );
            if ($payload === false) {
                throw new \RuntimeException('Can not unpack data from the binary buffer');
            }
            [$nameData, $valueData] = array_values($payload);

            $self->values[$nameData] = $valueData;

            $keyValueLength = $dataOffset + $nameLength + $valueLength;
            $binaryData     = substr($binaryData, $keyValueLength);
            $currentOffset  += $keyValueLength;
        } while ($currentOffset < $self->getContentLength());
    }

    /**