path: root/p2p/message.go

package p2p

import (
    // "fmt"
    "github.com/ethereum/go-ethereum/ethutil"
)

type MsgCode uint8

type Msg struct {
    code    MsgCode // this is the raw code as per adaptive msg code scheme
    data    *ethutil.Value
    encoded []byte
}

func (self *Msg) Code() MsgCode {
    return self.code
}

func (self *Msg) Data() *ethutil.Value {
    return self.data
}

func NewMsg(code MsgCode, params ...interface{}) (msg *Msg, err error) {

    // // data := [][]interface{}{}
    // data := []interface{}{}
    // for _, value := range params {
    //  if encodable, ok := value.(ethutil.RlpEncodeDecode); ok {
    //      data = append(data, encodable.RlpValue())
    //  } else if raw, ok := value.([]interface{}); ok {
    //      data = append(data, raw)
    //  } else {
    //      // data = append(data, interface{}(raw))
    //      err = fmt.Errorf("Unable to encode object of type %T", value)
    //      return
    //  }
    // }
    return &Msg{
        code: code,
        data: ethutil.NewValue(interface{}(params)),
    }, nil
}

func NewMsgFromBytes(encoded []byte) (msg *Msg, err error) {
    value := ethutil.NewValueFromBytes(encoded)
    // Type of message
    code := value.Get(0).Uint()
    // Actual data
    data := value.SliceFrom(1)

    msg = &Msg{
        code: MsgCode(code),
        data: data,
        // data:    ethutil.NewValue(data),
        encoded: encoded,
    }
    return
}

func (self *Msg) Decode(offset MsgCode) {
    self.code = self.code - offset
}

// encode takes an offset argument to implement adaptive message coding
// the encoded message is memoized to make msgs relayed to several peers more efficient
func (self *Msg) Encode(offset MsgCode) (res []byte) {
    if len(self.encoded) == 0 {
        res = ethutil.NewValue(append([]interface{}{byte(self.code + offset)}, self.data.Slice()...)).Encode()
        self.encoded = res
    } else {
        res = self.encoded
    }
    return
}