build all

554325746@qq.com

2019-07-24 fc1623501c41e62c1983ae32fefbed8362b2d909

 commsg.pb.go

@@ -1,11 +1,12 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: commsg.proto

package protomsg

import (
   fmt "fmt"
   proto "github.com/golang/protobuf/proto"
   proto "github.com/gogo/protobuf/proto"
   io "io"
   math "math"
)

@@ -18,15 +19,12 @@
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package

type SdkmsgWithTask struct {
   Ipcid                string   `protobuf:"bytes,1,opt,name=ipcid,proto3" json:"ipcid,omitempty"`
   Sdktype              string   `protobuf:"bytes,2,opt,name=sdktype,proto3" json:"sdktype,omitempty"`
   Sdkdata              []byte   `protobuf:"bytes,4,opt,name=sdkdata,proto3" json:"sdkdata,omitempty"`
   XXX_NoUnkeyedLiteral struct{} `json:"-"`
   XXX_unrecognized     []byte   `json:"-"`
   XXX_sizecache        int32    `json:"-"`
   Ipcid   string `protobuf:"bytes,1,opt,name=ipcid,proto3" json:"ipcid,omitempty"`
   Sdktype string `protobuf:"bytes,2,opt,name=sdktype,proto3" json:"sdktype,omitempty"`
   Sdkdata []byte `protobuf:"bytes,4,opt,name=sdkdata,proto3" json:"sdkdata,omitempty"`
}

func (m *SdkmsgWithTask) Reset()         { *m = SdkmsgWithTask{} }
@@ -35,18 +33,26 @@
func (*SdkmsgWithTask) Descriptor() ([]byte, []int) {
   return fileDescriptor_968fba5e415d8aac, []int{0}
}

func (m *SdkmsgWithTask) XXX_Unmarshal(b []byte) error {
   return xxx_messageInfo_SdkmsgWithTask.Unmarshal(m, b)
   return m.Unmarshal(b)
}
func (m *SdkmsgWithTask) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   return xxx_messageInfo_SdkmsgWithTask.Marshal(b, m, deterministic)
   if deterministic {
      return xxx_messageInfo_SdkmsgWithTask.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
      return b[:n], nil
   }
}
func (m *SdkmsgWithTask) XXX_Merge(src proto.Message) {
   xxx_messageInfo_SdkmsgWithTask.Merge(m, src)
}
func (m *SdkmsgWithTask) XXX_Size() int {
   return xxx_messageInfo_SdkmsgWithTask.Size(m)
   return m.Size()
}
func (m *SdkmsgWithTask) XXX_DiscardUnknown() {
   xxx_messageInfo_SdkmsgWithTask.DiscardUnknown(m)
@@ -76,13 +82,10 @@
}

type TaskLabel struct {
   Taskid               string            `protobuf:"bytes,1,opt,name=taskid,proto3" json:"taskid,omitempty"`
   Taskname             string            `protobuf:"bytes,2,opt,name=taskname,proto3" json:"taskname,omitempty"`
   Sdkinfos             []*SdkmsgWithTask `protobuf:"bytes,3,rep,name=sdkinfos,proto3" json:"sdkinfos,omitempty"`
   Index                int32             `protobuf:"varint,4,opt,name=index,proto3" json:"index,omitempty"`
   XXX_NoUnkeyedLiteral struct{}          `json:"-"`
   XXX_unrecognized     []byte            `json:"-"`
   XXX_sizecache        int32             `json:"-"`
   Taskid   string            `protobuf:"bytes,1,opt,name=taskid,proto3" json:"taskid,omitempty"`
   Taskname string            `protobuf:"bytes,2,opt,name=taskname,proto3" json:"taskname,omitempty"`
   Sdkinfos []*SdkmsgWithTask `protobuf:"bytes,3,rep,name=sdkinfos,proto3" json:"sdkinfos,omitempty"`
   Index    int32             `protobuf:"varint,4,opt,name=index,proto3" json:"index,omitempty"`
}

func (m *TaskLabel) Reset()         { *m = TaskLabel{} }
@@ -91,18 +94,26 @@
func (*TaskLabel) Descriptor() ([]byte, []int) {
   return fileDescriptor_968fba5e415d8aac, []int{1}
}

