使用统一的版本protobufV2

cheliequan

2023-02-10 5f1e6cdae7c31ecbc82d05095c44b36a4e351726

 commsg.pb.go

@@ -6,9 +6,7 @@
import (
   fmt "fmt"
   proto "github.com/gogo/protobuf/proto"
   io "io"
   math "math"
   math_bits "math/bits"
)

// Reference imports to suppress errors if they are not otherwise used.
@@ -23,9 +21,12 @@
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"`
   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:"-"`
}

func (m *SdkmsgWithTask) Reset()         { *m = SdkmsgWithTask{} }
@@ -35,25 +36,16 @@
   return fileDescriptor_968fba5e415d8aac, []int{0}
}
func (m *SdkmsgWithTask) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
   return xxx_messageInfo_SdkmsgWithTask.Unmarshal(m, b)
}
func (m *SdkmsgWithTask) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   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
   }
   return xxx_messageInfo_SdkmsgWithTask.Marshal(b, m, deterministic)
}
func (m *SdkmsgWithTask) XXX_Merge(src proto.Message) {
   xxx_messageInfo_SdkmsgWithTask.Merge(m, src)
}
func (m *SdkmsgWithTask) XXX_Size() int {
   return m.Size()
   return xxx_messageInfo_SdkmsgWithTask.Size(m)
}
func (m *SdkmsgWithTask) XXX_DiscardUnknown() {
   xxx_messageInfo_SdkmsgWithTask.DiscardUnknown(m)
@@ -83,10 +75,13 @@
}

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"`
   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:"-"`
}

func (m *TaskLabel) Reset()         { *m = TaskLabel{} }
@@ -96,25 +91,16 @@
   return fileDescriptor_968fba5e415d8aac, []int{1}
}
func (m *TaskLabel) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
   return xxx_messageInfo_TaskLabel.Unmarshal(m, b)
}
func (m *TaskLabel) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   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
   }
   return xxx_messageInfo_TaskLabel.Marshal(b, m, deterministic)
}
func (m *TaskLabel) XXX_Merge(src proto.Message) {
   xxx_messageInfo_TaskLabel.Merge(m, src)
}
func (m *TaskLabel) XXX_Size() int {
   return m.Size()
   return xxx_messageInfo_TaskLabel.Size(m)
}
func (m *TaskLabel) XXX_DiscardUnknown() {
   xxx_messageInfo_TaskLabel.DiscardUnknown(m)
@@ -151,11 +137,14 @@
}

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"`
   Push    *PushAttach `protobuf:"bytes,5,opt,name=push,proto3" json:"push,omitempty"`
   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"`
   Push                 *PushAttach `protobuf:"bytes,5,opt,name=push,proto3" json:"push,omitempty"`
   XXX_NoUnkeyedLiteral struct{}    `json:"-"`
   XXX_unrecognized     []byte      `json:"-"`
   XXX_sizecache        int32       `json:"-"`
}

func (m *SdkMessage) Reset()         { *m = SdkMessage{} }
@@ -165,25 +154,16 @@
   return fileDescriptor_968fba5e415d8aac, []int{2}
}
func (m *SdkMessage) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
   return xxx_messageInfo_SdkMessage.Unmarshal(m, b)
}
func (m *SdkMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   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
   }
   return xxx_messageInfo_SdkMessage.Marshal(b, m, deterministic)
}
func (m *SdkMessage) XXX_Merge(src proto.Message) {
   xxx_messageInfo_SdkMessage.Merge(m, src)
}
func (m *SdkMessage) XXX_Size() int {
   return m.Size()
   return xxx_messageInfo_SdkMessage.Size(m)
}
func (m *SdkMessage) XXX_DiscardUnknown() {
   xxx_messageInfo_SdkMessage.DiscardUnknown(m)
@@ -227,9 +207,12 @@
}

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"`
   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:"-"`
}

func (m *Recvmsg) Reset()         { *m = Recvmsg{} }
@@ -239,25 +222,16 @@
   return fileDescriptor_968fba5e415d8aac, []int{3}
}
func (m *Recvmsg) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
   return xxx_messageInfo_Recvmsg.Unmarshal(m, b)
}
func (m *Recvmsg) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   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
   }
   return xxx_messageInfo_Recvmsg.Marshal(b, m, deterministic)
}
func (m *Recvmsg) XXX_Merge(src proto.Message) {
   xxx_messageInfo_Recvmsg.Merge(m, src)
}
func (m *Recvmsg) XXX_Size() int {
   return m.Size()
   return xxx_messageInfo_Recvmsg.Size(m)
}
func (m *Recvmsg) XXX_DiscardUnknown() {
   xxx_messageInfo_Recvmsg.DiscardUnknown(m)
@@ -287,9 +261,14 @@
}

type RuleMessage 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"`
   Sdkmsg   *SdkMessage `protobuf:"bytes,3,opt,name=sdkmsg,proto3" json:"sdkmsg,omitempty"`
   Taskid               string        `protobuf:"bytes,1,opt,name=taskid,proto3" json:"taskid,omitempty"`
   Taskname             string        `protobuf:"bytes,2,opt,name=taskname,proto3" json:"taskname,omitempty"`
   Msgtype              string        `protobuf:"bytes,3,opt,name=msgtype,proto3" json:"msgtype,omitempty"`
   Sdkmsg               *SdkMessage   `protobuf:"bytes,4,opt,name=sdkmsg,proto3" json:"sdkmsg,omitempty"`
   Alarmmsg             *AlarmMessage `protobuf:"bytes,5,opt,name=alarmmsg,proto3" json:"alarmmsg,omitempty"`
   XXX_NoUnkeyedLiteral struct{}      `json:"-"`
   XXX_unrecognized     []byte        `json:"-"`
   XXX_sizecache        int32         `json:"-"`
}

