添加删除类型

zhangzengfei

2024-05-08 e2c32868dc935c0f9773b51ed88de5e94b2ea874

 dataprocess.pb.go

@@ -314,109 +314,6 @@
   return nil
}

type SOResult struct {
   IsEvent              bool        `protobuf:"varint,1,opt,name=IsEvent,proto3" json:"IsEvent,omitempty"`
   IsEndRecord          bool        `protobuf:"varint,2,opt,name=IsEndRecord,proto3" json:"IsEndRecord,omitempty"`
   Targets              []*SoTarget `protobuf:"bytes,3,rep,name=Targets,proto3" json:"Targets,omitempty"`
   FirstImage           *Image      `protobuf:"bytes,4,opt,name=FirstImage,proto3" json:"FirstImage,omitempty"`
   CacheImage           *Image      `protobuf:"bytes,5,opt,name=CacheImage,proto3" json:"CacheImage,omitempty"`
   SoRule               *SoRule     `protobuf:"bytes,6,opt,name=SoRule,proto3" json:"SoRule,omitempty"`
   GroupRule            *GroupRule  `protobuf:"bytes,7,opt,name=GroupRule,proto3" json:"GroupRule,omitempty"`
   SoType               string      `protobuf:"bytes,8,opt,name=SoType,proto3" json:"SoType,omitempty"`
   XXX_NoUnkeyedLiteral struct{}    `json:"-"`
   XXX_unrecognized     []byte      `json:"-"`
   XXX_sizecache        int32       `json:"-"`
}

func (m *SOResult) Reset()         { *m = SOResult{} }
func (m *SOResult) String() string { return proto.CompactTextString(m) }
func (*SOResult) ProtoMessage()    {}
func (*SOResult) Descriptor() ([]byte, []int) {
   return fileDescriptor_02f614a9207041cc, []int{3}
}
func (m *SOResult) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
}
func (m *SOResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   if deterministic {
      return xxx_messageInfo_SOResult.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 *SOResult) XXX_Merge(src proto.Message) {
   xxx_messageInfo_SOResult.Merge(m, src)
}
func (m *SOResult) XXX_Size() int {
   return m.Size()
}
func (m *SOResult) XXX_DiscardUnknown() {
   xxx_messageInfo_SOResult.DiscardUnknown(m)
}

var xxx_messageInfo_SOResult proto.InternalMessageInfo

func (m *SOResult) GetIsEvent() bool {
   if m != nil {
      return m.IsEvent
   }
   return false
}

func (m *SOResult) GetIsEndRecord() bool {
   if m != nil {
      return m.IsEndRecord
   }
   return false
}

func (m *SOResult) GetTargets() []*SoTarget {
   if m != nil {
      return m.Targets
   }
   return nil
}

func (m *SOResult) GetFirstImage() *Image {
   if m != nil {
      return m.FirstImage
   }
   return nil
}

func (m *SOResult) GetCacheImage() *Image {
   if m != nil {
      return m.CacheImage
   }
   return nil
}

func (m *SOResult) GetSoRule() *SoRule {
   if m != nil {
      return m.SoRule
   }
   return nil
}

func (m *SOResult) GetGroupRule() *GroupRule {
   if m != nil {
      return m.GroupRule
   }
   return nil
}

func (m *SOResult) GetSoType() string {
   if m != nil {
      return m.SoType
   }
   return ""
}

type SoTarget struct {
   SrcTarget            *Target                `protobuf:"bytes,1,opt,name=SrcTarget,proto3" json:"SrcTarget,omitempty"`
   AreaId               string                 `protobuf:"bytes,2,opt,name=AreaId,proto3" json:"AreaId,omitempty"`
@@ -433,7 +330,7 @@
func (m *SoTarget) String() string { return proto.CompactTextString(m) }
func (*SoTarget) ProtoMessage()    {}
func (*SoTarget) Descriptor() ([]byte, []int) {
   return fileDescriptor_02f614a9207041cc, []int{4}
   return fileDescriptor_02f614a9207041cc, []int{3}
}
func (m *SoTarget) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -502,6 +399,109 @@
      return m.ImageId
   }
   return 0
}

