ext-encoding 0.5.x support

Author: dktapps

.github/workflows/ci.yml

@@ -8,15 +8,16 @@ jobs:
     if: "!contains(github.event.head_commit.message, '[ci skip]')"
     strategy:
       matrix:
-        php: ['7.4', '8.0', '8.1', '8.2', '8.3', '8.4']
+        php: ['8.1', '8.2', '8.3', '8.4']
     name: PHP ${{ matrix.php }}
     steps:
     - uses: actions/checkout@v4
     - name: Setup PHP
-      uses: shivammathur/setup-php@2.31.1
+      uses: shivammathur/setup-php@2.35.4
       with:
         php-version: ${{ matrix.php }}
         ini-values: xdebug.max_nesting_level=3000
+        extensions: encoding-https://github.com/pmmp/ext-encoding@0.5.1
     - name: Cache Composer packages
       id: composer-cache
       uses: actions/cache@v4

composer.json

@@ -3,9 +3,9 @@
     "description": "PHP library for working with Named Binary Tags",
     "type": "library",
     "require": {
-        "php": "^7.4 || ^8.0",
+        "php": "^8.1",
         "php-64bit": "*",
-        "ext-encoding": "~0.4.0"
+        "ext-encoding": "~0.5.0"
     },
     "require-dev": {
         "phpstan/phpstan": "2.1.0",

src/BaseNbtSerializer.php

@@ -24,7 +24,8 @@
 namespace pocketmine\nbt;
 
 use pmmp\encoding\Byte;
-use pmmp\encoding\ByteBuffer;
+use pmmp\encoding\ByteBufferReader;
+use pmmp\encoding\ByteBufferWriter;
 use pmmp\encoding\DataDecodeException;
 use pocketmine\nbt\tag\Tag;
 use function strlen;
@@ -33,18 +34,15 @@
  * Base Named Binary Tag encoder/decoder
  */
 abstract class BaseNbtSerializer implements NbtStreamReader, NbtStreamWriter{
-	protected ByteBuffer $buffer;
-
-	public function __construct(){
-		$this->buffer = new ByteBuffer();
-	}
+	protected ByteBufferReader $reader;
+	protected ByteBufferWriter $writer;
 
 	/**
 	 * @throws DataDecodeException
 	 * @throws NbtDataException
 	 */
 	private function readRoot(int $maxDepth) : TreeRoot{
-		$type = Byte::readUnsigned($this->buffer);
+		$type = Byte::readUnsigned($this->reader);
 		if($type === NBT::TAG_End){
 			throw new NbtDataException("Found TAG_End at the start of buffer");
 		}
@@ -61,15 +59,15 @@ private function readRoot(int $maxDepth) : TreeRoot{
 	 * @throws NbtDataException
 	 */
 	public function read(string $buffer, int &$offset = 0, int $maxDepth = 0) : TreeRoot{
-		$this->buffer = new ByteBuffer($buffer);
-		$this->buffer->setReadOffset($offset);
+		$this->reader = new ByteBufferReader($buffer);
+		$this->reader->setOffset($offset);
 
 		try{
 			$data = $this->readRoot($maxDepth);
 		}catch(DataDecodeException $e){
 			throw new NbtDataException($e->getMessage(), 0, $e);
 		}
-		$offset = $this->buffer->getReadOffset();
+		$offset = $this->reader->getOffset();
 
 		return $data;
 	}
@@ -85,11 +83,11 @@ public function read(string $buffer, int &$offset = 0, int $maxDepth = 0) : Tree
 	 * @throws NbtDataException
 	 */
 	public function readHeadless(string $buffer, int $rootType, int &$offset = 0, int $maxDepth = 0) : Tag{
-		$this->buffer = new ByteBuffer($buffer);
-		$this->buffer->setReadOffset($offset);
+		$this->reader = new ByteBufferReader($buffer);
+		$this->reader->setOffset($offset);
 
 		$data = NBT::createTag($rootType, $this, new ReaderTracker($maxDepth));
-		$offset = $this->buffer->getReadOffset();
+		$offset = $this->reader->getOffset();
 
 		return $data;
 	}
@@ -104,11 +102,12 @@ public function readHeadless(string $buffer, int $rootType, int &$offset = 0, in
 	 * @throws NbtDataException
 	 */
 	public function readMultiple(string $buffer, int $maxDepth = 0) : array{
-		$this->buffer = new ByteBuffer($buffer);
+		$this->reader = new ByteBufferReader($buffer);
 
 		$retval = [];
 
-		while($this->buffer->getReadOffset() < $this->buffer->getUsedLength()){
+		$length = strlen($this->reader->getData());
+		while($this->reader->getOffset() < $length){
 			try{
 				$retval[] = $this->readRoot($maxDepth);
 			}catch(DataDecodeException $e){
@@ -120,17 +119,17 @@ public function readMultiple(string $buffer, int $maxDepth = 0) : array{
 	}
 
 	private function writeRoot(TreeRoot $root) : void{
-		Byte::writeUnsigned($this->buffer, $root->getTag()->getType());
+		Byte::writeUnsigned($this->writer, $root->getTag()->getType());
 		$this->writeString($root->getName());
 		$root->getTag()->write($this);
 	}
 
 	public function write(TreeRoot $data) : string{
-		$this->buffer = new ByteBuffer();
+		$this->writer = new ByteBufferWriter();
 
 		$this->writeRoot($data);
 
-		return $this->buffer->toString();
+		return $this->writer->getData();
 	}
 
 	/**
@@ -140,45 +139,45 @@ public function write(TreeRoot $data) : string{
 	 * @see BaseNbtSerializer::readHeadless()
 	 */
 	public function writeHeadless(Tag $data) : string{
-		$this->buffer = new ByteBuffer();
+		$this->writer = new ByteBufferWriter();
 		$data->write($this);
-		return $this->buffer->toString();
+		return $this->writer->getData();
 	}
 
 	/**
 	 * @param TreeRoot[] $data
 	 */
 	public function writeMultiple(array $data) : string{
-		$this->buffer = new ByteBuffer();
+		$this->writer = new ByteBufferWriter();
 		foreach($data as $root){
 			$this->writeRoot($root);
 		}
-		return $this->buffer->toString();
+		return $this->writer->getData();
 	}
 
 	public function readByte() : int{
-		return Byte::readUnsigned($this->buffer);
+		return Byte::readUnsigned($this->reader);
 	}
 
 	public function readSignedByte() : int{
-		return Byte::readSigned($this->buffer);
+		return Byte::readSigned($this->reader);
 	}
 
 	public function writeByte(int $v) : void{
-		Byte::writeUnsigned($this->buffer, $v);
+		Byte::writeUnsigned($this->writer, $v);
 	}
 
 	public function readByteArray() : string{
 		$length = $this->readInt();
 		if($length < 0){
 			throw new NbtDataException("Array length cannot be less than zero ($length < 0)");
 		}
-		return $this->buffer->readByteArray($length);
+		return $this->reader->readByteArray($length);
 	}
 
 	public function writeByteArray(string $v) : void{
 		$this->writeInt(strlen($v)); //TODO: overflow
-		$this->buffer->writeByteArray($v);
+		$this->writer->writeByteArray($v);
 	}
 
 	/**
@@ -202,14 +201,14 @@ protected static function checkWriteStringLength(int $len) : int{
 	}
 
 	public function readString() : string{
-		return $this->buffer->readByteArray(self::checkReadStringLength($this->readShort()));
+		return $this->reader->readByteArray(self::checkReadStringLength($this->readShort()));
 	}
 
 	/**
 	 * @throws \InvalidArgumentException if the string is too long
 	 */
 	public function writeString(string $v) : void{
 		$this->writeShort(self::checkWriteStringLength(strlen($v)));
-		$this->buffer->writeByteArray($v);
+		$this->writer->writeByteArray($v);
 	}
 }

src/BigEndianNbtSerializer.php

@@ -24,71 +24,64 @@
 namespace pocketmine\nbt;
 
 use pmmp\encoding\BE;
-use function array_values;
-use function assert;
 use function count;
-use function pack;
-use function unpack;
 
 class BigEndianNbtSerializer extends BaseNbtSerializer{
 
 	public function readShort() : int{
-		return BE::readUnsignedShort($this->buffer);
+		return BE::readUnsignedShort($this->reader);
 	}
 
 	public function readSignedShort() : int{
-		return BE::readSignedShort($this->buffer);
+		return BE::readSignedShort($this->reader);
 	}
 
 	public function writeShort(int $v) : void{
-		BE::writeUnsignedShort($this->buffer, $v);
+		BE::writeUnsignedShort($this->writer, $v);
 	}
 
 	public function readInt() : int{
-		return BE::readSignedInt($this->buffer);
+		return BE::readSignedInt($this->reader);
 	}
 
 	public function writeInt(int $v) : void{
-		BE::writeSignedInt($this->buffer, $v);
+		BE::writeSignedInt($this->writer, $v);
 	}
 
 	public function readLong() : int{
-		return BE::readSignedLong($this->buffer);
+		return BE::readSignedLong($this->reader);
 	}
 
 	public function writeLong(int $v) : void{
-		BE::writeSignedLong($this->buffer, $v);
+		BE::writeSignedLong($this->writer, $v);
 	}
 
 	public function readFloat() : float{
-		return BE::readFloat($this->buffer);
+		return BE::readFloat($this->reader);
 	}
 
 	public function writeFloat(float $v) : void{
-		BE::writeFloat($this->buffer, $v);
+		BE::writeFloat($this->writer, $v);
 	}
 
 	public function readDouble() : float{
-		return BE::readDouble($this->buffer);
+		return BE::readDouble($this->reader);
 	}
 
 	public function writeDouble(float $v) : void{
-		BE::writeDouble($this->buffer, $v);
+		BE::writeDouble($this->writer, $v);
 	}
 
 	public function readIntArray() : array{
 		$len = $this->readInt();
 		if($len < 0){
 			throw new NbtDataException("Array length cannot be less than zero ($len < 0)");
 		}
-		/** @var array<int>|false $unpacked */
-		$unpacked = unpack("N*", $this->buffer->readByteArray($len * 4));
-		assert($unpacked !== false, "The formatting string is valid, and we gave a multiple of 4 bytes");
-		return array_values($unpacked);
+		return BE::readSignedIntArray($this->reader, $len);
 	}
 
 	public function writeIntArray(array $array) : void{
 		$this->writeInt(count($array));
-		$this->buffer->writeByteArray(pack("N*", ...$array));
+		BE::writeSignedIntArray($this->writer, $array);
 	}
 }