func (m *RuleMessage) Reset()         { *m = RuleMessage{} }
@@ -299,25 +278,16 @@
   return fileDescriptor_968fba5e415d8aac, []int{4}
}
func (m *RuleMessage) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
   return xxx_messageInfo_RuleMessage.Unmarshal(m, b)
}
func (m *RuleMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   if deterministic {
      return xxx_messageInfo_RuleMessage.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalTo(b)
      if err != nil {
         return nil, err
      }
      return b[:n], nil
   }
   return xxx_messageInfo_RuleMessage.Marshal(b, m, deterministic)
}
func (m *RuleMessage) XXX_Merge(src proto.Message) {
   xxx_messageInfo_RuleMessage.Merge(m, src)
}
func (m *RuleMessage) XXX_Size() int {
   return m.Size()
   return xxx_messageInfo_RuleMessage.Size(m)
}
func (m *RuleMessage) XXX_DiscardUnknown() {
   xxx_messageInfo_RuleMessage.DiscardUnknown(m)
@@ -339,9 +309,23 @@
   return ""
}

func (m *RuleMessage) GetMsgtype() string {
   if m != nil {
      return m.Msgtype
   }
   return ""
}

func (m *RuleMessage) GetSdkmsg() *SdkMessage {
   if m != nil {
      return m.Sdkmsg
   }
   return nil
}

func (m *RuleMessage) GetAlarmmsg() *AlarmMessage {
   if m != nil {
      return m.Alarmmsg
   }
   return nil
}
@@ -357,1336 +341,29 @@
func init() { proto.RegisterFile("commsg.proto", fileDescriptor_968fba5e415d8aac) }