type SoResult struct {
   IsEvent              bool        `protobuf:"varint,1,opt,name=IsEvent,proto3" json:"IsEvent,omitempty"`
   IsEndRecord          bool        `protobuf:"varint,2,opt,name=IsEndRecord,proto3" json:"IsEndRecord,omitempty"`
   Targets              []*SoTarget `protobuf:"bytes,3,rep,name=Targets,proto3" json:"Targets,omitempty"`
   FirstImage           *Image      `protobuf:"bytes,4,opt,name=FirstImage,proto3" json:"FirstImage,omitempty"`
   CacheImage           *Image      `protobuf:"bytes,5,opt,name=CacheImage,proto3" json:"CacheImage,omitempty"`
   SoRule               *SoRule     `protobuf:"bytes,6,opt,name=soRule,proto3" json:"soRule,omitempty"`
   GroupRule            *GroupRule  `protobuf:"bytes,7,opt,name=groupRule,proto3" json:"groupRule,omitempty"`
   SoType               string      `protobuf:"bytes,8,opt,name=SoType,proto3" json:"SoType,omitempty"`
   XXX_NoUnkeyedLiteral struct{}    `json:"-"`
   XXX_unrecognized     []byte      `json:"-"`
   XXX_sizecache        int32       `json:"-"`
}