func (m *TaskLabel) XXX_Unmarshal(b []byte) error {
   return xxx_messageInfo_TaskLabel.Unmarshal(m, b)
   return m.Unmarshal(b)
}
func (m *TaskLabel) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   return xxx_messageInfo_TaskLabel.Marshal(b, m, deterministic)
   if deterministic {
      return xxx_messageInfo_TaskLabel.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
      return b[:n], nil
   }
}
func (m *TaskLabel) XXX_Merge(src proto.Message) {
   xxx_messageInfo_TaskLabel.Merge(m, src)
}
func (m *TaskLabel) XXX_Size() int {
   return xxx_messageInfo_TaskLabel.Size(m)
   return m.Size()
}
func (m *TaskLabel) XXX_DiscardUnknown() {
   xxx_messageInfo_TaskLabel.DiscardUnknown(m)
@@ -139,13 +150,10 @@
}

type SdkMessage struct {
   Cid                  string     `protobuf:"bytes,1,opt,name=cid,proto3" json:"cid,omitempty"`
   Caddr                string     `protobuf:"bytes,2,opt,name=caddr,proto3" json:"caddr,omitempty"`
   Tasklab              *TaskLabel `protobuf:"bytes,3,opt,name=tasklab,proto3" json:"tasklab,omitempty"`
   Data                 []byte     `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"`
   XXX_NoUnkeyedLiteral struct{}   `json:"-"`
   XXX_unrecognized     []byte     `json:"-"`
   XXX_sizecache        int32      `json:"-"`
   Cid     string     `protobuf:"bytes,1,opt,name=cid,proto3" json:"cid,omitempty"`
   Caddr   string     `protobuf:"bytes,2,opt,name=caddr,proto3" json:"caddr,omitempty"`
   Tasklab *TaskLabel `protobuf:"bytes,3,opt,name=tasklab,proto3" json:"tasklab,omitempty"`
   Data    []byte     `protobuf:"bytes,4,opt,name=data,proto3" json:"data,omitempty"`
}

func (m *SdkMessage) Reset()         { *m = SdkMessage{} }
@@ -154,18 +162,26 @@
func (*SdkMessage) Descriptor() ([]byte, []int) {
   return fileDescriptor_968fba5e415d8aac, []int{2}
}

func (m *SdkMessage) XXX_Unmarshal(b []byte) error {
   return xxx_messageInfo_SdkMessage.Unmarshal(m, b)
   return m.Unmarshal(b)
}
func (m *SdkMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   return xxx_messageInfo_SdkMessage.Marshal(b, m, deterministic)
   if deterministic {
      return xxx_messageInfo_SdkMessage.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
      return b[:n], nil
   }
}
func (m *SdkMessage) XXX_Merge(src proto.Message) {
   xxx_messageInfo_SdkMessage.Merge(m, src)
}
func (m *SdkMessage) XXX_Size() int {
   return xxx_messageInfo_SdkMessage.Size(m)
   return m.Size()
}
func (m *SdkMessage) XXX_DiscardUnknown() {
   xxx_messageInfo_SdkMessage.DiscardUnknown(m)
@@ -202,12 +218,9 @@
}

type Recvmsg struct {
   Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
   Addr                 string   `protobuf:"bytes,2,opt,name=addr,proto3" json:"addr,omitempty"`
   Picdata              []byte   `protobuf:"bytes,3,opt,name=picdata,proto3" json:"picdata,omitempty"`
   XXX_NoUnkeyedLiteral struct{} `json:"-"`
   XXX_unrecognized     []byte   `json:"-"`
   XXX_sizecache        int32    `json:"-"`
   Id      string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
   Addr    string `protobuf:"bytes,2,opt,name=addr,proto3" json:"addr,omitempty"`
   Picdata []byte `protobuf:"bytes,3,opt,name=picdata,proto3" json:"picdata,omitempty"`
}

func (m *Recvmsg) Reset()         { *m = Recvmsg{} }
@@ -216,18 +229,26 @@
func (*Recvmsg) Descriptor() ([]byte, []int) {
   return fileDescriptor_968fba5e415d8aac, []int{3}
}