var fileDescriptor_968fba5e415d8aac = []byte{
   // 374 bytes of a gzipped FileDescriptorProto
   0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x50, 0x3d, 0x4e, 0xf3, 0x40,
   0x14, 0xcc, 0xc6, 0xf9, 0x7d, 0x89, 0xa2, 0x4f, 0xfb, 0x45, 0x9f, 0x56, 0x29, 0x2c, 0xcb, 0x95,
   0x8b, 0x8f, 0x14, 0x81, 0x0b, 0x40, 0x43, 0x03, 0x12, 0xda, 0x20, 0x21, 0xd1, 0x6d, 0xbc, 0xc6,
   0xb6, 0x1c, 0xc7, 0x56, 0x9e, 0x83, 0xe0, 0x0c, 0x34, 0x5c, 0x81, 0xdb, 0x50, 0xa6, 0xa4, 0x44,
   0xc9, 0x45, 0xd0, 0xae, 0xd7, 0x4e, 0xd2, 0x52, 0x79, 0xc6, 0xef, 0xbd, 0xd9, 0x99, 0x81, 0xa1,
   0x9f, 0xa5, 0x29, 0x86, 0xd3, 0x7c, 0x9d, 0x15, 0x19, 0xed, 0xe9, 0x4f, 0x8a, 0xe1, 0x64, 0x54,
   0xa1, 0x72, 0xe2, 0x3e, 0xc2, 0x68, 0x2e, 0x93, 0x14, 0xc3, 0x87, 0xb8, 0x88, 0xee, 0x05, 0x26,
   0x74, 0x0c, 0xed, 0x38, 0xf7, 0x63, 0xc9, 0x88, 0x43, 0xbc, 0x3e, 0x2f, 0x09, 0x65, 0xd0, 0x45,
   0x99, 0x14, 0xaf, 0x79, 0xc0, 0x9a, 0xfa, 0x7f, 0x45, 0xcd, 0x44, 0x8a, 0x42, 0xb0, 0x96, 0x43,
   0xbc, 0x21, 0xaf, 0xa8, 0xfb, 0x46, 0xa0, 0xaf, 0x24, 0x6f, 0xc4, 0x22, 0x58, 0xd2, 0x7f, 0xd0,
   0x29, 0x04, 0x26, 0xb5, 0xb0, 0x61, 0x74, 0x02, 0x3d, 0x85, 0x56, 0x22, 0xad, 0xa4, 0x6b, 0x4e,
   0x2f, 0xa0, 0x87, 0x32, 0x89, 0x57, 0x4f, 0x19, 0x32, 0xcb, 0xb1, 0xbc, 0xc1, 0x8c, 0x4d, 0xeb,
   0x00, 0xa7, 0xbe, 0x79, 0xbd, 0xa9, 0x13, 0xac, 0x64, 0xf0, 0xa2, 0xfd, 0xb4, 0x79, 0x49, 0xdc,
   0x0f, 0x02, 0x30, 0x97, 0xc9, 0x6d, 0x80, 0x28, 0xc2, 0x80, 0xfe, 0x01, 0xeb, 0x10, 0x52, 0x41,
   0x75, 0xe6, 0x0b, 0x29, 0xd7, 0xc6, 0x45, 0x49, 0xe8, 0x19, 0x74, 0x95, 0x9d, 0xa5, 0x58, 0x30,
   0xcb, 0x21, 0xde, 0x60, 0xf6, 0xf7, 0xe0, 0xa0, 0x0e, 0xc7, 0xab, 0x1d, 0x4a, 0xa1, 0x75, 0x54,
   0x85, 0xc6, 0xd4, 0x83, 0x56, 0xbe, 0xc1, 0x88, 0xb5, 0xf5, 0xfd, 0xf8, 0x70, 0x7f, 0xb7, 0xc1,
   0xe8, 0xb2, 0x28, 0x84, 0x1f, 0x71, 0xbd, 0xe1, 0x5e, 0x43, 0x77, 0x1d, 0xf8, 0xcf, 0x29, 0x86,
   0x74, 0x04, 0xcd, 0xda, 0x5e, 0x33, 0x96, 0x4a, 0xf8, 0xc8, 0x9c, 0xc6, 0xaa, 0xfa, 0x3c, 0xf6,
   0xf5, 0x7b, 0x56, 0x59, 0xbd, 0xa1, 0x6e, 0x06, 0x03, 0xbe, 0x59, 0x06, 0x55, 0xd8, 0xdf, 0x74,
   0xff, 0x1f, 0x3a, 0xa8, 0x1b, 0x36, 0xb9, 0xc7, 0x27, 0xcd, 0x1b, 0x65, 0x6e, 0x76, 0xae, 0xd8,
   0xe7, 0xce, 0x26, 0xdb, 0x9d, 0x4d, 0xbe, 0x77, 0x36, 0x79, 0xdf, 0xdb, 0x8d, 0xed, 0xde, 0x6e,
   0x7c, 0xed, 0xed, 0xc6, 0xa2, 0xa3, 0xcf, 0xce, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0x56, 0x3f,
   0xf7, 0xf6, 0x92, 0x02, 0x00, 0x00,
   // 376 bytes of a gzipped FileDescriptorProto
   0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x52, 0xcd, 0x4e, 0x83, 0x40,
   0x18, 0x0c, 0xa5, 0x2d, 0xf4, 0xa3, 0x69, 0xcc, 0xda, 0x34, 0x9b, 0x9e, 0x08, 0x27, 0x0e, 0xda,
   0x43, 0xf5, 0x05, 0x7a, 0xf2, 0xa2, 0x89, 0xd9, 0x9a, 0x98, 0x78, 0xdb, 0xb2, 0x08, 0x04, 0xb6,
   0x10, 0x3e, 0x6a, 0xf4, 0x19, 0x7c, 0x0a, 0x1f, 0xc4, 0x77, 0x33, 0xbb, 0xcb, 0x4f, 0x7b, 0xf5,
   0xc4, 0x0c, 0x3b, 0xdf, 0xc7, 0xcc, 0x2c, 0x30, 0x8f, 0x4a, 0x29, 0x31, 0xd9, 0x54, 0x75, 0xd9,
   0x94, 0xc4, 0xd5, 0x0f, 0x89, 0xc9, 0x7a, 0xd1, 0x21, 0x73, 0xb2, 0xf6, 0x78, 0xc1, 0x6b, 0x69,
   0x48, 0xf0, 0x06, 0x8b, 0xbd, 0xc8, 0x25, 0x26, 0xaf, 0x59, 0x93, 0xbe, 0x70, 0xcc, 0xc9, 0x12,
   0x26, 0x59, 0x15, 0x65, 0x82, 0x5a, 0xbe, 0x15, 0xce, 0x98, 0x21, 0x84, 0x82, 0x83, 0x22, 0x6f,
   0xbe, 0xaa, 0x98, 0x8e, 0xf4, 0xfb, 0x8e, 0xb6, 0x27, 0x82, 0x37, 0x9c, 0x8e, 0x7d, 0x2b, 0x9c,
   0xb3, 0x8e, 0x06, 0xdf, 0x16, 0xcc, 0xd4, 0xca, 0x47, 0x7e, 0x88, 0x0b, 0xb2, 0x82, 0x69, 0xc3,
   0x31, 0xef, 0x17, 0xb7, 0x8c, 0xac, 0xc1, 0x55, 0xe8, 0xc8, 0x65, 0xb7, 0xba, 0xe7, 0xe4, 0x1e,
   0x5c, 0x14, 0x79, 0x76, 0x7c, 0x2f, 0x91, 0xda, 0xbe, 0x1d, 0x7a, 0x5b, 0xba, 0xe9, 0xd3, 0x5c,
   0xfa, 0x66, 0xbd, 0x52, 0x27, 0x38, 0x8a, 0xf8, 0x53, 0xfb, 0x99, 0x30, 0x43, 0x82, 0x1f, 0x0b,
   0x60, 0x2f, 0xf2, 0xa7, 0x18, 0x91, 0x27, 0x31, 0xb9, 0x02, 0x7b, 0x08, 0xa9, 0xa0, 0x1a, 0x8b,
   0xb8, 0x10, 0x75, 0xeb, 0xc2, 0x10, 0x72, 0x0b, 0x8e, 0xb2, 0x53, 0xf0, 0x03, 0xb5, 0x7d, 0x2b,
   0xf4, 0xb6, 0xd7, 0x83, 0x83, 0x3e, 0x1c, 0xeb, 0x34, 0x84, 0xc0, 0xf8, 0xac, 0x0a, 0x8d, 0x49,
   0x08, 0xe3, 0xea, 0x84, 0x29, 0x9d, 0xe8, 0xf9, 0xe5, 0x30, 0xff, 0x7c, 0xc2, 0x74, 0xd7, 0x34,
   0x3c, 0x4a, 0x99, 0x56, 0x04, 0x0f, 0xe0, 0xd4, 0x71, 0xf4, 0x21, 0x31, 0x21, 0x0b, 0x18, 0xf5,
   0xf6, 0x46, 0x99, 0x50, 0x8b, 0xcf, 0xcc, 0x69, 0xac, 0xaa, 0xaf, 0xb2, 0x48, 0x7f, 0xcf, 0x36,
   0xd5, 0xb7, 0x34, 0xf8, 0xb5, 0xc0, 0x63, 0xa7, 0x22, 0xee, 0xd2, 0xfe, 0xa7, 0x7c, 0x0a, 0x8e,
   0xc4, 0x44, 0x5f, 0xb9, 0x6d, 0xae, 0xbc, 0xa5, 0xe4, 0x06, 0xa6, 0xa8, 0xcb, 0xd7, 0x31, 0x2f,
   0x22, 0x0d, 0x0d, 0xb3, 0x56, 0x43, 0xb6, 0xe0, 0xea, 0x3f, 0x4e, 0xe9, 0x4d, 0x05, 0xab, 0x41,
   0xbf, 0x53, 0x27, 0xdd, 0x44, 0xaf, 0x3b, 0x4c, 0xb5, 0xe0, 0xee, 0x2f, 0x00, 0x00, 0xff, 0xff,
   0xc8, 0xc5, 0x13, 0x57, 0xd4, 0x02, 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)
   }
   if m.Push != nil {
      dAtA[i] = 0x2a
      i++
      i = encodeVarintCommsg(dAtA, i, uint64(m.Push.Size()))
      n2, err2 := m.Push.MarshalTo(dAtA[i:])
      if err2 != nil {
         return 0, err2
      }
      i += n2
   }
   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 (m *RuleMessage) 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 *RuleMessage) 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 m.Sdkmsg != nil {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintCommsg(dAtA, i, uint64(m.Sdkmsg.Size()))
      n3, err3 := m.Sdkmsg.MarshalTo(dAtA[i:])
      if err3 != nil {
         return 0, err3
      }
      i += n3
   }
   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))
   }
   if m.Push != nil {
      l = m.Push.Size()
      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 (m *RuleMessage) 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 m.Sdkmsg != nil {
      l = m.Sdkmsg.Size()
      n += 1 + l + sovCommsg(uint64(l))
   }
   return n
}

func sovCommsg(x uint64) (n int) {
   return (math_bits.Len64(x|1) + 6) / 7
}
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
      case 5:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Push", 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.Push == nil {
            m.Push = &PushAttach{}
         }
         if err := m.Push.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         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 (m *RuleMessage) 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: RuleMessage: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: RuleMessage: 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 Sdkmsg", 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.Sdkmsg == nil {
            m.Sdkmsg = &SdkMessage{}
         }
         if err := m.Sdkmsg.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         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")
)