func (m *SoResult) Reset()         { *m = SoResult{} }
func (m *SoResult) String() string { return proto.CompactTextString(m) }
func (*SoResult) ProtoMessage()    {}
func (*SoResult) Descriptor() ([]byte, []int) {
   return fileDescriptor_02f614a9207041cc, []int{4}
}
func (m *SoResult) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
}
func (m *SoResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   if deterministic {
      return xxx_messageInfo_SoResult.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 *SoResult) XXX_Merge(src proto.Message) {
   xxx_messageInfo_SoResult.Merge(m, src)
}
func (m *SoResult) XXX_Size() int {
   return m.Size()
}
func (m *SoResult) XXX_DiscardUnknown() {
   xxx_messageInfo_SoResult.DiscardUnknown(m)
}

var xxx_messageInfo_SoResult proto.InternalMessageInfo

func (m *SoResult) GetIsEvent() bool {
   if m != nil {
      return m.IsEvent
   }
   return false
}

func (m *SoResult) GetIsEndRecord() bool {
   if m != nil {
      return m.IsEndRecord
   }
   return false
}

func (m *SoResult) GetTargets() []*SoTarget {
   if m != nil {
      return m.Targets
   }
   return nil
}

func (m *SoResult) GetFirstImage() *Image {
   if m != nil {
      return m.FirstImage
   }
   return nil
}

func (m *SoResult) GetCacheImage() *Image {
   if m != nil {
      return m.CacheImage
   }
   return nil
}

func (m *SoResult) GetSoRule() *SoRule {
   if m != nil {
      return m.SoRule
   }
   return nil
}

func (m *SoResult) GetGroupRule() *GroupRule {
   if m != nil {
      return m.GroupRule
   }
   return nil
}

func (m *SoResult) GetSoType() string {
   if m != nil {
      return m.SoType
   }
   return ""
}

type EventCache struct {
@@ -697,8 +697,8 @@
   proto.RegisterType((*TaskBasicInfo)(nil), "protomsg.TaskBasicInfo")
   proto.RegisterType((*RuleParams)(nil), "protomsg.RuleParams")
   proto.RegisterType((*SoRule)(nil), "protomsg.SoRule")
   proto.RegisterType((*SOResult)(nil), "protomsg.SOResult")
   proto.RegisterType((*SoTarget)(nil), "protomsg.SoTarget")
   proto.RegisterType((*SoResult)(nil), "protomsg.SoResult")
   proto.RegisterType((*EventCache)(nil), "protomsg.EventCache")
   proto.RegisterMapType((map[int64]*Image)(nil), "protomsg.EventCache.ImagesEntry")
   proto.RegisterMapType((map[string]*GroupRule)(nil), "protomsg.EventCache.RuleGroupsEntry")
@@ -713,65 +713,65 @@
func init() { proto.RegisterFile("dataprocess.proto", fileDescriptor_02f614a9207041cc) }

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

func (m *TaskBasicInfo) Marshal() (dAtA []byte, err error) {
@@ -981,7 +981,7 @@
   return i, nil
}

func (m *SOResult) Marshal() (dAtA []byte, err error) {
func (m *SoTarget) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalTo(dAtA)
@@ -991,7 +991,73 @@
   return dAtA[:n], nil
}

func (m *SOResult) MarshalTo(dAtA []byte) (int, error) {
func (m *SoTarget) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if m.SrcTarget != nil {
      dAtA[i] = 0xa
      i++
      i = encodeVarintDataprocess(dAtA, i, uint64(m.SrcTarget.Size()))
      n1, err1 := m.SrcTarget.MarshalTo(dAtA[i:])
      if err1 != nil {
         return 0, err1
      }
      i += n1
   }
   if len(m.AreaId) > 0 {
      dAtA[i] = 0x12
      i++
      i = encodeVarintDataprocess(dAtA, i, uint64(len(m.AreaId)))
      i += copy(dAtA[i:], m.AreaId)
   }
   if len(m.AreaName) > 0 {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintDataprocess(dAtA, i, uint64(len(m.AreaName)))
      i += copy(dAtA[i:], m.AreaName)
   }
   if len(m.BelongsTargetID) > 0 {
      dAtA[i] = 0x22
      i++
      i = encodeVarintDataprocess(dAtA, i, uint64(len(m.BelongsTargetID)))
      i += copy(dAtA[i:], m.BelongsTargetID)
   }
   if len(m.CompDbInfo) > 0 {
      for _, msg := range m.CompDbInfo {
         dAtA[i] = 0x2a
         i++
         i = encodeVarintDataprocess(dAtA, i, uint64(msg.Size()))
         n, err := msg.MarshalTo(dAtA[i:])
         if err != nil {
            return 0, err
         }
         i += n
      }
   }
   if m.ImageId != 0 {
      dAtA[i] = 0x30
      i++
      i = encodeVarintDataprocess(dAtA, i, uint64(m.ImageId))
   }
   if m.XXX_unrecognized != nil {
      i += copy(dAtA[i:], m.XXX_unrecognized)
   }
   return i, nil
}

func (m *SoResult) 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 *SoResult) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
@@ -1032,113 +1098,47 @@
      dAtA[i] = 0x22
      i++
      i = encodeVarintDataprocess(dAtA, i, uint64(m.FirstImage.Size()))
      n1, err1 := m.FirstImage.MarshalTo(dAtA[i:])
      if err1 != nil {
         return 0, err1
      }
      i += n1
   }
   if m.CacheImage != nil {
      dAtA[i] = 0x2a
      i++
      i = encodeVarintDataprocess(dAtA, i, uint64(m.CacheImage.Size()))
      n2, err2 := m.CacheImage.MarshalTo(dAtA[i:])
      n2, err2 := m.FirstImage.MarshalTo(dAtA[i:])
      if err2 != nil {
         return 0, err2
      }
      i += n2
   }
   if m.SoRule != nil {
      dAtA[i] = 0x32
   if m.CacheImage != nil {
      dAtA[i] = 0x2a
      i++
      i = encodeVarintDataprocess(dAtA, i, uint64(m.SoRule.Size()))
      n3, err3 := m.SoRule.MarshalTo(dAtA[i:])
      i = encodeVarintDataprocess(dAtA, i, uint64(m.CacheImage.Size()))
      n3, err3 := m.CacheImage.MarshalTo(dAtA[i:])
      if err3 != nil {
         return 0, err3
      }
      i += n3
   }
   if m.GroupRule != nil {
      dAtA[i] = 0x3a
   if m.SoRule != nil {
      dAtA[i] = 0x32
      i++
      i = encodeVarintDataprocess(dAtA, i, uint64(m.GroupRule.Size()))
      n4, err4 := m.GroupRule.MarshalTo(dAtA[i:])
      i = encodeVarintDataprocess(dAtA, i, uint64(m.SoRule.Size()))
      n4, err4 := m.SoRule.MarshalTo(dAtA[i:])
      if err4 != nil {
         return 0, err4
      }
      i += n4
   }
   if m.GroupRule != nil {
      dAtA[i] = 0x3a
      i++
      i = encodeVarintDataprocess(dAtA, i, uint64(m.GroupRule.Size()))
      n5, err5 := m.GroupRule.MarshalTo(dAtA[i:])
      if err5 != nil {
         return 0, err5
      }
      i += n5
   }
   if len(m.SoType) > 0 {
      dAtA[i] = 0x42
      i++
      i = encodeVarintDataprocess(dAtA, i, uint64(len(m.SoType)))
      i += copy(dAtA[i:], m.SoType)
   }
   if m.XXX_unrecognized != nil {
      i += copy(dAtA[i:], m.XXX_unrecognized)
   }
   return i, nil
}

func (m *SoTarget) 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 *SoTarget) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if m.SrcTarget != nil {
      dAtA[i] = 0xa
      i++
      i = encodeVarintDataprocess(dAtA, i, uint64(m.SrcTarget.Size()))
      n5, err5 := m.SrcTarget.MarshalTo(dAtA[i:])
      if err5 != nil {
         return 0, err5
      }
      i += n5
   }
   if len(m.AreaId) > 0 {
      dAtA[i] = 0x12
      i++
      i = encodeVarintDataprocess(dAtA, i, uint64(len(m.AreaId)))
      i += copy(dAtA[i:], m.AreaId)
   }
   if len(m.AreaName) > 0 {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintDataprocess(dAtA, i, uint64(len(m.AreaName)))
      i += copy(dAtA[i:], m.AreaName)
   }
   if len(m.BelongsTargetID) > 0 {
      dAtA[i] = 0x22
      i++
      i = encodeVarintDataprocess(dAtA, i, uint64(len(m.BelongsTargetID)))
      i += copy(dAtA[i:], m.BelongsTargetID)
   }
   if len(m.CompDbInfo) > 0 {
      for _, msg := range m.CompDbInfo {
         dAtA[i] = 0x2a
         i++
         i = encodeVarintDataprocess(dAtA, i, uint64(msg.Size()))
         n, err := msg.MarshalTo(dAtA[i:])
         if err != nil {
            return 0, err
         }
         i += n
      }
   }
   if m.ImageId != 0 {
      dAtA[i] = 0x30
      i++
      i = encodeVarintDataprocess(dAtA, i, uint64(m.ImageId))
   }
   if m.XXX_unrecognized != nil {
      i += copy(dAtA[i:], m.XXX_unrecognized)
@@ -1538,7 +1538,44 @@
   return n
}

