Refactor vector structure implementation

Author: stefanak-michal

src/protocol/v6/structures/Vector.php

@@ -27,97 +27,100 @@ public function __toString(): string
         return json_encode([(string)$this->type_marker, (string)$this->data]);
     }
 
-    private static array $formats = ['s', 'l', 'q'];
+    private static array $endianesFormats = ['s', 'l', 'q'];
 
     /**
      * Encode array as vector structure
+     * This is a helper method to create Vector structure from array of numbers
      * @param int[]|float[] $data
+     * @param TypeMarker|null $type Optional type to force specific data type .. null = auto decide
      * @return self
      * @throws \InvalidArgumentException
      */
-    public static function encode(array $data): self
+    public static function encode(array $data, ?TypeMarker $type = null): self
     {
-        if (count($data) === 0) {
-            throw new \InvalidArgumentException('Vector cannot be empty');
-        }
-        if (count($data) > 4096) {
-            throw new \InvalidArgumentException('Vector cannot have more than 4096 elements');
+        $anyFloat = false;
+        foreach ($data as $entry) {
+            if (!is_int($entry) && !is_float($entry)) {
+                throw new \InvalidArgumentException('Vector can only contain numeric values');
+            }
+            if (!$anyFloat && is_float($entry)) {
+                $anyFloat = true;
+            }
         }
 
-        $anyFloat = in_array(true, array_map('is_float', $data));
-        $minValue = min($data);
-        $maxValue = max($data);
-        $marker = 0;
+        $minValue = count($data) ? min($data) : 0;
+        $maxValue = count($data) ? max($data) : 0;
         $packFormat = '';
 
         if ($anyFloat) {
             if ($minValue >= 1.4e-45 && $maxValue <= 3.4028235e+38) { // Single precision float (FLOAT_32)
-                $marker = 0xC6;
+                if ($type === null) $type = TypeMarker::FLOAT_32;
                 $packFormat = 'G';
             } else { // Double precision float (FLOAT_64)
-                $marker = 0xC1;
+                if ($type === null) $type = TypeMarker::FLOAT_64;
                 $packFormat = 'E';
             }
         } else {
             if ($minValue >= -128 && $maxValue <= 127) { // INT_8
-                $marker = 0xC8;
+                if ($type === null) $type = TypeMarker::INT_8;
                 $packFormat = 'c';
             } elseif ($minValue >= -32768 && $maxValue <= 32767) { // INT_16
-                $marker = 0xC9;
+                if ($type === null) $type = TypeMarker::INT_16;
                 $packFormat = 's';
             } elseif ($minValue >= -2147483648 && $maxValue <= 2147483647) { // INT_32
-                $marker = 0xCA;
+                if ($type === null) $type = TypeMarker::INT_32;
                 $packFormat = 'l';
             } else { // INT_64
-                $marker = 0xCB;
+                if ($type === null) $type = TypeMarker::INT_64;
                 $packFormat = 'q';
             }
         }
 
-        if ($marker === 0) {
+        if ($type === null) {
             throw new \InvalidArgumentException('Unsupported data type for vector');
         }
 
         // Pack the data
         $packed = [];
         $littleEndian = unpack('S', "\x01\x00")[1] === 1;
         foreach ($data as $entry) {
-            $value = pack($packFormat, $entry);
-            $packed[] = in_array($packFormat, self::$formats) && $littleEndian ? strrev($value) : $value;
+            $value = pack($packFormat, $anyFloat ? (float)$entry : (int)$entry);
+            $packed[] = in_array($packFormat, self::$endianesFormats) && $littleEndian ? strrev($value) : $value;
         }
 
-        return new self(new Bytes([chr($marker)]), new Bytes($packed));
+        return new self(new Bytes([chr($type->value)]), new Bytes($packed));
     }
 
     /**
-     * Decode vector structure .. returns binary $this->data as array
+     * Decode vector structure .. returns binary $this->data as array of numbers
      * @return int[]|float[]
      * @throws \InvalidArgumentException
      */
     public function decode(): array
     {
         switch (ord($this->type_marker[0])) {
-            case 0xC8: // INT_8
+            case TypeMarker::INT_8->value: // INT_8
                 $size = 1;
                 $unpackFormat = 'c';
                 break;
-            case 0xC9: // INT_16
+            case TypeMarker::INT_16->value: // INT_16
                 $size = 2;
                 $unpackFormat = 's';
                 break;
-            case 0xCA: // INT_32
+            case TypeMarker::INT_32->value: // INT_32
                 $size = 4;
                 $unpackFormat = 'l';
                 break;
-            case 0xCB: // INT_64
+            case TypeMarker::INT_64->value: // INT_64
                 $size = 8;
                 $unpackFormat = 'q';
                 break;
-            case 0xC6: // FLOAT_32
+            case TypeMarker::FLOAT_32->value: // FLOAT_32
                 $size = 4;
                 $unpackFormat = 'G';
                 break;
-            case 0xC1: // FLOAT_64
+            case TypeMarker::FLOAT_64->value: // FLOAT_64
                 $size = 8;
                 $unpackFormat = 'E';
                 break;
@@ -128,9 +131,19 @@ public function decode(): array
         $output = [];
         $littleEndian = unpack('S', "\x01\x00")[1] === 1;
         foreach(mb_str_split((string)$this->data, $size, '8bit') as $value) {
-            $output[] = unpack($unpackFormat, in_array($unpackFormat, self::$formats) && $littleEndian ? strrev($value) : $value)[1];
+            $output[] = unpack($unpackFormat, in_array($unpackFormat, self::$endianesFormats) && $littleEndian ? strrev($value) : $value)[1];
         }
 
         return $output;
     }
 }
+
+enum TypeMarker: int
+{
+    case INT_8 = 0xC8;
+    case INT_16 = 0xC9;
+    case INT_32 = 0xCA;
+    case INT_64 = 0xCB;
+    case FLOAT_32 = 0xC6;
+    case FLOAT_64 = 0xC1;
+}