func (m *Recvmsg) XXX_Unmarshal(b []byte) error {
   return xxx_messageInfo_Recvmsg.Unmarshal(m, b)
   return m.Unmarshal(b)
}
func (m *Recvmsg) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   return xxx_messageInfo_Recvmsg.Marshal(b, m, deterministic)
   if deterministic {
      return xxx_messageInfo_Recvmsg.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
      return b[:n], nil
   }
}
func (m *Recvmsg) XXX_Merge(src proto.Message) {
   xxx_messageInfo_Recvmsg.Merge(m, src)
}
func (m *Recvmsg) XXX_Size() int {
   return xxx_messageInfo_Recvmsg.Size(m)
   return m.Size()
}
func (m *Recvmsg) XXX_DiscardUnknown() {
   xxx_messageInfo_Recvmsg.DiscardUnknown(m)
@@ -266,23 +287,1075 @@
func init() { proto.RegisterFile("commsg.proto", fileDescriptor_968fba5e415d8aac) }

var fileDescriptor_968fba5e415d8aac = []byte{
   // 283 bytes of a gzipped FileDescriptorProto
   0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x54, 0x90, 0x4d, 0x4e, 0xc3, 0x30,
   0x10, 0x85, 0x95, 0xa4, 0x6d, 0xd2, 0x69, 0x55, 0xa1, 0x01, 0x21, 0x8b, 0x55, 0x94, 0x55, 0x36,
   0x64, 0x51, 0xb8, 0x03, 0x1b, 0xd8, 0xa4, 0x48, 0x48, 0xec, 0x9c, 0xd8, 0x04, 0xcb, 0x75, 0x12,
   0x65, 0x22, 0x7e, 0xce, 0xc0, 0xa5, 0x91, 0x9d, 0x9f, 0xb6, 0x2b, 0xbf, 0xcf, 0x1e, 0xbf, 0x79,
   0x33, 0xb0, 0x2d, 0x1b, 0x63, 0xa8, 0xca, 0xda, 0xae, 0xe9, 0x1b, 0x8c, 0xdc, 0x61, 0xa8, 0x4a,
   0xde, 0x61, 0x77, 0x10, 0xda, 0x50, 0xf5, 0xa6, 0xfa, 0xcf, 0x57, 0x4e, 0x1a, 0x6f, 0x60, 0xa9,
   0xda, 0x52, 0x09, 0xe6, 0xc5, 0x5e, 0xba, 0xce, 0x07, 0x40, 0x06, 0x21, 0x09, 0xdd, 0xff, 0xb6,
   0x92, 0xf9, 0xee, 0x7e, 0xc2, 0xf1, 0x45, 0xf0, 0x9e, 0xb3, 0x45, 0xec, 0xa5, 0xdb, 0x7c, 0xc2,
   0xe4, 0xcf, 0x83, 0xb5, 0xb5, 0x7c, 0xe6, 0x85, 0x3c, 0xe2, 0x2d, 0xac, 0x7a, 0x4e, 0x7a, 0x36,
   0x1e, 0x09, 0xef, 0x20, 0xb2, 0xaa, 0xe6, 0x66, 0xb2, 0x9e, 0x19, 0x1f, 0x21, 0x22, 0xa1, 0x55,
   0xfd, 0xd1, 0x10, 0x0b, 0xe2, 0x20, 0xdd, 0xec, 0x59, 0x36, 0x45, 0xcf, 0x2e, 0x73, 0xe7, 0x73,
   0xa5, 0x9b, 0xa0, 0x16, 0xf2, 0xc7, 0xe5, 0x59, 0xe6, 0x03, 0x24, 0xdf, 0x00, 0x07, 0xa1, 0x5f,
   0x24, 0x11, 0xaf, 0x24, 0x5e, 0x41, 0x70, 0x9a, 0xd1, 0x4a, 0xfb, 0xab, 0xe4, 0x42, 0x74, 0x63,
   0x88, 0x01, 0xf0, 0x1e, 0x42, 0x9b, 0xe6, 0xc8, 0x0b, 0x16, 0xc4, 0x5e, 0xba, 0xd9, 0x5f, 0x9f,
   0x02, 0xcc, 0xb3, 0xe5, 0x53, 0x0d, 0x22, 0x2c, 0xce, 0x36, 0xe1, 0x74, 0xf2, 0x04, 0x61, 0x27,
   0xcb, 0x2f, 0x43, 0x15, 0xee, 0xc0, 0x9f, 0x9b, 0xfa, 0x4a, 0xd8, 0xf2, 0xb3, 0x96, 0x4e, 0xdb,
   0x7d, 0xb6, 0xaa, 0x74, 0x2e, 0xc1, 0xb0, 0xcf, 0x11, 0x8b, 0x95, 0xeb, 0xfc, 0xf0, 0x1f, 0x00,
   0x00, 0xff, 0xff, 0xf6, 0xc9, 0xa4, 0x99, 0xcc, 0x01, 0x00, 0x00,
   // 315 bytes of a gzipped FileDescriptorProto
   0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x54, 0x90, 0xbb, 0x4e, 0xc3, 0x30,
   0x14, 0x86, 0xeb, 0xa6, 0xd7, 0xd3, 0xaa, 0x42, 0x06, 0x21, 0x8b, 0xc1, 0x8a, 0x32, 0x65, 0xa1,
   0x43, 0xe1, 0x09, 0x58, 0x58, 0x60, 0x49, 0x91, 0x90, 0xd8, 0xdc, 0xd8, 0x04, 0xcb, 0x75, 0x13,
   0xc5, 0x11, 0x97, 0x67, 0x60, 0xe1, 0xb1, 0x18, 0x3b, 0x32, 0xa2, 0xe4, 0x45, 0x90, 0x9d, 0x4b,
   0xcb, 0xe4, 0xff, 0xb3, 0x8f, 0xff, 0xf3, 0x9f, 0x03, 0xf3, 0x38, 0xd5, 0xda, 0x24, 0xcb, 0x2c,
   0x4f, 0x8b, 0x14, 0x4f, 0xdc, 0xa1, 0x4d, 0x12, 0x3c, 0xc1, 0x62, 0xcd, 0x95, 0x36, 0xc9, 0xa3,
   0x2c, 0x5e, 0x1e, 0x98, 0x51, 0xf8, 0x0c, 0x86, 0x32, 0x8b, 0x25, 0x27, 0xc8, 0x47, 0xe1, 0x34,
   0xaa, 0x01, 0x13, 0x18, 0x1b, 0xae, 0x8a, 0x8f, 0x4c, 0x90, 0xbe, 0xbb, 0x6f, 0xb1, 0x79, 0xe1,
   0xac, 0x60, 0x64, 0xe0, 0xa3, 0x70, 0x1e, 0xb5, 0x18, 0x7c, 0x22, 0x98, 0x5a, 0xcb, 0x3b, 0xb6,
   0x11, 0x5b, 0x7c, 0x0e, 0xa3, 0x82, 0x19, 0xd5, 0x19, 0x37, 0x84, 0x2f, 0x60, 0x62, 0xd5, 0x8e,
   0xe9, 0xd6, 0xba, 0x63, 0x7c, 0x0d, 0x13, 0xc3, 0x95, 0xdc, 0x3d, 0xa7, 0x86, 0x78, 0xbe, 0x17,
   0xce, 0x56, 0x64, 0xd9, 0x46, 0x5f, 0xfe, 0xcf, 0x1d, 0x75, 0x95, 0x6e, 0x82, 0x1d, 0x17, 0xef,
   0x2e, 0xcf, 0x30, 0xaa, 0x21, 0x78, 0x03, 0x58, 0x73, 0x75, 0x2f, 0x8c, 0x61, 0x89, 0xc0, 0x27,
   0xe0, 0x1d, 0x66, 0xb4, 0xd2, 0xfe, 0x8a, 0x19, 0xe7, 0x79, 0x13, 0xa2, 0x06, 0x7c, 0x09, 0x63,
   0x9b, 0x66, 0xcb, 0x36, 0xc4, 0xf3, 0x51, 0x38, 0x5b, 0x9d, 0x1e, 0x02, 0x74, 0xb3, 0x45, 0x6d,
   0x0d, 0xc6, 0x30, 0x38, 0xda, 0x84, 0xd3, 0xc1, 0x2d, 0x8c, 0x73, 0x11, 0xbf, 0x6a, 0x93, 0xe0,
   0x05, 0xf4, 0xbb, 0xa6, 0x7d, 0xc9, 0x6d, 0xf9, 0x51, 0x4b, 0xa7, 0xed, 0x3e, 0x33, 0x19, 0x3b,
   0x17, 0xaf, 0xde, 0x67, 0x83, 0x37, 0xe4, 0xbb, 0xa4, 0x68, 0x5f, 0x52, 0xf4, 0x5b, 0x52, 0xf4,
   0x55, 0xd1, 0xde, 0xbe, 0xa2, 0xbd, 0x9f, 0x8a, 0xf6, 0x36, 0x23, 0x97, 0xe9, 0xea, 0x2f, 0x00,
   0x00, 0xff, 0xff, 0xc8, 0x63, 0xfd, 0xdb, 0xe6, 0x01, 0x00, 0x00,
}

func (m *SdkmsgWithTask) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalTo(dAtA)
   if err != nil {
      return nil, err
   }
   return dAtA[:n], nil
}