func (m *SOResult) Size() (n int) {
func (m *SoTarget) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   if m.SrcTarget != nil {
      l = m.SrcTarget.Size()
      n += 1 + l + sovDataprocess(uint64(l))
   }
   l = len(m.AreaId)
   if l > 0 {
      n += 1 + l + sovDataprocess(uint64(l))
   }
   l = len(m.AreaName)
   if l > 0 {
      n += 1 + l + sovDataprocess(uint64(l))
   }
   l = len(m.BelongsTargetID)
   if l > 0 {
      n += 1 + l + sovDataprocess(uint64(l))
   }
   if len(m.CompDbInfo) > 0 {
      for _, e := range m.CompDbInfo {
         l = e.Size()
         n += 1 + l + sovDataprocess(uint64(l))
      }
   }
   if m.ImageId != 0 {
      n += 1 + sovDataprocess(uint64(m.ImageId))
   }
   if m.XXX_unrecognized != nil {
      n += len(m.XXX_unrecognized)
   }
   return n
}

func (m *SoResult) Size() (n int) {
   if m == nil {
      return 0
   }
@@ -1575,43 +1612,6 @@
   l = len(m.SoType)
   if l > 0 {
      n += 1 + l + sovDataprocess(uint64(l))
   }
   if m.XXX_unrecognized != nil {
      n += len(m.XXX_unrecognized)
   }
   return n
}

