Fix codec fallback and generate type imports

[govpp.git] / codec / marshaler.go

diff --git a/codec/marshaler.go b/codec/marshaler.go
index c6d33a3..803b0f5 100644 (file)
--- 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))
-}