Added 32 bit support to binser

binser/binser.go

@@ -31,7 +31,7 @@ import (
 const (
 	magicHeader = "serialization::archive"
 
-	Version uint16 = 0x11 // Boost archive version
+	Version uint16 = 0x13 // Boost archive version
 )
 
 var (
@@ -43,15 +43,23 @@ var (
 )
 
 var (
-	zeroHdr Header
-	bserHdr = Header{
+	zeroHdr   Header
+	bser64Hdr = Header{
 		Version: Version,
 		Flags: binary.LittleEndian.Uint64([]byte{
 			0x4, 0x8, // size of int, long
 			0x4, 0x8, // size of float, double
 			0x1, 0x0, 0x0, 0x0, // little-endian
 		}),
 	}
+	bser32Hdr = Header{
+		Version: Version,
+		Flags: binary.LittleEndian.Uint64([]byte{
+			0x4, 0x4, // size of int, long
+			0x4, 0x8, // size of float, double
+			0x1, 0x0, 0x0, 0x0, // little-endian
+		}),
+	}
 )
 
 // Unmarshaler is the interface implemented by types that can unmarshal a binary

binser/binser_example_test.go

@@ -49,6 +49,41 @@ func ExampleDecoder() {
 	// int8: 0x11
 }
 
+func ExampleDecoder32() {
+	f, err := os.Open("testdata/data32.bin")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer f.Close()
+
+	dec := binser.NewDecoder32(f)
+
+	var v1 bool
+	err = dec.Decode(&v1)
+	if err != nil {
+		log.Fatal(err)
+	}
+	fmt.Printf("bool: %v\n", v1)
+
+	err = dec.Decode(&v1)
+	if err != nil {
+		log.Fatal(err)
+	}
+	fmt.Printf("bool: %v\n", v1)
+
+	var i8 int8
+	err = dec.Decode(&i8)
+	if err != nil {
+		log.Fatal(err)
+	}
+	fmt.Printf("int8: %#x\n", i8)
+
+	// Output:
+	// bool: false
+	// bool: true
+	// int8: 0x11
+}
+
 func ExampleRBuffer() {
 	f, err := os.Open("testdata/data.bin")
 	if err != nil {
@@ -74,7 +109,47 @@ func ExampleRBuffer() {
 	fmt.Printf("float64: %v\n", r.ReadF64())
 
 	// Output:
-	// header: binser.Header{Version:0x11, Flags:0x108040804}
+	// header: binser.Header{Version:0x13, Flags:0x108040804}
+	// bool: false
+	// bool: true
+	// int8: 0x11
+	// int16: 0x2222
+	// int32: 0x33333333
+	// int64: 0x4444444444444444
+	// uint8: 0xff
+	// uint16: 0x2222
+	// uint32: 0x3333333
+	// uint64: 0x444444444444444
+	// float32: 2.2
+	// float64: 3.3
+}
+
+func ExampleRBuffer32() {
+	f, err := os.Open("testdata/data32.bin")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer f.Close()
+
+	r := binser.NewRBuffer32(f)
+
+	fmt.Printf("header: %#v\n", r.ReadHeader())
+
+	fmt.Printf("bool: %v\n", r.ReadBool())
+	fmt.Printf("bool: %v\n", r.ReadBool())
+	fmt.Printf("int8: %#x\n", r.ReadI8())
+	fmt.Printf("int16: %#x\n", r.ReadI16())
+	fmt.Printf("int32: %#x\n", r.ReadI32())
+	fmt.Printf("int64: %#x\n", r.ReadI64())
+	fmt.Printf("uint8: %#x\n", r.ReadU8())
+	fmt.Printf("uint16: %#x\n", r.ReadU16())
+	fmt.Printf("uint32: %#x\n", r.ReadU32())
+	fmt.Printf("uint64: %#x\n", r.ReadU64())
+	fmt.Printf("float32: %v\n", r.ReadF32())
+	fmt.Printf("float64: %v\n", r.ReadF64())
+
+	// Output:
+	// header: binser.Header{Version:0x13, Flags:0x108040404}
 	// bool: false
 	// bool: true
 	// int8: 0x11

binser/decoder.go

@@ -13,6 +13,7 @@ import (
 type Decoder struct {
 	r      *RBuffer
 	Header Header
+	bit32  bool
 }
 
 // NewDecoder returns a new decoder that reads from r.
@@ -23,6 +24,11 @@ func NewDecoder(r io.Reader) *Decoder {
 	return &Decoder{r: rr, Header: rr.ReadHeader()}
 }
 
+func NewDecoder32(r io.Reader) *Decoder {
+	rr := NewRBuffer32(r)
+	return &Decoder{r: rr, Header: rr.ReadHeader(), bit32: true}
+}
+
 // Decode reads the next value from its input and stores it in the
 // value pointed to by ptr.
 func (dec *Decoder) Decode(ptr interface{}) error {
@@ -75,7 +81,12 @@ func (dec *Decoder) Decode(ptr interface{}) error {
 	case reflect.Slice:
 		rt := rv.Type()
 		/*typ*/ _ = dec.r.ReadTypeDescr(rt)
-		n := dec.r.ReadU64()
+		var n int
+		if dec.bit32 {
+			n = int(dec.r.ReadU32())
+		} else {
+			n = int(dec.r.ReadU64())
+		}
 		if et := rt.Elem(); !isCxxBoostBuiltin(et.Kind()) {
 			_ = dec.r.ReadU32() // FIXME(sbinet): what is this ?
 		}
@@ -89,7 +100,12 @@ func (dec *Decoder) Decode(ptr interface{}) error {
 		}
 	case reflect.Array:
 		/*typ*/ _ = dec.r.ReadTypeDescr(rt)
-		n := int(dec.r.ReadU64())
+		var n int
+		if dec.bit32 {
+			n = int(dec.r.ReadU32())
+		} else {
+			n = int(dec.r.ReadU64())
+		}
 		if n != rv.Type().Len() {
 			return ErrInvalidArrayLen
 		}
@@ -99,7 +115,12 @@ func (dec *Decoder) Decode(ptr interface{}) error {
 		}
 	case reflect.Map:
 		/*typ*/ _ = dec.r.ReadTypeDescr(rt)
-		n := int(dec.r.ReadU64())
+		var n int
+		if dec.bit32 {
+			n = int(dec.r.ReadU32())
+		} else {
+			n = int(dec.r.ReadU64())
+		}
 		_ = dec.r.ReadU64() // FIXME(sbinet): what is this ?
 		_ = dec.r.ReadU8()  // FIXME(sbinet): ditto ?
 		kt := rv.Type().Key()

binser/decoder_test.go

@@ -39,6 +39,31 @@ func TestDecoder(t *testing.T) {
 	}
 }
 
+func TestDecoder32(t *testing.T) {
+	f, err := os.Open("testdata/data32.bin")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer f.Close()
+
+	dec := binser.NewDecoder32(f)
+	for _, tc := range typeTestCases {
+		t.Run(tc.name, func(t *testing.T) {
+			rv := reflect.New(reflect.TypeOf(tc.want)).Elem()
+			if rv.Kind() == reflect.Map {
+				rv.Set(reflect.MakeMap(rv.Type()))
+			}
+			err := dec.Decode(rv.Addr().Interface())
+			if err != nil {
+				t.Fatalf("could not read %q: %v", tc.name, err)
+			}
+			if got, want := rv.Interface(), tc.want; !reflect.DeepEqual(got, want) {
+				t.Fatalf("got=%#v (%T)\nwant=%#v (%T)", got, got, want, want)
+			}
+		})
+	}
+}
+
 func TestInvalidArchive(t *testing.T) {
 	for _, tc := range []struct {
 		raw []byte
@@ -120,6 +145,87 @@ func TestInvalidArchive(t *testing.T) {
 	}
 }
 
+func TestInvalidArchive32(t *testing.T) {
+	for _, tc := range []struct {
+		raw []byte
+		err error
+		val interface{}
+	}{
+		{
+			raw: nil,
+			err: binser.ErrNotBoost,
+		},
+		{
+			raw: []byte("boost"),
+			err: binser.ErrNotBoost,
+		},
+		{
+			raw: []byte{5, 0, 0, 0, 'b', 'o', 'o', 's', 't'},
+			err: binser.ErrNotBoost,
+		},
+		{
+			raw: []byte{
+				0x16, 0, 0, 0,
+				's', 'e', 'r', 'i', 'a', 'l', 'i', 'z', 'a', 't', 'i', 'o', 'n',
+				':', ':',
+				'a', 'r', 'c', 'h', 'i', 'v', 'e',
+			},
+			err: binser.ErrInvalidHeader,
+		},
+		{
+			raw: []byte{
+				0x16, 0, 0, 0,
+				's', 'e', 'r', 'i', 'a', 'l', 'i', 'z', 'a', 't', 'i', 'o', 'n',
+				':', ':',
+				'a', 'r', 'c', 'h', 'i', 'v', 'e',
+				0,
+			},
+			err: binser.ErrInvalidHeader,
+		},
+		{
+			raw: []byte{
+				0x16, 0, 0, 0,
+				's', 'e', 'r', 'i', 'a', 'l', 'i', 'z', 'a', 't', 'i', 'o', 'n',
+				':', ':',
+				'a', 'r', 'c', 'h', 'i', 'v', 'e',
+				1, 0,
+			},
+			err: binser.ErrInvalidHeader,
+		},
+		{
+			raw: []byte{
+				0x16, 0, 0, 0,
+				's', 'e', 'r', 'i', 'a', 'l', 'i', 'z', 'a', 't', 'i', 'o', 'n',
+				':', ':',
+				'a', 'r', 'c', 'h', 'i', 'v', 'e',
+				1, 0,
+				0,
+			},
+			err: binser.ErrInvalidHeader,
+		},
+		{
+			raw: []byte{
+				0x16, 0, 0, 0,
+				's', 'e', 'r', 'i', 'a', 'l', 'i', 'z', 'a', 't', 'i', 'o', 'n',
+				':', ':',
+				'a', 'r', 'c', 'h', 'i', 'v', 'e',
+				1, 0,
+				1, 0, 0, 0, 0, 0, 0, 0, 1,
+			},
+			err: io.ErrUnexpectedEOF,
+			val: new(uint16),
+		},
+	} {
+		t.Run("", func(t *testing.T) {
+			dec := binser.NewDecoder32(bytes.NewReader(tc.raw))
+			err := dec.Decode(tc.val)
+			if !reflect.DeepEqual(err, tc.err) {
+				t.Fatalf("got=%#v, want=%#v", err, tc.err)
+			}
+		})
+	}
+}
+
 type animal struct {
 	Name  string
 	Legs  int16
@@ -171,6 +277,20 @@ func TestRBufferReader(t *testing.T) {
 	}
 }
 
+func TestRBufferReader32(t *testing.T) {
+	want := []byte("hello")
+	r := binser.NewRBuffer32(bytes.NewReader(want))
+	got := make([]byte, len(want))
+	n, err := r.Read(got)
+	if err != nil {
+		t.Fatal(err)
+	}
+	got = got[:n]
+	if !bytes.Equal(got, want) {
+		t.Fatalf("got=%q, want=%q", got, want)
+	}
+}
+
 func TestInvalidArray(t *testing.T) {
 	buf := new(bytes.Buffer)
 	enc := binser.NewEncoder(buf)

binser/encoder.go

@@ -14,6 +14,7 @@ import (
 type Encoder struct {
 	w      *WBuffer
 	Header Header
+	bit32  bool
 
 	hdr sync.Once
 }
@@ -27,9 +28,18 @@ func NewEncoder(w io.Writer) *Encoder {
 	return &Encoder{w: ww}
 }
 
+func NewEncoder32(w io.Writer) *Encoder {
+	ww := NewWBuffer32(w)
+	return &Encoder{w: ww, bit32: true}
+}
+
 func (enc *Encoder) writeHeader() {
 	if enc.Header == zeroHdr {
-		enc.Header = bserHdr
+		if enc.bit32 {
+			enc.Header = bser32Hdr
+		} else {
+			enc.Header = bser64Hdr
+		}
 	}
 
 	enc.w.WriteString(magicHeader)
@@ -87,7 +97,11 @@ func (enc *Encoder) Encode(v interface{}) error {
 		rt := rv.Type()
 		enc.w.WriteTypeDescr(rt)
 		n := rv.Len()
-		enc.w.WriteU64(uint64(n))
+		if enc.bit32 {
+			enc.w.WriteU32(uint32(n))
+		} else {
+			enc.w.WriteU64(uint64(n))
+		}
 		if et := rt.Elem(); !isCxxBoostBuiltin(et.Kind()) {
 			enc.w.WriteU32(0) // FIXME(sbinet): what is this?
 		}
@@ -99,15 +113,24 @@ func (enc *Encoder) Encode(v interface{}) error {
 		rt := rv.Type()
 		enc.w.WriteTypeDescr(rt)
 		n := int(rv.Len())
-		enc.w.WriteU64(uint64(n))
+		if enc.bit32 {
+			enc.w.WriteU32(uint32(n))
+		} else {
+			enc.w.WriteU64(uint64(n))
+		}
 		for i := 0; i < n; i++ {
 			e := rv.Index(i)
 			enc.Encode(e.Interface()) // FIXME(sbinet): do not go through Decode each time
 		}
 	case reflect.Map:
 		rt := rv.Type()
 		enc.w.WriteTypeDescr(rt)
-		enc.w.WriteU64(uint64(rv.Len()))
+		n := int(rv.Len())
+		if enc.bit32 {
+			enc.w.WriteU32(uint32(n))
+		} else {
+			enc.w.WriteU64(uint64(n))
+		}
 		enc.w.WriteU64(0) // FIXME(sbinet): what is this ?
 		enc.w.WriteU8(0)  // FIXME(sbinet): ditto ?
 		keys := rv.MapKeys()