func (m *SdkmsgWithTask) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if len(m.Ipcid) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintCommsg(dAtA, i, uint64(len(m.Ipcid)))
      i += copy(dAtA[i:], m.Ipcid)
   }
   if len(m.Sdktype) > 0 {
      dAtA[i] = 0x12
      i++
      i = encodeVarintCommsg(dAtA, i, uint64(len(m.Sdktype)))
      i += copy(dAtA[i:], m.Sdktype)
   }
   if len(m.Sdkdata) > 0 {
      dAtA[i] = 0x22
      i++
      i = encodeVarintCommsg(dAtA, i, uint64(len(m.Sdkdata)))
      i += copy(dAtA[i:], m.Sdkdata)
   }
   return i, nil
}

func (m *TaskLabel) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalTo(dAtA)
   if err != nil {
      return nil, err
   }
   return dAtA[:n], nil
}

func (m *TaskLabel) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if len(m.Taskid) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintCommsg(dAtA, i, uint64(len(m.Taskid)))
      i += copy(dAtA[i:], m.Taskid)
   }
   if len(m.Taskname) > 0 {
      dAtA[i] = 0x12
      i++
      i = encodeVarintCommsg(dAtA, i, uint64(len(m.Taskname)))
      i += copy(dAtA[i:], m.Taskname)
   }
   if len(m.Sdkinfos) > 0 {
      for _, msg := range m.Sdkinfos {
         dAtA[i] = 0x1a
         i++
         i = encodeVarintCommsg(dAtA, i, uint64(msg.Size()))
         n, err := msg.MarshalTo(dAtA[i:])
         if err != nil {
            return 0, err
         }
         i += n
      }
   }
   if m.Index != 0 {
      dAtA[i] = 0x20
      i++
      i = encodeVarintCommsg(dAtA, i, uint64(m.Index))
   }
   return i, nil
}

