You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
138 lines
3.3 KiB
138 lines
3.3 KiB
package binary
|
|
|
|
import (
|
|
"errors"
|
|
"io"
|
|
"time"
|
|
)
|
|
|
|
type Codec interface {
|
|
WriteTo(io.Writer, interface{}, *int64, *error)
|
|
ReadFrom(io.Reader, *int64, *error) interface{}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
const (
|
|
typeNil = byte(0x00)
|
|
typeByte = byte(0x01)
|
|
typeInt8 = byte(0x02)
|
|
// typeUInt8 = byte(0x03)
|
|
typeInt16 = byte(0x04)
|
|
typeUInt16 = byte(0x05)
|
|
typeInt32 = byte(0x06)
|
|
typeUInt32 = byte(0x07)
|
|
typeInt64 = byte(0x08)
|
|
typeUInt64 = byte(0x09)
|
|
typeString = byte(0x10)
|
|
typeByteSlice = byte(0x11)
|
|
typeTime = byte(0x20)
|
|
)
|
|
|
|
var BasicCodec = basicCodec{}
|
|
|
|
type basicCodec struct{}
|
|
|
|
func (bc basicCodec) WriteTo(w io.Writer, o interface{}, n *int64, err *error) {
|
|
switch o.(type) {
|
|
case nil:
|
|
WriteByte(w, typeNil, n, err)
|
|
case byte:
|
|
WriteByte(w, typeByte, n, err)
|
|
WriteByte(w, o.(byte), n, err)
|
|
case int8:
|
|
WriteByte(w, typeInt8, n, err)
|
|
WriteInt8(w, o.(int8), n, err)
|
|
//case uint8:
|
|
// WriteByte(w, typeUInt8, n, err)
|
|
// WriteUInt8(w, o.(uint8), n, err)
|
|
case int16:
|
|
WriteByte(w, typeInt16, n, err)
|
|
WriteInt16(w, o.(int16), n, err)
|
|
case uint16:
|
|
WriteByte(w, typeUInt16, n, err)
|
|
WriteUInt16(w, o.(uint16), n, err)
|
|
case int32:
|
|
WriteByte(w, typeInt32, n, err)
|
|
WriteInt32(w, o.(int32), n, err)
|
|
case uint32:
|
|
WriteByte(w, typeUInt32, n, err)
|
|
WriteUInt32(w, o.(uint32), n, err)
|
|
case int64:
|
|
WriteByte(w, typeInt64, n, err)
|
|
WriteInt64(w, o.(int64), n, err)
|
|
case uint64:
|
|
WriteByte(w, typeUInt64, n, err)
|
|
WriteUInt64(w, o.(uint64), n, err)
|
|
case string:
|
|
WriteByte(w, typeString, n, err)
|
|
WriteString(w, o.(string), n, err)
|
|
case []byte:
|
|
WriteByte(w, typeByteSlice, n, err)
|
|
WriteByteSlice(w, o.([]byte), n, err)
|
|
case time.Time:
|
|
WriteByte(w, typeTime, n, err)
|
|
WriteTime(w, o.(time.Time), n, err)
|
|
default:
|
|
panic("Unsupported type")
|
|
}
|
|
return
|
|
}
|
|
|
|
func (bc basicCodec) ReadFrom(r io.Reader, n *int64, err *error) interface{} {
|
|
type_ := ReadByte(r, n, err)
|
|
switch type_ {
|
|
case typeNil:
|
|
return nil
|
|
case typeByte:
|
|
return ReadByte(r, n, err)
|
|
case typeInt8:
|
|
return ReadInt8(r, n, err)
|
|
//case typeUInt8:
|
|
// return ReadUInt8(r, n, err)
|
|
case typeInt16:
|
|
return ReadInt16(r, n, err)
|
|
case typeUInt16:
|
|
return ReadUInt16(r, n, err)
|
|
case typeInt32:
|
|
return ReadInt32(r, n, err)
|
|
case typeUInt32:
|
|
return ReadUInt32(r, n, err)
|
|
case typeInt64:
|
|
return ReadInt64(r, n, err)
|
|
case typeUInt64:
|
|
return ReadUInt64(r, n, err)
|
|
case typeString:
|
|
return ReadString(r, n, err)
|
|
case typeByteSlice:
|
|
return ReadByteSlice(r, n, err)
|
|
case typeTime:
|
|
return ReadTime(r, n, err)
|
|
default:
|
|
panic("Unsupported type")
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// Creates an adapter codec for Binary things.
|
|
// Resulting Codec can be used with merkle/*.
|
|
type BinaryCodec struct {
|
|
decoder func(io.Reader, *int64, *error) interface{}
|
|
}
|
|
|
|
func NewBinaryCodec(decoder func(io.Reader, *int64, *error) interface{}) *BinaryCodec {
|
|
return &BinaryCodec{decoder}
|
|
}
|
|
|
|
func (ca *BinaryCodec) WriteTo(w io.Writer, o interface{}, n *int64, err *error) {
|
|
if bo, ok := o.(Binary); ok {
|
|
WriteTo(w, BinaryBytes(bo), n, err)
|
|
} else {
|
|
*err = errors.New("BinaryCodec expected Binary object")
|
|
}
|
|
}
|
|
|
|
func (ca *BinaryCodec) ReadFrom(r io.Reader, n *int64, err *error) interface{} {
|
|
return ca.decoder(r, n, err)
|
|
}
|