refactor to use list instead of array

Author: bubunyo

list.go

@@ -0,0 +1,191 @@
+package bogo
+
+import (
+	"bytes"
+	"fmt"
+	"reflect"
+)
+
+func encodeList(list any) ([]byte, error) {
+	v := reflect.ValueOf(list)
+
+	if v.Kind() != reflect.Slice && v.Kind() != reflect.Array {
+		return nil, wrapError(arrEncErr, "type is not a list type")
+	}
+
+	buf := bytes.Buffer{}
+
+	for i := 0; i < v.Len(); i++ {
+		elem := v.Index(i)
+		data, err := encode(elem.Interface())
+		if err != nil {
+			return nil, wrapError(arrEncErr, "error encoding element in list", err.Error())
+		}
+		buf.Write(data)
+	}
+	data := buf.Bytes()
+	dataLen := len(data)
+	encodedLengthData, err := encodeUint(uint64(dataLen))
+	if err != nil {
+		return nil, wrapError(arrEncErr, "error encoding list length", err.Error())
+	}
+	// remove the type information
+	encodedLengthData = encodedLengthData[1:]
+
+	buf2 := bytes.Buffer{}
+	buf2.WriteByte(TypeUntypedList)
+	buf2.Write(encodedLengthData)
+	buf2.Write(data)
+	return buf2.Bytes(), nil
+}
+
+func decodeList(data []byte, v any) error {
+	rv := reflect.ValueOf(v)
+	if rv.Kind() != reflect.Pointer || rv.IsNil() {
+		return wrapError(arrDecErr, fmt.Sprintf("invalid decoder destination, %q", reflect.TypeOf(v)))
+	}
+	if rv.Kind() == reflect.Array || rv.Kind() == reflect.Slice {
+		return wrapError(arrDecErr, fmt.Sprintf("incompatible types %q", rv.Kind()))
+	}
+	elem := rv.Elem()
+
+	i := 0
+	computeDataSize := func() (uint64, error) {
+		i++
+		sizeLen := uint64(data[i])
+		i++
+		sizeLenEndI := i + int(sizeLen)
+		size, err := decodeUint(data[i:sizeLenEndI])
+		if err != nil {
+			return 0, wrapError(arrDecErr, err.Error())
+		}
+		i = sizeLenEndI
+		return size, nil
+	}
+
+	for i < len(data) {
+		var entryVal reflect.Value
+		entryType := Type(data[i])
+		switch entryType {
+		case TypeUntypedList:
+			size, err := computeDataSize()
+			if err != nil {
+				return err
+			}
+			var zeroSlice []any
+			err = decodeList(data[i:i+int(size)], &zeroSlice)
+			if err != nil {
+				return wrapError(arrDecErr, err.Error())
+			}
+			i += int(size)
+			entryVal = reflect.ValueOf(zeroSlice)
+		case TypeNull:
+			entryVal = reflect.Zero(reflect.TypeOf((*any)(nil)).Elem())
+			i++
+		case TypeBoolTrue:
+			entryVal = reflect.ValueOf(true)
+			i++
+		case TypeBoolFalse:
+			entryVal = reflect.ValueOf(false)
+			i++
+		case TypeByte:
+			entryVal = reflect.ValueOf(data[i])
+			i++
+		case TypeString:
+			size, err := computeDataSize()
+			if err != nil {
+				return err
+			}
+			entryVal = reflect.ValueOf(string(data[i : i+int(size)]))
+			i += int(size)
+		case TypeInt:
+			i++
+			sizeLen := uint64(data[i])
+			i++
+			endI := i + int(sizeLen)
+			n, err := decodeInt(data[i:endI])
+			if err != nil {
+				return wrapError(arrDecErr, err.Error())
+			}
+			entryVal = reflect.ValueOf(n)
+			i = endI
+		case TypeUint:
+			i++
+			sizeLen := uint64(data[i])
+			i++
+			endI := i + int(sizeLen)
+			n, err := decodeUint(data[i:endI])
+			if err != nil {
+				return wrapError(arrDecErr, err.Error())
+			}
+			entryVal = reflect.ValueOf(n)
+			i = endI
+		case TypeFloat:
+			i++
+			sizeLen := uint64(data[i])
+			i++
+			endI := i + int(sizeLen)
+			n, err := decodeFloat(data[i:endI])
+			if err != nil {
+				return wrapError(arrDecErr, err.Error())
+			}
+			entryVal = reflect.ValueOf(n)
+
+			i = endI
+		case TypeObject:
+			// Read object size
+			size, err := computeDataSize()
+			if err != nil {
+				return err
+			}
+
+			// Decode object
+			objData := data[i : i+int(size)]
+			obj, err := decodeObject(objData[2:]) // Skip type and size bytes
+			if err != nil {
+				return wrapError(arrDecErr, "failed to decode object", err.Error())
+			}
+
+			entryVal = reflect.ValueOf(obj)
+			i += int(size)
+		case TypeBlob:
+			// Read blob size
+			size, err := computeDataSize()
+			if err != nil {
+				return err
+			}
+
+			// Decode blob
+			blobData := data[i : i+int(size)]
+			blob, err := decodeBlob(blobData[2:]) // Skip type and size bytes
+			if err != nil {
+				return wrapError(arrDecErr, "failed to decode blob", err.Error())
+			}
+
+			entryVal = reflect.ValueOf(blob)
+			i += int(size)
+		case TypeTimestamp:
+			// Read timestamp (fixed 8 bytes)
+			if i+9 > len(data) { // 1 type + 8 data bytes
+				return wrapError(arrDecErr, "insufficient data for timestamp")
+			}
+
+			timestamp, err := decodeTimestamp(data[i+1 : i+9])
+			if err != nil {
+				return wrapError(arrDecErr, "failed to decode timestamp", err.Error())
+			}
+
+			entryVal = reflect.ValueOf(timestamp)
+			i += 9
+		default:
+			return wrapError(arrDecErr, fmt.Sprintf("unsupported list element type: %d", entryType))
+		}
+
+		if !entryVal.Type().AssignableTo(elem.Type().Elem()) {
+			return wrapError(arrDecErr, "item type does not match slice element type")
+		}
+		elem.Set(reflect.Append(elem, entryVal))
+	}
+
+	return nil
+}

list_test.go

@@ -0,0 +1,39 @@
+package bogo
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestListEncoding(t *testing.T) {
+	expected := []any{1, true, nil, "yes", 0.5, uint16(120), []any{7, 8, 9}, -98.0005}
+	res, err := encodeList(expected)
+	require.NoError(t, err)
+
+	assert.Equal(t, TypeUntypedList, int(res[0]))
+	arrLen := uint64(res[1])
+	size, err := decodeUint(res[2 : 2+arrLen])
+	require.NoError(t, err)
+	assert.Equal(t, size, uint64(len(res[2+arrLen:])))
+
+	var actual []any
+	err = decodeList(res[3:], &actual)
+	require.NoError(t, err)
+
+	assert.Equal(t, int64(expected[0].(int)), actual[0])
+	assert.Equal(t, expected[1], actual[1])
+	assert.Equal(t, expected[2], actual[2])
+	assert.Equal(t, expected[3], actual[3])
+	assert.Equal(t, expected[4], actual[4])
+	assert.Equal(t, uint64(expected[5].(uint16)), actual[5])
+
+	expInner := expected[6].([]interface{})
+	actInner := actual[6].([]interface{})
+	for i := range expInner {
+		assert.Equal(t, int64(expInner[i].(int)), actInner[i])
+	}
+
+	assert.Equal(t, expected[7], actual[7])
+}