mirror of
https://github.com/msgpack/msgpack-c.git
synced 2025-03-18 12:34:15 +01:00
make C/C++ implementation independent from other language implementations
This commit is contained in:
FURUHASHI Sadayuki
parent
06ebdbfd37
commit
e96e20ccfd
10
.gitignore
vendored
10
.gitignore
vendored
@ -1,15 +1,5 @@
|
||||
*.o
|
||||
*.so
|
||||
ruby/Makefile
|
||||
*.5
|
||||
*.8
|
||||
*.6
|
||||
_obj
|
||||
_test
|
||||
/csharp/MsgPack.suo
|
||||
/csharp/MsgPack/bin
|
||||
/csharp/MsgPack/obj
|
||||
/csharp/MsgPack/MsgPack.csproj.user
|
||||
/csharp/MsgPack.Test/obj
|
||||
/csharp/MsgPack.Test/bin
|
||||
/csharp/MsgPack.Test/MsgPack.Test.csproj.user
|
||||
|
||||
@ -1 +0,0 @@
|
||||
MessagePack for C# was moved to https://github.com/msgpack/msgpack-cli.
|
||||
5
erlang/.gitignore
vendored
5
erlang/.gitignore
vendored
@ -1,5 +0,0 @@
|
||||
MANIFEST
|
||||
*.beam
|
||||
.omakedb*
|
||||
*.omc
|
||||
*~
|
||||
@ -1,5 +0,0 @@
|
||||
MessagePack for Erlang
|
||||
======================
|
||||
|
||||
This project has moved to its own repository for good usage in rebar.
|
||||
New repository is http://github.com/msgpack/msgpack-erlang .
|
||||
@ -1,5 +0,0 @@
|
||||
require 'msgpack'
|
||||
|
||||
serialized = [1, -1, true, false, nil, {"key" => "value"}].to_msgpack
|
||||
p MessagePack.unpack(serialized)
|
||||
|
||||
@ -1,72 +0,0 @@
|
||||
require 'msgpack'
|
||||
|
||||
class Server
|
||||
def initialize(sock)
|
||||
@sock = sock
|
||||
@pk = MessagePack::Unpacker.new
|
||||
@buffer = ''
|
||||
@nread = 0
|
||||
end
|
||||
|
||||
def run
|
||||
while true
|
||||
begin
|
||||
data = @sock.sysread(1024)
|
||||
rescue
|
||||
puts "connection closed (#{$!})"
|
||||
return
|
||||
end
|
||||
receive_data(data)
|
||||
end
|
||||
end
|
||||
|
||||
private
|
||||
def receive_data(data)
|
||||
@buffer << data
|
||||
|
||||
while true
|
||||
@nread = @pk.execute(@buffer, @nread)
|
||||
|
||||
if @pk.finished?
|
||||
msg = @pk.data
|
||||
process_message(msg)
|
||||
|
||||
@pk.reset
|
||||
@buffer.slice!(0, @nread)
|
||||
@nread = 0
|
||||
|
||||
next unless @buffer.empty?
|
||||
end
|
||||
|
||||
break
|
||||
end
|
||||
|
||||
if @buffer.length > 10*1024*1024
|
||||
raise "message is too large"
|
||||
end
|
||||
|
||||
rescue
|
||||
puts "error while processing client packet: #{$!}"
|
||||
end
|
||||
|
||||
def process_message(msg)
|
||||
puts "message reached: #{msg.inspect}"
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
rpipe, wpipe = IO.pipe
|
||||
|
||||
# run server thread
|
||||
thread = Thread.new(Server.new(rpipe)) {|srv|
|
||||
srv.run
|
||||
}
|
||||
|
||||
# client thread:
|
||||
wpipe.write ["put", "apple", "red"].to_msgpack
|
||||
wpipe.write ["put", "lemon", "yellow"].to_msgpack
|
||||
wpipe.write ["get", "apple"].to_msgpack
|
||||
wpipe.close
|
||||
|
||||
thread.join
|
||||
|
||||
@ -1,3 +0,0 @@
|
||||
THIS directory is moved to separeted repository.
|
||||
|
||||
Please go http://github.com/msgpack/msgpack-go/
|
||||
@ -1,353 +0,0 @@
|
||||
package msgpack
|
||||
|
||||
import (
|
||||
"testing"
|
||||
"bytes"
|
||||
"reflect"
|
||||
"math"
|
||||
)
|
||||
|
||||
func equal(lhs reflect.Value, rhs reflect.Value) bool {
|
||||
{
|
||||
_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())
|
||||
}
|
||||
}
|
||||
|
||||
func TestPackBytes(t *testing.T) {
|
||||
for _, i := range []struct {
|
||||
s string
|
||||
b []byte
|
||||
}{
|
||||
{"a", []byte("\xa1a")},
|
||||
{"hello", []byte("\xa5hello")},
|
||||
{"world world world", []byte("\xb1world world world")},
|
||||
{"world world world world world world", []byte("\xda\x00#world world world world world world")},
|
||||
} {
|
||||
|
||||
b := &bytes.Buffer{}
|
||||
|
||||
_, err := PackBytes(b, []byte(i.s))
|
||||
if err != nil {
|
||||
t.Error("err != nil")
|
||||
}
|
||||
|
||||
v, _, e := Unpack(b)
|
||||
if e != nil {
|
||||
t.Error("err != nil")
|
||||
}
|
||||
|
||||
if !equal(v, reflect.ValueOf([]byte(i.s))) {
|
||||
t.Error("unpack(pack(%s)) != %s", i.s)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
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())
|
||||
}
|
||||
}
|
||||
|
||||
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())
|
||||
}
|
||||
}
|
||||
|
||||
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())
|
||||
}
|
||||
}
|
||||
|
||||
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())
|
||||
}
|
||||
}
|
||||
|
||||
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())
|
||||
}
|
||||
}
|
||||
|
||||
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())
|
||||
}
|
||||
}
|
||||
|
||||
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())
|
||||
}
|
||||
}
|
||||
|
||||
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())
|
||||
}
|
||||
}
|
||||
|
||||
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())
|
||||
}
|
||||
}
|
||||
|
||||
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())
|
||||
}
|
||||
}
|
||||
|
||||
func TestPackArray(t *testing.T) {
|
||||
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.ValueOf(map[int]int{0: 1, 2: 3, 4: 5}))
|
||||
if err != nil {
|
||||
t.Error("err != nil")
|
||||
}
|
||||
|
||||
// map ordering is no longer deterministic -- check all possible orderings :(
|
||||
if bytes.Compare(b.Bytes(), []byte{0x83, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05}) != 0 &&
|
||||
bytes.Compare(b.Bytes(), []byte{0x83, 0x00, 0x01, 0x04, 0x05, 0x02, 0x03}) != 0 &&
|
||||
bytes.Compare(b.Bytes(), []byte{0x83, 0x02, 0x03, 0x00, 0x01, 0x04, 0x05}) != 0 &&
|
||||
bytes.Compare(b.Bytes(), []byte{0x83, 0x02, 0x03, 0x04, 0x05, 0x00, 0x01}) != 0 &&
|
||||
bytes.Compare(b.Bytes(), []byte{0x83, 0x04, 0x05, 0x00, 0x01, 0x02, 0x03}) != 0 &&
|
||||
bytes.Compare(b.Bytes(), []byte{0x83, 0x04, 0x05, 0x02, 0x03, 0x00, 0x01}) != 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, "astring"} {
|
||||
_, 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, 0xe0, 0xff, 0xd0, 0xdf, 0xd1, 0x00, 0x80, 0xA7, 'a', 's', 't', 'r', 'i', 'n', 'g'}) != 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.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)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
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)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
776
go/pack.go
776
go/pack.go
@ -1,776 +0,0 @@
|
||||
package msgpack
|
||||
|
||||
import (
|
||||
"io"
|
||||
"os"
|
||||
"reflect"
|
||||
"unsafe"
|
||||
)
|
||||
|
||||
// Packs a given value and writes it into the specified writer.
|
||||
func PackUint8(writer io.Writer, value uint8) (n int, err error) {
|
||||
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 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)})
|
||||
}
|
||||
|
||||
// Packs a given value and writes it into the specified writer.
|
||||
func PackUint32(writer io.Writer, value uint32) (n int, err 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)})
|
||||
}
|
||||
|
||||
// Packs a given value and writes it into the specified writer.
|
||||
func PackUint64(writer io.Writer, value uint64) (n int, err 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)})
|
||||
}
|
||||
|
||||
func PackUint(writer io.Writer, value uint) (n int, err 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.ErrNotExist // never get here
|
||||
}
|
||||
|
||||
// Packs a given value and writes it into the specified writer.
|
||||
func PackInt8(writer io.Writer, value int8) (n int, err error) {
|
||||
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 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)})
|
||||
}
|
||||
|
||||
// Packs a given value and writes it into the specified writer.
|
||||
func PackInt32(writer io.Writer, value int32) (n int, err 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)})
|
||||
}
|
||||
|
||||
// Packs a given value and writes it into the specified writer.
|
||||
func PackInt64(writer io.Writer, value int64) (n int, err 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)})
|
||||
}
|
||||
|
||||
// Packs a given value and writes it into the specified writer.
|
||||
func PackInt(writer io.Writer, value int) (n int, err 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.ErrNotExist // never get here
|
||||
}
|
||||
|
||||
// Packs a given value and writes it into the specified writer.
|
||||
func PackNil(writer io.Writer) (n int, err error) {
|
||||
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 error) {
|
||||
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 error) {
|
||||
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 error) {
|
||||
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 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
|
||||
}
|
||||
|
||||
// Packs a given value and writes it into the specified writer.
|
||||
func PackUint16Array(writer io.Writer, value []uint16) (n int, err 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
|
||||
}
|
||||
|
||||
// Packs a given value and writes it into the specified writer.
|
||||
func PackUint32Array(writer io.Writer, value []uint32) (n int, err 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
|
||||
}
|
||||
|
||||
// Packs a given value and writes it into the specified writer.
|
||||
func PackUint64Array(writer io.Writer, value []uint64) (n int, err 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
|
||||
}
|
||||
|
||||
// Packs a given value and writes it into the specified writer.
|
||||
func PackUintArray(writer io.Writer, value []uint) (n int, err 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.ErrNotExist // never get here
|
||||
}
|
||||
|
||||
// Packs a given value and writes it into the specified writer.
|
||||
func PackInt8Array(writer io.Writer, value []int8) (n int, err 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
|
||||
}
|
||||
|
||||
// Packs a given value and writes it into the specified writer.
|
||||
func PackInt16Array(writer io.Writer, value []int16) (n int, err 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
|
||||
}
|
||||
|
||||
// Packs a given value and writes it into the specified writer.
|
||||
func PackInt32Array(writer io.Writer, value []int32) (n int, err 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
|
||||
}
|
||||
|
||||
// Packs a given value and writes it into the specified writer.
|
||||
func PackInt64Array(writer io.Writer, value []int64) (n int, err 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
|
||||
}
|
||||
|
||||
// Packs a given value and writes it into the specified writer.
|
||||
func PackIntArray(writer io.Writer, value []int) (n int, err 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.ErrNotExist // never get here
|
||||
}
|
||||
|
||||
// Packs a given value and writes it into the specified writer.
|
||||
func PackFloat32Array(writer io.Writer, value []float32) (n int, err 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
|
||||
}
|
||||
|
||||
// Packs a given value and writes it into the specified writer.
|
||||
func PackFloat64Array(writer io.Writer, value []float64) (n int, err 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
|
||||
}
|
||||
|
||||
// Packs a given value and writes it into the specified writer.
|
||||
func PackArray(writer io.Writer, value reflect.Value) (n int, err 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.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.Value) (n int, err 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 error) {
|
||||
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.String:
|
||||
return PackBytes(writer, []byte(_value.String()))
|
||||
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 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)
|
||||
case string:
|
||||
return PackBytes(writer, []byte(_value))
|
||||
default:
|
||||
return PackValue(writer, reflect.ValueOf(value))
|
||||
}
|
||||
return 0, nil // never get here
|
||||
}
|
||||
365
go/unpack.go
365
go/unpack.go
@ -1,365 +0,0 @@
|
||||
package msgpack
|
||||
|
||||
import (
|
||||
"io"
|
||||
"reflect"
|
||||
"strconv"
|
||||
"unsafe"
|
||||
)
|
||||
|
||||
func readByte(reader io.Reader) (v uint8, err error) {
|
||||
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 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
|
||||
}
|
||||
|
||||
func readUint32(reader io.Reader) (v uint32, n int, err 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
|
||||
}
|
||||
|
||||
func readUint64(reader io.Reader) (v uint64, n int, err 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
|
||||
}
|
||||
|
||||
func readInt16(reader io.Reader) (v int16, n int, err 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
|
||||
}
|
||||
|
||||
func readInt32(reader io.Reader) (v int32, n int, err 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
|
||||
}
|
||||
|
||||
func readInt64(reader io.Reader) (v int64, n int, err 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
|
||||
}
|
||||
|
||||
func unpackArray(reader io.Reader, nelems uint) (v reflect.Value, n int, err 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 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 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 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 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 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 error) {
|
||||
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 error) {
|
||||
var retval reflect.Value
|
||||
var nbytesread int = 0
|
||||
|
||||
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&0x1f)
|
||||
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 error) {
|
||||
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 error) {
|
||||
return unpack(reader, true)
|
||||
}
|
||||
@ -1 +0,0 @@
|
||||
MessagePack for Haskell moved to https://github.com/msgpack/msgpack-haskell.
|
||||
@ -1 +0,0 @@
|
||||
MessagePack for Java was moved to https://github.com/msgpack/msgpack-java.
|
||||
@ -1 +0,0 @@
|
||||
MessagePack for OCaml moved to https://github.com/msgpack/msgpack-ocaml.
|
||||
@ -1 +0,0 @@
|
||||
MessagePack for Ruby moved to https://github.com/msgpack/msgpack-ruby.
|
||||
40
scala/.gitignore
vendored
40
scala/.gitignore
vendored
@ -1,40 +0,0 @@
|
||||
# use glob syntax.
|
||||
syntax: glob
|
||||
*.ser
|
||||
*.class
|
||||
*~
|
||||
*.bak
|
||||
#*.off
|
||||
*.old
|
||||
|
||||
# eclipse conf file
|
||||
.settings
|
||||
.classpath
|
||||
.project
|
||||
.manager
|
||||
.scala_dependencies
|
||||
|
||||
# idea
|
||||
.idea
|
||||
*.iml
|
||||
|
||||
# building
|
||||
target
|
||||
build
|
||||
null
|
||||
tmp*
|
||||
dist
|
||||
test-output
|
||||
build.log
|
||||
|
||||
# other scm
|
||||
.svn
|
||||
.CVS
|
||||
.hg*
|
||||
|
||||
# switch to regexp syntax.
|
||||
# syntax: regexp
|
||||
# ^\.pc/
|
||||
|
||||
#SHITTY output not in target directory
|
||||
build.log
|
||||
@ -1 +0,0 @@
|
||||
MessagePack for Scala moved to https://github.com/msgpack/msgpack-scala.
|
||||
Loading…
x
Reference in New Issue
Block a user