func (m *SoTarget) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   if m.SrcTarget != nil {
      l = m.SrcTarget.Size()
      n += 1 + l + sovDataprocess(uint64(l))
   }
   l = len(m.AreaId)
   if l > 0 {
      n += 1 + l + sovDataprocess(uint64(l))
   }
   l = len(m.AreaName)
   if l > 0 {
      n += 1 + l + sovDataprocess(uint64(l))
   }
   l = len(m.BelongsTargetID)
   if l > 0 {
      n += 1 + l + sovDataprocess(uint64(l))
   }
   if len(m.CompDbInfo) > 0 {
      for _, e := range m.CompDbInfo {
         l = e.Size()
         n += 1 + l + sovDataprocess(uint64(l))
      }
   }
   if m.ImageId != 0 {
      n += 1 + sovDataprocess(uint64(m.ImageId))
   }
   if m.XXX_unrecognized != nil {
      n += len(m.XXX_unrecognized)
@@ -2578,7 +2578,7 @@
   }
   return nil
}
func (m *SOResult) Unmarshal(dAtA []byte) error {
func (m *SoTarget) Unmarshal(dAtA []byte) error {
   l := len(dAtA)
   iNdEx := 0
   for iNdEx < l {
@@ -2601,10 +2601,249 @@
      fieldNum := int32(wire >> 3)
      wireType := int(wire & 0x7)
      if wireType == 4 {
         return fmt.Errorf("proto: SOResult: wiretype end group for non-group")
         return fmt.Errorf("proto: SoTarget: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: SOResult: illegal tag %d (wire type %d)", fieldNum, wire)
         return fmt.Errorf("proto: SoTarget: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field SrcTarget", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowDataprocess
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            msglen |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if msglen < 0 {
            return ErrInvalidLengthDataprocess
         }
         postIndex := iNdEx + msglen
         if postIndex < 0 {
            return ErrInvalidLengthDataprocess
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         if m.SrcTarget == nil {
            m.SrcTarget = &Target{}
         }
         if err := m.SrcTarget.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      case 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field AreaId", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowDataprocess
            }
            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 ErrInvalidLengthDataprocess
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthDataprocess
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.AreaId = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 3:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field AreaName", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowDataprocess
            }
            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 ErrInvalidLengthDataprocess
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthDataprocess
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.AreaName = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 4:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field BelongsTargetID", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowDataprocess
            }
            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 ErrInvalidLengthDataprocess
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthDataprocess
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.BelongsTargetID = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 5:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field CompDbInfo", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowDataprocess
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            msglen |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if msglen < 0 {
            return ErrInvalidLengthDataprocess
         }
         postIndex := iNdEx + msglen
         if postIndex < 0 {
            return ErrInvalidLengthDataprocess
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.CompDbInfo = append(m.CompDbInfo, &RuleBaseCompareInfo{})
         if err := m.CompDbInfo[len(m.CompDbInfo)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      case 6:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field ImageId", wireType)
         }
         m.ImageId = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowDataprocess
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.ImageId |= int64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      default:
         iNdEx = preIndex
         skippy, err := skipDataprocess(dAtA[iNdEx:])
         if err != nil {
            return err
         }
         if skippy < 0 {
            return ErrInvalidLengthDataprocess
         }
         if (iNdEx + skippy) < 0 {
            return ErrInvalidLengthDataprocess
         }
         if (iNdEx + skippy) > l {
            return io.ErrUnexpectedEOF
         }
         m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
         iNdEx += skippy
      }
   }

   if iNdEx > l {
      return io.ErrUnexpectedEOF
   }
   return nil
}
func (m *SoResult) 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 ErrIntOverflowDataprocess
         }
         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: SoResult: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: SoResult: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
@@ -2857,245 +3096,6 @@
         }
         m.SoType = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      default:
         iNdEx = preIndex
         skippy, err := skipDataprocess(dAtA[iNdEx:])
         if err != nil {
            return err
         }
         if skippy < 0 {
            return ErrInvalidLengthDataprocess
         }
         if (iNdEx + skippy) < 0 {
            return ErrInvalidLengthDataprocess
         }
         if (iNdEx + skippy) > l {
            return io.ErrUnexpectedEOF
         }
         m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
         iNdEx += skippy
      }
   }

   if iNdEx > l {
      return io.ErrUnexpectedEOF
   }
   return nil
}
func (m *SoTarget) 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 ErrIntOverflowDataprocess
         }
         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: SoTarget: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: SoTarget: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field SrcTarget", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowDataprocess
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            msglen |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if msglen < 0 {
            return ErrInvalidLengthDataprocess
         }
         postIndex := iNdEx + msglen
         if postIndex < 0 {
            return ErrInvalidLengthDataprocess
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         if m.SrcTarget == nil {
            m.SrcTarget = &Target{}
         }
         if err := m.SrcTarget.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      case 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field AreaId", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowDataprocess
            }
            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 ErrInvalidLengthDataprocess
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthDataprocess
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.AreaId = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 3:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field AreaName", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowDataprocess
            }
            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 ErrInvalidLengthDataprocess
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthDataprocess
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.AreaName = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 4:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field BelongsTargetID", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowDataprocess
            }
            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 ErrInvalidLengthDataprocess
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthDataprocess
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.BelongsTargetID = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 5:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field CompDbInfo", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowDataprocess
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            msglen |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if msglen < 0 {
            return ErrInvalidLengthDataprocess
         }
         postIndex := iNdEx + msglen
         if postIndex < 0 {
            return ErrInvalidLengthDataprocess
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.CompDbInfo = append(m.CompDbInfo, &RuleBaseCompareInfo{})
         if err := m.CompDbInfo[len(m.CompDbInfo)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      case 6:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field ImageId", wireType)
         }
         m.ImageId = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowDataprocess
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.ImageId |= int64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      default:
         iNdEx = preIndex
         skippy, err := skipDataprocess(dAtA[iNdEx:])