rm DbPersonCompCache

liuxiaolong

2019-08-19 d841c07672143f9059ed4df9356bd9df3b425189

 es.pb.go

@@ -28,6 +28,7 @@
   Tableid      string  `protobuf:"bytes,2,opt,name=tableid,proto3" json:"tableid,omitempty"`
   FaceFeature  string  `protobuf:"bytes,3,opt,name=faceFeature,proto3" json:"faceFeature,omitempty"`
   CompareScore float32 `protobuf:"fixed32,4,opt,name=compareScore,proto3" json:"compareScore,omitempty"`
   Enable       int32   `protobuf:"varint,5,opt,name=enable,proto3" json:"enable,omitempty"`
}

func (m *Esinfo) Reset()         { *m = Esinfo{} }
@@ -91,68 +92,7 @@
   return 0
}

type DbPersonCompCache 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"`
   FaceFeature string `protobuf:"bytes,3,opt,name=faceFeature,proto3" json:"faceFeature,omitempty"`
   Enable      int32  `protobuf:"varint,4,opt,name=enable,proto3" json:"enable,omitempty"`
}

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

var xxx_messageInfo_DbPersonCompCache proto.InternalMessageInfo

func (m *DbPersonCompCache) GetId() string {
   if m != nil {
      return m.Id
   }
   return ""
}

func (m *DbPersonCompCache) GetTableId() string {
   if m != nil {
      return m.TableId
   }
   return ""
}

func (m *DbPersonCompCache) GetFaceFeature() string {
   if m != nil {
      return m.FaceFeature
   }
   return ""
}

func (m *DbPersonCompCache) GetEnable() int32 {
func (m *Esinfo) GetEnable() int32 {
   if m != nil {
      return m.Enable
   }
@@ -183,7 +123,7 @@
func (m *Dbperson) String() string { return proto.CompactTextString(m) }
func (*Dbperson) ProtoMessage()    {}
func (*Dbperson) Descriptor() ([]byte, []int) {
   return fileDescriptor_718db5c20d0f3738, []int{2}
   return fileDescriptor_718db5c20d0f3738, []int{1}
}
func (m *Dbperson) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -353,7 +293,7 @@
func (m *Dbtable) String() string { return proto.CompactTextString(m) }
func (*Dbtable) ProtoMessage()    {}
func (*Dbtable) Descriptor() ([]byte, []int) {
   return fileDescriptor_718db5c20d0f3738, []int{3}
   return fileDescriptor_718db5c20d0f3738, []int{2}
}
func (m *Dbtable) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
@@ -489,7 +429,6 @@

func init() {
   proto.RegisterType((*Esinfo)(nil), "protomsg.Esinfo")
   proto.RegisterType((*DbPersonCompCache)(nil), "protomsg.DbPersonCompCache")
   proto.RegisterType((*Dbperson)(nil), "protomsg.Dbperson")
   proto.RegisterType((*Dbtable)(nil), "protomsg.Dbtable")
}
@@ -497,40 +436,39 @@
func init() { proto.RegisterFile("es.proto", fileDescriptor_718db5c20d0f3738) }

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

func (m *Esinfo) Marshal() (dAtA []byte, err error) {
@@ -572,44 +510,8 @@
      encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.CompareScore))))
      i += 4
   }
   return i, nil
}

func (m *DbPersonCompCache) 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 *DbPersonCompCache) MarshalTo(dAtA []byte) (int, error) {
   var i int
   _ = i
   var l int
   _ = l
   if len(m.Id) > 0 {
      dAtA[i] = 0xa
      i++
      i = encodeVarintEs(dAtA, i, uint64(len(m.Id)))
      i += copy(dAtA[i:], m.Id)
   }
   if len(m.TableId) > 0 {
      dAtA[i] = 0x12
      i++
      i = encodeVarintEs(dAtA, i, uint64(len(m.TableId)))
      i += copy(dAtA[i:], m.TableId)
   }
   if len(m.FaceFeature) > 0 {
      dAtA[i] = 0x1a
      i++
      i = encodeVarintEs(dAtA, i, uint64(len(m.FaceFeature)))
      i += copy(dAtA[i:], m.FaceFeature)
   }
   if m.Enable != 0 {
      dAtA[i] = 0x20
      dAtA[i] = 0x28
      i++
      i = encodeVarintEs(dAtA, i, uint64(m.Enable))
   }
@@ -873,27 +775,6 @@
   }
   if m.CompareScore != 0 {
      n += 5
   }
   return n
}

func (m *DbPersonCompCache) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   l = len(m.Id)
   if l > 0 {
      n += 1 + l + sovEs(uint64(l))
   }
   l = len(m.TableId)
   if l > 0 {
      n += 1 + l + sovEs(uint64(l))
   }
   l = len(m.FaceFeature)
   if l > 0 {
      n += 1 + l + sovEs(uint64(l))
   }
   if m.Enable != 0 {
      n += 1 + sovEs(uint64(m.Enable))
@@ -1185,156 +1066,7 @@
         v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
         iNdEx += 4
         m.CompareScore = float32(math.Float32frombits(v))
      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 *DbPersonCompCache) 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: DbPersonCompCache: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: DbPersonCompCache: 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 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.Id = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 2:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field TableId", 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.TableId = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 3:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field FaceFeature", 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.FaceFeature = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 4:
      case 5:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Enable", wireType)
         }