add MultiFeaCache

liuxiaolong

2019-12-09 e77f90d515cd4db9e5456e9d9dde735426657072

 es.pb.go

@@ -9,6 +9,7 @@
   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.
@@ -106,6 +107,134 @@
   return ""
}

type MultiFeaCache struct {
   EsInfo        *Esinfo       `protobuf:"bytes,1,opt,name=esInfo,proto3" json:"esInfo,omitempty"`
   AttachFeature string        `protobuf:"bytes,2,opt,name=attachFeature,proto3" json:"attachFeature,omitempty"`
   CameraId      string        `protobuf:"bytes,3,opt,name=cameraId,proto3" json:"cameraId,omitempty"`
   LinkEsInfo    []*LinkEsInfo `protobuf:"bytes,4,rep,name=linkEsInfo,proto3" json:"linkEsInfo,omitempty"`
}

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

var xxx_messageInfo_MultiFeaCache proto.InternalMessageInfo

func (m *MultiFeaCache) GetEsInfo() *Esinfo {
   if m != nil {
      return m.EsInfo
   }
   return nil
}

func (m *MultiFeaCache) GetAttachFeature() string {
   if m != nil {
      return m.AttachFeature
   }
   return ""
}

func (m *MultiFeaCache) GetCameraId() string {
   if m != nil {
      return m.CameraId
   }
   return ""
}

func (m *MultiFeaCache) GetLinkEsInfo() []*LinkEsInfo {
   if m != nil {
      return m.LinkEsInfo
   }
   return nil
}

type LinkEsInfo struct {
   CameraId      string `protobuf:"bytes,1,opt,name=cameraId,proto3" json:"cameraId,omitempty"`
   Feature       string `protobuf:"bytes,2,opt,name=feature,proto3" json:"feature,omitempty"`
   AttachFeature string `protobuf:"bytes,3,opt,name=attachFeature,proto3" json:"attachFeature,omitempty"`
}

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

var xxx_messageInfo_LinkEsInfo proto.InternalMessageInfo

func (m *LinkEsInfo) GetCameraId() string {
   if m != nil {
      return m.CameraId
   }
   return ""
}

func (m *LinkEsInfo) GetFeature() string {
   if m != nil {
      return m.Feature
   }
   return ""
}

func (m *LinkEsInfo) GetAttachFeature() string {
   if m != nil {
      return m.AttachFeature
   }
   return ""
}

type Dbperson struct {
   Id           string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
   TableId      string `protobuf:"bytes,2,opt,name=tableId,proto3" json:"tableId,omitempty"`
@@ -130,7 +259,7 @@
func (m *Dbperson) String() string { return proto.CompactTextString(m) }
func (*Dbperson) ProtoMessage()    {}
func (*Dbperson) Descriptor() ([]byte, []int) {
   return fileDescriptor_718db5c20d0f3738, []int{1}
   return fileDescriptor_718db5c20d0f3738, []int{3}
}
func (m *Dbperson) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -300,7 +429,7 @@
func (m *Dbtable) String() string { return proto.CompactTextString(m) }
func (*Dbtable) ProtoMessage()    {}
func (*Dbtable) Descriptor() ([]byte, []int) {
   return fileDescriptor_718db5c20d0f3738, []int{2}
   return fileDescriptor_718db5c20d0f3738, []int{4}
}
func (m *Dbtable) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -436,6 +565,8 @@

func init() {
   proto.RegisterType((*Esinfo)(nil), "protomsg.Esinfo")
   proto.RegisterType((*MultiFeaCache)(nil), "protomsg.MultiFeaCache")
   proto.RegisterType((*LinkEsInfo)(nil), "protomsg.LinkEsInfo")
   proto.RegisterType((*Dbperson)(nil), "protomsg.Dbperson")
   proto.RegisterType((*Dbtable)(nil), "protomsg.Dbtable")
}
@@ -443,40 +574,46 @@
func init() { proto.RegisterFile("es.proto", fileDescriptor_718db5c20d0f3738) }

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

func (m *Esinfo) Marshal() (dAtA []byte, err error) {
@@ -528,6 +665,94 @@
      i++
      i = encodeVarintEs(dAtA, i, uint64(len(m.AnalyServerId)))
      i += copy(dAtA[i:], m.AnalyServerId)
   }
   return i, nil
}

func (m *MultiFeaCache) 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 *MultiFeaCache) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if m.EsInfo != nil {
      dAtA[i] = 0xa
      i++
      i = encodeVarintEs(dAtA, i, uint64(m.EsInfo.Size()))
      n1, err1 := m.EsInfo.MarshalTo(dAtA[i:])
      if err1 != nil {
         return 0, err1
      }
      i += n1
   }
   if len(m.AttachFeature) > 0 {
      dAtA[i] = 0x12
      i++
      i = encodeVarintEs(dAtA, i, uint64(len(m.AttachFeature)))
      i += copy(dAtA[i:], m.AttachFeature)
   }
   if len(m.CameraId) > 0 {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintEs(dAtA, i, uint64(len(m.CameraId)))
      i += copy(dAtA[i:], m.CameraId)
   }
   if len(m.LinkEsInfo) > 0 {
      for _, msg := range m.LinkEsInfo {
         dAtA[i] = 0x22
         i++
         i = encodeVarintEs(dAtA, i, uint64(msg.Size()))
         n, err := msg.MarshalTo(dAtA[i:])
         if err != nil {
            return 0, err
         }
         i += n
      }
   }
   return i, nil
}

