diff --git a/go/msgpack_test.go b/go/msgpack_test.go index 50de668a..2c32fee2 100644 --- a/go/msgpack_test.go +++ b/go/msgpack_test.go @@ -1,218 +1,318 @@ package msgpack_test import ( - . "msgpack" - "testing" - "bytes" - "reflect" - "math" -); + . "msgpack" + "testing" + "bytes" + "reflect" + "math" +) func equal(lhs reflect.Value, rhs reflect.Value) bool { - { - _rhs, ok := rhs.(*reflect.InterfaceValue) - if ok { return equal(lhs, _rhs.Elem()) } - } - switch _lhs := lhs.(type) { - case *reflect.InterfaceValue: - return equal(_lhs.Elem(), rhs) - case *reflect.BoolValue: - _rhs, ok := rhs.(*reflect.BoolValue) - return ok && _lhs.Get() == _rhs.Get() - case *reflect.UintValue: - _rhs, ok := rhs.(*reflect.UintValue) - return ok && _lhs.Get() == _rhs.Get() - case *reflect.IntValue: - _rhs, ok := rhs.(*reflect.IntValue) - return ok && _lhs.Get() == _rhs.Get() - case *reflect.FloatValue: - _rhs, ok := rhs.(*reflect.FloatValue) - return ok && _lhs.Get() == _rhs.Get() - case reflect.ArrayOrSliceValue: - _rhs := rhs.(reflect.ArrayOrSliceValue) - if _lhs.Len() != _rhs.Len() { return false; } - for i := 0; i < _lhs.Len(); i++ { - if !equal(_lhs.Elem(i), _rhs.Elem(i)) { return false; } - } - return true; - case *reflect.MapValue: - _rhs := rhs.(*reflect.MapValue) - if _lhs.Len() != _rhs.Len() { return false; } - for _, k := range _lhs.Keys() { - lv, rv := _lhs.Elem(k), _rhs.Elem(k) - if lv == nil || rv == nil || !equal(lv, rv) { return false; } - } - return true; - } - return false; + { + _rhs := rhs + if _rhs.Kind() == reflect.Interface { + return equal(lhs, _rhs.Elem()) + } + } + switch _lhs := lhs; _lhs.Kind() { + case reflect.Interface: + return equal(_lhs.Elem(), rhs) + case reflect.Bool: + _rhs := rhs + return _rhs.Kind() == reflect.Bool && + _lhs.Bool() == _rhs.Bool() + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: + _rhs := rhs + return (_rhs.Kind() == reflect.Uint || _rhs.Kind() == reflect.Uint8 || _rhs.Kind() == reflect.Uint16 || _rhs.Kind() == reflect.Uint32 || _rhs.Kind() == reflect.Uint64 || _rhs.Kind() == reflect.Uintptr) && + _lhs.Uint() == _rhs.Uint() + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + _rhs := rhs + return (_rhs.Kind() == reflect.Int || _rhs.Kind() == reflect.Int8 || _rhs.Kind() == reflect.Int16 || _rhs.Kind() == reflect.Int32 || _rhs.Kind() == reflect.Int64) && + _lhs.Int() == _rhs.Int() + case reflect.Float32, reflect.Float64: + _rhs := rhs + return (_rhs.Kind() == reflect.Float32 || _rhs.Kind() == reflect.Float64) && + _lhs.Float() == _rhs.Float() + case reflect.Array, reflect.Slice: + _rhs := rhs + if _lhs.Len() != _rhs.Len() { + return false + } + for i := 0; i < _lhs.Len(); i++ { + if !equal(_lhs.Index(i), _rhs.Index(i)) { + return false + } + } + return true + case reflect.Map: + _rhs := rhs + if _lhs.Len() != _rhs.Len() { + return false + } + for _, k := range _lhs.MapKeys() { + lv, rv := _lhs.MapIndex(k), _rhs.MapIndex(k) + if !lv.IsValid() || !rv.IsValid() || !equal(lv, rv) { + return false + } + } + return true + } + return false } func TestPackUint8(t *testing.T) { - b := &bytes.Buffer{} - for _, i := range []uint8 { 0, 1, 2, 125, 126, 127, 128, 253, 254, 255 } { - _, err := PackUint8(b, i) - if err != nil { t.Error("err != nil") } - } - if bytes.Compare(b.Bytes(), []byte { 0x00, 0x01, 0x02, 0x7d, 0x7e, 0x7f, 0xcc, 0x80, 0xcc, 0xfd, 0xcc, 0xfe, 0xcc, 0xff }) != 0 { t.Error("wrong output", b.Bytes()) } + b := &bytes.Buffer{} + for _, i := range []uint8{0, 1, 2, 125, 126, 127, 128, 253, 254, 255} { + _, err := PackUint8(b, i) + if err != nil { + t.Error("err != nil") + } + } + if bytes.Compare(b.Bytes(), []byte{0x00, 0x01, 0x02, 0x7d, 0x7e, 0x7f, 0xcc, 0x80, 0xcc, 0xfd, 0xcc, 0xfe, 0xcc, 0xff}) != 0 { + t.Error("wrong output", b.Bytes()) + } } func TestPackUint16(t *testing.T) { - b := &bytes.Buffer{} - for _, i := range []uint16 { 0, 1, 2, 125, 126, 127, 128, 253, 254, 255, 256, 65533, 65534, 65535 } { - _, err := PackUint16(b, i) - if err != nil { t.Error("err != nil") } - } - if bytes.Compare(b.Bytes(), []byte { 0x00, 0x01, 0x02, 0x7d, 0x7e, 0x7f, 0xcc, 0x80, 0xcc, 0xfd, 0xcc, 0xfe, 0xcc, 0xff, 0xcd, 0x01, 0x00, 0xcd, 0xff, 0xfd, 0xcd, 0xff, 0xfe, 0xcd, 0xff, 0xff }) != 0 { t.Error("wrong output", b.Bytes()) } + b := &bytes.Buffer{} + for _, i := range []uint16{0, 1, 2, 125, 126, 127, 128, 253, 254, 255, 256, 65533, 65534, 65535} { + _, err := PackUint16(b, i) + if err != nil { + t.Error("err != nil") + } + } + if bytes.Compare(b.Bytes(), []byte{0x00, 0x01, 0x02, 0x7d, 0x7e, 0x7f, 0xcc, 0x80, 0xcc, 0xfd, 0xcc, 0xfe, 0xcc, 0xff, 0xcd, 0x01, 0x00, 0xcd, 0xff, 0xfd, 0xcd, 0xff, 0xfe, 0xcd, 0xff, 0xff}) != 0 { + t.Error("wrong output", b.Bytes()) + } } func TestPackUint32(t *testing.T) { - b := &bytes.Buffer{} - for _, i := range []uint32 { 0, 1, 2, 125, 126, 127, 128, 253, 254, 255, 256, 65533, 65534, 65535, 65536, 4294967293, 4294967294, 4294967295 } { - _, err := PackUint32(b, i) - if err != nil { t.Error("err != nil") } - } - if bytes.Compare(b.Bytes(), []byte { 0x00, 0x01, 0x02, 0x7d, 0x7e, 0x7f, 0xcc, 0x80, 0xcc, 0xfd, 0xcc, 0xfe, 0xcc, 0xff, 0xcd, 0x01, 0x00, 0xcd, 0xff, 0xfd, 0xcd, 0xff, 0xfe, 0xcd, 0xff, 0xff, 0xce, 0x00, 0x01, 0x00, 0x00, 0xce, 0xff, 0xff, 0xff, 0xfd, 0xce, 0xff, 0xff, 0xff, 0xfe, 0xce, 0xff, 0xff, 0xff, 0xff }) != 0 { t.Error("wrong output", b.Bytes()) } + b := &bytes.Buffer{} + for _, i := range []uint32{0, 1, 2, 125, 126, 127, 128, 253, 254, 255, 256, 65533, 65534, 65535, 65536, 4294967293, 4294967294, 4294967295} { + _, err := PackUint32(b, i) + if err != nil { + t.Error("err != nil") + } + } + if bytes.Compare(b.Bytes(), []byte{0x00, 0x01, 0x02, 0x7d, 0x7e, 0x7f, 0xcc, 0x80, 0xcc, 0xfd, 0xcc, 0xfe, 0xcc, 0xff, 0xcd, 0x01, 0x00, 0xcd, 0xff, 0xfd, 0xcd, 0xff, 0xfe, 0xcd, 0xff, 0xff, 0xce, 0x00, 0x01, 0x00, 0x00, 0xce, 0xff, 0xff, 0xff, 0xfd, 0xce, 0xff, 0xff, 0xff, 0xfe, 0xce, 0xff, 0xff, 0xff, 0xff}) != 0 { + t.Error("wrong output", b.Bytes()) + } } func TestPackUint64(t *testing.T) { - b := &bytes.Buffer{} - for _, i := range []uint64 { 0, 1, 2, 125, 126, 127, 128, 253, 254, 255, 256, 65533, 65534, 65535, 65536, 4294967293, 4294967294, 4294967295, 4294967296, 18446744073709551613, 18446744073709551614, 18446744073709551615 } { - _, err := PackUint64(b, i) - if err != nil { t.Error("err != nil") } - } - if bytes.Compare(b.Bytes(), []byte { 0x00, 0x01, 0x02, 0x7d, 0x7e, 0x7f, 0xcc, 0x80, 0xcc, 0xfd, 0xcc, 0xfe, 0xcc, 0xff, 0xcd, 0x01, 0x00, 0xcd, 0xff, 0xfd, 0xcd, 0xff, 0xfe, 0xcd, 0xff, 0xff, 0xce, 0x00, 0x01, 0x00, 0x00, 0xce, 0xff, 0xff, 0xff, 0xfd, 0xce, 0xff, 0xff, 0xff, 0xfe, 0xce, 0xff, 0xff, 0xff, 0xff, 0xcf, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }) != 0 { t.Error("wrong output", b.Bytes()) } + b := &bytes.Buffer{} + for _, i := range []uint64{0, 1, 2, 125, 126, 127, 128, 253, 254, 255, 256, 65533, 65534, 65535, 65536, 4294967293, 4294967294, 4294967295, 4294967296, 18446744073709551613, 18446744073709551614, 18446744073709551615} { + _, err := PackUint64(b, i) + if err != nil { + t.Error("err != nil") + } + } + if bytes.Compare(b.Bytes(), []byte{0x00, 0x01, 0x02, 0x7d, 0x7e, 0x7f, 0xcc, 0x80, 0xcc, 0xfd, 0xcc, 0xfe, 0xcc, 0xff, 0xcd, 0x01, 0x00, 0xcd, 0xff, 0xfd, 0xcd, 0xff, 0xfe, 0xcd, 0xff, 0xff, 0xce, 0x00, 0x01, 0x00, 0x00, 0xce, 0xff, 0xff, 0xff, 0xfd, 0xce, 0xff, 0xff, 0xff, 0xfe, 0xce, 0xff, 0xff, 0xff, 0xff, 0xcf, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}) != 0 { + t.Error("wrong output", b.Bytes()) + } } func TestPackInt8(t *testing.T) { - b := &bytes.Buffer{} - for _, i := range []int8 { -128, -127, -34, -33, -32, -31, 0, 1, 126, 127 } { - _, err := PackInt8(b, i) - if err != nil { t.Error("err != nil") } - } - if bytes.Compare(b.Bytes(), []byte { 0xd0, 0x80, 0xd0, 0x81, 0xd0, 0xde, 0xd0, 0xdf, 0xe0, 0xe1, 0x00, 0x01, 0x7e, 0x7f }) != 0 { t.Error("wrong output", b.Bytes()) } + b := &bytes.Buffer{} + for _, i := range []int8{-128, -127, -34, -33, -32, -31, 0, 1, 126, 127} { + _, err := PackInt8(b, i) + if err != nil { + t.Error("err != nil") + } + } + if bytes.Compare(b.Bytes(), []byte{0xd0, 0x80, 0xd0, 0x81, 0xd0, 0xde, 0xd0, 0xdf, 0xe0, 0xe1, 0x00, 0x01, 0x7e, 0x7f}) != 0 { + t.Error("wrong output", b.Bytes()) + } } func TestPackInt16(t *testing.T) { - b := &bytes.Buffer{} - for _, i := range []int16 { -32768, -32767, -131, -130, -129, -128, -127, -34, -33, -32, -31, 0, 1, 126, 127, 128, 129, 130, 32765, 32766, 32767 } { - _, err := PackInt16(b, i) - if err != nil { t.Error("err != nil") } - } - if bytes.Compare(b.Bytes(), []byte { 0xd1, 0x80, 0x00, 0xd1, 0x80, 0x01, 0xd1, 0xff, 0x7d, 0xd1, 0xff, 0x7e, 0xd1, 0xff, 0x7f, 0xd0, 0x80, 0xd0, 0x81, 0xd0, 0xde, 0xd0, 0xdf, 0xe0, 0xe1, 0x00, 0x01, 0x7e, 0x7f, 0xd1, 0x00, 0x80, 0xd1, 0x00, 0x81, 0xd1, 0x00, 0x82, 0xd1, 0x7f, 0xfd, 0xd1, 0x7f, 0xfe, 0xd1, 0x7f, 0xff }) != 0 { t.Error("wrong output", b.Bytes()) } + b := &bytes.Buffer{} + for _, i := range []int16{-32768, -32767, -131, -130, -129, -128, -127, -34, -33, -32, -31, 0, 1, 126, 127, 128, 129, 130, 32765, 32766, 32767} { + _, err := PackInt16(b, i) + if err != nil { + t.Error("err != nil") + } + } + if bytes.Compare(b.Bytes(), []byte{0xd1, 0x80, 0x00, 0xd1, 0x80, 0x01, 0xd1, 0xff, 0x7d, 0xd1, 0xff, 0x7e, 0xd1, 0xff, 0x7f, 0xd0, 0x80, 0xd0, 0x81, 0xd0, 0xde, 0xd0, 0xdf, 0xe0, 0xe1, 0x00, 0x01, 0x7e, 0x7f, 0xd1, 0x00, 0x80, 0xd1, 0x00, 0x81, 0xd1, 0x00, 0x82, 0xd1, 0x7f, 0xfd, 0xd1, 0x7f, 0xfe, 0xd1, 0x7f, 0xff}) != 0 { + t.Error("wrong output", b.Bytes()) + } } func TestPackInt32(t *testing.T) { - b := &bytes.Buffer{} - for _, i := range []int32 { -2147483648, -2147483647, -2147483646, -32771, -32770, -32769, -32768, -32767, -131, -130, -129, -128, -127, -34, -33, -32, -31, 0, 1, 126, 127, 128, 129, 130, 32765, 32766, 32767, 32768, 32769, 32770, 2147483645, 2147483646, 2147483647 } { - _, err := PackInt32(b, i) - if err != nil { t.Error("err != nil") } - } - if bytes.Compare(b.Bytes(), []byte { 0xd2, 0x80, 0x00, 0x00, 0x00, 0xd2, 0x80, 0x00, 0x00, 0x01, 0xd2, 0x80, 0x00, 0x00, 0x02, 0xd2, 0xff, 0xff, 0x7f, 0xfd, 0xd2, 0xff, 0xff, 0x7f, 0xfe, 0xd2, 0xff, 0xff, 0x7f, 0xff, 0xd1, 0x80, 0x00, 0xd1, 0x80, 0x01, 0xd1, 0xff, 0x7d, 0xd1, 0xff, 0x7e, 0xd1, 0xff, 0x7f, 0xd0, 0x80, 0xd0, 0x81, 0xd0, 0xde, 0xd0, 0xdf, 0xe0, 0xe1, 0x00, 0x01, 0x7e, 0x7f, 0xd1, 0x00, 0x80, 0xd1, 0x00, 0x81, 0xd1, 0x00, 0x82, 0xd1, 0x7f, 0xfd, 0xd1, 0x7f, 0xfe, 0xd1, 0x7f, 0xff, 0xd2, 0x00, 0x00, 0x80, 0x00, 0xd2, 0x00, 0x00, 0x80, 0x01, 0xd2, 0x00, 0x00, 0x80, 0x02, 0xd2, 0x7f, 0xff, 0xff, 0xfd, 0xd2, 0x7f, 0xff, 0xff, 0xfe, 0xd2, 0x7f, 0xff, 0xff, 0xff }) != 0 { t.Error("wrong output", b.Bytes()) } + b := &bytes.Buffer{} + for _, i := range []int32{-2147483648, -2147483647, -2147483646, -32771, -32770, -32769, -32768, -32767, -131, -130, -129, -128, -127, -34, -33, -32, -31, 0, 1, 126, 127, 128, 129, 130, 32765, 32766, 32767, 32768, 32769, 32770, 2147483645, 2147483646, 2147483647} { + _, err := PackInt32(b, i) + if err != nil { + t.Error("err != nil") + } + } + if bytes.Compare(b.Bytes(), []byte{0xd2, 0x80, 0x00, 0x00, 0x00, 0xd2, 0x80, 0x00, 0x00, 0x01, 0xd2, 0x80, 0x00, 0x00, 0x02, 0xd2, 0xff, 0xff, 0x7f, 0xfd, 0xd2, 0xff, 0xff, 0x7f, 0xfe, 0xd2, 0xff, 0xff, 0x7f, 0xff, 0xd1, 0x80, 0x00, 0xd1, 0x80, 0x01, 0xd1, 0xff, 0x7d, 0xd1, 0xff, 0x7e, 0xd1, 0xff, 0x7f, 0xd0, 0x80, 0xd0, 0x81, 0xd0, 0xde, 0xd0, 0xdf, 0xe0, 0xe1, 0x00, 0x01, 0x7e, 0x7f, 0xd1, 0x00, 0x80, 0xd1, 0x00, 0x81, 0xd1, 0x00, 0x82, 0xd1, 0x7f, 0xfd, 0xd1, 0x7f, 0xfe, 0xd1, 0x7f, 0xff, 0xd2, 0x00, 0x00, 0x80, 0x00, 0xd2, 0x00, 0x00, 0x80, 0x01, 0xd2, 0x00, 0x00, 0x80, 0x02, 0xd2, 0x7f, 0xff, 0xff, 0xfd, 0xd2, 0x7f, 0xff, 0xff, 0xfe, 0xd2, 0x7f, 0xff, 0xff, 0xff}) != 0 { + t.Error("wrong output", b.Bytes()) + } } func TestPackInt64(t *testing.T) { - b := &bytes.Buffer{} - for _, i := range []int64 { -9223372036854775808, -9223372036854775807, -9223372036854775806, -2147483651, -2147483650, -2147483649, -2147483648, -2147483647, -2147483646, -32771, -32770, -32769, -32768, -32767, -131, -130, -129, -128, -127, -34, -33, -32, -31, 0, 1, 126, 127, 128, 129, 130, 32765, 32766, 32767, 32768, 32769, 32770, 2147483645, 2147483646, 2147483647, 2147483648, 2147483649, 2147483650, 4294967296, 4294967297, 4294967298 } { - _, err := PackInt64(b, i) - if err != nil { t.Error("err != nil") } - } - if bytes.Compare(b.Bytes(), []byte { 0xd3, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xd3, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xd3, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xfd, 0xd3, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xfe, 0xd3, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xd2, 0x80, 0x00, 0x00, 0x00, 0xd2, 0x80, 0x00, 0x00, 0x01, 0xd2, 0x80, 0x00, 0x00, 0x02, 0xd2, 0xff, 0xff, 0x7f, 0xfd, 0xd2, 0xff, 0xff, 0x7f, 0xfe, 0xd2, 0xff, 0xff, 0x7f, 0xff, 0xd1, 0x80, 0x00, 0xd1, 0x80, 0x01, 0xd1, 0xff, 0x7d, 0xd1, 0xff, 0x7e, 0xd1, 0xff, 0x7f, 0xd0, 0x80, 0xd0, 0x81, 0xd0, 0xde, 0xd0, 0xdf, 0xe0, 0xe1, 0x00, 0x01, 0x7e, 0x7f, 0xd1, 0x00, 0x80, 0xd1, 0x00, 0x81, 0xd1, 0x00, 0x82, 0xd1, 0x7f, 0xfd, 0xd1, 0x7f, 0xfe, 0xd1, 0x7f, 0xff, 0xd2, 0x00, 0x00, 0x80, 0x00, 0xd2, 0x00, 0x00, 0x80, 0x01, 0xd2, 0x00, 0x00, 0x80, 0x02, 0xd2, 0x7f, 0xff, 0xff, 0xfd, 0xd2, 0x7f, 0xff, 0xff, 0xfe, 0xd2, 0x7f, 0xff, 0xff, 0xff, 0xd3, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0xd3, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x01, 0xd3, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x02, 0xd3, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0xd3, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02 }) != 0 { t.Error("wrong output", b.Bytes()) } + b := &bytes.Buffer{} + for _, i := range []int64{-9223372036854775808, -9223372036854775807, -9223372036854775806, -2147483651, -2147483650, -2147483649, -2147483648, -2147483647, -2147483646, -32771, -32770, -32769, -32768, -32767, -131, -130, -129, -128, -127, -34, -33, -32, -31, 0, 1, 126, 127, 128, 129, 130, 32765, 32766, 32767, 32768, 32769, 32770, 2147483645, 2147483646, 2147483647, 2147483648, 2147483649, 2147483650, 4294967296, 4294967297, 4294967298} { + _, err := PackInt64(b, i) + if err != nil { + t.Error("err != nil") + } + } + if bytes.Compare(b.Bytes(), []byte{0xd3, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xd3, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xd3, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xfd, 0xd3, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xfe, 0xd3, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xd2, 0x80, 0x00, 0x00, 0x00, 0xd2, 0x80, 0x00, 0x00, 0x01, 0xd2, 0x80, 0x00, 0x00, 0x02, 0xd2, 0xff, 0xff, 0x7f, 0xfd, 0xd2, 0xff, 0xff, 0x7f, 0xfe, 0xd2, 0xff, 0xff, 0x7f, 0xff, 0xd1, 0x80, 0x00, 0xd1, 0x80, 0x01, 0xd1, 0xff, 0x7d, 0xd1, 0xff, 0x7e, 0xd1, 0xff, 0x7f, 0xd0, 0x80, 0xd0, 0x81, 0xd0, 0xde, 0xd0, 0xdf, 0xe0, 0xe1, 0x00, 0x01, 0x7e, 0x7f, 0xd1, 0x00, 0x80, 0xd1, 0x00, 0x81, 0xd1, 0x00, 0x82, 0xd1, 0x7f, 0xfd, 0xd1, 0x7f, 0xfe, 0xd1, 0x7f, 0xff, 0xd2, 0x00, 0x00, 0x80, 0x00, 0xd2, 0x00, 0x00, 0x80, 0x01, 0xd2, 0x00, 0x00, 0x80, 0x02, 0xd2, 0x7f, 0xff, 0xff, 0xfd, 0xd2, 0x7f, 0xff, 0xff, 0xfe, 0xd2, 0x7f, 0xff, 0xff, 0xff, 0xd3, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0xd3, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x01, 0xd3, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x02, 0xd3, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0xd3, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02}) != 0 { + t.Error("wrong output", b.Bytes()) + } } func TestPackNil(t *testing.T) { - b := &bytes.Buffer{} - nbyteswrite, err := PackNil(b) - if nbyteswrite != 1 { t.Error("nbyteswrite != 1") } - if err != nil { t.Error("err != nil") } - if bytes.Compare(b.Bytes(), []byte { 0xc0 }) != 0 { t.Error("wrong output", b.Bytes()) } + b := &bytes.Buffer{} + nbyteswrite, err := PackNil(b) + if nbyteswrite != 1 { + t.Error("nbyteswrite != 1") + } + if err != nil { + t.Error("err != nil") + } + if bytes.Compare(b.Bytes(), []byte{0xc0}) != 0 { + t.Error("wrong output", b.Bytes()) + } } func TestPackBool(t *testing.T) { - b := &bytes.Buffer{} - for _, i := range []bool { false, true } { - nbyteswrite, err := PackBool(b, i) - if nbyteswrite != 1 { t.Error("nbyteswrite != 1") } - if err != nil { t.Error("err != nil") } - } - if bytes.Compare(b.Bytes(), []byte { 0xc2, 0xc3 }) != 0 { t.Error("wrong output", b.Bytes()) } + b := &bytes.Buffer{} + for _, i := range []bool{false, true} { + nbyteswrite, err := PackBool(b, i) + if nbyteswrite != 1 { + t.Error("nbyteswrite != 1") + } + if err != nil { + t.Error("err != nil") + } + } + if bytes.Compare(b.Bytes(), []byte{0xc2, 0xc3}) != 0 { + t.Error("wrong output", b.Bytes()) + } } func TestPackInt32Array(t *testing.T) { - b := &bytes.Buffer{} - _, err := PackInt32Array(b, []int32 {}) - if err != nil { t.Error("err != nil") } - _, err = PackInt32Array(b, []int32 { 0 }) - if err != nil { t.Error("err != nil") } - _, err = PackInt32Array(b, []int32 { 0, 1 }) - if err != nil { t.Error("err != nil") } - _, err = PackInt32Array(b, []int32 { 0, 1, 2 }) - if err != nil { t.Error("err != nil") } - if bytes.Compare(b.Bytes(), []byte { 0x90, 0x91, 0x00, 0x92, 0x00, 0x01, 0x93, 0x00, 0x01, 0x02 }) != 0 { t.Error("wrong output", b.Bytes()) } + b := &bytes.Buffer{} + _, err := PackInt32Array(b, []int32{}) + if err != nil { + t.Error("err != nil") + } + _, err = PackInt32Array(b, []int32{0}) + if err != nil { + t.Error("err != nil") + } + _, err = PackInt32Array(b, []int32{0, 1}) + if err != nil { + t.Error("err != nil") + } + _, err = PackInt32Array(b, []int32{0, 1, 2}) + if err != nil { + t.Error("err != nil") + } + if bytes.Compare(b.Bytes(), []byte{0x90, 0x91, 0x00, 0x92, 0x00, 0x01, 0x93, 0x00, 0x01, 0x02}) != 0 { + t.Error("wrong output", b.Bytes()) + } } func TestPackArray(t *testing.T) { - b := &bytes.Buffer{} - _, err := PackArray(b, reflect.NewValue([]int32 {}).(reflect.ArrayOrSliceValue)) - if err != nil { t.Error("err != nil") } - _, err = PackArray(b, reflect.NewValue([]int32 { 0 }).(reflect.ArrayOrSliceValue)) - if err != nil { t.Error("err != nil") } - _, err = PackArray(b, reflect.NewValue([]int32 { 0, 1 }).(reflect.ArrayOrSliceValue)) - if err != nil { t.Error("err != nil") } - _, err = PackArray(b, reflect.NewValue([]int32 { 0, 1, 2 }).(reflect.ArrayOrSliceValue)) - if err != nil { t.Error("err != nil") } - if bytes.Compare(b.Bytes(), []byte { 0x90, 0x91, 0x00, 0x92, 0x00, 0x01, 0x93, 0x00, 0x01, 0x02 }) != 0 { t.Error("wrong output", b.Bytes()) } + b := &bytes.Buffer{} + _, err := PackArray(b, reflect.ValueOf([]int32{})) + if err != nil { + t.Error("err != nil") + } + _, err = PackArray(b, reflect.ValueOf([]int32{0})) + if err != nil { + t.Error("err != nil") + } + _, err = PackArray(b, reflect.ValueOf([]int32{0, 1})) + if err != nil { + t.Error("err != nil") + } + _, err = PackArray(b, reflect.ValueOf([]int32{0, 1, 2})) + if err != nil { + t.Error("err != nil") + } + if bytes.Compare(b.Bytes(), []byte{0x90, 0x91, 0x00, 0x92, 0x00, 0x01, 0x93, 0x00, 0x01, 0x02}) != 0 { + t.Error("wrong output", b.Bytes()) + } } func TestPackMap(t *testing.T) { - b := &bytes.Buffer{} - _, err := PackMap(b, reflect.NewValue(map[int] int { 0: 1, 2: 3, 4: 5 }).(*reflect.MapValue)) - if err != nil { t.Error("err != nil") } - if bytes.Compare(b.Bytes(), []byte { 0x83, 0x00, 0x01, 0x04, 0x05, 0x02, 0x03 }) != 0 { t.Error("wrong output", b.Bytes()) } + b := &bytes.Buffer{} + _, err := PackMap(b, reflect.ValueOf(map[int]int{0: 1, 2: 3, 4: 5})) + if err != nil { + t.Error("err != nil") + } + if bytes.Compare(b.Bytes(), []byte{0x83, 0x00, 0x01, 0x04, 0x05, 0x02, 0x03}) != 0 { + t.Error("wrong output", b.Bytes()) + } } func TestPack(t *testing.T) { - b := &bytes.Buffer{} - for _, i := range [](interface{}) { nil, false, true, 0, 1, 2, 3, 127, -32, -1, -33, 128 } { - _, err := Pack(b, i) - if err != nil { t.Error("err != nil") } - } - if bytes.Compare(b.Bytes(), []byte { 0xc0, 0xc2, 0xc3, 0x00, 0x01, 0x02, 0x03, 0x7f, 0xf0, 0xff, 0xd0, 0xef, 0xd1, 0x00, 0x80 }) == 0 { t.Error("wrong output") } + b := &bytes.Buffer{} + for _, i := range [](interface{}){nil, false, true, 0, 1, 2, 3, 127, -32, -1, -33, 128} { + _, err := Pack(b, i) + if err != nil { + t.Error("err != nil") + } + } + if bytes.Compare(b.Bytes(), []byte{0xc0, 0xc2, 0xc3, 0x00, 0x01, 0x02, 0x03, 0x7f, 0xf0, 0xff, 0xd0, 0xef, 0xd1, 0x00, 0x80}) == 0 { + t.Error("wrong output") + } } func TestUnpackArray(t *testing.T) { - b := bytes.NewBuffer([]byte { 0x90, 0x91, 0x00, 0x92, 0x00, 0x01, 0x93, 0xd1, 0x00, 0x00, 0xd2, 0x00, 0x00, 0x00, 0x01, 0xd3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xdc, 0x00, 0x02, 0x00, 0x01, 0xdd, 0x00, 0x00, 0x00, 0x04, 0x00, 0x01, 0x02, 0x03 }) - for _, v := range [](interface{}) { [](interface{}) {}, [](interface{}) { int8(0) }, [](interface{}) { int8(0), int8(1) }, [](interface{}) { int16(0), int32(1), int64(2) }, [](interface{}){ int8(0), int8(1) }, [](interface{}) { int8(0), int8(1), int8(2), int8(3) } } { - retval, _, e := Unpack(b) - if e != nil { t.Error("err != nil") } - if !equal(reflect.NewValue(retval.Interface()), reflect.NewValue(v)) { t.Errorf("%s != %s", retval.Interface(), v) } - } + b := bytes.NewBuffer([]byte{0x90, 0x91, 0x00, 0x92, 0x00, 0x01, 0x93, 0xd1, 0x00, 0x00, 0xd2, 0x00, 0x00, 0x00, 0x01, 0xd3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xdc, 0x00, 0x02, 0x00, 0x01, 0xdd, 0x00, 0x00, 0x00, 0x04, 0x00, 0x01, 0x02, 0x03}) + for _, v := range [](interface{}){[](interface{}){}, [](interface{}){int8(0)}, [](interface{}){int8(0), int8(1)}, [](interface{}){int16(0), int32(1), int64(2)}, [](interface{}){int8(0), int8(1)}, [](interface{}){int8(0), int8(1), int8(2), int8(3)}} { + retval, _, e := Unpack(b) + if e != nil { + t.Error("err != nil") + } + if !equal(reflect.ValueOf(retval.Interface()), reflect.ValueOf(v)) { + t.Errorf("%s != %s", retval.Interface(), v) + } + } } func TestUnpackInt(t *testing.T) { - b := bytes.NewBuffer([]byte { 0xff, 0xe0, 0x00, 0x01, 0x02, 0x7d, 0x7e, 0x7f, 0xd0, 0x01, 0xd0, 0x80, 0xd0, 0xff, 0xcc, 0x80, 0xcc, 0xfd, 0xcc, 0xfe, 0xcc, 0xff, 0xd1, 0x00, 0x00, 0xd1, 0x7f, 0xff, 0xd1, 0xff, 0xff, 0xcd, 0x80, 0x00, 0xcd, 0xff, 0xff, 0xd2, 0x7f, 0xff, 0xff, 0xff, 0xce, 0x7f, 0xff, 0xff, 0xff, 0xd3, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }) - for _, v := range [](interface{}) { - int8(-1), int8(-32), int8(0), int8(1), int8(2), int8(125), int8(126), int8(127), int8(1), int8(-128), int8(-1), uint8(128), uint8(253), uint8(254), uint8(255), int16(0), int16(32767), int16(-1), uint16(32768), uint16(65535), int32(2147483647), uint32(2147483647), int64(9223372036854775807), uint64(18446744073709551615) } { - retval, _, e := Unpack(b) - if e != nil { t.Error("err != nil") } - if retval.Interface() != v { t.Errorf("%u != %u", retval.Interface(), v) } - } + b := bytes.NewBuffer([]byte{0xff, 0xe0, 0x00, 0x01, 0x02, 0x7d, 0x7e, 0x7f, 0xd0, 0x01, 0xd0, 0x80, 0xd0, 0xff, 0xcc, 0x80, 0xcc, 0xfd, 0xcc, 0xfe, 0xcc, 0xff, 0xd1, 0x00, 0x00, 0xd1, 0x7f, 0xff, 0xd1, 0xff, 0xff, 0xcd, 0x80, 0x00, 0xcd, 0xff, 0xff, 0xd2, 0x7f, 0xff, 0xff, 0xff, 0xce, 0x7f, 0xff, 0xff, 0xff, 0xd3, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xcf, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}) + for _, v := range [](interface{}){ + int8(-1), int8(-32), int8(0), int8(1), int8(2), int8(125), int8(126), int8(127), int8(1), int8(-128), int8(-1), uint8(128), uint8(253), uint8(254), uint8(255), int16(0), int16(32767), int16(-1), uint16(32768), uint16(65535), int32(2147483647), uint32(2147483647), int64(9223372036854775807), uint64(18446744073709551615)} { + retval, _, e := Unpack(b) + if e != nil { + t.Error("err != nil") + } + if retval.Interface() != v { + t.Errorf("%u != %u", retval.Interface(), v) + } + } } func TestUnpackFloat(t *testing.T) { - b := bytes.NewBuffer([]byte { 0xca, 0x3d, 0xcc, 0xcc, 0xcd, 0xca, 0x3e, 0x4c, 0xcc, 0xcd, 0xca, 0xbd, 0xcc, 0xcc, 0xcd, 0xca, 0xbe, 0x4c, 0xcc, 0xcd, 0xca, 0x7f, 0x80, 0x00, 0x00, 0xca, 0xff, 0x80, 0x00, 0x00, 0xca, 0xff, 0xc0, 0x00, 0x0, 0xcb, 0x3f, 0xb9, 0x99, 0x99, 0x99, 0x99, 0x99, 0x9a, 0xcb, 0x3f, 0xc9, 0x99, 0x99, 0x99, 0x99, 0x99, 0x9a, 0xcb, 0xbf, 0xb9, 0x99, 0x99, 0x99, 0x99, 0x99, 0x9a, 0xcb, 0xbf, 0xc9, 0x99, 0x99, 0x99, 0x99, 0x99, 0x9a, 0xcb, 0x7f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcb, 0xcb, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcb, 0x7f, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }) - for _, v := range [](interface{}) { float32(.1), float32(.2), float32(-.1), float32(-.2), float32(math.Inf(1)), float32(math.Inf(-1)), float32(math.NaN()), float64(.1), float64(.2), float64(-.1), float64(-.2) } { - retval, _, e := Unpack(b) - if e != nil { t.Error("err != nil") } - isnan := false - if _v, ok := v.(float64); ok { - isnan = math.IsNaN(_v) - } else if _v, ok := v.(float32); ok { - isnan = math.IsNaN(float64(_v)) - } - if isnan { - if retval.Interface() == v { t.Errorf("[NaN] %u == %u", retval.Interface(), v) } - } else { - if retval.Interface() != v { t.Errorf("%u != %u", retval.Interface(), v) } - } - } + b := bytes.NewBuffer([]byte{0xca, 0x3d, 0xcc, 0xcc, 0xcd, 0xca, 0x3e, 0x4c, 0xcc, 0xcd, 0xca, 0xbd, 0xcc, 0xcc, 0xcd, 0xca, 0xbe, 0x4c, 0xcc, 0xcd, 0xca, 0x7f, 0x80, 0x00, 0x00, 0xca, 0xff, 0x80, 0x00, 0x00, 0xca, 0xff, 0xc0, 0x00, 0x0, 0xcb, 0x3f, 0xb9, 0x99, 0x99, 0x99, 0x99, 0x99, 0x9a, 0xcb, 0x3f, 0xc9, 0x99, 0x99, 0x99, 0x99, 0x99, 0x9a, 0xcb, 0xbf, 0xb9, 0x99, 0x99, 0x99, 0x99, 0x99, 0x9a, 0xcb, 0xbf, 0xc9, 0x99, 0x99, 0x99, 0x99, 0x99, 0x9a, 0xcb, 0x7f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcb, 0xcb, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcb, 0x7f, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}) + for _, v := range [](interface{}){float32(.1), float32(.2), float32(-.1), float32(-.2), float32(math.Inf(1)), float32(math.Inf(-1)), float32(math.NaN()), float64(.1), float64(.2), float64(-.1), float64(-.2)} { + retval, _, e := Unpack(b) + if e != nil { + t.Error("err != nil") + } + isnan := false + if _v, ok := v.(float64); ok { + isnan = math.IsNaN(_v) + } else if _v, ok := v.(float32); ok { + isnan = math.IsNaN(float64(_v)) + } + if isnan { + if retval.Interface() == v { + t.Errorf("[NaN] %u == %u", retval.Interface(), v) + } + } else { + if retval.Interface() != v { + t.Errorf("%u != %u", retval.Interface(), v) + } + } + } } diff --git a/go/pack.go b/go/pack.go index c129166e..763f9b08 100644 --- a/go/pack.go +++ b/go/pack.go @@ -1,591 +1,772 @@ package msgpack import ( - "io" - "os" - "unsafe" - "reflect" -); + "io" + "os" + "unsafe" + "reflect" +) // Packs a given value and writes it into the specified writer. func PackUint8(writer io.Writer, value uint8) (n int, err os.Error) { - if value < 128 { - return writer.Write([]byte { byte(value) }) - } - return writer.Write([]byte { 0xcc, byte(value) }) + if value < 128 { + return writer.Write([]byte{byte(value)}) + } + return writer.Write([]byte{0xcc, byte(value)}) } // Packs a given value and writes it into the specified writer. func PackUint16(writer io.Writer, value uint16) (n int, err os.Error) { - if value < 128 { - return writer.Write([]byte { byte(value) }) - } else if value < 256 { - return writer.Write([]byte { 0xcc, byte(value) }) - } - return writer.Write([]byte { 0xcd, byte(value >> 8), byte(value) }) + if value < 128 { + return writer.Write([]byte{byte(value)}) + } else if value < 256 { + return writer.Write([]byte{0xcc, byte(value)}) + } + return writer.Write([]byte{0xcd, byte(value >> 8), byte(value)}) } // Packs a given value and writes it into the specified writer. func PackUint32(writer io.Writer, value uint32) (n int, err os.Error) { - if value < 128 { - return writer.Write([]byte { byte(value) }) - } else if value < 256 { - return writer.Write([]byte { 0xcc, byte(value) }) - } else if value < 65536 { - return writer.Write([]byte { 0xcd, byte(value >> 8), byte(value) }) - } - return writer.Write([]byte { 0xce, byte(value >> 24), byte(value >> 16), byte(value >> 8), byte(value) }) + if value < 128 { + return writer.Write([]byte{byte(value)}) + } else if value < 256 { + return writer.Write([]byte{0xcc, byte(value)}) + } else if value < 65536 { + return writer.Write([]byte{0xcd, byte(value >> 8), byte(value)}) + } + return writer.Write([]byte{0xce, byte(value >> 24), byte(value >> 16), byte(value >> 8), byte(value)}) } // Packs a given value and writes it into the specified writer. func PackUint64(writer io.Writer, value uint64) (n int, err os.Error) { - if value < 128 { - return writer.Write([]byte { byte(value) }) - } else if value < 256 { - return writer.Write([]byte { 0xcc, byte(value) }) - } else if value < 65536 { - return writer.Write([]byte { 0xcd, byte(value >> 8), byte(value) }) - } else if value < 4294967296 { - return writer.Write([]byte { 0xce, byte(value >> 24), byte(value >> 16), byte(value >> 8), byte(value) }) - } - return writer.Write([]byte { 0xcf, byte(value >> 56), byte(value >> 48), byte(value >> 40), byte(value >> 32), byte(value >> 24), byte(value >> 16), byte(value >> 8), byte(value) }) + if value < 128 { + return writer.Write([]byte{byte(value)}) + } else if value < 256 { + return writer.Write([]byte{0xcc, byte(value)}) + } else if value < 65536 { + return writer.Write([]byte{0xcd, byte(value >> 8), byte(value)}) + } else if value < 4294967296 { + return writer.Write([]byte{0xce, byte(value >> 24), byte(value >> 16), byte(value >> 8), byte(value)}) + } + return writer.Write([]byte{0xcf, byte(value >> 56), byte(value >> 48), byte(value >> 40), byte(value >> 32), byte(value >> 24), byte(value >> 16), byte(value >> 8), byte(value)}) } func PackUint(writer io.Writer, value uint) (n int, err os.Error) { -// Packs a given value and writes it into the specified writer. - switch unsafe.Sizeof(value) { - case 4: - return PackUint32(writer, *(*uint32)(unsafe.Pointer(&value))) - case 8: - return PackUint64(writer, *(*uint64)(unsafe.Pointer(&value))) - } - return 0, os.ENOENT // never get here + // Packs a given value and writes it into the specified writer. + switch unsafe.Sizeof(value) { + case 4: + return PackUint32(writer, *(*uint32)(unsafe.Pointer(&value))) + case 8: + return PackUint64(writer, *(*uint64)(unsafe.Pointer(&value))) + } + return 0, os.ENOENT // never get here } // Packs a given value and writes it into the specified writer. func PackInt8(writer io.Writer, value int8) (n int, err os.Error) { - if value < -32 { - return writer.Write([]byte { 0xd0, byte(value) }) - } - return writer.Write([]byte { byte(value) }) + if value < -32 { + return writer.Write([]byte{0xd0, byte(value)}) + } + return writer.Write([]byte{byte(value)}) } // Packs a given value and writes it into the specified writer. func PackInt16(writer io.Writer, value int16) (n int, err os.Error) { - if value < -128 || value >= 128 { - return writer.Write([]byte { 0xd1, byte(uint16(value) >> 8), byte(value) }) - } else if value < -32 { - return writer.Write([]byte { 0xd0, byte(value) }) - } - return writer.Write([]byte { byte(value) }) + if value < -128 || value >= 128 { + return writer.Write([]byte{0xd1, byte(uint16(value) >> 8), byte(value)}) + } else if value < -32 { + return writer.Write([]byte{0xd0, byte(value)}) + } + return writer.Write([]byte{byte(value)}) } // Packs a given value and writes it into the specified writer. func PackInt32(writer io.Writer, value int32) (n int, err os.Error) { - if value < -32768 || value >= 32768 { - return writer.Write([]byte { 0xd2, byte(uint32(value) >> 24), byte(uint32(value) >> 16), byte(uint32(value) >> 8), byte(value) }) - } else if value < -128 { - return writer.Write([]byte { 0xd1, byte(uint32(value) >> 8), byte(value) }) - } else if value < -32 { - return writer.Write([]byte { 0xd0, byte(value) }) - } else if value >= 128 { - return writer.Write([]byte { 0xd1, byte(uint32(value) >> 8), byte(value) }) - } - return writer.Write([]byte { byte(value) }) + if value < -32768 || value >= 32768 { + return writer.Write([]byte{0xd2, byte(uint32(value) >> 24), byte(uint32(value) >> 16), byte(uint32(value) >> 8), byte(value)}) + } else if value < -128 { + return writer.Write([]byte{0xd1, byte(uint32(value) >> 8), byte(value)}) + } else if value < -32 { + return writer.Write([]byte{0xd0, byte(value)}) + } else if value >= 128 { + return writer.Write([]byte{0xd1, byte(uint32(value) >> 8), byte(value)}) + } + return writer.Write([]byte{byte(value)}) } // Packs a given value and writes it into the specified writer. func PackInt64(writer io.Writer, value int64) (n int, err os.Error) { - if value < -2147483648 || value >= 2147483648 { - return writer.Write([]byte { 0xd3, byte(uint64(value) >> 56), byte(uint64(value) >> 48), byte(uint64(value) >> 40), byte(uint64(value) >> 32), byte(uint64(value) >> 24), byte(uint64(value) >> 16), byte(uint64(value) >> 8), byte(value) }) - } else if value < -32768 || value >= 32768 { - return writer.Write([]byte { 0xd2, byte(uint64(value) >> 24), byte(uint64(value) >> 16), byte(uint64(value) >> 8), byte(value) }) - } else if value < -128 || value >= 128 { - return writer.Write([]byte { 0xd1, byte(uint64(value) >> 8), byte(value) }) - } else if value < -32 { - return writer.Write([]byte { 0xd0, byte(value) }) - } - return writer.Write([]byte { byte(value) }) + if value < -2147483648 || value >= 2147483648 { + return writer.Write([]byte{0xd3, byte(uint64(value) >> 56), byte(uint64(value) >> 48), byte(uint64(value) >> 40), byte(uint64(value) >> 32), byte(uint64(value) >> 24), byte(uint64(value) >> 16), byte(uint64(value) >> 8), byte(value)}) + } else if value < -32768 || value >= 32768 { + return writer.Write([]byte{0xd2, byte(uint64(value) >> 24), byte(uint64(value) >> 16), byte(uint64(value) >> 8), byte(value)}) + } else if value < -128 || value >= 128 { + return writer.Write([]byte{0xd1, byte(uint64(value) >> 8), byte(value)}) + } else if value < -32 { + return writer.Write([]byte{0xd0, byte(value)}) + } + return writer.Write([]byte{byte(value)}) } // Packs a given value and writes it into the specified writer. func PackInt(writer io.Writer, value int) (n int, err os.Error) { - switch unsafe.Sizeof(value) { - case 4: - return PackInt32(writer, *(*int32)(unsafe.Pointer(&value))) - case 8: - return PackInt64(writer, *(*int64)(unsafe.Pointer(&value))) - } - return 0, os.ENOENT // never get here + switch unsafe.Sizeof(value) { + case 4: + return PackInt32(writer, *(*int32)(unsafe.Pointer(&value))) + case 8: + return PackInt64(writer, *(*int64)(unsafe.Pointer(&value))) + } + return 0, os.ENOENT // never get here } // Packs a given value and writes it into the specified writer. func PackNil(writer io.Writer) (n int, err os.Error) { - return writer.Write([]byte{ 0xc0 }) + return writer.Write([]byte{0xc0}) } // Packs a given value and writes it into the specified writer. func PackBool(writer io.Writer, value bool) (n int, err os.Error) { - var code byte; - if value { - code = 0xc3 - } else { - code = 0xc2 - } - return writer.Write([]byte{ code }) + var code byte + if value { + code = 0xc3 + } else { + code = 0xc2 + } + return writer.Write([]byte{code}) } // Packs a given value and writes it into the specified writer. func PackFloat32(writer io.Writer, value float32) (n int, err os.Error) { - return PackUint32(writer, *(*uint32)(unsafe.Pointer(&value))) + return PackUint32(writer, *(*uint32)(unsafe.Pointer(&value))) } // Packs a given value and writes it into the specified writer. func PackFloat64(writer io.Writer, value float64) (n int, err os.Error) { - return PackUint64(writer, *(*uint64)(unsafe.Pointer(&value))) + return PackUint64(writer, *(*uint64)(unsafe.Pointer(&value))) } // Packs a given value and writes it into the specified writer. func PackBytes(writer io.Writer, value []byte) (n int, err os.Error) { - if len(value) < 32 { - n1, err := writer.Write([]byte { 0xa0 | uint8(len(value)) }) - if err != nil { return n1, err } - n2, err := writer.Write(value) - return n1 + n2, err - } else if len(value) < 65536 { - n1, err := writer.Write([]byte { 0xda, byte(len(value) >> 16), byte(len(value)) }) - if err != nil { return n1, err } - n2, err := writer.Write(value) - return n1 + n2, err - } - n1, err := writer.Write([]byte { 0xdb, byte(len(value) >> 24), byte(len(value) >> 16), byte(len(value) >> 8), byte(len(value)) }) - if err != nil { return n1, err } - n2, err := writer.Write(value) - return n1 + n2, err + if len(value) < 32 { + n1, err := writer.Write([]byte{0xa0 | uint8(len(value))}) + if err != nil { + return n1, err + } + n2, err := writer.Write(value) + return n1 + n2, err + } else if len(value) < 65536 { + n1, err := writer.Write([]byte{0xda, byte(len(value) >> 16), byte(len(value))}) + if err != nil { + return n1, err + } + n2, err := writer.Write(value) + return n1 + n2, err + } + n1, err := writer.Write([]byte{0xdb, byte(len(value) >> 24), byte(len(value) >> 16), byte(len(value) >> 8), byte(len(value))}) + if err != nil { + return n1, err + } + n2, err := writer.Write(value) + return n1 + n2, err } // Packs a given value and writes it into the specified writer. func PackUint16Array(writer io.Writer, value []uint16) (n int, err os.Error) { - if len(value) < 16 { - n, err := writer.Write([]byte { 0x90 | byte(len(value)) }) - if err != nil { return n, err } - for _, i := range value { - _n, err := PackUint16(writer, i) - if err != nil { return n, err } - n += _n - } - } else if len(value) < 65536 { - n, err := writer.Write([]byte { 0xdc, byte(len(value) >> 8), byte(len(value)) }) - if err != nil { return n, err } - for _, i := range value { - _n, err := PackUint16(writer, i) - if err != nil { return n, err } - n += _n - } - } else { - n, err := writer.Write([]byte { 0xdd, byte(len(value) >> 24), byte(len(value) >> 16), byte(len(value) >> 8), byte(len(value)) }) - if err != nil { return n, err } - for _, i := range value { - _n, err := PackUint16(writer, i) - if err != nil { return n, err } - n += _n - } - } - return n, nil + if len(value) < 16 { + n, err := writer.Write([]byte{0x90 | byte(len(value))}) + if err != nil { + return n, err + } + for _, i := range value { + _n, err := PackUint16(writer, i) + if err != nil { + return n, err + } + n += _n + } + } else if len(value) < 65536 { + n, err := writer.Write([]byte{0xdc, byte(len(value) >> 8), byte(len(value))}) + if err != nil { + return n, err + } + for _, i := range value { + _n, err := PackUint16(writer, i) + if err != nil { + return n, err + } + n += _n + } + } else { + n, err := writer.Write([]byte{0xdd, byte(len(value) >> 24), byte(len(value) >> 16), byte(len(value) >> 8), byte(len(value))}) + if err != nil { + return n, err + } + for _, i := range value { + _n, err := PackUint16(writer, i) + if err != nil { + return n, err + } + n += _n + } + } + return n, nil } // Packs a given value and writes it into the specified writer. func PackUint32Array(writer io.Writer, value []uint32) (n int, err os.Error) { - if len(value) < 16 { - n, err := writer.Write([]byte { 0x90 | byte(len(value)) }) - if err != nil { return n, err } - for _, i := range value { - _n, err := PackUint32(writer, i) - if err != nil { return n, err } - n += _n - } - } else if len(value) < 65536 { - n, err := writer.Write([]byte { 0xdc, byte(len(value) >> 8), byte(len(value)) }) - if err != nil { return n, err } - for _, i := range value { - _n, err := PackUint32(writer, i) - if err != nil { return n, err } - n += _n - } - } else { - n, err := writer.Write([]byte { 0xdd, byte(len(value) >> 24), byte(len(value) >> 16), byte(len(value) >> 8), byte(len(value)) }) - if err != nil { return n, err } - for _, i := range value { - _n, err := PackUint32(writer, i) - if err != nil { return n, err } - n += _n - } - } - return n, nil + if len(value) < 16 { + n, err := writer.Write([]byte{0x90 | byte(len(value))}) + if err != nil { + return n, err + } + for _, i := range value { + _n, err := PackUint32(writer, i) + if err != nil { + return n, err + } + n += _n + } + } else if len(value) < 65536 { + n, err := writer.Write([]byte{0xdc, byte(len(value) >> 8), byte(len(value))}) + if err != nil { + return n, err + } + for _, i := range value { + _n, err := PackUint32(writer, i) + if err != nil { + return n, err + } + n += _n + } + } else { + n, err := writer.Write([]byte{0xdd, byte(len(value) >> 24), byte(len(value) >> 16), byte(len(value) >> 8), byte(len(value))}) + if err != nil { + return n, err + } + for _, i := range value { + _n, err := PackUint32(writer, i) + if err != nil { + return n, err + } + n += _n + } + } + return n, nil } // Packs a given value and writes it into the specified writer. func PackUint64Array(writer io.Writer, value []uint64) (n int, err os.Error) { - if len(value) < 16 { - n, err := writer.Write([]byte { 0x90 | byte(len(value)) }) - if err != nil { return n, err } - for _, i := range value { - _n, err := PackUint64(writer, i) - if err != nil { return n, err } - n += _n - } - } else if len(value) < 65536 { - n, err := writer.Write([]byte { 0xdc, byte(len(value) >> 8), byte(len(value)) }) - if err != nil { return n, err } - for _, i := range value { - _n, err := PackUint64(writer, i) - if err != nil { return n, err } - n += _n - } - } else { - n, err := writer.Write([]byte { 0xdd, byte(len(value) >> 24), byte(len(value) >> 16), byte(len(value) >> 8), byte(len(value)) }) - if err != nil { return n, err } - for _, i := range value { - _n, err := PackUint64(writer, i) - if err != nil { return n, err } - n += _n - } - } - return n, nil + if len(value) < 16 { + n, err := writer.Write([]byte{0x90 | byte(len(value))}) + if err != nil { + return n, err + } + for _, i := range value { + _n, err := PackUint64(writer, i) + if err != nil { + return n, err + } + n += _n + } + } else if len(value) < 65536 { + n, err := writer.Write([]byte{0xdc, byte(len(value) >> 8), byte(len(value))}) + if err != nil { + return n, err + } + for _, i := range value { + _n, err := PackUint64(writer, i) + if err != nil { + return n, err + } + n += _n + } + } else { + n, err := writer.Write([]byte{0xdd, byte(len(value) >> 24), byte(len(value) >> 16), byte(len(value) >> 8), byte(len(value))}) + if err != nil { + return n, err + } + for _, i := range value { + _n, err := PackUint64(writer, i) + if err != nil { + return n, err + } + n += _n + } + } + return n, nil } // Packs a given value and writes it into the specified writer. func PackUintArray(writer io.Writer, value []uint) (n int, err os.Error) { - switch unsafe.Sizeof(0) { - case 4: - return PackUint32Array(writer, *(*[]uint32)(unsafe.Pointer(&value))) - case 8: - return PackUint64Array(writer, *(*[]uint64)(unsafe.Pointer(&value))) - } - return 0, os.ENOENT // never get here + switch unsafe.Sizeof(0) { + case 4: + return PackUint32Array(writer, *(*[]uint32)(unsafe.Pointer(&value))) + case 8: + return PackUint64Array(writer, *(*[]uint64)(unsafe.Pointer(&value))) + } + return 0, os.ENOENT // never get here } // Packs a given value and writes it into the specified writer. func PackInt8Array(writer io.Writer, value []int8) (n int, err os.Error) { - if len(value) < 16 { - n, err := writer.Write([]byte { 0x90 | byte(len(value)) }) - if err != nil { return n, err } - for _, i := range value { - _n, err := PackInt8(writer, i) - if err != nil { return n, err } - n += _n - } - } else if len(value) < 65536 { - n, err := writer.Write([]byte { 0xdc, byte(len(value) >> 8), byte(len(value)) }) - if err != nil { return n, err } - for _, i := range value { - _n, err := PackInt8(writer, i) - if err != nil { return n, err } - n += _n - } - } else { - n, err := writer.Write([]byte { 0xdd, byte(len(value) >> 24), byte(len(value) >> 16), byte(len(value) >> 8), byte(len(value)) }) - if err != nil { return n, err } - for _, i := range value { - _n, err := PackInt8(writer, i) - if err != nil { return n, err } - n += _n - } - } - return n, nil + if len(value) < 16 { + n, err := writer.Write([]byte{0x90 | byte(len(value))}) + if err != nil { + return n, err + } + for _, i := range value { + _n, err := PackInt8(writer, i) + if err != nil { + return n, err + } + n += _n + } + } else if len(value) < 65536 { + n, err := writer.Write([]byte{0xdc, byte(len(value) >> 8), byte(len(value))}) + if err != nil { + return n, err + } + for _, i := range value { + _n, err := PackInt8(writer, i) + if err != nil { + return n, err + } + n += _n + } + } else { + n, err := writer.Write([]byte{0xdd, byte(len(value) >> 24), byte(len(value) >> 16), byte(len(value) >> 8), byte(len(value))}) + if err != nil { + return n, err + } + for _, i := range value { + _n, err := PackInt8(writer, i) + if err != nil { + return n, err + } + n += _n + } + } + return n, nil } // Packs a given value and writes it into the specified writer. func PackInt16Array(writer io.Writer, value []int16) (n int, err os.Error) { - if len(value) < 16 { - n, err := writer.Write([]byte { 0x90 | byte(len(value)) }) - if err != nil { return n, err } - for _, i := range value { - _n, err := PackInt16(writer, i) - if err != nil { return n, err } - n += _n - } - } else if len(value) < 65536 { - n, err := writer.Write([]byte { 0xdc, byte(len(value) >> 8), byte(len(value)) }) - if err != nil { return n, err } - for _, i := range value { - _n, err := PackInt16(writer, i) - if err != nil { return n, err } - n += _n - } - } else { - n, err := writer.Write([]byte { 0xdd, byte(len(value) >> 24), byte(len(value) >> 16), byte(len(value) >> 8), byte(len(value)) }) - if err != nil { return n, err } - for _, i := range value { - _n, err := PackInt16(writer, i) - if err != nil { return n, err } - n += _n - } - } - return n, nil + if len(value) < 16 { + n, err := writer.Write([]byte{0x90 | byte(len(value))}) + if err != nil { + return n, err + } + for _, i := range value { + _n, err := PackInt16(writer, i) + if err != nil { + return n, err + } + n += _n + } + } else if len(value) < 65536 { + n, err := writer.Write([]byte{0xdc, byte(len(value) >> 8), byte(len(value))}) + if err != nil { + return n, err + } + for _, i := range value { + _n, err := PackInt16(writer, i) + if err != nil { + return n, err + } + n += _n + } + } else { + n, err := writer.Write([]byte{0xdd, byte(len(value) >> 24), byte(len(value) >> 16), byte(len(value) >> 8), byte(len(value))}) + if err != nil { + return n, err + } + for _, i := range value { + _n, err := PackInt16(writer, i) + if err != nil { + return n, err + } + n += _n + } + } + return n, nil } // Packs a given value and writes it into the specified writer. func PackInt32Array(writer io.Writer, value []int32) (n int, err os.Error) { - if len(value) < 16 { - n, err := writer.Write([]byte { 0x90 | byte(len(value)) }) - if err != nil { return n, err } - for _, i := range value { - _n, err := PackInt32(writer, i) - if err != nil { return n, err } - n += _n - } - } else if len(value) < 65536 { - n, err := writer.Write([]byte { 0xdc, byte(len(value) >> 8), byte(len(value)) }) - if err != nil { return n, err } - for _, i := range value { - _n, err := PackInt32(writer, i) - if err != nil { return n, err } - n += _n - } - } else { - n, err := writer.Write([]byte { 0xdd, byte(len(value) >> 24), byte(len(value) >> 16), byte(len(value) >> 8), byte(len(value)) }) - if err != nil { return n, err } - for _, i := range value { - _n, err := PackInt32(writer, i) - if err != nil { return n, err } - n += _n - } - } - return n, nil + if len(value) < 16 { + n, err := writer.Write([]byte{0x90 | byte(len(value))}) + if err != nil { + return n, err + } + for _, i := range value { + _n, err := PackInt32(writer, i) + if err != nil { + return n, err + } + n += _n + } + } else if len(value) < 65536 { + n, err := writer.Write([]byte{0xdc, byte(len(value) >> 8), byte(len(value))}) + if err != nil { + return n, err + } + for _, i := range value { + _n, err := PackInt32(writer, i) + if err != nil { + return n, err + } + n += _n + } + } else { + n, err := writer.Write([]byte{0xdd, byte(len(value) >> 24), byte(len(value) >> 16), byte(len(value) >> 8), byte(len(value))}) + if err != nil { + return n, err + } + for _, i := range value { + _n, err := PackInt32(writer, i) + if err != nil { + return n, err + } + n += _n + } + } + return n, nil } // Packs a given value and writes it into the specified writer. func PackInt64Array(writer io.Writer, value []int64) (n int, err os.Error) { - if len(value) < 16 { - n, err := writer.Write([]byte { 0x90 | byte(len(value)) }) - if err != nil { return n, err } - for _, i := range value { - _n, err := PackInt64(writer, i) - if err != nil { return n, err } - n += _n - } - } else if len(value) < 65536 { - n, err := writer.Write([]byte { 0xdc, byte(len(value) >> 8), byte(len(value)) }) - if err != nil { return n, err } - for _, i := range value { - _n, err := PackInt64(writer, i) - if err != nil { return n, err } - n += _n - } - } else { - n, err := writer.Write([]byte { 0xdd, byte(len(value) >> 24), byte(len(value) >> 16), byte(len(value) >> 8), byte(len(value)) }) - if err != nil { return n, err } - for _, i := range value { - _n, err := PackInt64(writer, i) - if err != nil { return n, err } - n += _n - } - } - return n, nil + if len(value) < 16 { + n, err := writer.Write([]byte{0x90 | byte(len(value))}) + if err != nil { + return n, err + } + for _, i := range value { + _n, err := PackInt64(writer, i) + if err != nil { + return n, err + } + n += _n + } + } else if len(value) < 65536 { + n, err := writer.Write([]byte{0xdc, byte(len(value) >> 8), byte(len(value))}) + if err != nil { + return n, err + } + for _, i := range value { + _n, err := PackInt64(writer, i) + if err != nil { + return n, err + } + n += _n + } + } else { + n, err := writer.Write([]byte{0xdd, byte(len(value) >> 24), byte(len(value) >> 16), byte(len(value) >> 8), byte(len(value))}) + if err != nil { + return n, err + } + for _, i := range value { + _n, err := PackInt64(writer, i) + if err != nil { + return n, err + } + n += _n + } + } + return n, nil } // Packs a given value and writes it into the specified writer. func PackIntArray(writer io.Writer, value []int) (n int, err os.Error) { - switch unsafe.Sizeof(0) { - case 4: - return PackInt32Array(writer, *(*[]int32)(unsafe.Pointer(&value))) - case 8: - return PackInt64Array(writer, *(*[]int64)(unsafe.Pointer(&value))) - } - return 0, os.ENOENT // never get here + switch unsafe.Sizeof(0) { + case 4: + return PackInt32Array(writer, *(*[]int32)(unsafe.Pointer(&value))) + case 8: + return PackInt64Array(writer, *(*[]int64)(unsafe.Pointer(&value))) + } + return 0, os.ENOENT // never get here } // Packs a given value and writes it into the specified writer. func PackFloat32Array(writer io.Writer, value []float32) (n int, err os.Error) { - if len(value) < 16 { - n, err := writer.Write([]byte { 0x90 | byte(len(value)) }) - if err != nil { return n, err } - for _, i := range value { - _n, err := PackFloat32(writer, i) - if err != nil { return n, err } - n += _n - } - } else if len(value) < 65536 { - n, err := writer.Write([]byte { 0xdc, byte(len(value) >> 8), byte(len(value)) }) - if err != nil { return n, err } - for _, i := range value { - _n, err := PackFloat32(writer, i) - if err != nil { return n, err } - n += _n - } - } else { - n, err := writer.Write([]byte { 0xdd, byte(len(value) >> 24), byte(len(value) >> 16), byte(len(value) >> 8), byte(len(value)) }) - if err != nil { return n, err } - for _, i := range value { - _n, err := PackFloat32(writer, i) - if err != nil { return n, err } - n += _n - } - } - return n, nil + if len(value) < 16 { + n, err := writer.Write([]byte{0x90 | byte(len(value))}) + if err != nil { + return n, err + } + for _, i := range value { + _n, err := PackFloat32(writer, i) + if err != nil { + return n, err + } + n += _n + } + } else if len(value) < 65536 { + n, err := writer.Write([]byte{0xdc, byte(len(value) >> 8), byte(len(value))}) + if err != nil { + return n, err + } + for _, i := range value { + _n, err := PackFloat32(writer, i) + if err != nil { + return n, err + } + n += _n + } + } else { + n, err := writer.Write([]byte{0xdd, byte(len(value) >> 24), byte(len(value) >> 16), byte(len(value) >> 8), byte(len(value))}) + if err != nil { + return n, err + } + for _, i := range value { + _n, err := PackFloat32(writer, i) + if err != nil { + return n, err + } + n += _n + } + } + return n, nil } // Packs a given value and writes it into the specified writer. func PackFloat64Array(writer io.Writer, value []float64) (n int, err os.Error) { - if len(value) < 16 { - n, err := writer.Write([]byte { 0x90 | byte(len(value)) }) - if err != nil { return n, err } - for _, i := range value { - _n, err := PackFloat64(writer, i) - if err != nil { return n, err } - n += _n - } - } else if len(value) < 65536 { - n, err := writer.Write([]byte { 0xdc, byte(len(value) >> 8), byte(len(value)) }) - if err != nil { return n, err } - for _, i := range value { - _n, err := PackFloat64(writer, i) - if err != nil { return n, err } - n += _n - } - } else { - n, err := writer.Write([]byte { 0xdd, byte(len(value) >> 24), byte(len(value) >> 16), byte(len(value) >> 8), byte(len(value)) }) - if err != nil { return n, err } - for _, i := range value { - _n, err := PackFloat64(writer, i) - if err != nil { return n, err } - n += _n - } - } - return n, nil + if len(value) < 16 { + n, err := writer.Write([]byte{0x90 | byte(len(value))}) + if err != nil { + return n, err + } + for _, i := range value { + _n, err := PackFloat64(writer, i) + if err != nil { + return n, err + } + n += _n + } + } else if len(value) < 65536 { + n, err := writer.Write([]byte{0xdc, byte(len(value) >> 8), byte(len(value))}) + if err != nil { + return n, err + } + for _, i := range value { + _n, err := PackFloat64(writer, i) + if err != nil { + return n, err + } + n += _n + } + } else { + n, err := writer.Write([]byte{0xdd, byte(len(value) >> 24), byte(len(value) >> 16), byte(len(value) >> 8), byte(len(value))}) + if err != nil { + return n, err + } + for _, i := range value { + _n, err := PackFloat64(writer, i) + if err != nil { + return n, err + } + n += _n + } + } + return n, nil } // Packs a given value and writes it into the specified writer. -func PackArray(writer io.Writer, value reflect.ArrayOrSliceValue) (n int, err os.Error) { - { - elemType, ok := value.Type().(reflect.ArrayOrSliceType).Elem().(*reflect.UintType) - if ok && elemType.Kind() == reflect.Uint8 { - return PackBytes(writer, value.Interface().([]byte)) - } - } +func PackArray(writer io.Writer, value reflect.Value) (n int, err os.Error) { + { + elemType := value.Type().Elem() + if (elemType.Kind() == reflect.Uint || elemType.Kind() == reflect.Uint8 || elemType.Kind() == reflect.Uint16 || elemType.Kind() == reflect.Uint32 || elemType.Kind() == reflect.Uint64 || elemType.Kind() == reflect.Uintptr) && + elemType.Kind() == reflect.Uint8 { + return PackBytes(writer, value.Interface().([]byte)) + } + } - l := value.Len() - if l < 16 { - n, err := writer.Write([]byte { 0x90 | byte(l) }) - if err != nil { return n, err } - for i := 0; i < l; i++ { - _n, err := PackValue(writer, value.Elem(i)) - if err != nil { return n, err } - n += _n - } - } else if l < 65536 { - n, err := writer.Write([]byte { 0xdc, byte(l >> 8), byte(l) }) - if err != nil { return n, err } - for i := 0; i < l; i++ { - _n, err := PackValue(writer, value.Elem(i)) - if err != nil { return n, err } - n += _n - } - } else { - n, err := writer.Write([]byte { 0xdd, byte(l >> 24), byte(l >> 16), byte(l >> 8), byte(l) }) - if err != nil { return n, err } - for i := 0; i < l; i++ { - _n, err := PackValue(writer, value.Elem(i)) - if err != nil { return n, err } - n += _n - } - } - return n, nil + l := value.Len() + if l < 16 { + n, err := writer.Write([]byte{0x90 | byte(l)}) + if err != nil { + return n, err + } + for i := 0; i < l; i++ { + _n, err := PackValue(writer, value.Index(i)) + if err != nil { + return n, err + } + n += _n + } + } else if l < 65536 { + n, err := writer.Write([]byte{0xdc, byte(l >> 8), byte(l)}) + if err != nil { + return n, err + } + for i := 0; i < l; i++ { + _n, err := PackValue(writer, value.Index(i)) + if err != nil { + return n, err + } + n += _n + } + } else { + n, err := writer.Write([]byte{0xdd, byte(l >> 24), byte(l >> 16), byte(l >> 8), byte(l)}) + if err != nil { + return n, err + } + for i := 0; i < l; i++ { + _n, err := PackValue(writer, value.Index(i)) + if err != nil { + return n, err + } + n += _n + } + } + return n, nil } // Packs a given value and writes it into the specified writer. -func PackMap(writer io.Writer, value *reflect.MapValue) (n int, err os.Error) { - keys := value.Keys() - if value.Len() < 16 { - n, err := writer.Write([]byte { 0x80 | byte(len(keys)) }) - if err != nil { return n, err } - for _, k := range keys { - _n, err := PackValue(writer, k) - if err != nil { return n, err } - n += _n - _n, err = PackValue(writer, value.Elem(k)) - if err != nil { return n, err } - n += _n - } - } else if value.Len() < 65536 { - n, err := writer.Write([]byte { 0xde, byte(len(keys) >> 8), byte(len(keys)) }) - if err != nil { return n, err } - for _, k := range keys { - _n, err := PackValue(writer, k) - if err != nil { return n, err } - n += _n - _n, err = PackValue(writer, value.Elem(k)) - if err != nil { return n, err } - n += _n - } - } else { - n, err := writer.Write([]byte { 0xdf, byte(len(keys) >> 24), byte(len(keys) >> 16), byte(len(keys) >> 8), byte(len(keys)) }) - if err != nil { return n, err } - for _, k := range keys { - _n, err := PackValue(writer, k) - if err != nil { return n, err } - n += _n - _n, err = PackValue(writer, value.Elem(k)) - if err != nil { return n, err } - n += _n - } - } - return n, nil +func PackMap(writer io.Writer, value reflect.Value) (n int, err os.Error) { + keys := value.MapKeys() + if value.Len() < 16 { + n, err := writer.Write([]byte{0x80 | byte(len(keys))}) + if err != nil { + return n, err + } + for _, k := range keys { + _n, err := PackValue(writer, k) + if err != nil { + return n, err + } + n += _n + _n, err = PackValue(writer, value.MapIndex(k)) + if err != nil { + return n, err + } + n += _n + } + } else if value.Len() < 65536 { + n, err := writer.Write([]byte{0xde, byte(len(keys) >> 8), byte(len(keys))}) + if err != nil { + return n, err + } + for _, k := range keys { + _n, err := PackValue(writer, k) + if err != nil { + return n, err + } + n += _n + _n, err = PackValue(writer, value.MapIndex(k)) + if err != nil { + return n, err + } + n += _n + } + } else { + n, err := writer.Write([]byte{0xdf, byte(len(keys) >> 24), byte(len(keys) >> 16), byte(len(keys) >> 8), byte(len(keys))}) + if err != nil { + return n, err + } + for _, k := range keys { + _n, err := PackValue(writer, k) + if err != nil { + return n, err + } + n += _n + _n, err = PackValue(writer, value.MapIndex(k)) + if err != nil { + return n, err + } + n += _n + } + } + return n, nil } // Packs a given value and writes it into the specified writer. func PackValue(writer io.Writer, value reflect.Value) (n int, err os.Error) { - if value == nil || value.Type() == nil { return PackNil(writer) } - switch _value := value.(type) { - case *reflect.BoolValue: return PackBool(writer, _value.Get()) - case *reflect.UintValue: return PackUint64(writer, _value.Get()) - case *reflect.IntValue: return PackInt64(writer, _value.Get()) - case *reflect.FloatValue: return PackFloat64(writer, _value.Get()) - case *reflect.ArrayValue: return PackArray(writer, _value) - case *reflect.SliceValue: return PackArray(writer, _value) - case *reflect.MapValue: return PackMap(writer, _value) - case *reflect.InterfaceValue: - __value := reflect.NewValue(_value.Interface()) - _, ok := __value.(*reflect.InterfaceValue) - if !ok { - return PackValue(writer, __value) - } - } - panic("unsupported type: " + value.Type().String()) + if !value.IsValid() || value.Type() == nil { + return PackNil(writer) + } + switch _value := value; _value.Kind() { + case reflect.Bool: + return PackBool(writer, _value.Bool()) + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: + return PackUint64(writer, _value.Uint()) + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + return PackInt64(writer, _value.Int()) + case reflect.Float32, reflect.Float64: + return PackFloat64(writer, _value.Float()) + case reflect.Array: + return PackArray(writer, _value) + case reflect.Slice: + return PackArray(writer, _value) + case reflect.Map: + return PackMap(writer, _value) + case reflect.Interface: + __value := reflect.ValueOf(_value.Interface()) + + if __value.Kind() != reflect.Interface { + return PackValue(writer, __value) + } + } + panic("unsupported type: " + value.Type().String()) } // Packs a given value and writes it into the specified writer. func Pack(writer io.Writer, value interface{}) (n int, err os.Error) { - if value == nil { return PackNil(writer) } - switch _value := value.(type) { - case bool: return PackBool(writer, _value) - case uint8: return PackUint8(writer, _value) - case uint16: return PackUint16(writer, _value) - case uint32: return PackUint32(writer, _value) - case uint64: return PackUint64(writer, _value) - case uint: return PackUint(writer, _value) - case int8: return PackInt8(writer, _value) - case int16: return PackInt16(writer, _value) - case int32: return PackInt32(writer, _value) - case int64: return PackInt64(writer, _value) - case int: return PackInt(writer, _value) - case float32: return PackFloat32(writer, _value) - case float64: return PackFloat64(writer, _value) - case []byte: return PackBytes(writer, _value) - case []uint16: return PackUint16Array(writer, _value) - case []uint32: return PackUint32Array(writer, _value) - case []uint64: return PackUint64Array(writer, _value) - case []uint: return PackUintArray(writer, _value) - case []int8: return PackInt8Array(writer, _value) - case []int16: return PackInt16Array(writer, _value) - case []int32: return PackInt32Array(writer, _value) - case []int64: return PackInt64Array(writer, _value) - case []int: return PackIntArray(writer, _value) - case []float32: return PackFloat32Array(writer, _value) - case []float64: return PackFloat64Array(writer, _value) - default: - return PackValue(writer, reflect.NewValue(value)) - } - return 0, nil // never get here + if value == nil { + return PackNil(writer) + } + switch _value := value.(type) { + case bool: + return PackBool(writer, _value) + case uint8: + return PackUint8(writer, _value) + case uint16: + return PackUint16(writer, _value) + case uint32: + return PackUint32(writer, _value) + case uint64: + return PackUint64(writer, _value) + case uint: + return PackUint(writer, _value) + case int8: + return PackInt8(writer, _value) + case int16: + return PackInt16(writer, _value) + case int32: + return PackInt32(writer, _value) + case int64: + return PackInt64(writer, _value) + case int: + return PackInt(writer, _value) + case float32: + return PackFloat32(writer, _value) + case float64: + return PackFloat64(writer, _value) + case []byte: + return PackBytes(writer, _value) + case []uint16: + return PackUint16Array(writer, _value) + case []uint32: + return PackUint32Array(writer, _value) + case []uint64: + return PackUint64Array(writer, _value) + case []uint: + return PackUintArray(writer, _value) + case []int8: + return PackInt8Array(writer, _value) + case []int16: + return PackInt16Array(writer, _value) + case []int32: + return PackInt32Array(writer, _value) + case []int64: + return PackInt64Array(writer, _value) + case []int: + return PackIntArray(writer, _value) + case []float32: + return PackFloat32Array(writer, _value) + case []float64: + return PackFloat64Array(writer, _value) + default: + return PackValue(writer, reflect.ValueOf(value)) + } + return 0, nil // never get here } diff --git a/go/unpack.go b/go/unpack.go index 6bf0159d..cc67fcc1 100644 --- a/go/unpack.go +++ b/go/unpack.go @@ -1,288 +1,366 @@ package msgpack import ( - "io" - "os" - "unsafe" - "strconv" - "reflect" + "io" + "os" + "unsafe" + "strconv" + "reflect" ) func readByte(reader io.Reader) (v uint8, err os.Error) { - data := [1]byte{} - _, e := reader.Read(data[0:]) - if e != nil { return 0, e } - return data[0], nil + data := [1]byte{} + _, e := reader.Read(data[0:]) + if e != nil { + return 0, e + } + return data[0], nil } func readUint16(reader io.Reader) (v uint16, n int, err os.Error) { - data := [2]byte{} - n, e := reader.Read(data[0:]) - if e != nil { return 0, n, e } - return (uint16(data[0]) << 8) | uint16(data[1]), n, nil + data := [2]byte{} + n, e := reader.Read(data[0:]) + if e != nil { + return 0, n, e + } + return (uint16(data[0]) << 8) | uint16(data[1]), n, nil } func readUint32(reader io.Reader) (v uint32, n int, err os.Error) { - data := [4]byte{} - n, e := reader.Read(data[0:]) - if e != nil { return 0, n, e } - return (uint32(data[0]) << 24) | (uint32(data[1]) << 16) | (uint32(data[2]) << 8) | uint32(data[3]), n, nil + data := [4]byte{} + n, e := reader.Read(data[0:]) + if e != nil { + return 0, n, e + } + return (uint32(data[0]) << 24) | (uint32(data[1]) << 16) | (uint32(data[2]) << 8) | uint32(data[3]), n, nil } func readUint64(reader io.Reader) (v uint64, n int, err os.Error) { - data := [8]byte{} - n, e := reader.Read(data[0:]) - if e != nil { return 0, n, e } - return (uint64(data[0]) << 56) | (uint64(data[1]) << 48) | (uint64(data[2]) << 40) | (uint64(data[3]) << 32) | (uint64(data[4]) << 24) | (uint64(data[5]) << 16) | (uint64(data[6]) << 8) | uint64(data[7]), n, nil + data := [8]byte{} + n, e := reader.Read(data[0:]) + if e != nil { + return 0, n, e + } + return (uint64(data[0]) << 56) | (uint64(data[1]) << 48) | (uint64(data[2]) << 40) | (uint64(data[3]) << 32) | (uint64(data[4]) << 24) | (uint64(data[5]) << 16) | (uint64(data[6]) << 8) | uint64(data[7]), n, nil } func readInt16(reader io.Reader) (v int16, n int, err os.Error) { - data := [2]byte{} - n, e := reader.Read(data[0:]) - if e != nil { return 0, n, e } - return (int16(data[0]) << 8) | int16(data[1]), n, nil + data := [2]byte{} + n, e := reader.Read(data[0:]) + if e != nil { + return 0, n, e + } + return (int16(data[0]) << 8) | int16(data[1]), n, nil } func readInt32(reader io.Reader) (v int32, n int, err os.Error) { - data := [4]byte{} - n, e := reader.Read(data[0:]) - if e != nil { return 0, n, e } - return (int32(data[0]) << 24) | (int32(data[1]) << 16) | (int32(data[2]) << 8) | int32(data[3]), n, nil + data := [4]byte{} + n, e := reader.Read(data[0:]) + if e != nil { + return 0, n, e + } + return (int32(data[0]) << 24) | (int32(data[1]) << 16) | (int32(data[2]) << 8) | int32(data[3]), n, nil } func readInt64(reader io.Reader) (v int64, n int, err os.Error) { - data := [8]byte{} - n, e := reader.Read(data[0:]) - if e != nil { return 0, n, e } - return (int64(data[0]) << 56) | (int64(data[1]) << 48) | (int64(data[2]) << 40) | (int64(data[3]) << 32) | (int64(data[4]) << 24) | (int64(data[5]) << 16) | (int64(data[6]) << 8) | int64(data[7]), n, nil + data := [8]byte{} + n, e := reader.Read(data[0:]) + if e != nil { + return 0, n, e + } + return (int64(data[0]) << 56) | (int64(data[1]) << 48) | (int64(data[2]) << 40) | (int64(data[3]) << 32) | (int64(data[4]) << 24) | (int64(data[5]) << 16) | (int64(data[6]) << 8) | int64(data[7]), n, nil } func unpackArray(reader io.Reader, nelems uint) (v reflect.Value, n int, err os.Error) { - retval := make([]interface{}, nelems) - nbytesread := 0 - var i uint - for i = 0; i < nelems; i++ { - v, n, e := Unpack(reader) - nbytesread += n - if e != nil { return nil, nbytesread, e } - retval[i] = v.Interface() - } - return reflect.NewValue(retval), nbytesread, nil + retval := make([]interface{}, nelems) + nbytesread := 0 + var i uint + for i = 0; i < nelems; i++ { + v, n, e := Unpack(reader) + nbytesread += n + if e != nil { + return reflect.Value{}, nbytesread, e + } + retval[i] = v.Interface() + } + return reflect.ValueOf(retval), nbytesread, nil } func unpackArrayReflected(reader io.Reader, nelems uint) (v reflect.Value, n int, err os.Error) { - retval := make([]reflect.Value, nelems) - nbytesread := 0 - var i uint - for i = 0; i < nelems; i++ { - v, n, e := UnpackReflected(reader) - nbytesread += n - if e != nil { return nil, nbytesread, e } - retval[i] = v - } - return reflect.NewValue(retval), nbytesread, nil + retval := make([]reflect.Value, nelems) + nbytesread := 0 + var i uint + for i = 0; i < nelems; i++ { + v, n, e := UnpackReflected(reader) + nbytesread += n + if e != nil { + return reflect.Value{}, nbytesread, e + } + retval[i] = v + } + return reflect.ValueOf(retval), nbytesread, nil } func unpackMap(reader io.Reader, nelems uint) (v reflect.Value, n int, err os.Error) { - retval := make(map [interface{}] interface{}) - nbytesread := 0 - var i uint - for i = 0; i < nelems; i++ { - k, n, e := Unpack(reader) - nbytesread += n - if e != nil { return nil, nbytesread, e } - v, n, e := Unpack(reader) - nbytesread += n - if e != nil { return nil, nbytesread, e } - retval[k.Interface()] = v.Interface() - } - return reflect.NewValue(retval), nbytesread, nil + retval := make(map[interface{}]interface{}) + nbytesread := 0 + var i uint + for i = 0; i < nelems; i++ { + k, n, e := Unpack(reader) + nbytesread += n + if e != nil { + return reflect.Value{}, nbytesread, e + } + v, n, e := Unpack(reader) + nbytesread += n + if e != nil { + return reflect.Value{}, nbytesread, e + } + retval[k.Interface()] = v.Interface() + } + return reflect.ValueOf(retval), nbytesread, nil } func unpackMapReflected(reader io.Reader, nelems uint) (v reflect.Value, n int, err os.Error) { - retval := make(map [reflect.Value] reflect.Value) - nbytesread := 0 - var i uint - for i = 0; i < nelems; i++ { - k, n, e := UnpackReflected(reader) - nbytesread += n - if e != nil { return nil, nbytesread, e } - v, n, e := UnpackReflected(reader) - nbytesread += n - if e != nil { return nil, nbytesread, e } - retval[k] = v - } - return reflect.NewValue(retval), nbytesread, nil + retval := make(map[interface{}]reflect.Value) + nbytesread := 0 + var i uint + for i = 0; i < nelems; i++ { + k, n, e := UnpackReflected(reader) + nbytesread += n + if e != nil { + return reflect.Value{}, nbytesread, e + } + v, n, e := UnpackReflected(reader) + nbytesread += n + if e != nil { + return reflect.Value{}, nbytesread, e + } + retval[k] = v + } + return reflect.ValueOf(retval), nbytesread, nil } func unpack(reader io.Reader, reflected bool) (v reflect.Value, n int, err os.Error) { - var retval reflect.Value - var nbytesread int = 0 + var retval reflect.Value + var nbytesread int = 0 - c, e := readByte(reader) - if e != nil { return nil, 0, e } - nbytesread += 1 - if c < 0x80 || c >= 0xe0 { - retval = reflect.NewValue(int8(c)) - } else if c >= 0x80 && c <= 0x8f { - if reflected { - retval, n, e = unpackMapReflected(reader, uint(c & 0xf)) - } else { - retval, n, e = unpackMap(reader, uint(c & 0xf)) - } - nbytesread += n - if e != nil { return nil, nbytesread, e } - nbytesread += n - } else if c >= 0x90 && c <= 0x9f { - if reflected { - retval, n, e = unpackArrayReflected(reader, uint(c & 0xf)) - } else { - retval, n, e = unpackArray(reader, uint(c & 0xf)) - } - nbytesread += n - if e != nil { return nil, nbytesread, e } - nbytesread += n - } else if c >= 0xa0 && c <= 0xbf { - data := make([]byte, c & 0xf); - n, e := reader.Read(data) - nbytesread += n - if e != nil { return nil, nbytesread, e } - retval = reflect.NewValue(data) - } else { - switch c { - case 0xc0: retval = reflect.NewValue(nil) - case 0xc2: retval = reflect.NewValue(false) - case 0xc3: retval = reflect.NewValue(true) - case 0xca: - data, n, e := readUint32(reader) - nbytesread += n - if e != nil { return nil, nbytesread, e } - retval = reflect.NewValue(*(*float32)(unsafe.Pointer(&data))) - case 0xcb: - data, n, e := readUint64(reader) - nbytesread += n - if e != nil { return nil, nbytesread, e } - retval = reflect.NewValue(*(*float64)(unsafe.Pointer(&data))) - case 0xcc: - data, e := readByte(reader) - if e != nil { return nil, nbytesread, e } - retval = reflect.NewValue(uint8(data)) - nbytesread += 1 - case 0xcd: - data, n, e := readUint16(reader) - nbytesread += n - if e != nil { return nil, nbytesread, e } - retval = reflect.NewValue(data) - case 0xce: - data, n, e := readUint32(reader) - nbytesread += n - if e != nil { return nil, nbytesread, e } - retval = reflect.NewValue(data) - case 0xcf: - data, n, e := readUint64(reader) - nbytesread += n - if e != nil { return nil, nbytesread, e } - retval = reflect.NewValue(data) - case 0xd0: - data, e := readByte(reader) - if e != nil { return nil, nbytesread, e } - retval = reflect.NewValue(int8(data)) - nbytesread += 1 - case 0xd1: - data, n, e := readInt16(reader) - nbytesread += n - if e != nil { return nil, nbytesread, e } - retval = reflect.NewValue(data) - case 0xd2: - data, n, e := readInt32(reader) - nbytesread += n - if e != nil { return nil, nbytesread, e } - retval = reflect.NewValue(data) - case 0xd3: - data, n, e := readInt64(reader) - nbytesread += n - if e != nil { return nil, nbytesread, e } - retval = reflect.NewValue(data) - case 0xda: - nbytestoread, n, e := readUint16(reader) - nbytesread += n - if e != nil { return nil, nbytesread, e } - data := make([]byte, nbytestoread) - n, e = reader.Read(data) - nbytesread += n - if e != nil { return nil, nbytesread, e } - retval = reflect.NewValue(data) - case 0xdb: - nbytestoread, n, e := readUint32(reader) - nbytesread += n - if e != nil { return nil, nbytesread, e } - data := make([]byte, nbytestoread) - n, e = reader.Read(data) - nbytesread += n - if e != nil { return nil, nbytesread, e } - retval = reflect.NewValue(data) - case 0xdc: - nelemstoread, n, e := readUint16(reader) - nbytesread += n - if e != nil { return nil, nbytesread, e } - if reflected { - retval, n, e = unpackArrayReflected(reader, uint(nelemstoread)) - } else { - retval, n, e = unpackArray(reader, uint(nelemstoread)) - } - nbytesread += n - if e != nil { return nil, nbytesread, e } - case 0xdd: - nelemstoread, n, e := readUint32(reader) - nbytesread += n - if e != nil { return nil, nbytesread, e } - if reflected { - retval, n, e = unpackArrayReflected(reader, uint(nelemstoread)) - } else { - retval, n, e = unpackArray(reader, uint(nelemstoread)) - } - nbytesread += n - if e != nil { return nil, nbytesread, e } - case 0xde: - nelemstoread, n, e := readUint16(reader) - nbytesread += n - if e != nil { return nil, nbytesread, e } - if reflected { - retval, n, e = unpackMapReflected(reader, uint(nelemstoread)) - } else { - retval, n, e = unpackMap(reader, uint(nelemstoread)) - } - nbytesread += n - if e != nil { return nil, nbytesread, e } - case 0xdf: - nelemstoread, n, e := readUint32(reader) - nbytesread += n - if e != nil { return nil, nbytesread, e } - if reflected { - retval, n, e = unpackMapReflected(reader, uint(nelemstoread)) - } else { - retval, n, e = unpackMap(reader, uint(nelemstoread)) - } - nbytesread += n - if e != nil { return nil, nbytesread, e } - default: - panic("unsupported code: " + strconv.Itoa(int(c))) - } - } - return retval, nbytesread, nil + c, e := readByte(reader) + if e != nil { + return reflect.Value{}, 0, e + } + nbytesread += 1 + if c < 0x80 || c >= 0xe0 { + retval = reflect.ValueOf(int8(c)) + } else if c >= 0x80 && c <= 0x8f { + if reflected { + retval, n, e = unpackMapReflected(reader, uint(c&0xf)) + } else { + retval, n, e = unpackMap(reader, uint(c&0xf)) + } + nbytesread += n + if e != nil { + return reflect.Value{}, nbytesread, e + } + nbytesread += n + } else if c >= 0x90 && c <= 0x9f { + if reflected { + retval, n, e = unpackArrayReflected(reader, uint(c&0xf)) + } else { + retval, n, e = unpackArray(reader, uint(c&0xf)) + } + nbytesread += n + if e != nil { + return reflect.Value{}, nbytesread, e + } + nbytesread += n + } else if c >= 0xa0 && c <= 0xbf { + data := make([]byte, c&0xf) + n, e := reader.Read(data) + nbytesread += n + if e != nil { + return reflect.Value{}, nbytesread, e + } + retval = reflect.ValueOf(data) + } else { + switch c { + case 0xc0: + retval = reflect.ValueOf(nil) + case 0xc2: + retval = reflect.ValueOf(false) + case 0xc3: + retval = reflect.ValueOf(true) + case 0xca: + data, n, e := readUint32(reader) + nbytesread += n + if e != nil { + return reflect.Value{}, nbytesread, e + } + retval = reflect.ValueOf(*(*float32)(unsafe.Pointer(&data))) + case 0xcb: + data, n, e := readUint64(reader) + nbytesread += n + if e != nil { + return reflect.Value{}, nbytesread, e + } + retval = reflect.ValueOf(*(*float64)(unsafe.Pointer(&data))) + case 0xcc: + data, e := readByte(reader) + if e != nil { + return reflect.Value{}, nbytesread, e + } + retval = reflect.ValueOf(uint8(data)) + nbytesread += 1 + case 0xcd: + data, n, e := readUint16(reader) + nbytesread += n + if e != nil { + return reflect.Value{}, nbytesread, e + } + retval = reflect.ValueOf(data) + case 0xce: + data, n, e := readUint32(reader) + nbytesread += n + if e != nil { + return reflect.Value{}, nbytesread, e + } + retval = reflect.ValueOf(data) + case 0xcf: + data, n, e := readUint64(reader) + nbytesread += n + if e != nil { + return reflect.Value{}, nbytesread, e + } + retval = reflect.ValueOf(data) + case 0xd0: + data, e := readByte(reader) + if e != nil { + return reflect.Value{}, nbytesread, e + } + retval = reflect.ValueOf(int8(data)) + nbytesread += 1 + case 0xd1: + data, n, e := readInt16(reader) + nbytesread += n + if e != nil { + return reflect.Value{}, nbytesread, e + } + retval = reflect.ValueOf(data) + case 0xd2: + data, n, e := readInt32(reader) + nbytesread += n + if e != nil { + return reflect.Value{}, nbytesread, e + } + retval = reflect.ValueOf(data) + case 0xd3: + data, n, e := readInt64(reader) + nbytesread += n + if e != nil { + return reflect.Value{}, nbytesread, e + } + retval = reflect.ValueOf(data) + case 0xda: + nbytestoread, n, e := readUint16(reader) + nbytesread += n + if e != nil { + return reflect.Value{}, nbytesread, e + } + data := make([]byte, nbytestoread) + n, e = reader.Read(data) + nbytesread += n + if e != nil { + return reflect.Value{}, nbytesread, e + } + retval = reflect.ValueOf(data) + case 0xdb: + nbytestoread, n, e := readUint32(reader) + nbytesread += n + if e != nil { + return reflect.Value{}, nbytesread, e + } + data := make([]byte, nbytestoread) + n, e = reader.Read(data) + nbytesread += n + if e != nil { + return reflect.Value{}, nbytesread, e + } + retval = reflect.ValueOf(data) + case 0xdc: + nelemstoread, n, e := readUint16(reader) + nbytesread += n + if e != nil { + return reflect.Value{}, nbytesread, e + } + if reflected { + retval, n, e = unpackArrayReflected(reader, uint(nelemstoread)) + } else { + retval, n, e = unpackArray(reader, uint(nelemstoread)) + } + nbytesread += n + if e != nil { + return reflect.Value{}, nbytesread, e + } + case 0xdd: + nelemstoread, n, e := readUint32(reader) + nbytesread += n + if e != nil { + return reflect.Value{}, nbytesread, e + } + if reflected { + retval, n, e = unpackArrayReflected(reader, uint(nelemstoread)) + } else { + retval, n, e = unpackArray(reader, uint(nelemstoread)) + } + nbytesread += n + if e != nil { + return reflect.Value{}, nbytesread, e + } + case 0xde: + nelemstoread, n, e := readUint16(reader) + nbytesread += n + if e != nil { + return reflect.Value{}, nbytesread, e + } + if reflected { + retval, n, e = unpackMapReflected(reader, uint(nelemstoread)) + } else { + retval, n, e = unpackMap(reader, uint(nelemstoread)) + } + nbytesread += n + if e != nil { + return reflect.Value{}, nbytesread, e + } + case 0xdf: + nelemstoread, n, e := readUint32(reader) + nbytesread += n + if e != nil { + return reflect.Value{}, nbytesread, e + } + if reflected { + retval, n, e = unpackMapReflected(reader, uint(nelemstoread)) + } else { + retval, n, e = unpackMap(reader, uint(nelemstoread)) + } + nbytesread += n + if e != nil { + return reflect.Value{}, nbytesread, e + } + default: + panic("unsupported code: " + strconv.Itoa(int(c))) + } + } + return retval, nbytesread, nil } // Reads a value from the reader, unpack and returns it. func Unpack(reader io.Reader) (v reflect.Value, n int, err os.Error) { - return unpack(reader, false) + return unpack(reader, false) } // Reads unpack a value from the reader, unpack and returns it. When the // value is an array or map, leaves the elements wrapped by corresponding // wrapper objects defined in reflect package. func UnpackReflected(reader io.Reader) (v reflect.Value, n int, err os.Error) { - return unpack(reader, true) + return unpack(reader, true) } - - -