Merge pull request #90 from neo4j-php/84-bytearray

added missing data type bytearray

Author: stefanak-michal

src/Bolt.php

@@ -115,7 +115,7 @@ private function unpackProtocolVersion(): string
     {
         $result = [];
 
-        foreach (str_split($this->connection->read(4)) as $ch) {
+        foreach (mb_str_split($this->connection->read(4), 1, '8bit') as $ch) {
             $result[] = unpack('C', $ch)[1] ?? 0;
         }
 

src/PackStream/v1/Packer.php

@@ -15,7 +15,8 @@
     LocalDateTime,
     Duration,
     Point2D,
-    Point3D
+    Point3D,
+    Bytes
 };
 
 /**
@@ -117,6 +118,8 @@ private function p($param): string
             case 'object':
                 if ($param instanceof IStructure) {
                     return $this->packStructure($param);
+                } elseif ($param instanceof Bytes) {
+                    return $this->packByteArray($param);
                 } else {
                     return $this->packMap((array)$param);
                 }
@@ -263,4 +266,23 @@ private function packStructure(IStructure $structure): string
         return $output;
     }
 
+    /**
+     * @param Bytes $bytes
+     * @return string
+     * @throws PackException
+     */
+    private function packByteArray(Bytes $bytes): string
+    {
+        $size = count($bytes);
+        if ($size < self::MEDIUM) {
+            return chr(0xCC) . pack('C', $size) . $bytes;
+        } elseif ($size < self::LARGE) {
+            return chr(0xCD) . pack('n', $size) . $bytes;
+        } elseif ($size <= 2147483647) {
+            return chr(0xCE) . pack('N', $size) . $bytes;
+        } else {
+            throw new PackException('ByteArray too big');
+        }
+    }
+
 }

src/PackStream/v1/Unpacker.php

@@ -16,7 +16,8 @@
     LocalDateTime,
     Duration,
     Point2D,
-    Point3D
+    Point3D,
+    Bytes
 };
 use Bolt\PackStream\IUnpacker;
 use Bolt\error\UnpackException;
@@ -130,6 +131,10 @@ private function u()
         if ($output !== null) {
             return $output;
         }
+        $output = $this->unpackByteArray($marker);
+        if ($output !== null) {
+            return $output;
+        }
 
         return null;
     }
@@ -186,7 +191,7 @@ private function unpackSpecificStructure(string $class, string ...$methods): ISt
 
     /**
      * @param int $marker
-     * @return array
+     * @return array|null
      * @throws UnpackException
      */
     private function unpackMap(int $marker): ?array
@@ -212,7 +217,7 @@ private function unpackMap(int $marker): ?array
 
     /**
      * @param int $marker
-     * @return string
+     * @return string|null
      */
     private function unpackString(int $marker): ?string
     {
@@ -233,7 +238,7 @@ private function unpackString(int $marker): ?string
 
     /**
      * @param int $marker
-     * @return int
+     * @return int|null
      */
     private function unpackInteger(int $marker): ?int
     {
@@ -257,7 +262,7 @@ private function unpackInteger(int $marker): ?int
 
     /**
      * @param int $marker
-     * @return float
+     * @return float|null
      */
     private function unpackFloat(int $marker): ?float
     {
@@ -271,7 +276,7 @@ private function unpackFloat(int $marker): ?float
 
     /**
      * @param int $marker
-     * @return array
+     * @return array|null
      * @throws UnpackException
      */
     private function unpackList(int $marker): ?array
@@ -296,4 +301,23 @@ private function unpackList(int $marker): ?array
         return $output;
     }
 
+    /**
+     * @param int $marker
+     * @return Bytes|null
+     */
+    private function unpackByteArray(int $marker): ?Bytes
+    {
+        if ($marker == 0xCC) {
+            $size = (int)unpack('C', $this->next(1))[1];
+        } elseif ($marker == 0xCD) {
+            $size = (int)unpack('n', $this->next(2))[1];
+        } elseif ($marker == 0xCE) {
+            $size = (int)unpack('N', $this->next(4))[1];
+        } else {
+            return null;
+        }
+
+        return new Bytes(mb_str_split($this->next($size), 1, '8bit'));
+    }
+
 }

src/structures/Bytes.php

@@ -0,0 +1,56 @@
+<?php
+
+namespace Bolt\structures;
+
+use ArrayAccess, Countable;
+
+/**
+ * Class ByteArray
+ *
+ * @author Michal Stefanak
+ * @link https://github.com/neo4j-php/Bolt
+ * @link https://7687.org/packstream/packstream-specification-1.html#bytes
+ * @package Bolt\structures
+ */
+class Bytes implements ArrayAccess, Countable
+{
+    private array $bytes = [];
+
+    public function __construct(array $bytes = [])
+    {
+        $this->bytes = $bytes;
+    }
+
+    public function offsetExists($offset): bool
+    {
+        return array_key_exists($offset, $this->bytes);
+    }
+
+    public function offsetGet($offset): ?string
+    {
+        return $this->bytes[$offset] ?? null;
+    }
+
+    public function offsetSet($offset, $value)
+    {
+        if ($offset === null)
+            $this->bytes[] = $value;
+        else
+            $this->bytes[$offset] = $value;
+    }
+
+    public function offsetUnset($offset)
+    {
+        unset($this->bytes[$offset]);
+    }
+
+    public function count(): int
+    {
+        return count($this->bytes);
+    }
+
+    public function __toString(): string
+    {
+        return implode($this->bytes);
+    }
+}

tests/PackStream/v1/StructuresTest.php

@@ -17,7 +17,8 @@
     LocalDateTime,
     Duration,
     Point2D,
-    Point3D
+    Point3D,
+    Bytes
 };
 use PHPUnit\Framework\TestCase;
 use Exception;
@@ -451,4 +452,30 @@ private function randomTimestamp(string $timezone = '+0000'): int
         }
     }
 
+    /**
+     * @depends      testInit
+     * @dataProvider providerByteArray
+     */
+    public function testByteArray(Bytes $arr, AProtocol $protocol)
+    {
+        try {
+            $protocol->run('RETURN $arr', ['arr' => $arr]);
+            $res = $protocol->pullAll();
+            $this->assertEquals($arr, $res[0][0]);
+        } catch (Exception $e) {
+            $this->markTestIncomplete($e->getMessage());
+        }
+    }
+
+    public function providerByteArray(): \Generator
+    {
+        foreach ([0, 200, 60000, 70000] as $size) {
+            $arr = new Bytes();
+            while (count($arr) < $size) {
+                $arr[] = pack('H', mt_rand(0, 255));
+            }
+            yield 'bytes: ' . count($arr) => [$arr];
+        }
+    }
+
 }