Added oneshot pack*() and unpack*() variants of all functions

these are useful for one-off encoding of simple stuff.
While it's possible to write a utility method that accepts a first-class
callable and creates a throwaway buffer internally, like

function encodeOneOff(T $value, Closure $writeFunc) : string{
	$writer = new ByteBufferWriter();
	$writeFunc($writer, $value);
	return $writer->getBuffer();
}

this is quite a bit slower than even unpack() for simple types, as well
as being mildly inconvenient.
So having dedicated one-off functions like in `Binary::` that aren't
slow is a good idea.

Author: dktapps

classes/ByteBufferReader.cpp

@@ -12,9 +12,9 @@ static zend_object_handlers byte_buffer_reader_zend_object_handlers;
 zend_class_entry* byte_buffer_reader_ce;
 
 static void reader_init_properties(byte_buffer_reader_zend_object* object, zend_string* buffer, size_t offset) {
-	object->buffer = buffer;
+	object->reader.buffer = buffer;
 	zend_string_addref(buffer);
-	object->offset = offset;
+	object->reader.offset = offset;
 }
 
 static zend_object* reader_new(zend_class_entry* ce) {
@@ -31,15 +31,15 @@ static zend_object* reader_clone(zend_object* object) {
 
 	zend_objects_clone_members(&new_object->std, &old_object->std);
 
-	reader_init_properties(new_object, old_object->buffer, old_object->offset);
+	reader_init_properties(new_object, old_object->reader.buffer, old_object->reader.offset);
 
 	return &new_object->std;
 }
 
 static void reader_free(zend_object* std) {
 	auto object = fetch_from_zend_object<byte_buffer_reader_zend_object>(std);
 
-	zend_string_release_ex(object->buffer, 0);
+	zend_string_release_ex(object->reader.buffer, 0);
 }
 
 static int reader_compare_objects(zval* obj1, zval* obj2) {
@@ -49,8 +49,8 @@ static int reader_compare_objects(zval* obj1, zval* obj2) {
 			auto object2 = fetch_from_zend_object<byte_buffer_reader_zend_object>(Z_OBJ_P(obj2));
 
 			if (
-				object1->offset == object2->offset &&
-				zend_string_equals(object1->buffer, object2->buffer)
+				object1->reader.offset == object2->reader.offset &&
+				zend_string_equals(object1->reader.buffer, object2->reader.buffer)
 				) {
 				return 0;
 			}
@@ -71,8 +71,8 @@ READER_METHOD(__construct) {
 	ZEND_PARSE_PARAMETERS_END();
 
 	object = READER_THIS();
-	if (object->buffer) {
-		zend_string_release_ex(object->buffer, 0);
+	if (object->reader.buffer) {
+		zend_string_release_ex(object->reader.buffer, 0);
 	}
 
 	reader_init_properties(object, buffer, 0);
@@ -82,7 +82,7 @@ READER_METHOD(getData) {
 	zend_parse_parameters_none_throw();
 
 	auto object = READER_THIS();
-	RETURN_STR_COPY(object->buffer);
+	RETURN_STR_COPY(object->reader.buffer);
 }
 
 READER_METHOD(readByteArray) {
@@ -105,19 +105,19 @@ READER_METHOD(readByteArray) {
 
 	object = READER_THIS();
 
-	if (ZSTR_LEN(object->buffer) - object->offset < length) {
-		zend_throw_exception_ex(data_decode_exception_ce, 0, "Need at least %zu bytes, but only have %zu bytes", length, ZSTR_LEN(object->buffer) - object->offset);
+	if (ZSTR_LEN(object->reader.buffer) - object->reader.offset < length) {
+		zend_throw_exception_ex(data_decode_exception_ce, 0, "Need at least %zu bytes, but only have %zu bytes", length, ZSTR_LEN(object->reader.buffer) - object->reader.offset);
 		return;
 	}
 
-	RETVAL_STRINGL(ZSTR_VAL(object->buffer) + object->offset, length);
-	object->offset += length;
+	RETVAL_STRINGL(ZSTR_VAL(object->reader.buffer) + object->reader.offset, length);
+	object->reader.offset += length;
 }
 
 READER_METHOD(getOffset) {
 	zend_parse_parameters_none_throw();
 	auto object = READER_THIS();
-	RETURN_LONG(object->offset);
+	RETURN_LONG(object->reader.offset);
 }
 
 READER_METHOD(setOffset) {
@@ -128,29 +128,29 @@ READER_METHOD(setOffset) {
 	ZEND_PARSE_PARAMETERS_END();
 
 	auto object = READER_THIS();
-	if (offset < 0 || static_cast<size_t>(offset) > ZSTR_LEN(object->buffer)) {
+	if (offset < 0 || static_cast<size_t>(offset) > ZSTR_LEN(object->reader.buffer)) {
 		zend_value_error("Offset must not be less than zero or greater than the available data size");
 		return;
 	}
 
-	object->offset = static_cast<size_t>(offset);
+	object->reader.offset = static_cast<size_t>(offset);
 }
 
 READER_METHOD(getUnreadLength) {
 	zend_parse_parameters_none_throw();
 
 	auto object = READER_THIS();
-	RETURN_LONG(ZSTR_LEN(object->buffer) - object->offset);
+	RETURN_LONG(ZSTR_LEN(object->reader.buffer) - object->reader.offset);
 }
 
 READER_METHOD(__serialize) {
 	zend_parse_parameters_none_throw();
 
 	auto object = READER_THIS();
 	array_init(return_value);
-	zend_string_addref(object->buffer);
-	add_assoc_str(return_value, "buffer", object->buffer);
-	add_assoc_long(return_value, "offset", object->offset);
+	zend_string_addref(object->reader.buffer);
+	add_assoc_str(return_value, "buffer", object->reader.buffer);
+	add_assoc_long(return_value, "offset", object->reader.offset);
 }
 
 static zval* fetch_serialized_property(HashTable* data, const char* name, int type) {
@@ -193,9 +193,9 @@ READER_METHOD(__debugInfo) {
 
 	auto object = READER_THIS();
 	array_init(return_value);
-	zend_string_addref(object->buffer);
-	add_assoc_str(return_value, "buffer", object->buffer);
-	add_assoc_long(return_value, "offset", object->offset);
+	zend_string_addref(object->reader.buffer);
+	add_assoc_str(return_value, "buffer", object->reader.buffer);
+	add_assoc_long(return_value, "offset", object->reader.offset);
 }
 
 zend_class_entry* init_class_ByteBufferReader(void) {

classes/ByteBufferReader.h

@@ -6,9 +6,13 @@ extern "C" {
 }
 #include "../ZendUtil.h"
 
-typedef struct _byte_buffer_reader_zend_object {
+typedef struct _byte_buffer_reader_t {
 	zend_string* buffer;
 	size_t offset;
+} byte_buffer_reader_t;
+
+typedef struct _byte_buffer_reader_zend_object {
+	byte_buffer_reader_t reader;
 	zend_object std;
 } byte_buffer_reader_zend_object;
 

classes/ByteBufferWriter.cpp

@@ -12,10 +12,10 @@ static zend_object_handlers byte_buffer_writer_zend_object_handlers;
 zend_class_entry* byte_buffer_writer_ce;
 
 static void writer_init_properties(byte_buffer_writer_zend_object* object, zend_string* buffer, size_t used, size_t offset) {
-	object->buffer = buffer;
+	object->writer.buffer = buffer;
 	zend_string_addref(buffer);
-	object->offset = offset;
-	object->used = used;
+	object->writer.offset = offset;
+	object->writer.used = used;
 }
 
 static zend_object* writer_new(zend_class_entry* ce) {
@@ -32,15 +32,15 @@ static zend_object* writer_clone(zend_object* object) {
 
 	zend_objects_clone_members(&new_object->std, &old_object->std);
 
-	writer_init_properties(new_object, old_object->buffer, old_object->used, old_object->offset);
+	writer_init_properties(new_object, old_object->writer.buffer, old_object->writer.used, old_object->writer.offset);
 
 	return &new_object->std;
 }
 
 static void writer_free(zend_object* std) {
 	auto object = fetch_from_zend_object<byte_buffer_writer_zend_object>(std);
 
-	zend_string_release_ex(object->buffer, 0);
+	zend_string_release_ex(object->writer.buffer, 0);
 }
 
 static int writer_compare_objects(zval* obj1, zval* obj2) {
@@ -50,9 +50,9 @@ static int writer_compare_objects(zval* obj1, zval* obj2) {
 			auto object2 = fetch_from_zend_object<byte_buffer_writer_zend_object>(Z_OBJ_P(obj2));
 
 			if (
-				object1->offset == object2->offset &&
-				object1->used == object2->used &&
-				zend_string_equals(object1->buffer, object2->buffer)
+				object1->writer.offset == object2->writer.offset &&
+				object1->writer.used == object2->writer.used &&
+				zend_string_equals(object1->writer.buffer, object2->writer.buffer)
 				) {
 				return 0;
 			}
@@ -74,8 +74,8 @@ WRITER_METHOD(__construct) {
 	ZEND_PARSE_PARAMETERS_END();
 
 	object = WRITER_THIS();
-	if (object->buffer) {
-		zend_string_release_ex(object->buffer, 0);
+	if (object->writer.buffer) {
+		zend_string_release_ex(object->writer.buffer, 0);
 	}
 
 	if (buffer == NULL) {
@@ -90,7 +90,7 @@ WRITER_METHOD(getData) {
 	zend_parse_parameters_none_throw();
 
 	auto object = WRITER_THIS();
-	RETURN_STRINGL(ZSTR_VAL(object->buffer), object->used);
+	RETURN_STRINGL(ZSTR_VAL(object->writer.buffer), object->writer.used);
 }
 
 WRITER_METHOD(writeByteArray) {
@@ -106,18 +106,18 @@ WRITER_METHOD(writeByteArray) {
 
 	auto size = ZSTR_LEN(value);
 
-	extendBuffer(object->buffer, object->offset, size);
-	memcpy(ZSTR_VAL(object->buffer) + object->offset, ZSTR_VAL(value), size);
-	object->offset += size;
-	if (object->offset > object->used) {
-		object->used = object->offset;
+	extendBuffer(object->writer.buffer, object->writer.offset, size);
+	memcpy(ZSTR_VAL(object->writer.buffer) + object->writer.offset, ZSTR_VAL(value), size);
+	object->writer.offset += size;
+	if (object->writer.offset > object->writer.used) {
+		object->writer.used = object->writer.offset;
 	}
 }
 
 WRITER_METHOD(getOffset) {
 	zend_parse_parameters_none_throw();
 	auto object = WRITER_THIS();
-	RETURN_LONG(object->offset);
+	RETURN_LONG(object->writer.offset);
 }
 
 WRITER_METHOD(setOffset) {
@@ -128,26 +128,26 @@ WRITER_METHOD(setOffset) {
 	ZEND_PARSE_PARAMETERS_END();
 
 	auto object = WRITER_THIS();
-	if (offset < 0 || static_cast<size_t>(offset) > object->used) {
+	if (offset < 0 || static_cast<size_t>(offset) > object->writer.used) {
 		zend_value_error("Offset must not be less than zero or greater than the buffer size");
 		return;
 	}
 
-	object->offset = static_cast<size_t>(offset);
+	object->writer.offset = static_cast<size_t>(offset);
 }
 
 WRITER_METHOD(getUsedLength) {
 	zend_parse_parameters_none_throw();
 
 	auto object = WRITER_THIS();
-	RETURN_LONG(object->used);
+	RETURN_LONG(object->writer.used);
 }
 
 WRITER_METHOD(getReservedLength) {
 	zend_parse_parameters_none_throw();
 
 	auto object = WRITER_THIS();
-	RETURN_LONG(ZSTR_LEN(object->buffer));
+	RETURN_LONG(ZSTR_LEN(object->writer.buffer));
 }
 
 WRITER_METHOD(reserve) {
@@ -162,24 +162,24 @@ WRITER_METHOD(reserve) {
 		return;
 	}
 	auto object = WRITER_THIS();
-	extendBuffer(object->buffer, static_cast<size_t>(zlength), 0);
+	extendBuffer(object->writer.buffer, static_cast<size_t>(zlength), 0);
 }
 
 WRITER_METHOD(trim) {
 	zend_parse_parameters_none_throw();
 
 	auto object = WRITER_THIS();
-	if (ZSTR_LEN(object->buffer) > object->used) {
-		object->buffer = zend_string_truncate(object->buffer, object->used, 0);
+	if (ZSTR_LEN(object->writer.buffer) > object->writer.used) {
+		object->writer.buffer = zend_string_truncate(object->writer.buffer, object->writer.used, 0);
 	}
 }
 
 WRITER_METHOD(clear) {
 	zend_parse_parameters_none_throw();
 
 	auto object = WRITER_THIS();
-	object->offset = 0;
-	object->used = 0;
+	object->writer.offset = 0;
+	object->writer.used = 0;
 }
 
 WRITER_METHOD(__serialize) {
@@ -189,8 +189,8 @@ WRITER_METHOD(__serialize) {
 	array_init(return_value);
 
 	//don't return the writer buffer directly - it may have uninitialized reserved memory
-	add_assoc_stringl(return_value, "buffer", ZSTR_VAL(object->buffer), object->used);
-	add_assoc_long(return_value, "offset", object->offset);
+	add_assoc_stringl(return_value, "buffer", ZSTR_VAL(object->writer.buffer), object->writer.used);
+	add_assoc_long(return_value, "offset", object->writer.offset);
 }
 
 static zval* fetch_serialized_property(HashTable* data, const char* name, int type) {
@@ -235,8 +235,8 @@ WRITER_METHOD(__debugInfo) {
 	array_init(return_value);
 
 	//don't return the writer buffer directly - it may have uninitialized reserved memory
-	add_assoc_stringl(return_value, "buffer", ZSTR_VAL(object->buffer), object->used);
-	add_assoc_long(return_value, "offset", object->offset);
+	add_assoc_stringl(return_value, "buffer", ZSTR_VAL(object->writer.buffer), object->writer.used);
+	add_assoc_long(return_value, "offset", object->writer.offset);
 }
 
 zend_class_entry* init_class_ByteBufferWriter(void) {

classes/ByteBufferWriter.h

@@ -6,10 +6,14 @@ extern "C" {
 }
 #include "../ZendUtil.h"
 
-typedef struct _byte_buffer_writer_zend_object {
+typedef struct _byte_buffer_writer_t {
 	zend_string* buffer;
 	size_t offset;
 	size_t used;
+} byte_buffer_writer_t;
+
+typedef struct _byte_buffer_writer_zend_object {
+	byte_buffer_writer_t writer;
 	zend_object std;
 } byte_buffer_writer_zend_object;