Protocol::decompress() - Code Metrics - Inspection of "Feature swoole" - SeasX/seas-logger - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Pull Request — master (#12)

unknown

created 2019-09-12 05:39 UTC

Protocol::decompress() A

↳ Parent: Protocol

Complexity

Conditions	4
Paths	4

Size

Total Lines	15
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
cc	4
eloc	7
c	1
b	0
f	1
nc	4
nop	2
dl	0
loc	15
rs	10

<?php
declare(strict_types=1);

namespace Seasx\SeasLogger\Kafka;

use BadMethodCallException;
use Exception;
use function array_map;
use function array_shift;
use function array_values;
use function count;
use function gzdecode;
use function gzencode;
use function hex2bin;
use function in_array;
use function is_array;
use function pack;
use function strlen;
use function substr;
use function unpack;
use function version_compare;

abstract class Protocol
{
    public const NO_ERROR = 0;
    /**
     *  Default kafka broker verion
     */
    public const DEFAULT_BROKER_VERION = '0.9.0.0';

    /**
     *  Kafka server protocol version0
     */
    public const API_VERSION0 = 0;

    /**
     *  Kafka server protocol version 1
     */
    public const API_VERSION1 = 1;

    /**
     *  Kafka server protocol version 2
     */
    public const API_VERSION2 = 2;

    /**
     * use encode message, This is a version id used to allow backwards
     * compatible evolution of the message binary format.
     */
    public const MESSAGE_MAGIC_VERSION0 = 0;

    /**
     * use encode message, This is a version id used to allow backwards
     * compatible evolution of the message binary format.
     */
    public const MESSAGE_MAGIC_VERSION1 = 1;

    /**
     * message no compression
     */
    public const COMPRESSION_NONE = 0;

    /**
     * Message using gzip compression
     */
    public const COMPRESSION_GZIP = 1;

    /**
     * Message using Snappy compression
     */
    public const COMPRESSION_SNAPPY = 2;

    /**
     *  pack int32 type
     */
    public const PACK_INT32 = 0;

    /**
     * pack int16 type
     */
    public const PACK_INT16 = 1;

    /**
     * protocol request code
     */
    public const PRODUCE_REQUEST = 0;

    public const METADATA_REQUEST = 3;

    // unpack/pack bit
    public const BIT_B64 = 'N2';

    public const BIT_B32 = 'N';

    public const BIT_B16 = 'n';

    public const BIT_B16_SIGNED = 's';

    public const BIT_B8 = 'C';
    /**
     * gets set to true if the computer this code is running is little endian,
     * gets set to false if the computer this code is running on is big endian.
     *
     * @var null|bool
     */
    private static $isLittleEndianSystem;
    /**
     * @var string
     */
    protected $version = self::DEFAULT_BROKER_VERION;

    public function __construct(string $version = self::DEFAULT_BROKER_VERION)
    {
        $this->version = $version;
    }

    /**
     * @param array $array
     * @param callable $func
     * @param int|null $options
     * @return string
     */
    public static function encodeArray(array $array, callable $func, ?int $options = null): string
    {
        $arrayCount = count($array);

        $body = '';
        foreach ($array as $value) {
            $body .= $options !== null ? $func($value, $options) : $func($value);
        }

        return self::pack(self::BIT_B32, (string)$arrayCount) . $body;
    }

    public static function pack(string $type, string $data): string
    {
        if ($type !== self::BIT_B64) {
            return pack($type, $data);
        }

        if ((int)$data === -1) { // -1L
            return hex2bin('ffffffffffffffff');
        }

        if ((int)$data === -2) { // -2L
            return hex2bin('fffffffffffffffe');
        }

        $left = 0xffffffff00000000;
        $right = 0x00000000ffffffff;

        $l = ($data & $left) >> 32;
        $r = $data & $right;

        return pack($type, $l, $r);
    }

    /**
     * Get kafka api text
     * @param int $apikey
     * @return string
     */
    public static function getApiText(int $apikey): string
    {
        $apis = [
            self::PRODUCE_REQUEST => 'ProduceRequest',
            self::METADATA_REQUEST => 'MetadataRequest'
        ];

        return $apis[$apikey] ?? 'Unknown message';
    }

    /**
     * @param string $clientId
     * @param int $correlationId
     * @param int $apiKey
     * @return string
     */
    public function requestHeader(string $clientId, int $correlationId, int $apiKey): string
    {
        // int16 -- apiKey int16 -- apiVersion int32 correlationId
        $binData = self::pack(self::BIT_B16, (string)$apiKey);
        $binData .= self::pack(self::BIT_B16, (string)$this->getApiVersion($apiKey));
        $binData .= self::pack(self::BIT_B32, (string)$correlationId);

        // concat client id
        $binData .= self::encodeString($clientId, self::PACK_INT16);

        return $binData;
    }

    /**
     * Get kafka api version according to specify kafka broker version
     * @param int $apikey
     * @return int
     */
    public function getApiVersion(int $apikey): int
    {
        switch ($apikey) {
            case self::METADATA_REQUEST:
                return self::API_VERSION0;
            case self::PRODUCE_REQUEST:
                if (version_compare($this->version, '0.10.0') >= 0) {
                    return self::API_VERSION2;
                }

                if (version_compare($this->version, '0.9.0') >= 0) {
                    return self::API_VERSION1;
                }

                return self::API_VERSION0;
        }

        // default
        return self::API_VERSION0;
    }

    /**
     * @param string $string
     * @param int $bytes
     * @param int $compression
     * @return string
     */
    public static function encodeString(string $string, int $bytes, int $compression = self::COMPRESSION_NONE): string
    {
        $packLen = $bytes === self::PACK_INT32 ? self::BIT_B32 : self::BIT_B16;
        $string = self::compress($string, $compression);

        return self::pack($packLen, (string)strlen($string)) . $string;
    }

    /**
     * @param string $string
     * @param int $compression
     * @return string
     */
    private static function compress(string $string, int $compression): string
    {
        if ($compression === self::COMPRESSION_NONE) {
            return $string;
        }

        if ($compression === self::COMPRESSION_SNAPPY) {
            throw new BadMethodCallException('SNAPPY compression not yet implemented');
        }

        if ($compression !== self::COMPRESSION_GZIP) {
            throw new BadMethodCallException('Unknown compression flag: ' . $compression);
        }

        return gzencode($string);
    }

    /**
     * @param string $data
     * @param string $bytes
     * @param int $compression
     * @return mixed[]
     *
     * @throws Exception
     */
    public function decodeString(string $data, string $bytes, int $compression = self::COMPRESSION_NONE): array
    {
        $offset = $bytes === self::BIT_B32 ? 4 : 2;
        $packLen = self::unpack($bytes, substr($data, 0, $offset)); // int16 topic name length

        if ($packLen === 4294967295) { // uint32(4294967295) is int32 (-1)
            $packLen = 0;
        }

        if ($packLen === 0) {
            return ['length' => $offset, 'data' => ''];
        }

        $data = (string)substr($data, $offset, (int)$packLen);
        $offset += $packLen;

        return ['length' => $offset, 'data' => self::decompress($data, $compression)];
    }

    /**
     * Unpack a bit integer as big endian long
     *
     * @param string $type
     * @param string $bytes
     * @return mixed
     * @throws Exception
     */
    public static function unpack(string $type, string $bytes)
    {
        self::checkLen($type, $bytes);

        if ($type === self::BIT_B64) {
            $set = unpack($type, $bytes);
            $result = ($set[1] & 0xFFFFFFFF) << 32 | ($set[2] & 0xFFFFFFFF);
        } elseif ($type === self::BIT_B16_SIGNED) {
            // According to PHP docs: 's' = signed short (always 16 bit, machine byte order)
            // So lets unpack it..
            $set = unpack($type, $bytes);

            // But if our system is little endian
            if (self::isSystemLittleEndian()) {
                // We need to flip the endianess because coming from kafka it is big endian
                $set = self::convertSignedShortFromLittleEndianToBigEndian(/** @scrutinizer ignore-type */ $set);
            }
            $result = $set;
        } else {
            $result = unpack($type, $bytes);
        }

        return is_array($result) ? array_shift($result) : $result;
    }

    /**
     * check unpack bit is valid
     *
     * @param string $type
     * @param string $bytes
     * @throws Exception
     */
    protected static function checkLen(string $type, string $bytes): void
    {
        $expectedLength = 0;

        switch ($type) {
            case self::BIT_B64:
                $expectedLength = 8;
                break;
            case self::BIT_B32:
                $expectedLength = 4;
                break;
            case self::BIT_B16_SIGNED:
            case self::BIT_B16:
                $expectedLength = 2;
                break;
            case self::BIT_B8:
                $expectedLength = 1;
                break;
        }

        $length = strlen($bytes);

        if ($length !== $expectedLength) {
            throw new Exception('unpack failed. string(raw) length is ' . $length . ' , TO ' . $type);
        }
    }

    /**
     * Determines if the computer currently running this code is big endian or little endian.
     */
    public static function isSystemLittleEndian(): bool
    {
        // If we don't know if our system is big endian or not yet...
        if (self::$isLittleEndianSystem === null) {
            $value = unpack('L1L', pack('V', 1));
            if ($value === false) {
                self::$isLittleEndianSystem = false;
            } else {
                [$endianTest] = array_values($value);

                self::$isLittleEndianSystem = (int)$endianTest === 1;
            }
        }

        return self::$isLittleEndianSystem;
    }

    /**
     * Converts a signed short (16 bits) from little endian to big endian.
     *
     * @param int[] $bits
     *
     * @return int[]
     */
    public static function convertSignedShortFromLittleEndianToBigEndian(array $bits): array
    {
        $convert = function (int $bit): int {
            $lsb = $bit & 0xff;
            $msb = $bit >> 8 & 0xff;
            $bit = $lsb << 8 | $msb;

            if ($bit >= 32768) {
                $bit -= 65536;
            }

            return $bit;
        };

        return array_map($convert, $bits);
    }

    private static function decompress(string $string, int $compression): string
    {
        if ($compression === self::COMPRESSION_NONE) {
            return $string;
        }

        if ($compression === self::COMPRESSION_SNAPPY) {
            throw new BadMethodCallException('SNAPPY compression not yet implemented');
        }

        if ($compression !== self::COMPRESSION_GZIP) {
            throw new BadMethodCallException('Unknown compression flag: ' . $compression);
        }

        return gzdecode($string);
    }

    /**
     * @param string $data
     * @param callable $func
     * @param mixed|null $options
     *
     * @return mixed[]
     *
     * @throws Exception
     */
    public function decodeArray(string $data, callable $func, $options = null): array
    {
        $offset = 0;
        $arrayCount = self::unpack(self::BIT_B32, substr($data, $offset, 4));
        $offset += 4;

        $result = [];

        for ($i = 0; $i < $arrayCount; $i++) {
            $value = substr($data, $offset);
            $ret = $options !== null ? $func($value, $options) : $func($value);

            if (!is_array($ret) && $ret === false) {
                break;
            }

            if (!isset($ret['length'], $ret['data'])) {
                throw new Exception('Decode array failed, given function return format is invalid');
            }
            if ((int)$ret['length'] === 0) {
                continue;
            }

            $offset += $ret['length'];
            $result[] = $ret['data'];
        }

        return ['length' => $offset, 'data' => $result];
    }

    /**
     * @param string $data
     * @param string $bit
     * @return mixed[]
     *
     */
    public function decodePrimitiveArray(string $data, string $bit): array
    {
        $offset = 0;
        $arrayCount = self::unpack(self::BIT_B32, substr($data, $offset, 4));
        $offset += 4;

        if ($arrayCount === 4294967295) {
            $arrayCount = 0;
        }

        $result = [];

        for ($i = 0; $i < $arrayCount; $i++) {
            if ($bit === self::BIT_B64) {
                $result[] = self::unpack(self::BIT_B64, substr($data, $offset, 8));
                $offset += 8;
            } elseif ($bit === self::BIT_B32) {
                $result[] = self::unpack(self::BIT_B32, substr($data, $offset, 4));
                $offset += 4;
            } elseif (in_array($bit, [self::BIT_B16, self::BIT_B16_SIGNED], true)) {
                $result[] = self::unpack($bit, substr($data, $offset, 2));
                $offset += 2;
            } elseif ($bit === self::BIT_B8) {
                $result[] = self::unpack($bit, substr($data, $offset, 1));
                ++$offset;
            }
        }

        return ['length' => $offset, 'data' => $result];
    }

    /**
     * @param array $payloads
     * @return string
     */
    abstract public function encode(array $payloads = []): string;

    /**
     * @param string $data
     * @return array
     */
    abstract public function decode(string $data): array;
}


1			<?php
2			declare(strict_types=1);
3
4			namespace Seasx\SeasLogger\Kafka;
5
6			use BadMethodCallException;
7			use Exception;
8			use function array_map;
9			use function array_shift;
10			use function array_values;
11			use function count;
12			use function gzdecode;
13			use function gzencode;
14			use function hex2bin;
15			use function in_array;
16			use function is_array;
17			use function pack;
18			use function strlen;
19			use function substr;
20			use function unpack;
21			use function version_compare;
22
23			abstract class Protocol
24			{
25			public const NO_ERROR = 0;
26			/**
27			* Default kafka broker verion
28			*/
29			public const DEFAULT_BROKER_VERION = '0.9.0.0';
30
31			/**
32			* Kafka server protocol version0
33			*/
34			public const API_VERSION0 = 0;
35
36			/**
37			* Kafka server protocol version 1
38			*/
39			public const API_VERSION1 = 1;
40
41			/**
42			* Kafka server protocol version 2
43			*/
44			public const API_VERSION2 = 2;
45
46			/**
47			* use encode message, This is a version id used to allow backwards
48			* compatible evolution of the message binary format.
49			*/
50			public const MESSAGE_MAGIC_VERSION0 = 0;
51
52			/**
53			* use encode message, This is a version id used to allow backwards
54			* compatible evolution of the message binary format.
55			*/
56			public const MESSAGE_MAGIC_VERSION1 = 1;
57
58			/**
59			* message no compression
60			*/
61			public const COMPRESSION_NONE = 0;
62
63			/**
64			* Message using gzip compression
65			*/
66			public const COMPRESSION_GZIP = 1;
67
68			/**
69			* Message using Snappy compression
70			*/
71			public const COMPRESSION_SNAPPY = 2;
72
73			/**
74			* pack int32 type
75			*/
76			public const PACK_INT32 = 0;
77
78			/**
79			* pack int16 type
80			*/
81			public const PACK_INT16 = 1;
82
83			/**
84			* protocol request code
85			*/
86			public const PRODUCE_REQUEST = 0;
87
88			public const METADATA_REQUEST = 3;
89
90			// unpack/pack bit
91			public const BIT_B64 = 'N2';
92
93			public const BIT_B32 = 'N';
94
95			public const BIT_B16 = 'n';
96
97			public const BIT_B16_SIGNED = 's';
98
99			public const BIT_B8 = 'C';
100			/**
101			* gets set to true if the computer this code is running is little endian,
102			* gets set to false if the computer this code is running on is big endian.
103			*
104			* @var null\|bool
105			*/
106			private static $isLittleEndianSystem;
107			/**
108			* @var string
109			*/
110			protected $version = self::DEFAULT_BROKER_VERION;
111
112			public function __construct(string $version = self::DEFAULT_BROKER_VERION)
113			{
114			$this->version = $version;
115			}
116
117			/**
118			* @param array $array
119			* @param callable $func
120			* @param int\|null $options
121			* @return string
122			*/
123			public static function encodeArray(array $array, callable $func, ?int $options = null): string
124			{
125			$arrayCount = count($array);
126
127			$body = '';
128			foreach ($array as $value) {
129			$body .= $options !== null ? $func($value, $options) : $func($value);
130			}
131
132			return self::pack(self::BIT_B32, (string)$arrayCount) . $body;
133			}
134
135			public static function pack(string $type, string $data): string
136			{
137			if ($type !== self::BIT_B64) {
138			return pack($type, $data);
139			}
140
141			if ((int)$data === -1) { // -1L
142			return hex2bin('ffffffffffffffff');
143			}
144
145			if ((int)$data === -2) { // -2L
146			return hex2bin('fffffffffffffffe');
147			}
148
149			$left = 0xffffffff00000000;
150			$right = 0x00000000ffffffff;
151
152			$l = ($data & $left) >> 32;
153			$r = $data & $right;
154
155			return pack($type, $l, $r);
156			}
157
158			/**
159			* Get kafka api text
160			* @param int $apikey
161			* @return string
162			*/
163			public static function getApiText(int $apikey): string
164			{
165			$apis = [
166			self::PRODUCE_REQUEST => 'ProduceRequest',
167			self::METADATA_REQUEST => 'MetadataRequest'
168			];
169
170			return $apis[$apikey] ?? 'Unknown message';
171			}
172
173			/**
174			* @param string $clientId
175			* @param int $correlationId
176			* @param int $apiKey
177			* @return string
178			*/
179			public function requestHeader(string $clientId, int $correlationId, int $apiKey): string
180			{
181			// int16 -- apiKey int16 -- apiVersion int32 correlationId
182			$binData = self::pack(self::BIT_B16, (string)$apiKey);
183			$binData .= self::pack(self::BIT_B16, (string)$this->getApiVersion($apiKey));
184			$binData .= self::pack(self::BIT_B32, (string)$correlationId);
185
186			// concat client id
187			$binData .= self::encodeString($clientId, self::PACK_INT16);
188
189			return $binData;
190			}
191
192			/**
193			* Get kafka api version according to specify kafka broker version
194			* @param int $apikey
195			* @return int
196			*/
197			public function getApiVersion(int $apikey): int
198			{
199			switch ($apikey) {
200			case self::METADATA_REQUEST:
201			return self::API_VERSION0;
202			case self::PRODUCE_REQUEST:
203			if (version_compare($this->version, '0.10.0') >= 0) {
204			return self::API_VERSION2;
205			}
206
207			if (version_compare($this->version, '0.9.0') >= 0) {
208			return self::API_VERSION1;
209			}
210
211			return self::API_VERSION0;
212			}
213
214			// default
215			return self::API_VERSION0;
216			}
217
218			/**
219			* @param string $string
220			* @param int $bytes
221			* @param int $compression
222			* @return string
223			*/
224			public static function encodeString(string $string, int $bytes, int $compression = self::COMPRESSION_NONE): string
225			{
226			$packLen = $bytes === self::PACK_INT32 ? self::BIT_B32 : self::BIT_B16;
227			$string = self::compress($string, $compression);
228
229			return self::pack($packLen, (string)strlen($string)) . $string;
230			}
231
232			/**
233			* @param string $string
234			* @param int $compression
235			* @return string
236			*/
237			private static function compress(string $string, int $compression): string
238			{
239			if ($compression === self::COMPRESSION_NONE) {
240			return $string;
241			}
242
243			if ($compression === self::COMPRESSION_SNAPPY) {
244			throw new BadMethodCallException('SNAPPY compression not yet implemented');
245			}
246
247			if ($compression !== self::COMPRESSION_GZIP) {
248			throw new BadMethodCallException('Unknown compression flag: ' . $compression);
249			}
250
251			return gzencode($string);
252			}
253
254			/**
255			* @param string $data
256			* @param string $bytes
257			* @param int $compression
258			* @return mixed[]
259			*
260			* @throws Exception
261			*/
262			public function decodeString(string $data, string $bytes, int $compression = self::COMPRESSION_NONE): array
263			{
264			$offset = $bytes === self::BIT_B32 ? 4 : 2;
265			$packLen = self::unpack($bytes, substr($data, 0, $offset)); // int16 topic name length
266
267			if ($packLen === 4294967295) { // uint32(4294967295) is int32 (-1)
268			$packLen = 0;
269			}
270
271			if ($packLen === 0) {
272			return ['length' => $offset, 'data' => ''];
273			}
274
275			$data = (string)substr($data, $offset, (int)$packLen);
276			$offset += $packLen;
277
278			return ['length' => $offset, 'data' => self::decompress($data, $compression)];
279			}
280
281			/**
282			* Unpack a bit integer as big endian long
283			*
284			* @param string $type
285			* @param string $bytes
286			* @return mixed
287			* @throws Exception
288			*/
289			public static function unpack(string $type, string $bytes)
290			{
291			self::checkLen($type, $bytes);
292
293			if ($type === self::BIT_B64) {
294			$set = unpack($type, $bytes);
295			$result = ($set[1] & 0xFFFFFFFF) << 32 \| ($set[2] & 0xFFFFFFFF);
296			} elseif ($type === self::BIT_B16_SIGNED) {
297			// According to PHP docs: 's' = signed short (always 16 bit, machine byte order)
298			// So lets unpack it..
299			$set = unpack($type, $bytes);
300
301			// But if our system is little endian
302			if (self::isSystemLittleEndian()) {
303			// We need to flip the endianess because coming from kafka it is big endian
304			$set = self::convertSignedShortFromLittleEndianToBigEndian(/** @scrutinizer ignore-type */ $set);
305			}
306			$result = $set;
307			} else {
308			$result = unpack($type, $bytes);
309			}
310
311			return is_array($result) ? array_shift($result) : $result;
312			}
313
314			/**
315			* check unpack bit is valid
316			*
317			* @param string $type
318			* @param string $bytes
319			* @throws Exception
320			*/
321			protected static function checkLen(string $type, string $bytes): void
322			{
323			$expectedLength = 0;
324
325			switch ($type) {
326			case self::BIT_B64:
327			$expectedLength = 8;
328			break;
329			case self::BIT_B32:
330			$expectedLength = 4;
331			break;
332			case self::BIT_B16_SIGNED:
333			case self::BIT_B16:
334			$expectedLength = 2;
335			break;
336			case self::BIT_B8:
337			$expectedLength = 1;
338			break;
339			}
340
341			$length = strlen($bytes);
342
343			if ($length !== $expectedLength) {
344			throw new Exception('unpack failed. string(raw) length is ' . $length . ' , TO ' . $type);
345			}
346			}
347
348			/**
349			* Determines if the computer currently running this code is big endian or little endian.
350			*/
351			public static function isSystemLittleEndian(): bool
352			{
353			// If we don't know if our system is big endian or not yet...
354			if (self::$isLittleEndianSystem === null) {
355			$value = unpack('L1L', pack('V', 1));
356			if ($value === false) {
357			self::$isLittleEndianSystem = false;
358			} else {
359			[$endianTest] = array_values($value);
360
361			self::$isLittleEndianSystem = (int)$endianTest === 1;
362			}
363			}
364
365			return self::$isLittleEndianSystem;
366			}
367
368			/**
369			* Converts a signed short (16 bits) from little endian to big endian.
370			*
371			* @param int[] $bits
372			*
373			* @return int[]
374			*/
375			public static function convertSignedShortFromLittleEndianToBigEndian(array $bits): array
376			{
377			$convert = function (int $bit): int {
378			$lsb = $bit & 0xff;
379			$msb = $bit >> 8 & 0xff;
380			$bit = $lsb << 8 \| $msb;
381
382			if ($bit >= 32768) {
383			$bit -= 65536;
384			}
385
386			return $bit;
387			};
388
389			return array_map($convert, $bits);
390			}
391
392			private static function decompress(string $string, int $compression): string
393			{
394			if ($compression === self::COMPRESSION_NONE) {
395			return $string;
396			}
397
398			if ($compression === self::COMPRESSION_SNAPPY) {
399			throw new BadMethodCallException('SNAPPY compression not yet implemented');
400			}
401
402			if ($compression !== self::COMPRESSION_GZIP) {
403			throw new BadMethodCallException('Unknown compression flag: ' . $compression);
404			}
405
406			return gzdecode($string);
407			}
408
409			/**
410			* @param string $data
411			* @param callable $func
412			* @param mixed\|null $options
413			*
414			* @return mixed[]
415			*
416			* @throws Exception
417			*/
418			public function decodeArray(string $data, callable $func, $options = null): array
419			{
420			$offset = 0;
421			$arrayCount = self::unpack(self::BIT_B32, substr($data, $offset, 4));
422			$offset += 4;
423
424			$result = [];
425
426			for ($i = 0; $i < $arrayCount; $i++) {
427			$value = substr($data, $offset);
428			$ret = $options !== null ? $func($value, $options) : $func($value);
429
430			if (!is_array($ret) && $ret === false) {
431			break;
432			}
433
434			if (!isset($ret['length'], $ret['data'])) {
435			throw new Exception('Decode array failed, given function return format is invalid');
436			}
437			if ((int)$ret['length'] === 0) {
438			continue;
439			}
440
441			$offset += $ret['length'];
442			$result[] = $ret['data'];
443			}
444
445			return ['length' => $offset, 'data' => $result];
446			}
447
448			/**
449			* @param string $data
450			* @param string $bit
451			* @return mixed[]
452			*
453			*/
454			public function decodePrimitiveArray(string $data, string $bit): array
455			{
456			$offset = 0;
457			$arrayCount = self::unpack(self::BIT_B32, substr($data, $offset, 4));
458			$offset += 4;
459
460			if ($arrayCount === 4294967295) {
461			$arrayCount = 0;
462			}
463
464			$result = [];
465
466			for ($i = 0; $i < $arrayCount; $i++) {
467			if ($bit === self::BIT_B64) {
468			$result[] = self::unpack(self::BIT_B64, substr($data, $offset, 8));
469			$offset += 8;
470			} elseif ($bit === self::BIT_B32) {
471			$result[] = self::unpack(self::BIT_B32, substr($data, $offset, 4));
472			$offset += 4;
473			} elseif (in_array($bit, [self::BIT_B16, self::BIT_B16_SIGNED], true)) {
474			$result[] = self::unpack($bit, substr($data, $offset, 2));
475			$offset += 2;
476			} elseif ($bit === self::BIT_B8) {
477			$result[] = self::unpack($bit, substr($data, $offset, 1));
478			++$offset;
479			}
480			}
481
482			return ['length' => $offset, 'data' => $result];
483			}
484
485			/**
486			* @param array $payloads
487			* @return string
488			*/
489			abstract public function encode(array $payloads = []): string;
490
491			/**
492			* @param string $data
493			* @return array
494			*/
495			abstract public function decode(string $data): array;
496			}
497

SeasX / seas-logger

Pull Request — master (#12)

Protocol::decompress() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like