add minimal port of Slime API

client/go/internal/slime/array_traverser.go

@@ -0,0 +1,8 @@
+// Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+// Author: arnej
+
+package slime
+
+type ArrayTraverser interface {
+	Entry(idx int, value Inspector)
+}

client/go/internal/slime/array_value.go

@@ -0,0 +1,96 @@
+// Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+// Author: arnej
+
+package slime
+
+type ArrayValue struct {
+	valueBase
+	v []Cursor
+}
+
+func newArrayValue() *ArrayValue {
+	return &ArrayValue{
+		v: make([]Cursor, 0, 10),
+	}
+}
+
+func (a *ArrayValue) addElement(elem Cursor) Cursor {
+	a.v = append(a.v, elem)
+	return elem
+}
+
+func (a *ArrayValue) Valid() bool {
+	return true
+}
+
+func (a *ArrayValue) Type() Type {
+	return ARRAY
+}
+
+func (a *ArrayValue) Entries() int {
+	return len(a.v)
+}
+
+func (a *ArrayValue) TraverseArray(traverser ArrayTraverser) {
+	for idx, value := range a.v {
+		traverser.Entry(idx, value)
+	}
+}
+
+func (a *ArrayValue) Entry(idx int) Inspector {
+	if idx < len(a.v) {
+		return a.v[idx]
+	}
+	return InvalidNix
+}
+
+func (a *ArrayValue) MutableEntry(idx int) Cursor {
+	if idx < len(a.v) {
+		return a.v[idx]
+	}
+	return InvalidNix
+}
+
+func (a *ArrayValue) AddNix() Inspector {
+	return a.addElement(ValidNix)
+}
+
+func (a *ArrayValue) AddBool(value bool) Inspector {
+	return a.addElement(newBoolValue(value))
+}
+
+func (a *ArrayValue) AddLong(value int64) Inspector {
+	n := newLongValue(value)
+	a.v = append(a.v, n)
+	return n
+}
+
+func (a *ArrayValue) AddDouble(value float64) Inspector {
+	n := newDoubleValue(value)
+	a.v = append(a.v, n)
+	return n
+}
+
+func (a *ArrayValue) AddString(value string) Inspector {
+	n := newStringValue(value)
+	a.v = append(a.v, n)
+	return n
+}
+
+func (a *ArrayValue) AddData(value []byte) Inspector {
+	n := newDataValue(value)
+	a.v = append(a.v, n)
+	return n
+}
+
+func (a *ArrayValue) AddArray() Cursor {
+	n := newArrayValue()
+	a.v = append(a.v, n)
+	return n
+}
+
+func (a *ArrayValue) AddObject() Cursor {
+	n := newObjectValue()
+	a.v = append(a.v, n)
+	return n
+}

client/go/internal/slime/binary_decoder.go

