请问可以和protobuf结合使用吗？ about link HOT 7 CLOSED

package main

import (
    "io"
    "sync"

    "github.com/funny/binary"
    "github.com/funny/link"
    "github.com/golang/protobuf/proto"
)

func main() {
    serverInitWait.Add(1)
    serverStopWait.Add(1)
    go server()
    go client()
    serverStopWait.Wait()
}

var (
    serverAddr     string
    serverInitWait sync.WaitGroup
    serverStopWait sync.WaitGroup
)

func server() {
    server, err := link.Serve("tcp", "0.0.0.0:0", link.Packet(link.Uint16BE, ProtobufCodec{}))
    if err != nil {
        panic(err)
    }
    serverAddr = server.Listener().Addr().String()
    serverInitWait.Done()

    session, err := server.Accept()
    if err != nil {
        panic(err)
    }

    newTest := &Test{}
    err = session.Receive(newTest)
    if err != nil {
        panic(err)
    }

    if newTest.GetLabel() != "hello" {
        println("data mismatch %q != 'hello'")
    } else {
        println("done")
    }

    session.Close()
    server.Stop()

    serverStopWait.Done()
}

func client() {
    serverInitWait.Wait()
    client, err := link.Connect("tcp", serverAddr, link.Packet(link.Uint16BE, ProtobufCodec{}))
    if err != nil {
        panic(err)
    }

    err = client.Send(&Test{
        Label: proto.String("hello"),
        Type:  proto.Int32(17),
        Optionalgroup: &Test_OptionalGroup{
            RequiredField: proto.String("good bye"),
        },
    })

    if err != nil {
        panic(err)
    }

    client.Close()
}

type ProtobufCodec struct {
}

func (_ ProtobufCodec) NewEncoder(w io.Writer) link.Encoder {
    return ProtobufEncoder{
        writer: w.(*binary.PacketWriter),
    }
}

func (_ ProtobufCodec) NewDecoder(r io.Reader) link.Decoder {
    return ProtobufDecoder{
        reader: r.(*binary.PacketReader),
    }
}

type ProtobufEncoder struct {
    writer io.Writer
}

func (pe ProtobufEncoder) Encode(msg interface{}) error {
    data, err := proto.Marshal(msg.(proto.Message))
    if err != nil {
        return err
    }
    _, err = pe.writer.Write(data)
    return err
}

type ProtobufDecoder struct {
    reader *binary.PacketReader
}

func (pe ProtobufDecoder) Decode(msg interface{}) error {
    data, err := pe.reader.ReadPacket()
    if err != nil {
        return err
    }
    return proto.Unmarshal(data, msg.(proto.Message))
}

// Code generated by protoc-gen-go.
// source: test.proto
// DO NOT EDIT!

/*
Package example is a generated protocol buffer package.

It is generated from these files:
    test.proto

It has these top-level messages:
    Test
*/
package main

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

type FOO int32

const (
    FOO_X FOO = 17
)

var FOO_name = map[int32]string{
    17: "X",
}
var FOO_value = map[string]int32{
    "X": 17,
}

func (x FOO) Enum() *FOO {
    p := new(FOO)
    *p = x
    return p
}
func (x FOO) String() string {
    return proto.EnumName(FOO_name, int32(x))
}
func (x *FOO) UnmarshalJSON(data []byte) error {
    value, err := proto.UnmarshalJSONEnum(FOO_value, data, "FOO")
    if err != nil {
        return err
    }
    *x = FOO(value)
    return nil
}

type Test struct {
    Label            *string             `protobuf:"bytes,1,req,name=label" json:"label,omitempty"`
    Type             *int32              `protobuf:"varint,2,opt,name=type,def=77" json:"type,omitempty"`
    Reps             []int64             `protobuf:"varint,3,rep,name=reps" json:"reps,omitempty"`
    Optionalgroup    *Test_OptionalGroup `protobuf:"group,4,opt,name=OptionalGroup" json:"optionalgroup,omitempty"`
    XXX_unrecognized []byte              `json:"-"`
}

func (m *Test) Reset()         { *m = Test{} }
func (m *Test) String() string { return proto.CompactTextString(m) }
func (*Test) ProtoMessage()    {}

const Default_Test_Type int32 = 77

func (m *Test) GetLabel() string {
    if m != nil && m.Label != nil {
        return *m.Label
    }
    return ""
}

func (m *Test) GetType() int32 {
    if m != nil && m.Type != nil {
        return *m.Type
    }
    return Default_Test_Type
}

func (m *Test) GetReps() []int64 {
    if m != nil {
        return m.Reps
    }
    return nil
}

func (m *Test) GetOptionalgroup() *Test_OptionalGroup {
    if m != nil {
        return m.Optionalgroup
    }
    return nil
}

type Test_OptionalGroup struct {
    RequiredField    *string `protobuf:"bytes,5,req" json:"RequiredField,omitempty"`
    XXX_unrecognized []byte  `json:"-"`
}

func (m *Test_OptionalGroup) Reset()         { *m = Test_OptionalGroup{} }
func (m *Test_OptionalGroup) String() string { return proto.CompactTextString(m) }
func (*Test_OptionalGroup) ProtoMessage()    {}

func (m *Test_OptionalGroup) GetRequiredField() string {
    if m != nil && m.RequiredField != nil {
        return *m.RequiredField
    }
    return ""
}

func init() {
    proto.RegisterEnum("example.FOO", FOO_name, FOO_value)
}