--- /dev/null
+// Copyright (c) 2020 Cisco and/or its affiliates.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at:
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+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 {
+ Size() int
+ Marshal([]byte) ([]byte, error)
+}
+
+// Unmarshaler is the interface implemented by the binary API messages that can
+// unmarshal a binary representation of itself from the wire.
+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
+}
+
+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
+ }
+
+ return 0, nil
+}
+
+type OldCodec struct{}
+
+func (c *OldCodec) Marshal(v interface{}) (b []byte, err error) {
+ buf := new(bytes.Buffer)
+ if err := struc.Pack(buf, v); err != nil {
+ return nil, err
+ }
+ return buf.Bytes(), nil
+}
+
+func (c *OldCodec) Unmarshal(data []byte, v interface{}) error {
+ buf := bytes.NewReader(data)
+ if err := struc.Unpack(buf, v); 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))
+}
Code Review / govpp.git / blobdiff