func (m *SdkMessage) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalTo(dAtA)
   if err != nil {
      return nil, err
   }
   return dAtA[:n], nil
}

func (m *SdkMessage) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if len(m.Cid) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintCommsg(dAtA, i, uint64(len(m.Cid)))
      i += copy(dAtA[i:], m.Cid)
   }
   if len(m.Caddr) > 0 {
      dAtA[i] = 0x12
      i++
      i = encodeVarintCommsg(dAtA, i, uint64(len(m.Caddr)))
      i += copy(dAtA[i:], m.Caddr)
   }
   if m.Tasklab != nil {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintCommsg(dAtA, i, uint64(m.Tasklab.Size()))
      n1, err1 := m.Tasklab.MarshalTo(dAtA[i:])
      if err1 != nil {
         return 0, err1
      }
      i += n1
   }
   if len(m.Data) > 0 {
      dAtA[i] = 0x22
      i++
      i = encodeVarintCommsg(dAtA, i, uint64(len(m.Data)))
      i += copy(dAtA[i:], m.Data)
   }
   return i, nil
}

func (m *Recvmsg) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalTo(dAtA)
   if err != nil {
      return nil, err
   }
   return dAtA[:n], nil
}

func (m *Recvmsg) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if len(m.Id) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintCommsg(dAtA, i, uint64(len(m.Id)))
      i += copy(dAtA[i:], m.Id)
   }
   if len(m.Addr) > 0 {
      dAtA[i] = 0x12
      i++
      i = encodeVarintCommsg(dAtA, i, uint64(len(m.Addr)))
      i += copy(dAtA[i:], m.Addr)
   }
   if len(m.Picdata) > 0 {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintCommsg(dAtA, i, uint64(len(m.Picdata)))
      i += copy(dAtA[i:], m.Picdata)
   }
   return i, nil
}

