support packed type

Author: zhanglei28

breeze.go

@@ -6,35 +6,57 @@ import (
 
 // breeze type
 const (
-	NULL = iota
-	TRUE
-	FALSE
-	STRING
-	BYTE
-	BYTES
-	INT16
-	INT32
-	INT64
-	FLOAT32
-	FLOAT64
-
-	MAP     = 20
-	ARRAY   = 21
-	MESSAGE = 22
-	SCHEMA  = 23
+	StringType              = 0x3f
+	DirectStringMinType     = 0x00
+	DirectStringMaxType     = 0x3e
+	Int32Type               = 0x7f
+	DirectInt32MinType      = 0x40
+	DirectInt32MaxType      = 0x7e
+	Int64Type               = 0x98
+	DirectInt64MinType      = 0x80
+	DirectInt64MaxType      = 0x97
+	NullType                = 0x99
+	TrueType                = 0x9a
+	FalseType               = 0x9b
+	ByteType                = 0x9c
+	BytesType               = 0x9d
+	Int16Type               = 0x9e
+	Float32Type             = 0x9f
+	Float64Type             = 0xa0
+	MapType                 = 0xd9
+	ArrayType               = 0xda
+	PackedMapType           = 0xdb
+	PackedArrayType         = 0xdc
+	SchemaType              = 0xdd
+	MessageType             = 0xde
+	RefMessageType          = 0xdf
+	DirectRefMessageMaxType = 0xff
+)
+
+// direct value limit
+const (
+	Int32Zero                int32 = 0x50
+	Int64Zero                int64 = 0x88
+	DirectStringMaxLength          = DirectStringMaxType
+	DirectInt32MinValue            = DirectInt32MinType - Int32Zero
+	DirectInt32MaxValue            = DirectInt32MaxType - Int32Zero
+	DirectInt64MinValue            = DirectInt64MinType - Int64Zero
+	DirectInt64MaxValue            = DirectInt64MaxType - Int64Zero
+	DirectRefMessageMaxValue       = DirectRefMessageMaxType - RefMessageType
 )
 
 // configure
 var (
 	MaxWriteCount = 0 // TODO check circular reference
+	MaxElemSize   = 100000
 )
 
 // common errors
 var (
-	ErrNoSchema  = errors.New("Breeze: not have breeze schema")
-	ErrWrongSize = errors.New("Breeze: read byte size not correct")
-	ErrNotEnough = errors.New("Breeze: not enough bytes")
-	ErrOverflow  = errors.New("Breeze: integer overflow")
+	ErrNoSchema  = errors.New("breeze: not have breeze schema")
+	ErrWrongSize = errors.New("breeze: read byte size not correct")
+	ErrNotEnough = errors.New("breeze: not enough bytes")
+	ErrOverflow  = errors.New("breeze: integer overflow")
 )
 
 // Message is a interface of breeze message. all breeze message must implement Message
@@ -52,6 +74,40 @@ type Enum interface {
 	ReadEnum(buf *Buffer, asAddr bool) (Enum, error)
 }
 
+// Context is a context of breeze encode/decode in BreezeBuffer
+type Context struct {
+	messageTypeRefCount int
+	messageTypeRefName  map[int]string
+	messageTypeRefIndex map[string]int
+}
+
+func (c *Context) getMessageTypeName(index int) (name string) {
+	if c.messageTypeRefName != nil {
+		name = c.messageTypeRefName[index]
+	}
+	return name
+}
+
+func (c *Context) getMessageTypeIndex(name string) int {
+	if c.messageTypeRefIndex != nil {
+		index, ok := c.messageTypeRefIndex[name]
+		if ok {
+			return index
+		}
+	}
+	return -1
+}
+
+func (c *Context) putMessageType(name string) {
+	if c.messageTypeRefName == nil {
+		c.messageTypeRefName = make(map[int]string, 16)
+		c.messageTypeRefIndex = make(map[string]int, 16)
+	}
+	c.messageTypeRefCount++
+	c.messageTypeRefName[c.messageTypeRefCount] = name
+	c.messageTypeRefIndex[name] = c.messageTypeRefCount
+}
+
 // GenericMessage is a generic breeze message. it can receive any breeze message
 type GenericMessage struct {
 	Name   string
@@ -60,23 +116,23 @@ type GenericMessage struct {
 	fields map[int]interface{}
 }
 
-// GetAlias return breeze message alias for multi language compat
+// GetAlias return breeze message alias for multi language compatible
 func (g *GenericMessage) GetAlias() string {
 	return g.Alias
 }
 
 // WriteTo write breeze message to breeze buffer.
 func (g *GenericMessage) WriteTo(buf *Buffer) error {
-	return WriteMessage(buf, g.Name, func(buf *Buffer) {
+	return WriteMessageWithoutType(buf, func(buf *Buffer) {
 		for k, v := range g.fields {
-			WriteMessageField(buf, k, v)
+			WriteField(buf, k, v)
 		}
 	})
 }
 
 // ReadFrom read a breeze message from breeze buffer
 func (g *GenericMessage) ReadFrom(buf *Buffer) error {
-	return ReadMessageByField(buf, func(buf *Buffer, index int) (err error) {
+	return ReadMessageField(buf, func(buf *Buffer, index int) (err error) {
 		v, err := ReadValue(buf, nil)
 		if err != nil {
 			return err

breezeBuffer.go

@@ -8,21 +8,22 @@ import (
 // Buffer is A variable-sized buffer of bytes with Read and Write methods.
 // Buffer is not thread safe for multi goroutine operation.
 type Buffer struct {
-	buf   []byte // contents are the bytes buf[0 : woff] in write, are the bytes buf[roff: len(buf)] in read
-	rpos  int    // read position
-	wpos  int    // write position
-	order binary.ByteOrder
-	temp  []byte
+	buf     []byte // contents are the bytes buf[0 : wpos] in write, are the bytes buf[rpos: len(buf)] in read
+	rpos    int    // read position
+	wpos    int    // write position
+	order   binary.ByteOrder
+	temp    []byte
+	context *Context
 }
 
 // NewBuffer create A empty Buffer with initial size
-func NewBuffer(initsize int) *Buffer {
-	return NewBufferWithOrder(initsize, binary.BigEndian)
+func NewBuffer(initSize int) *Buffer {
+	return NewBufferWithOrder(initSize, binary.BigEndian)
 }
 
 // NewBufferWithOrder create A empty Buffer with initial size and byte order
-func NewBufferWithOrder(initsize int, order binary.ByteOrder) *Buffer {
-	return &Buffer{buf: make([]byte, initsize),
+func NewBufferWithOrder(initSize int, order binary.ByteOrder) *Buffer {
+	return &Buffer{buf: make([]byte, initSize),
 		order: order,
 		temp:  make([]byte, 8),
 	}
@@ -77,11 +78,13 @@ func (b *Buffer) WriteByte(c byte) {
 // Write write A byte array append the Buffer, and the wpos will increase len(bytes)
 func (b *Buffer) Write(bytes []byte) {
 	l := len(bytes)
-	if len(b.buf) < b.wpos+l {
-		b.grow(l)
+	if l > 0 {
+		if len(b.buf) < b.wpos+l {
+			b.grow(l)
+		}
+		copy(b.buf[b.wpos:], bytes)
+		b.wpos += l
 	}
-	copy(b.buf[b.wpos:], bytes)
-	b.wpos += l
 }
 
 // WriteUint16 write A uint16 append the Buffer according to buffer's order
@@ -116,16 +119,16 @@ func (b *Buffer) WriteUint64(u uint64) {
 
 // WriteZigzag32 write a uint32 append to the Buffer with zigzag algorithm
 func (b *Buffer) WriteZigzag32(u uint32) int {
-	return b.WriteVarint(uint64((u << 1) ^ uint32(int32(u)>>31)))
+	return b.WriteVarInt(uint64((u << 1) ^ uint32(int32(u)>>31)))
 }
 
 // WriteZigzag64 write a uint64 append to the Buffer with zigzag algorithm
 func (b *Buffer) WriteZigzag64(u uint64) int {
-	return b.WriteVarint(uint64((u << 1) ^ uint64(int64(u)>>63)))
+	return b.WriteVarInt(uint64((u << 1) ^ uint64(int64(u)>>63)))
 }
 
-// WriteVarint write a uint64 into buffer with variable length
-func (b *Buffer) WriteVarint(u uint64) int {
+// WriteVarInt write a uint64 into buffer with variable length
+func (b *Buffer) WriteVarInt(u uint64) int {
 	l := 0
 	for u >= 1<<7 {
 		b.WriteByte(uint8(u&0x7f | 0x80))
@@ -143,7 +146,7 @@ func (b *Buffer) grow(n int) {
 	b.buf = buf
 }
 
-// Bytes return a bytes slice of under bytebuffer.
+// Bytes return a bytes slice of under byte buffer.
 func (b *Buffer) Bytes() []byte { return b.buf[:b.wpos] }
 
 // Read read buffer's byte to byte array. return value n is read size.
@@ -206,28 +209,28 @@ func (b *Buffer) ReadUint64() (n uint64, err error) {
 	return n, nil
 }
 
-// ReadZigzag64 read a zigzaged uint64 from buffer.
+// ReadZigzag64 read a zigzag uint64 from buffer.
 func (b *Buffer) ReadZigzag64() (x uint64, err error) {
-	x, err = b.ReadVarint()
+	x, err = b.ReadVarInt()
 	if err != nil {
 		return
 	}
 	x = (x >> 1) ^ uint64(-int64(x&1))
 	return
 }
 
-// ReadZigzag32 read a zigzaged uint32 from buffer.
+// ReadZigzag32 read a zigzag uint32 from buffer.
 func (b *Buffer) ReadZigzag32() (x uint64, err error) {
-	x, err = b.ReadVarint()
+	x, err = b.ReadVarInt()
 	if err != nil {
 		return
 	}
 	x = uint64((uint32(x) >> 1) ^ uint32(-int32(x&1)))
 	return
 }
 
-// ReadVarint read a variable length uint64 form buffer
-func (b *Buffer) ReadVarint() (x uint64, err error) {
+// ReadVarInt read a variable length uint64 form buffer
+func (b *Buffer) ReadVarInt() (x uint64, err error) {
 	var temp byte
 	for offset := uint(0); offset < 64; offset += 7 {
 		temp, err = b.ReadByte()
@@ -280,5 +283,13 @@ func (b *Buffer) Remain() int { return b.wpos - b.rpos }
 // Len return the len of buffer' bytes,
 func (b *Buffer) Len() int { return b.wpos - 0 }
 
-// Cap return the capacity of the under bytebuffer
+// Cap return the capacity of the under byte buffer
 func (b *Buffer) Cap() int { return cap(b.buf) }
+
+// GetContext get breeze context
+func (b *Buffer) GetContext() *Context {
+	if b.context == nil {
+		b.context = &Context{}
+	}
+	return b.context
+}