func (m *LinkEsInfo) 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 *LinkEsInfo) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if len(m.CameraId) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintEs(dAtA, i, uint64(len(m.CameraId)))
      i += copy(dAtA[i:], m.CameraId)
   }
   if len(m.Feature) > 0 {
      dAtA[i] = 0x12
      i++
      i = encodeVarintEs(dAtA, i, uint64(len(m.Feature)))
      i += copy(dAtA[i:], m.Feature)
   }
   if len(m.AttachFeature) > 0 {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintEs(dAtA, i, uint64(len(m.AttachFeature)))
      i += copy(dAtA[i:], m.AttachFeature)
   }
   return i, nil
}
@@ -800,6 +1025,54 @@
   return n
}

func (m *MultiFeaCache) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   if m.EsInfo != nil {
      l = m.EsInfo.Size()
      n += 1 + l + sovEs(uint64(l))
   }
   l = len(m.AttachFeature)
   if l > 0 {
      n += 1 + l + sovEs(uint64(l))
   }
   l = len(m.CameraId)
   if l > 0 {
      n += 1 + l + sovEs(uint64(l))
   }
   if len(m.LinkEsInfo) > 0 {
      for _, e := range m.LinkEsInfo {
         l = e.Size()
         n += 1 + l + sovEs(uint64(l))
      }
   }
   return n
}

func (m *LinkEsInfo) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   l = len(m.CameraId)
   if l > 0 {
      n += 1 + l + sovEs(uint64(l))
   }
   l = len(m.Feature)
   if l > 0 {
      n += 1 + l + sovEs(uint64(l))
   }
   l = len(m.AttachFeature)
   if l > 0 {
      n += 1 + l + sovEs(uint64(l))
   }
   return n
}

func (m *Dbperson) Size() (n int) {
   if m == nil {
      return 0
@@ -943,14 +1216,7 @@
}

func sovEs(x uint64) (n int) {
   for {
      n++
      x >>= 7
      if x == 0 {
         break
      }
   }
   return n
   return (math_bits.Len64(x|1) + 6) / 7
}
func sozEs(x uint64) (n int) {
   return sovEs(uint64((x << 1) ^ uint64((int64(x) >> 63))))
@@ -1166,6 +1432,342 @@
   }
   return nil
}
func (m *MultiFeaCache) 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 ErrIntOverflowEs
         }
         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: MultiFeaCache: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: MultiFeaCache: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field EsInfo", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowEs
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            msglen |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if msglen < 0 {
            return ErrInvalidLengthEs
         }
         postIndex := iNdEx + msglen
         if postIndex < 0 {
            return ErrInvalidLengthEs
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         if m.EsInfo == nil {
            m.EsInfo = &Esinfo{}
         }
         if err := m.EsInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      case 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field AttachFeature", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowEs
            }
            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 ErrInvalidLengthEs
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthEs
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.AttachFeature = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 3:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field CameraId", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowEs
            }
            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 ErrInvalidLengthEs
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthEs
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.CameraId = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 4:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field LinkEsInfo", wireType)
         }
         var msglen int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowEs
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            msglen |= int(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if msglen < 0 {
            return ErrInvalidLengthEs
         }
         postIndex := iNdEx + msglen
         if postIndex < 0 {
            return ErrInvalidLengthEs
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.LinkEsInfo = append(m.LinkEsInfo, &LinkEsInfo{})
         if err := m.LinkEsInfo[len(m.LinkEsInfo)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
            return err
         }
         iNdEx = postIndex
      default:
         iNdEx = preIndex
         skippy, err := skipEs(dAtA[iNdEx:])
         if err != nil {
            return err
         }
         if skippy < 0 {
            return ErrInvalidLengthEs
         }
         if (iNdEx + skippy) < 0 {
            return ErrInvalidLengthEs
         }
         if (iNdEx + skippy) > l {
            return io.ErrUnexpectedEOF
         }
         iNdEx += skippy
      }
   }

   if iNdEx > l {
      return io.ErrUnexpectedEOF
   }
   return nil
}
func (m *LinkEsInfo) 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 ErrIntOverflowEs
         }
         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: LinkEsInfo: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: LinkEsInfo: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field CameraId", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowEs
            }
            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 ErrInvalidLengthEs
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthEs
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.CameraId = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Feature", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowEs
            }
            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 ErrInvalidLengthEs
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthEs
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Feature = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 3:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field AttachFeature", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowEs
            }
            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 ErrInvalidLengthEs
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthEs
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.AttachFeature = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      default:
         iNdEx = preIndex
         skippy, err := skipEs(dAtA[iNdEx:])
         if err != nil {
            return err
         }
         if skippy < 0 {
            return ErrInvalidLengthEs
         }
         if (iNdEx + skippy) < 0 {
            return ErrInvalidLengthEs
         }
         if (iNdEx + skippy) > l {
            return io.ErrUnexpectedEOF
         }
         iNdEx += skippy
      }
   }

   if iNdEx > l {
      return io.ErrUnexpectedEOF
   }
   return nil
}
func (m *Dbperson) Unmarshal(dAtA []byte) error {
   l := len(dAtA)
   iNdEx := 0