func encodeVarintCommsg(dAtA []byte, offset int, v uint64) int {
   for v >= 1<<7 {
      dAtA[offset] = uint8(v&0x7f | 0x80)
      v >>= 7
      offset++
   }
   dAtA[offset] = uint8(v)
   return offset + 1
}
func (m *SdkmsgWithTask) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   l = len(m.Ipcid)
   if l > 0 {
      n += 1 + l + sovCommsg(uint64(l))
   }
   l = len(m.Sdktype)
   if l > 0 {
      n += 1 + l + sovCommsg(uint64(l))
   }
   l = len(m.Sdkdata)
   if l > 0 {
      n += 1 + l + sovCommsg(uint64(l))
   }
   return n
}

func (m *TaskLabel) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   l = len(m.Taskid)
   if l > 0 {
      n += 1 + l + sovCommsg(uint64(l))
   }
   l = len(m.Taskname)
   if l > 0 {
      n += 1 + l + sovCommsg(uint64(l))
   }
   if len(m.Sdkinfos) > 0 {
      for _, e := range m.Sdkinfos {
         l = e.Size()
         n += 1 + l + sovCommsg(uint64(l))
      }
   }
   if m.Index != 0 {
      n += 1 + sovCommsg(uint64(m.Index))
   }
   return n
}

func (m *SdkMessage) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   l = len(m.Cid)
   if l > 0 {
      n += 1 + l + sovCommsg(uint64(l))
   }
   l = len(m.Caddr)
   if l > 0 {
      n += 1 + l + sovCommsg(uint64(l))
   }
   if m.Tasklab != nil {
      l = m.Tasklab.Size()
      n += 1 + l + sovCommsg(uint64(l))
   }
   l = len(m.Data)
   if l > 0 {
      n += 1 + l + sovCommsg(uint64(l))
   }
   return n
}

func (m *Recvmsg) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   l = len(m.Id)
   if l > 0 {
      n += 1 + l + sovCommsg(uint64(l))
   }
   l = len(m.Addr)
   if l > 0 {
      n += 1 + l + sovCommsg(uint64(l))
   }
   l = len(m.Picdata)
   if l > 0 {
      n += 1 + l + sovCommsg(uint64(l))
   }
   return n
}

