1 files changed, 17 insertions, 176 deletions

diff --git a/codec/marshaler.go b/codec/marshaler.go
index c6d33a3..803b0f5 100644
--- a/codec/marshaler.go
+++ b/codec/marshaler.go
@@ -16,20 +16,13 @@ package codec
 
 import (
 	"bytes"
-	"encoding/binary"
-	"errors"
-	"fmt"
-	"math"
 	"reflect"
-	"unsafe"
 
 	"github.com/lunixbochs/struc"
 
 	"git.fd.io/govpp.git/api"
 )
 
-var DefaultCodec = &NewCodec{} // &MsgCodec{}
-
 // Marshaler is the interface implemented by the binary API messages that can
 // marshal itself into binary form for the wire.
 type Marshaler interface {
@@ -43,187 +36,35 @@ type Unmarshaler interface {
 	Unmarshal([]byte) error
 }
 
-type NewCodec struct{}
-
-func (*NewCodec) EncodeMsg(msg api.Message, msgID uint16) (data []byte, err error) {
-	if msg == nil {
-		return nil, errors.New("nil message passed in")
-	}
-	marshaller, ok := msg.(Marshaler)
-	if !ok {
-		return nil, fmt.Errorf("message %s does not implement marshaller", msg.GetMessageName())
-	}
-
-	size := marshaller.Size()
-	offset := getOffset(msg)
-	//fmt.Printf("size=%d offset=%d\n", size, offset)
-
-	b := make([]byte, size+offset)
-	b[0] = byte(msgID >> 8)
-	b[1] = byte(msgID)
-
-	//fmt.Printf("len(b)=%d cap(b)=%d\n", len(b), cap(b))
-	//b = append(b, byte(msgID>>8), byte(msgID))
-
-	//buf := new(bytes.Buffer)
-	//buf.Grow(size)
-
-	// encode msg ID
-	//buf.WriteByte(byte(msgID >> 8))
-	//buf.WriteByte(byte(msgID))
-
-	data, err = marshaller.Marshal(b[offset:])
-	if err != nil {
-		return nil, err
-	}
-	//buf.Write(b)
-
-	return b[0:len(b):len(b)], nil
-}
-
-func getOffset(msg api.Message) (offset int) {
-	switch msg.GetMessageType() {
-	case api.RequestMessage:
-		return 10
-	case api.ReplyMessage:
-		return 6
-	case api.EventMessage:
-		return 6
-	}
-	return 2
-}
-
-func (*NewCodec) DecodeMsg(data []byte, msg api.Message) (err error) {
-	if msg == nil {
-		return errors.New("nil message passed in")
-	}
-	marshaller, ok := msg.(Unmarshaler)
-	if !ok {
-		return fmt.Errorf("message %s does not implement marshaller", msg.GetMessageName())
-	}
-
-	offset := getOffset(msg)
-
-	err = marshaller.Unmarshal(data[offset:len(data)])
-	if err != nil {
-		return err
-	}
-
-	return nil
+type Wrapper struct {
+	api.Message
 }
 
-func (*NewCodec) DecodeMsgContext(data []byte, msg api.Message) (context uint32, err error) {
-	if msg == nil {
-		return 0, errors.New("nil message passed in")
-	}
-
-	switch msg.GetMessageType() {
-	case api.RequestMessage:
-		return order.Uint32(data[6:10]), nil
-	case api.ReplyMessage:
-		return order.Uint32(data[2:6]), nil
+func (w Wrapper) Size() int {
+	if size, err := struc.Sizeof(w.Message); err != nil {
+		return 0
+	} else {
+		return size
 	}
-
-	return 0, nil
 }
 
-type OldCodec struct{}
-
-func (c *OldCodec) Marshal(v interface{}) (b []byte, err error) {
+func (w Wrapper) Marshal(b []byte) ([]byte, error) {
 	buf := new(bytes.Buffer)
-	if err := struc.Pack(buf, v); err != nil {
-		return nil, err
+	if reflect.TypeOf(w.Message).Elem().NumField() > 0 {
+		if err := struc.Pack(buf, w.Message); err != nil {
+			return nil, err
+		}
+	}
+	if b != nil {
+		copy(b, buf.Bytes())
 	}
 	return buf.Bytes(), nil
 }
 
-func (c *OldCodec) Unmarshal(data []byte, v interface{}) error {
+func (w Wrapper) Unmarshal(data []byte) error {
 	buf := bytes.NewReader(data)
-	if err := struc.Unpack(buf, v); err != nil {
+	if err := struc.Unpack(buf, w.Message); err != nil {
 		return err
 	}
 	return nil
 }
-
-/*type CodecNew struct{}
-
-func (c *CodecNew) Marshal(v interface{}) (b []byte, err error) {
-	buf := new(bytes.Buffer)
-	if err := binary.Write(buf, binary.BigEndian, v); err != nil {
-		return nil, err
-	}
-	return buf.Bytes(), nil
-}*/
-
-func EncodeBool(b bool) byte {
-	if b {
-		return 1
-	}
-	return 0
-}
-
-func MarshalValue(value interface{}) []byte {
-	switch value.(type) {
-	case int8:
-		return []byte{byte(value.(int8))}
-	case uint8:
-		return []byte{byte(value.(uint8))}
-	}
-	return nil
-}
-
-var order = binary.BigEndian
-
-type Buffer struct {
-	pos int
-	buf []byte
-}
-
-func (b *Buffer) Bytes() []byte {
-	return b.buf[:b.pos]
-}
-
-func (b *Buffer) EncodeUint8(v uint8) {
-	b.buf[b.pos] = v
-	b.pos += 1
-}
-
-func (b *Buffer) EncodeUint16(v uint16) {
-	order.PutUint16(b.buf[b.pos:b.pos+2], v)
-	b.pos += 2
-}
-
-func (b *Buffer) EncodeUint32(v uint32) {
-	order.PutUint32(b.buf[b.pos:b.pos+4], v)
-	b.pos += 4
-}
-
-func (b *Buffer) EncodeUint64(v uint64) {
-	order.PutUint64(b.buf[b.pos:b.pos+8], v)
-	b.pos += 8
-}
-
-func (b *Buffer) EncodeFloat64(v float64) {
-	order.PutUint64(b.buf[b.pos:b.pos+8], math.Float64bits(v))
-	b.pos += 8
-}
-
-func (b *Buffer) EncodeBool(v bool) {
-	if v {
-		b.buf[b.pos] = 1
-	} else {
-		b.buf[b.pos] = 0
-	}
-	b.pos += 1
-}
-
-func (b *Buffer) EncodeString(v string) {
-
-	b.pos += 1
-}
-
-func DecodeString(b []byte) string {
-	sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&b))
-	stringHeader := reflect.StringHeader{Data: sliceHeader.Data, Len: sliceHeader.Len}
-	return *(*string)(unsafe.Pointer(&stringHeader))
-}