@@ -0,0 +1,188 @@
+// Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
+// Author: arnej
+
+package slime
+
+type binaryDecoder struct {
+	buf     []byte
+	pos     int
+	symbols []string
+	failed  bool
+	failure string
+}
+
+var emptyByteSlice = make([]byte, 0)
+
+func newBinaryDecoder(input []byte) binaryDecoder {
+	return binaryDecoder{
+		buf:    input,
+		pos:    0,
+		failed: false,
+	}
+}
+
+func (in *binaryDecoder) fail(reason string) {
+	in.failed = true
+	in.failure = reason
+}
+
+func (in *binaryDecoder) getByte() byte {
+	var b byte = 0
+	if !in.failed {
+		if in.pos < len(in.buf) {
+			b = in.buf[in.pos]
+			in.pos++
+		} else {
+			in.fail("buffer underflow")
+		}
+	}
+	return b
+}
+
+func (in *binaryDecoder) getBytes(sz int) []byte {
+	if !in.failed {
+		if in.pos+sz <= len(in.buf) {
+			start := in.pos
+			endp := start + sz
+			in.pos = endp
+			return in.buf[start:endp]
+		}
+		in.fail("buffer underflow")
+	}
+	return emptyByteSlice
+}
+
+func (in *binaryDecoder) read_bytes_le(sz uint32) uint64 {
+	var value uint64 = 0
+	shift := 0
+	for i := uint32(0); i < sz; i++ {
+		b := uint64(in.getByte())
+		value = value | (b << shift)
+		shift = shift + 8
+	}
+	return value
+}
+
+func (in *binaryDecoder) read_bytes_be(sz uint32) uint64 {
+	var value uint64 = 0
+	shift := 56
+	for i := uint32(0); i < sz; i++ {
+		b := uint64(in.getByte())
+		value = value | (b << shift)
+		shift = shift - 8
+	}
+	return value
+}
+
+func (in *binaryDecoder) read_cmpr_int() int {
+	next := in.getByte()
+	var value int64 = int64(next & 0x7f)
+	shift := 0
+	for (next & 0x80) != 0 {
+		shift += 7
+		next = in.getByte()
+		value = value | ((int64(next) & 0x7f) << shift)
+		if shift > 32 || value > 0x7fff_ffff {
+			in.fail("compressed int overflow")
+			value = 0
+			next = 0
+		}
+	}
+	return int(value)
+}
+
+func (in *binaryDecoder) read_size(meta uint32) int {
+	if meta != 0 {
+		return int(meta - 1)
+	}
+	return in.read_cmpr_int()
+}
+
+func (in *binaryDecoder) decodeSymbolTable() {
+	numSymbols := in.read_cmpr_int()
+	in.symbols = make([]string, numSymbols)
+	for i := 0; i < numSymbols; i++ {
+		sz := in.read_cmpr_int()
+		buf := in.getBytes(sz)
+		in.symbols[i] = string(buf)
+	}
+}
+
+func (in *binaryDecoder) decodeValue() Cursor {
+	b := in.getByte()
+	ty := decode_type(b)
+	meta := decode_meta(b)
+	switch ty {
+	case NIX:
+		return ValidNix
+	case BOOL:
+		return in.decodeBOOL(meta)
+	case LONG:
+		return in.decodeLONG(meta)
+	case DOUBLE:
+		return in.decodeDOUBLE(meta)
+	case STRING:
+		return in.decodeSTRING(meta)
+	case DATA:
+		return in.decodeDATA(meta)
+	case ARRAY:
+		return in.decodeARRAY(meta)
+	case OBJECT:
+		return in.decodeOBJECT(meta)
+	}
+	panic("bad type")
+	// return InvalidNix
+}
+
+func (in *binaryDecoder) decodeBOOL(meta uint32) Cursor {
+	return newBoolValue(meta != 0)
+}
+
+func (in *binaryDecoder) decodeLONG(meta uint32) Cursor {
+	var encoded uint64 = in.read_bytes_le(meta)
+	return newLongValue(decode_zigzag(encoded))
+}
+
+func (in *binaryDecoder) decodeDOUBLE(meta uint32) Cursor {
+	var encoded uint64 = in.read_bytes_be(meta)
+	return newDoubleValue(decode_double(encoded))
+}
+
+func (in *binaryDecoder) decodeSTRING(meta uint32) Cursor {
+	sz := in.read_size(meta)
+	image := in.getBytes(sz)
+	return newStringValue(string(image))
+}
+
+func (in *binaryDecoder) decodeDATA(meta uint32) Cursor {
+	sz := in.read_size(meta)
+	image := in.getBytes(sz)
+	return newDataValue(image)
+}
+
+func (in *binaryDecoder) decodeARRAY(meta uint32) Cursor {
+	res := newArrayValue()
+	sz := in.read_size(meta)
+	for i := 0; i < sz; i++ {
+		elem := in.decodeValue()
+		res.addElement(elem)
+	}
+	return res
+}
+
+func (in *binaryDecoder) decodeOBJECT(meta uint32) Cursor {
+	res := newObjectValue()
+	sz := in.read_size(meta)
+	for i := 0; i < sz; i++ {
+		symbol := in.read_cmpr_int()
+		if symbol < len(in.symbols) {
+			name := in.symbols[symbol]
+			elem := in.decodeValue()
+			res.addElement(name, elem)
+		} else {
+			in.fail("symbol id out of range decoding object")
+			return res
+		}
+	}
+	return res
+}