func sovCommsg(x uint64) (n int) {
   for {
      n++
      x >>= 7
      if x == 0 {
         break
      }
   }
   return n
}
func sozCommsg(x uint64) (n int) {
   return sovCommsg(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *SdkmsgWithTask) Unmarshal(dAtA []byte) error {
   l := len(dAtA)
   iNdEx := 0
   for iNdEx < l {
      preIndex := iNdEx
      var wire uint64
      for shift := uint(0); ; shift += 7 {
         if shift >= 64 {
            return ErrIntOverflowCommsg
         }
         if iNdEx >= l {
            return io.ErrUnexpectedEOF
         }
         b := dAtA[iNdEx]
         iNdEx++
         wire |= uint64(b&0x7F) << shift
         if b < 0x80 {
            break
         }
      }
      fieldNum := int32(wire >> 3)
      wireType := int(wire & 0x7)
      if wireType == 4 {
         return fmt.Errorf("proto: SdkmsgWithTask: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: SdkmsgWithTask: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Ipcid", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowCommsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthCommsg
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthCommsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Ipcid = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Sdktype", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowCommsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthCommsg
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthCommsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Sdktype = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 4:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Sdkdata", wireType)
         }
         var byteLen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowCommsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            byteLen |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if byteLen < 0 {
            return ErrInvalidLengthCommsg
         }
         postIndex := iNdEx + byteLen
         if postIndex < 0 {
            return ErrInvalidLengthCommsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Sdkdata = append(m.Sdkdata[:0], dAtA[iNdEx:postIndex]...)
         if m.Sdkdata == nil {
            m.Sdkdata = []byte{}
         }
         iNdEx = postIndex
      default:
         iNdEx = preIndex
         skippy, err := skipCommsg(dAtA[iNdEx:])
         if err != nil {
            return err
         }
         if skippy < 0 {
            return ErrInvalidLengthCommsg
         }
         if (iNdEx + skippy) < 0 {
            return ErrInvalidLengthCommsg
         }
         if (iNdEx + skippy) > l {
            return io.ErrUnexpectedEOF
         }
         iNdEx += skippy
      }
   }

   if iNdEx > l {
      return io.ErrUnexpectedEOF
   }
   return nil
}
func (m *TaskLabel) Unmarshal(dAtA []byte) error {
   l := len(dAtA)
   iNdEx := 0
   for iNdEx < l {
      preIndex := iNdEx
      var wire uint64
      for shift := uint(0); ; shift += 7 {
         if shift >= 64 {
            return ErrIntOverflowCommsg
         }
         if iNdEx >= l {
            return io.ErrUnexpectedEOF
         }
         b := dAtA[iNdEx]
         iNdEx++
         wire |= uint64(b&0x7F) << shift
         if b < 0x80 {
            break
         }
      }
      fieldNum := int32(wire >> 3)
      wireType := int(wire & 0x7)
      if wireType == 4 {
         return fmt.Errorf("proto: TaskLabel: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: TaskLabel: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Taskid", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowCommsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthCommsg
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthCommsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Taskid = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Taskname", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowCommsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthCommsg
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthCommsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Taskname = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 3:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Sdkinfos", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowCommsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            msglen |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if msglen < 0 {
            return ErrInvalidLengthCommsg
         }
         postIndex := iNdEx + msglen
         if postIndex < 0 {
            return ErrInvalidLengthCommsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Sdkinfos = append(m.Sdkinfos, &SdkmsgWithTask{})
         if err := m.Sdkinfos[len(m.Sdkinfos)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      case 4:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
         }
         m.Index = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowCommsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.Index |= int32(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      default:
         iNdEx = preIndex
         skippy, err := skipCommsg(dAtA[iNdEx:])
         if err != nil {
            return err
         }
         if skippy < 0 {
            return ErrInvalidLengthCommsg
         }
         if (iNdEx + skippy) < 0 {
            return ErrInvalidLengthCommsg
         }
         if (iNdEx + skippy) > l {
            return io.ErrUnexpectedEOF
         }
         iNdEx += skippy
      }
   }

   if iNdEx > l {
      return io.ErrUnexpectedEOF
   }
   return nil
}
func (m *SdkMessage) Unmarshal(dAtA []byte) error {
   l := len(dAtA)
   iNdEx := 0
   for iNdEx < l {
      preIndex := iNdEx
      var wire uint64
      for shift := uint(0); ; shift += 7 {
         if shift >= 64 {
            return ErrIntOverflowCommsg
         }
         if iNdEx >= l {
            return io.ErrUnexpectedEOF
         }
         b := dAtA[iNdEx]
         iNdEx++
         wire |= uint64(b&0x7F) << shift
         if b < 0x80 {
            break
         }
      }
      fieldNum := int32(wire >> 3)
      wireType := int(wire & 0x7)
      if wireType == 4 {
         return fmt.Errorf("proto: SdkMessage: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: SdkMessage: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Cid", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowCommsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthCommsg
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthCommsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Cid = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Caddr", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowCommsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthCommsg
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthCommsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Caddr = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 3:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Tasklab", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowCommsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            msglen |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if msglen < 0 {
            return ErrInvalidLengthCommsg
         }
         postIndex := iNdEx + msglen
         if postIndex < 0 {
            return ErrInvalidLengthCommsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         if m.Tasklab == nil {
            m.Tasklab = &TaskLabel{}
         }
         if err := m.Tasklab.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      case 4:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
         }
         var byteLen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowCommsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            byteLen |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if byteLen < 0 {
            return ErrInvalidLengthCommsg
         }
         postIndex := iNdEx + byteLen
         if postIndex < 0 {
            return ErrInvalidLengthCommsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
         if m.Data == nil {
            m.Data = []byte{}
         }
         iNdEx = postIndex
      default:
         iNdEx = preIndex
         skippy, err := skipCommsg(dAtA[iNdEx:])
         if err != nil {
            return err
         }
         if skippy < 0 {
            return ErrInvalidLengthCommsg
         }
         if (iNdEx + skippy) < 0 {
            return ErrInvalidLengthCommsg
         }
         if (iNdEx + skippy) > l {
            return io.ErrUnexpectedEOF
         }
         iNdEx += skippy
      }
   }

   if iNdEx > l {
      return io.ErrUnexpectedEOF
   }
   return nil
}
func (m *Recvmsg) Unmarshal(dAtA []byte) error {
   l := len(dAtA)
   iNdEx := 0
   for iNdEx < l {
      preIndex := iNdEx
      var wire uint64
      for shift := uint(0); ; shift += 7 {
         if shift >= 64 {
            return ErrIntOverflowCommsg
         }
         if iNdEx >= l {
            return io.ErrUnexpectedEOF
         }
         b := dAtA[iNdEx]
         iNdEx++
         wire |= uint64(b&0x7F) << shift
         if b < 0x80 {
            break
         }
      }
      fieldNum := int32(wire >> 3)
      wireType := int(wire & 0x7)
      if wireType == 4 {
         return fmt.Errorf("proto: recvmsg: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: recvmsg: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowCommsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthCommsg
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthCommsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Id = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Addr", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowCommsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthCommsg
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthCommsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Addr = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 3:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Picdata", wireType)
         }
         var byteLen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowCommsg
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            byteLen |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if byteLen < 0 {
            return ErrInvalidLengthCommsg
         }
         postIndex := iNdEx + byteLen
         if postIndex < 0 {
            return ErrInvalidLengthCommsg
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Picdata = append(m.Picdata[:0], dAtA[iNdEx:postIndex]...)
         if m.Picdata == nil {
            m.Picdata = []byte{}
         }
         iNdEx = postIndex
      default:
         iNdEx = preIndex
         skippy, err := skipCommsg(dAtA[iNdEx:])
         if err != nil {
            return err
         }
         if skippy < 0 {
            return ErrInvalidLengthCommsg
         }
         if (iNdEx + skippy) < 0 {
            return ErrInvalidLengthCommsg
         }
         if (iNdEx + skippy) > l {
            return io.ErrUnexpectedEOF
         }
         iNdEx += skippy
      }
   }

   if iNdEx > l {
      return io.ErrUnexpectedEOF
   }
   return nil
}
func skipCommsg(dAtA []byte) (n int, err error) {
   l := len(dAtA)
   iNdEx := 0
   for iNdEx < l {
      var wire uint64
      for shift := uint(0); ; shift += 7 {
         if shift >= 64 {
            return 0, ErrIntOverflowCommsg
         }
         if iNdEx >= l {
            return 0, io.ErrUnexpectedEOF
         }
         b := dAtA[iNdEx]
         iNdEx++
         wire |= (uint64(b) & 0x7F) << shift
         if b < 0x80 {
            break
         }
      }
      wireType := int(wire & 0x7)
      switch wireType {
      case 0:
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return 0, ErrIntOverflowCommsg
            }
            if iNdEx >= l {
               return 0, io.ErrUnexpectedEOF
            }
            iNdEx++
            if dAtA[iNdEx-1] < 0x80 {
               break
            }
         }
         return iNdEx, nil
      case 1:
         iNdEx += 8
         return iNdEx, nil
      case 2:
         var length int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return 0, ErrIntOverflowCommsg
            }
            if iNdEx >= l {
               return 0, io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            length |= (int(b) & 0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if length < 0 {
            return 0, ErrInvalidLengthCommsg
         }
         iNdEx += length
         if iNdEx < 0 {
            return 0, ErrInvalidLengthCommsg
         }
         return iNdEx, nil
      case 3:
         for {
            var innerWire uint64
            var start int = iNdEx
            for shift := uint(0); ; shift += 7 {
               if shift >= 64 {
                  return 0, ErrIntOverflowCommsg
               }
               if iNdEx >= l {
                  return 0, io.ErrUnexpectedEOF
               }
               b := dAtA[iNdEx]
               iNdEx++
               innerWire |= (uint64(b) & 0x7F) << shift
               if b < 0x80 {
                  break
               }
            }
            innerWireType := int(innerWire & 0x7)
            if innerWireType == 4 {
               break
            }
            next, err := skipCommsg(dAtA[start:])
            if err != nil {
               return 0, err
            }
            iNdEx = start + next
            if iNdEx < 0 {
               return 0, ErrInvalidLengthCommsg
            }
         }
         return iNdEx, nil
      case 4:
         return iNdEx, nil
      case 5:
         iNdEx += 4
         return iNdEx, nil
      default:
         return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
      }
   }
   panic("unreachable")
}

var (
   ErrInvalidLengthCommsg = fmt.Errorf("proto: negative length found during unmarshaling")
   ErrIntOverflowCommsg   = fmt.Errorf("proto: integer overflow")
)