From 5d483655e888dbb97a1011c45f890669b7a74cc5 Mon Sep 17 00:00:00 2001 From: cheliequan <liequanche@126.com> Date: 星期五, 10 二月 2023 14:02:22 +0800 Subject: [PATCH] 增加SOResult相关结构体 --- dataprocess.pb.go | 2262 +++++++++++++++++++++++++++++++++++++++++++++++---------- dataprocess.proto | 36 2 files changed, 1,897 insertions(+), 401 deletions(-) diff --git a/dataprocess.pb.go b/dataprocess.pb.go index 34fdd71..08ac63d 100644 --- a/dataprocess.pb.go +++ b/dataprocess.pb.go @@ -8,7 +8,6 @@ proto "github.com/golang/protobuf/proto" io "io" math "math" - math_bits "math/bits" ) // Reference imports to suppress errors if they are not otherwise used. @@ -20,7 +19,7 @@ // is compatible with the proto package it is being compiled against. // A compilation error at this line likely means your copy of the // proto package needs to be updated. -const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package +const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package type TaskBasicInfo struct { CamId string `protobuf:"bytes,1,opt,name=CamId,proto3" json:"CamId,omitempty"` @@ -51,7 +50,7 @@ return xxx_messageInfo_TaskBasicInfo.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) + n, err := m.MarshalTo(b) if err != nil { return nil, err } @@ -133,6 +132,291 @@ return "" } +type RuleParams struct { + SdkArgAlias string `protobuf:"bytes,1,opt,name=SdkArgAlias,proto3" json:"SdkArgAlias,omitempty"` + Operator string `protobuf:"bytes,2,opt,name=Operator,proto3" json:"Operator,omitempty"` + OperatorType string `protobuf:"bytes,3,opt,name=OperatorType,proto3" json:"OperatorType,omitempty"` + SdkArgValue string `protobuf:"bytes,4,opt,name=SdkArgValue,proto3" json:"SdkArgValue,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RuleParams) Reset() { *m = RuleParams{} } +func (m *RuleParams) String() string { return proto.CompactTextString(m) } +func (*RuleParams) ProtoMessage() {} +func (*RuleParams) Descriptor() ([]byte, []int) { + return fileDescriptor_02f614a9207041cc, []int{1} +} +func (m *RuleParams) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RuleParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RuleParams.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 *RuleParams) XXX_Merge(src proto.Message) { + xxx_messageInfo_RuleParams.Merge(m, src) +} +func (m *RuleParams) XXX_Size() int { + return m.Size() +} +func (m *RuleParams) XXX_DiscardUnknown() { + xxx_messageInfo_RuleParams.DiscardUnknown(m) +} + +var xxx_messageInfo_RuleParams proto.InternalMessageInfo + +func (m *RuleParams) GetSdkArgAlias() string { + if m != nil { + return m.SdkArgAlias + } + return "" +} + +func (m *RuleParams) GetOperator() string { + if m != nil { + return m.Operator + } + return "" +} + +func (m *RuleParams) GetOperatorType() string { + if m != nil { + return m.OperatorType + } + return "" +} + +func (m *RuleParams) GetSdkArgValue() string { + if m != nil { + return m.SdkArgValue + } + return "" +} + +type SoRule struct { + Id string `protobuf:"bytes,1,opt,name=Id,proto3" json:"Id,omitempty"` + CameraId string `protobuf:"bytes,2,opt,name=CameraId,proto3" json:"CameraId,omitempty"` + PolygonId string `protobuf:"bytes,3,opt,name=PolygonId,proto3" json:"PolygonId,omitempty"` + SdkId string `protobuf:"bytes,4,opt,name=SdkId,proto3" json:"SdkId,omitempty"` + Sort int32 `protobuf:"varint,5,opt,name=Sort,proto3" json:"Sort,omitempty"` + RuleWithPre string `protobuf:"bytes,6,opt,name=RuleWithPre,proto3" json:"RuleWithPre,omitempty"` + IsSaveAnyhow bool `protobuf:"varint,7,opt,name=IsSaveAnyhow,proto3" json:"IsSaveAnyhow,omitempty"` + GroupId string `protobuf:"bytes,8,opt,name=GroupId,proto3" json:"GroupId,omitempty"` + Params []*RuleParams `protobuf:"bytes,9,rep,name=Params,proto3" json:"Params,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SoRule) Reset() { *m = SoRule{} } +func (m *SoRule) String() string { return proto.CompactTextString(m) } +func (*SoRule) ProtoMessage() {} +func (*SoRule) Descriptor() ([]byte, []int) { + return fileDescriptor_02f614a9207041cc, []int{2} +} +func (m *SoRule) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SoRule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SoRule.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 *SoRule) XXX_Merge(src proto.Message) { + xxx_messageInfo_SoRule.Merge(m, src) +} +func (m *SoRule) XXX_Size() int { + return m.Size() +} +func (m *SoRule) XXX_DiscardUnknown() { + xxx_messageInfo_SoRule.DiscardUnknown(m) +} + +var xxx_messageInfo_SoRule proto.InternalMessageInfo + +func (m *SoRule) GetId() string { + if m != nil { + return m.Id + } + return "" +} + +func (m *SoRule) GetCameraId() string { + if m != nil { + return m.CameraId + } + return "" +} + +func (m *SoRule) GetPolygonId() string { + if m != nil { + return m.PolygonId + } + return "" +} + +func (m *SoRule) GetSdkId() string { + if m != nil { + return m.SdkId + } + return "" +} + +func (m *SoRule) GetSort() int32 { + if m != nil { + return m.Sort + } + return 0 +} + +func (m *SoRule) GetRuleWithPre() string { + if m != nil { + return m.RuleWithPre + } + return "" +} + +func (m *SoRule) GetIsSaveAnyhow() bool { + if m != nil { + return m.IsSaveAnyhow + } + return false +} + +func (m *SoRule) GetGroupId() string { + if m != nil { + return m.GroupId + } + return "" +} + +func (m *SoRule) GetParams() []*RuleParams { + if m != nil { + return m.Params + } + 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"` @@ -149,7 +433,7 @@ func (m *SoTarget) String() string { return proto.CompactTextString(m) } func (*SoTarget) ProtoMessage() {} func (*SoTarget) Descriptor() ([]byte, []int) { - return fileDescriptor_02f614a9207041cc, []int{1} + return fileDescriptor_02f614a9207041cc, []int{4} } func (m *SoTarget) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -159,7 +443,7 @@ return xxx_messageInfo_SoTarget.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) + n, err := m.MarshalTo(b) if err != nil { return nil, err } @@ -233,7 +517,7 @@ func (m *EventCache) String() string { return proto.CompactTextString(m) } func (*EventCache) ProtoMessage() {} func (*EventCache) Descriptor() ([]byte, []int) { - return fileDescriptor_02f614a9207041cc, []int{2} + return fileDescriptor_02f614a9207041cc, []int{5} } func (m *EventCache) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -243,7 +527,7 @@ return xxx_messageInfo_EventCache.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) + n, err := m.MarshalTo(b) if err != nil { return nil, err } @@ -296,7 +580,7 @@ func (m *TargetCache) String() string { return proto.CompactTextString(m) } func (*TargetCache) ProtoMessage() {} func (*TargetCache) Descriptor() ([]byte, []int) { - return fileDescriptor_02f614a9207041cc, []int{3} + return fileDescriptor_02f614a9207041cc, []int{6} } func (m *TargetCache) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -306,7 +590,7 @@ return xxx_messageInfo_TargetCache.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) + n, err := m.MarshalTo(b) if err != nil { return nil, err } @@ -359,7 +643,7 @@ func (m *FilterResult) String() string { return proto.CompactTextString(m) } func (*FilterResult) ProtoMessage() {} func (*FilterResult) Descriptor() ([]byte, []int) { - return fileDescriptor_02f614a9207041cc, []int{4} + return fileDescriptor_02f614a9207041cc, []int{7} } func (m *FilterResult) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -369,7 +653,7 @@ return xxx_messageInfo_FilterResult.Marshal(b, m, deterministic) } else { b = b[:cap(b)] - n, err := m.MarshalToSizedBuffer(b) + n, err := m.MarshalTo(b) if err != nil { return nil, err } @@ -411,6 +695,9 @@ func init() { 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((*EventCache)(nil), "protomsg.EventCache") proto.RegisterMapType((map[int64]*Image)(nil), "protomsg.EventCache.ImagesEntry") @@ -426,55 +713,71 @@ func init() { proto.RegisterFile("dataprocess.proto", fileDescriptor_02f614a9207041cc) } var fileDescriptor_02f614a9207041cc = []byte{ - // 665 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x94, 0xcd, 0x6e, 0xd3, 0x40, - 0x10, 0xc7, 0x71, 0xdc, 0xa4, 0xc9, 0xb8, 0xd0, 0xb2, 0x14, 0xb0, 0x22, 0x1a, 0x19, 0x43, 0x25, - 0x53, 0xa4, 0x20, 0xb5, 0x97, 0xaa, 0x55, 0x0f, 0xe4, 0xa3, 0x60, 0x0e, 0x45, 0x6c, 0x7b, 0xe2, - 0xb6, 0x8d, 0x97, 0x10, 0xd5, 0x1f, 0x91, 0xd7, 0xa9, 0xd4, 0x07, 0xe0, 0x1d, 0x78, 0x15, 0xde, - 0x80, 0x23, 0x8f, 0x80, 0xc2, 0x13, 0x70, 0xe6, 0x82, 0x76, 0xd6, 0x8e, 0x37, 0x95, 0x23, 0x4e, - 0x9c, 0xb2, 0x33, 0x9e, 0xff, 0x6f, 0x67, 0xe7, 0x23, 0x70, 0x3f, 0x60, 0x19, 0x9b, 0xa6, 0xc9, - 0x88, 0x0b, 0xd1, 0x9d, 0xa6, 0x49, 0x96, 0x90, 0x26, 0xfe, 0x44, 0x62, 0xdc, 0x6e, 0x89, 0xe0, - 0x4a, 0x39, 0xdb, 0x90, 0xce, 0x42, 0x9e, 0x9f, 0xef, 0x15, 0x01, 0xca, 0x76, 0xbf, 0xd4, 0xe0, - 0xee, 0x05, 0x13, 0x57, 0x3d, 0x26, 0x26, 0x23, 0x3f, 0xfe, 0x94, 0x90, 0x6d, 0xa8, 0xf7, 0x59, - 0xe4, 0x07, 0xb6, 0xe1, 0x18, 0x5e, 0x8b, 0x2a, 0x83, 0xd8, 0xb0, 0xde, 0x67, 0xd1, 0x19, 0x8b, - 0xb8, 0x5d, 0x43, 0x7f, 0x61, 0x92, 0x47, 0xd0, 0x90, 0x00, 0x7f, 0x60, 0x9b, 0xf8, 0x21, 0xb7, - 0x48, 0x1b, 0x9a, 0xf2, 0x84, 0x92, 0x35, 0xfc, 0xb2, 0xb0, 0x49, 0x07, 0xe0, 0x2d, 0x8b, 0x83, - 0x90, 0x5f, 0x4c, 0x22, 0x6e, 0xd7, 0xf1, 0xab, 0xe6, 0x91, 0xb7, 0xf9, 0x11, 0x1b, 0x73, 0x3f, - 0xb0, 0x1b, 0x8e, 0xe1, 0x99, 0xb4, 0x30, 0xc9, 0x13, 0x68, 0xe1, 0x11, 0x85, 0xeb, 0x28, 0x2c, - 0x1d, 0xc4, 0x01, 0xcb, 0x17, 0xc3, 0x38, 0xa0, 0x7c, 0x94, 0xa4, 0x81, 0xdd, 0x74, 0x0c, 0xaf, - 0x49, 0x75, 0x97, 0xcc, 0xf6, 0x74, 0x12, 0x4a, 0x70, 0x4b, 0x65, 0xab, 0x2c, 0xf7, 0xb7, 0x01, - 0xcd, 0xf3, 0xe4, 0x82, 0xa5, 0x63, 0x9e, 0x91, 0x2e, 0xb4, 0xce, 0xd3, 0x91, 0x32, 0xb0, 0x0c, - 0xd6, 0xfe, 0x56, 0x77, 0x51, 0x38, 0xe5, 0xa7, 0x65, 0x88, 0x84, 0xbe, 0x4e, 0x39, 0xf3, 0x83, - 0xbc, 0x36, 0xb9, 0x25, 0x4b, 0x20, 0x4f, 0x58, 0x02, 0x55, 0x9c, 0x85, 0x4d, 0x3c, 0xd8, 0xec, - 0xf1, 0x30, 0x89, 0xc7, 0x42, 0x41, 0xfc, 0x41, 0x5e, 0xa5, 0xdb, 0x6e, 0x72, 0x02, 0xd0, 0x4f, - 0xa2, 0xe9, 0xe0, 0x52, 0xb6, 0xc7, 0xae, 0x3b, 0xa6, 0x67, 0xed, 0xef, 0x94, 0xe9, 0xd0, 0x59, - 0xc8, 0x7b, 0x4c, 0x70, 0x19, 0xc3, 0x52, 0x2e, 0x83, 0xa8, 0x26, 0x58, 0x5d, 0x4b, 0xf7, 0x9b, - 0x09, 0x30, 0xbc, 0xe6, 0x71, 0xd6, 0x67, 0xa3, 0xcf, 0x9c, 0x1c, 0xc3, 0xba, 0xba, 0x53, 0xd8, - 0x06, 0x5e, 0xf2, 0xb4, 0xbc, 0xa4, 0x0c, 0xcb, 0x9f, 0x2f, 0x86, 0x71, 0x96, 0xde, 0xd0, 0x42, - 0x41, 0x06, 0x00, 0x32, 0x91, 0x37, 0x69, 0x32, 0x9b, 0x0a, 0xbb, 0x86, 0xfa, 0xe7, 0x95, 0xfa, - 0x32, 0x4c, 0x21, 0x34, 0x1d, 0x39, 0x84, 0x06, 0x26, 0x27, 0x6c, 0x13, 0x09, 0x4e, 0x25, 0x41, - 0x85, 0x28, 0x75, 0x1e, 0xdf, 0x3e, 0x83, 0x0d, 0x3d, 0x31, 0xb2, 0x05, 0xe6, 0x15, 0xbf, 0xc1, - 0xe6, 0xad, 0x51, 0x79, 0x24, 0x1e, 0xd4, 0xaf, 0x59, 0x38, 0x53, 0xf3, 0x6b, 0xed, 0x93, 0x12, - 0x5d, 0xf4, 0x9d, 0xaa, 0x80, 0xa3, 0xda, 0xa1, 0xd1, 0xa6, 0xb0, 0x79, 0x2b, 0x51, 0x1d, 0xd9, - 0x52, 0xc8, 0x17, 0xcb, 0xc8, 0x07, 0x25, 0x12, 0x75, 0x12, 0xa0, 0x33, 0xdf, 0x81, 0xa5, 0xa5, - 0xae, 0xf3, 0x4c, 0xc5, 0xdb, 0x5d, 0xe6, 0x6d, 0x96, 0x3c, 0xd4, 0x69, 0x2c, 0xf7, 0x8f, 0x01, - 0x96, 0xca, 0x5a, 0x35, 0x6f, 0x4f, 0x6e, 0x61, 0x3e, 0xaf, 0xe6, 0x8a, 0xe7, 0xe5, 0x11, 0x64, - 0x58, 0xd1, 0xab, 0xdd, 0xdb, 0xf3, 0xfd, 0xef, 0x66, 0xed, 0x42, 0x1d, 0xd3, 0xc2, 0xd1, 0xae, - 0xca, 0x16, 0x7f, 0xfe, 0x47, 0x25, 0xdd, 0x79, 0x0d, 0x36, 0x4e, 0x27, 0x61, 0xc6, 0x53, 0xca, - 0xc5, 0x2c, 0xcc, 0xc8, 0x01, 0x34, 0xe5, 0x0e, 0xe0, 0x86, 0xa8, 0x85, 0x7d, 0xac, 0x3f, 0x48, - 0xfb, 0x7f, 0xa3, 0x8b, 0x40, 0x72, 0x04, 0x0d, 0x9c, 0xaa, 0xa2, 0x06, 0x6e, 0x29, 0xd1, 0xe1, - 0x6a, 0xf4, 0x8a, 0x79, 0x53, 0x06, 0x39, 0x29, 0x97, 0x45, 0x8d, 0xea, 0xb3, 0x15, 0xe2, 0xca, - 0x75, 0x69, 0xbf, 0x07, 0x4b, 0xa3, 0x56, 0x14, 0x64, 0x6f, 0xb9, 0x20, 0xdb, 0x55, 0x8b, 0xa0, - 0xcf, 0xd6, 0x87, 0xd5, 0xf3, 0x9f, 0x13, 0x5f, 0x2e, 0x13, 0x1f, 0x56, 0x36, 0x5c, 0x43, 0xf6, - 0x76, 0xbe, 0xcf, 0x3b, 0xc6, 0x8f, 0x79, 0xc7, 0xf8, 0x39, 0xef, 0x18, 0x5f, 0x7f, 0x75, 0xee, - 0x7c, 0xb4, 0xba, 0xaf, 0x8e, 0x0b, 0xd5, 0x65, 0x03, 0x4f, 0x07, 0x7f, 0x03, 0x00, 0x00, 0xff, - 0xff, 0x48, 0x0f, 0xda, 0x74, 0x86, 0x06, 0x00, 0x00, + // 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, } func (m *TaskBasicInfo) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) + n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } @@ -482,90 +785,305 @@ } func (m *TaskBasicInfo) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *TaskBasicInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) + var i int _ = i var l int _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) + if len(m.CamId) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintDataprocess(dAtA, i, uint64(len(m.CamId))) + i += copy(dAtA[i:], m.CamId) } - if len(m.FileId) > 0 { - i -= len(m.FileId) - copy(dAtA[i:], m.FileId) - i = encodeVarintDataprocess(dAtA, i, uint64(len(m.FileId))) - i-- - dAtA[i] = 0x4a + if len(m.CamName) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintDataprocess(dAtA, i, uint64(len(m.CamName))) + i += copy(dAtA[i:], m.CamName) + } + if len(m.TaskID) > 0 { + dAtA[i] = 0x1a + i++ + i = encodeVarintDataprocess(dAtA, i, uint64(len(m.TaskID))) + i += copy(dAtA[i:], m.TaskID) + } + if len(m.TaskName) > 0 { + dAtA[i] = 0x22 + i++ + i = encodeVarintDataprocess(dAtA, i, uint64(len(m.TaskName))) + i += copy(dAtA[i:], m.TaskName) + } + if len(m.HandleTime) > 0 { + dAtA[i] = 0x2a + i++ + i = encodeVarintDataprocess(dAtA, i, uint64(len(m.HandleTime))) + i += copy(dAtA[i:], m.HandleTime) + } + if m.ImageId != 0 { + dAtA[i] = 0x30 + i++ + i = encodeVarintDataprocess(dAtA, i, uint64(m.ImageId)) + } + if len(m.ImageTime) > 0 { + dAtA[i] = 0x3a + i++ + i = encodeVarintDataprocess(dAtA, i, uint64(len(m.ImageTime))) + i += copy(dAtA[i:], m.ImageTime) } if m.IsEndRecord { - i-- + dAtA[i] = 0x40 + i++ if m.IsEndRecord { dAtA[i] = 1 } else { dAtA[i] = 0 } - i-- - dAtA[i] = 0x40 + i++ } - if len(m.ImageTime) > 0 { - i -= len(m.ImageTime) - copy(dAtA[i:], m.ImageTime) - i = encodeVarintDataprocess(dAtA, i, uint64(len(m.ImageTime))) - i-- - dAtA[i] = 0x3a + if len(m.FileId) > 0 { + dAtA[i] = 0x4a + i++ + i = encodeVarintDataprocess(dAtA, i, uint64(len(m.FileId))) + i += copy(dAtA[i:], m.FileId) } - if m.ImageId != 0 { - i = encodeVarintDataprocess(dAtA, i, uint64(m.ImageId)) - i-- - dAtA[i] = 0x30 + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) } - if len(m.HandleTime) > 0 { - i -= len(m.HandleTime) - copy(dAtA[i:], m.HandleTime) - i = encodeVarintDataprocess(dAtA, i, uint64(len(m.HandleTime))) - i-- - dAtA[i] = 0x2a + return i, nil +} + +func (m *RuleParams) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalTo(dAtA) + if err != nil { + return nil, err } - if len(m.TaskName) > 0 { - i -= len(m.TaskName) - copy(dAtA[i:], m.TaskName) - i = encodeVarintDataprocess(dAtA, i, uint64(len(m.TaskName))) - i-- - dAtA[i] = 0x22 - } - if len(m.TaskID) > 0 { - i -= len(m.TaskID) - copy(dAtA[i:], m.TaskID) - i = encodeVarintDataprocess(dAtA, i, uint64(len(m.TaskID))) - i-- - dAtA[i] = 0x1a - } - if len(m.CamName) > 0 { - i -= len(m.CamName) - copy(dAtA[i:], m.CamName) - i = encodeVarintDataprocess(dAtA, i, uint64(len(m.CamName))) - i-- - dAtA[i] = 0x12 - } - if len(m.CamId) > 0 { - i -= len(m.CamId) - copy(dAtA[i:], m.CamId) - i = encodeVarintDataprocess(dAtA, i, uint64(len(m.CamId))) - i-- + return dAtA[:n], nil +} + +func (m *RuleParams) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.SdkArgAlias) > 0 { dAtA[i] = 0xa + i++ + i = encodeVarintDataprocess(dAtA, i, uint64(len(m.SdkArgAlias))) + i += copy(dAtA[i:], m.SdkArgAlias) } - return len(dAtA) - i, nil + if len(m.Operator) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintDataprocess(dAtA, i, uint64(len(m.Operator))) + i += copy(dAtA[i:], m.Operator) + } + if len(m.OperatorType) > 0 { + dAtA[i] = 0x1a + i++ + i = encodeVarintDataprocess(dAtA, i, uint64(len(m.OperatorType))) + i += copy(dAtA[i:], m.OperatorType) + } + if len(m.SdkArgValue) > 0 { + dAtA[i] = 0x22 + i++ + i = encodeVarintDataprocess(dAtA, i, uint64(len(m.SdkArgValue))) + i += copy(dAtA[i:], m.SdkArgValue) + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil +} + +func (m *SoRule) 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 *SoRule) MarshalTo(dAtA []byte) (int, error) { + var i int + _ = i + var l int + _ = l + if len(m.Id) > 0 { + dAtA[i] = 0xa + i++ + i = encodeVarintDataprocess(dAtA, i, uint64(len(m.Id))) + i += copy(dAtA[i:], m.Id) + } + if len(m.CameraId) > 0 { + dAtA[i] = 0x12 + i++ + i = encodeVarintDataprocess(dAtA, i, uint64(len(m.CameraId))) + i += copy(dAtA[i:], m.CameraId) + } + if len(m.PolygonId) > 0 { + dAtA[i] = 0x1a + i++ + i = encodeVarintDataprocess(dAtA, i, uint64(len(m.PolygonId))) + i += copy(dAtA[i:], m.PolygonId) + } + if len(m.SdkId) > 0 { + dAtA[i] = 0x22 + i++ + i = encodeVarintDataprocess(dAtA, i, uint64(len(m.SdkId))) + i += copy(dAtA[i:], m.SdkId) + } + if m.Sort != 0 { + dAtA[i] = 0x28 + i++ + i = encodeVarintDataprocess(dAtA, i, uint64(m.Sort)) + } + if len(m.RuleWithPre) > 0 { + dAtA[i] = 0x32 + i++ + i = encodeVarintDataprocess(dAtA, i, uint64(len(m.RuleWithPre))) + i += copy(dAtA[i:], m.RuleWithPre) + } + if m.IsSaveAnyhow { + dAtA[i] = 0x38 + i++ + if m.IsSaveAnyhow { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i++ + } + if len(m.GroupId) > 0 { + dAtA[i] = 0x42 + i++ + i = encodeVarintDataprocess(dAtA, i, uint64(len(m.GroupId))) + i += copy(dAtA[i:], m.GroupId) + } + if len(m.Params) > 0 { + for _, msg := range m.Params { + dAtA[i] = 0x4a + i++ + i = encodeVarintDataprocess(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + 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 + _ = l + if m.IsEvent { + dAtA[i] = 0x8 + i++ + if m.IsEvent { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i++ + } + if m.IsEndRecord { + dAtA[i] = 0x10 + i++ + if m.IsEndRecord { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i++ + } + if len(m.Targets) > 0 { + for _, msg := range m.Targets { + dAtA[i] = 0x1a + i++ + i = encodeVarintDataprocess(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) + if err != nil { + return 0, err + } + i += n + } + } + if m.FirstImage != nil { + 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:]) + if err2 != nil { + return 0, err2 + } + i += n2 + } + if m.SoRule != nil { + dAtA[i] = 0x32 + i++ + i = encodeVarintDataprocess(dAtA, i, uint64(m.SoRule.Size())) + n3, err3 := m.SoRule.MarshalTo(dAtA[i:]) + if err3 != nil { + return 0, err3 + } + i += n3 + } + if m.GroupRule != nil { + dAtA[i] = 0x3a + i++ + i = encodeVarintDataprocess(dAtA, i, uint64(m.GroupRule.Size())) + n4, err4 := m.GroupRule.MarshalTo(dAtA[i:]) + if err4 != nil { + return 0, err4 + } + i += n4 + } + 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.MarshalToSizedBuffer(dAtA[:size]) + n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } @@ -573,78 +1091,65 @@ } func (m *SoTarget) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *SoTarget) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) + var i int _ = i var l int _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) - } - if m.ImageId != 0 { - i = encodeVarintDataprocess(dAtA, i, uint64(m.ImageId)) - i-- - dAtA[i] = 0x30 - } - if len(m.CompDbInfo) > 0 { - for iNdEx := len(m.CompDbInfo) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.CompDbInfo[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDataprocess(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x2a + 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 } - } - if len(m.BelongsTargetID) > 0 { - i -= len(m.BelongsTargetID) - copy(dAtA[i:], m.BelongsTargetID) - i = encodeVarintDataprocess(dAtA, i, uint64(len(m.BelongsTargetID))) - i-- - dAtA[i] = 0x22 - } - if len(m.AreaName) > 0 { - i -= len(m.AreaName) - copy(dAtA[i:], m.AreaName) - i = encodeVarintDataprocess(dAtA, i, uint64(len(m.AreaName))) - i-- - dAtA[i] = 0x1a + i += n5 } if len(m.AreaId) > 0 { - i -= len(m.AreaId) - copy(dAtA[i:], m.AreaId) - i = encodeVarintDataprocess(dAtA, i, uint64(len(m.AreaId))) - i-- dAtA[i] = 0x12 + i++ + i = encodeVarintDataprocess(dAtA, i, uint64(len(m.AreaId))) + i += copy(dAtA[i:], m.AreaId) } - if m.SrcTarget != nil { - { - size, err := m.SrcTarget.MarshalToSizedBuffer(dAtA[:i]) + 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 -= size - i = encodeVarintDataprocess(dAtA, i, uint64(size)) + i += n } - i-- - dAtA[i] = 0xa } - return len(dAtA) - i, nil + 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 *EventCache) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) + n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } @@ -652,100 +1157,102 @@ } func (m *EventCache) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *EventCache) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) + var i int _ = i var l int _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) - } - if len(m.Images) > 0 { - for k := range m.Images { - v := m.Images[k] - baseI := i + if len(m.Targets) > 0 { + for k, _ := range m.Targets { + dAtA[i] = 0xa + i++ + v := m.Targets[k] + msgSize := 0 if v != nil { - { - size, err := v.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDataprocess(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 + msgSize = v.Size() + msgSize += 1 + sovDataprocess(uint64(msgSize)) } - i = encodeVarintDataprocess(dAtA, i, uint64(k)) - i-- + mapSize := 1 + sovDataprocess(uint64(k)) + msgSize + i = encodeVarintDataprocess(dAtA, i, uint64(mapSize)) dAtA[i] = 0x8 - i = encodeVarintDataprocess(dAtA, i, uint64(baseI-i)) - i-- - dAtA[i] = 0x1a + i++ + i = encodeVarintDataprocess(dAtA, i, uint64(k)) + if v != nil { + dAtA[i] = 0x12 + i++ + i = encodeVarintDataprocess(dAtA, i, uint64(v.Size())) + n6, err6 := v.MarshalTo(dAtA[i:]) + if err6 != nil { + return 0, err6 + } + i += n6 + } } } if len(m.RuleGroups) > 0 { - for k := range m.RuleGroups { - v := m.RuleGroups[k] - baseI := i - if v != nil { - { - size, err := v.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDataprocess(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - i -= len(k) - copy(dAtA[i:], k) - i = encodeVarintDataprocess(dAtA, i, uint64(len(k))) - i-- - dAtA[i] = 0xa - i = encodeVarintDataprocess(dAtA, i, uint64(baseI-i)) - i-- + for k, _ := range m.RuleGroups { dAtA[i] = 0x12 - } - } - if len(m.Targets) > 0 { - for k := range m.Targets { - v := m.Targets[k] - baseI := i + i++ + v := m.RuleGroups[k] + msgSize := 0 if v != nil { - { - size, err := v.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDataprocess(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 + msgSize = v.Size() + msgSize += 1 + sovDataprocess(uint64(msgSize)) } - i = encodeVarintDataprocess(dAtA, i, uint64(k)) - i-- - dAtA[i] = 0x8 - i = encodeVarintDataprocess(dAtA, i, uint64(baseI-i)) - i-- + mapSize := 1 + len(k) + sovDataprocess(uint64(len(k))) + msgSize + i = encodeVarintDataprocess(dAtA, i, uint64(mapSize)) dAtA[i] = 0xa + i++ + i = encodeVarintDataprocess(dAtA, i, uint64(len(k))) + i += copy(dAtA[i:], k) + if v != nil { + dAtA[i] = 0x12 + i++ + i = encodeVarintDataprocess(dAtA, i, uint64(v.Size())) + n7, err7 := v.MarshalTo(dAtA[i:]) + if err7 != nil { + return 0, err7 + } + i += n7 + } } } - return len(dAtA) - i, nil + if len(m.Images) > 0 { + for k, _ := range m.Images { + dAtA[i] = 0x1a + i++ + v := m.Images[k] + msgSize := 0 + if v != nil { + msgSize = v.Size() + msgSize += 1 + sovDataprocess(uint64(msgSize)) + } + mapSize := 1 + sovDataprocess(uint64(k)) + msgSize + i = encodeVarintDataprocess(dAtA, i, uint64(mapSize)) + dAtA[i] = 0x8 + i++ + i = encodeVarintDataprocess(dAtA, i, uint64(k)) + if v != nil { + dAtA[i] = 0x12 + i++ + i = encodeVarintDataprocess(dAtA, i, uint64(v.Size())) + n8, err8 := v.MarshalTo(dAtA[i:]) + if err8 != nil { + return 0, err8 + } + i += n8 + } + } + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil } func (m *TargetCache) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) + n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } @@ -753,78 +1260,70 @@ } func (m *TargetCache) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *TargetCache) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) + var i int _ = i var l int _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) - } - if m.Image != nil { - { - size, err := m.Image.MarshalToSizedBuffer(dAtA[:i]) + if len(m.Target) > 0 { + for _, msg := range m.Target { + dAtA[i] = 0xa + i++ + i = encodeVarintDataprocess(dAtA, i, uint64(msg.Size())) + n, err := msg.MarshalTo(dAtA[i:]) if err != nil { return 0, err } - i -= size - i = encodeVarintDataprocess(dAtA, i, uint64(size)) + i += n } - i-- - dAtA[i] = 0x1a } if len(m.RuleGroups) > 0 { - for k := range m.RuleGroups { - v := m.RuleGroups[k] - baseI := i - if v != nil { - { - size, err := v.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDataprocess(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - i -= len(k) - copy(dAtA[i:], k) - i = encodeVarintDataprocess(dAtA, i, uint64(len(k))) - i-- - dAtA[i] = 0xa - i = encodeVarintDataprocess(dAtA, i, uint64(baseI-i)) - i-- + for k, _ := range m.RuleGroups { dAtA[i] = 0x12 - } - } - if len(m.Target) > 0 { - for iNdEx := len(m.Target) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Target[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDataprocess(dAtA, i, uint64(size)) + i++ + v := m.RuleGroups[k] + msgSize := 0 + if v != nil { + msgSize = v.Size() + msgSize += 1 + sovDataprocess(uint64(msgSize)) } - i-- + mapSize := 1 + len(k) + sovDataprocess(uint64(len(k))) + msgSize + i = encodeVarintDataprocess(dAtA, i, uint64(mapSize)) dAtA[i] = 0xa + i++ + i = encodeVarintDataprocess(dAtA, i, uint64(len(k))) + i += copy(dAtA[i:], k) + if v != nil { + dAtA[i] = 0x12 + i++ + i = encodeVarintDataprocess(dAtA, i, uint64(v.Size())) + n9, err9 := v.MarshalTo(dAtA[i:]) + if err9 != nil { + return 0, err9 + } + i += n9 + } } } - return len(dAtA) - i, nil + if m.Image != nil { + dAtA[i] = 0x1a + i++ + i = encodeVarintDataprocess(dAtA, i, uint64(m.Image.Size())) + n10, err10 := m.Image.MarshalTo(dAtA[i:]) + if err10 != nil { + return 0, err10 + } + i += n10 + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil } func (m *FilterResult) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) + n, err := m.MarshalTo(dAtA) if err != nil { return nil, err } @@ -832,96 +1331,90 @@ } func (m *FilterResult) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *FilterResult) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) + var i int _ = i var l int _ = l - if m.XXX_unrecognized != nil { - i -= len(m.XXX_unrecognized) - copy(dAtA[i:], m.XXX_unrecognized) - } - if len(m.Targets) > 0 { - for k := range m.Targets { - v := m.Targets[k] - baseI := i - if v != nil { - { - size, err := v.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDataprocess(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - i -= len(k) - copy(dAtA[i:], k) - i = encodeVarintDataprocess(dAtA, i, uint64(len(k))) - i-- - dAtA[i] = 0xa - i = encodeVarintDataprocess(dAtA, i, uint64(baseI-i)) - i-- - dAtA[i] = 0x1a + if m.BaseInfo != nil { + dAtA[i] = 0xa + i++ + i = encodeVarintDataprocess(dAtA, i, uint64(m.BaseInfo.Size())) + n11, err11 := m.BaseInfo.MarshalTo(dAtA[i:]) + if err11 != nil { + return 0, err11 } + i += n11 } if len(m.Events) > 0 { - for k := range m.Events { - v := m.Events[k] - baseI := i - if v != nil { - { - size, err := v.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintDataprocess(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - i -= len(k) - copy(dAtA[i:], k) - i = encodeVarintDataprocess(dAtA, i, uint64(len(k))) - i-- - dAtA[i] = 0xa - i = encodeVarintDataprocess(dAtA, i, uint64(baseI-i)) - i-- + for k, _ := range m.Events { dAtA[i] = 0x12 - } - } - if m.BaseInfo != nil { - { - size, err := m.BaseInfo.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err + i++ + v := m.Events[k] + msgSize := 0 + if v != nil { + msgSize = v.Size() + msgSize += 1 + sovDataprocess(uint64(msgSize)) } - i -= size - i = encodeVarintDataprocess(dAtA, i, uint64(size)) + mapSize := 1 + len(k) + sovDataprocess(uint64(len(k))) + msgSize + i = encodeVarintDataprocess(dAtA, i, uint64(mapSize)) + dAtA[i] = 0xa + i++ + i = encodeVarintDataprocess(dAtA, i, uint64(len(k))) + i += copy(dAtA[i:], k) + if v != nil { + dAtA[i] = 0x12 + i++ + i = encodeVarintDataprocess(dAtA, i, uint64(v.Size())) + n12, err12 := v.MarshalTo(dAtA[i:]) + if err12 != nil { + return 0, err12 + } + i += n12 + } } - i-- - dAtA[i] = 0xa } - return len(dAtA) - i, nil + if len(m.Targets) > 0 { + for k, _ := range m.Targets { + dAtA[i] = 0x1a + i++ + v := m.Targets[k] + msgSize := 0 + if v != nil { + msgSize = v.Size() + msgSize += 1 + sovDataprocess(uint64(msgSize)) + } + mapSize := 1 + len(k) + sovDataprocess(uint64(len(k))) + msgSize + i = encodeVarintDataprocess(dAtA, i, uint64(mapSize)) + dAtA[i] = 0xa + i++ + i = encodeVarintDataprocess(dAtA, i, uint64(len(k))) + i += copy(dAtA[i:], k) + if v != nil { + dAtA[i] = 0x12 + i++ + i = encodeVarintDataprocess(dAtA, i, uint64(v.Size())) + n13, err13 := v.MarshalTo(dAtA[i:]) + if err13 != nil { + return 0, err13 + } + i += n13 + } + } + } + if m.XXX_unrecognized != nil { + i += copy(dAtA[i:], m.XXX_unrecognized) + } + return i, nil } func encodeVarintDataprocess(dAtA []byte, offset int, v uint64) int { - offset -= sovDataprocess(v) - base := offset for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) - return base + return offset + 1 } func (m *TaskBasicInfo) Size() (n int) { if m == nil { @@ -960,6 +1453,126 @@ n += 2 } l = len(m.FileId) + if l > 0 { + n += 1 + l + sovDataprocess(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *RuleParams) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.SdkArgAlias) + if l > 0 { + n += 1 + l + sovDataprocess(uint64(l)) + } + l = len(m.Operator) + if l > 0 { + n += 1 + l + sovDataprocess(uint64(l)) + } + l = len(m.OperatorType) + if l > 0 { + n += 1 + l + sovDataprocess(uint64(l)) + } + l = len(m.SdkArgValue) + if l > 0 { + n += 1 + l + sovDataprocess(uint64(l)) + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *SoRule) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Id) + if l > 0 { + n += 1 + l + sovDataprocess(uint64(l)) + } + l = len(m.CameraId) + if l > 0 { + n += 1 + l + sovDataprocess(uint64(l)) + } + l = len(m.PolygonId) + if l > 0 { + n += 1 + l + sovDataprocess(uint64(l)) + } + l = len(m.SdkId) + if l > 0 { + n += 1 + l + sovDataprocess(uint64(l)) + } + if m.Sort != 0 { + n += 1 + sovDataprocess(uint64(m.Sort)) + } + l = len(m.RuleWithPre) + if l > 0 { + n += 1 + l + sovDataprocess(uint64(l)) + } + if m.IsSaveAnyhow { + n += 2 + } + l = len(m.GroupId) + if l > 0 { + n += 1 + l + sovDataprocess(uint64(l)) + } + if len(m.Params) > 0 { + for _, e := range m.Params { + l = e.Size() + n += 1 + l + sovDataprocess(uint64(l)) + } + } + if m.XXX_unrecognized != nil { + n += len(m.XXX_unrecognized) + } + return n +} + +func (m *SOResult) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.IsEvent { + n += 2 + } + if m.IsEndRecord { + n += 2 + } + if len(m.Targets) > 0 { + for _, e := range m.Targets { + l = e.Size() + n += 1 + l + sovDataprocess(uint64(l)) + } + } + if m.FirstImage != nil { + l = m.FirstImage.Size() + n += 1 + l + sovDataprocess(uint64(l)) + } + if m.CacheImage != nil { + l = m.CacheImage.Size() + n += 1 + l + sovDataprocess(uint64(l)) + } + if m.SoRule != nil { + l = m.SoRule.Size() + n += 1 + l + sovDataprocess(uint64(l)) + } + if m.GroupRule != nil { + l = m.GroupRule.Size() + n += 1 + l + sovDataprocess(uint64(l)) + } + l = len(m.SoType) if l > 0 { n += 1 + l + sovDataprocess(uint64(l)) } @@ -1135,7 +1748,14 @@ } func sovDataprocess(x uint64) (n int) { - return (math_bits.Len64(x|1) + 6) / 7 + for { + n++ + x >>= 7 + if x == 0 { + break + } + } + return n } func sozDataprocess(x uint64) (n int) { return sovDataprocess(uint64((x << 1) ^ uint64((int64(x) >> 63)))) @@ -1438,7 +2058,815 @@ if err != nil { return err } - if (skippy < 0) || (iNdEx+skippy) < 0 { + 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 *RuleParams) 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: RuleParams: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RuleParams: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SdkArgAlias", 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.SdkArgAlias = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Operator", 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.Operator = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field OperatorType", 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.OperatorType = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SdkArgValue", 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.SdkArgValue = 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 *SoRule) 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: SoRule: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SoRule: 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 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.Id = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + 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 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.CameraId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field PolygonId", 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.PolygonId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SdkId", 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.SdkId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Sort", wireType) + } + m.Sort = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDataprocess + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Sort |= int32(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RuleWithPre", 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.RuleWithPre = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field IsSaveAnyhow", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDataprocess + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.IsSaveAnyhow = bool(v != 0) + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GroupId", 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.GroupId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Params", 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.Params = append(m.Params, &RuleParams{}) + if err := m.Params[len(m.Params)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + 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 *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: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field IsEvent", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDataprocess + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.IsEvent = bool(v != 0) + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field IsEndRecord", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowDataprocess + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.IsEndRecord = bool(v != 0) + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Targets", 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.Targets = append(m.Targets, &SoTarget{}) + if err := m.Targets[len(m.Targets)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field FirstImage", 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.FirstImage == nil { + m.FirstImage = &Image{} + } + if err := m.FirstImage.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CacheImage", 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.CacheImage == nil { + m.CacheImage = &Image{} + } + if err := m.CacheImage.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SoRule", 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.SoRule == nil { + m.SoRule = &SoRule{} + } + if err := m.SoRule.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 7: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field GroupRule", 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.GroupRule == nil { + m.GroupRule = &GroupRule{} + } + if err := m.GroupRule.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 8: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SoType", 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.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 { @@ -1674,7 +3102,10 @@ if err != nil { return err } - if (skippy < 0) || (iNdEx+skippy) < 0 { + if skippy < 0 { + return ErrInvalidLengthDataprocess + } + if (iNdEx + skippy) < 0 { return ErrInvalidLengthDataprocess } if (iNdEx + skippy) > l { @@ -1823,7 +3254,7 @@ if err != nil { return err } - if (skippy < 0) || (iNdEx+skippy) < 0 { + if skippy < 0 { return ErrInvalidLengthDataprocess } if (iNdEx + skippy) > postIndex { @@ -1952,7 +3383,7 @@ if err != nil { return err } - if (skippy < 0) || (iNdEx+skippy) < 0 { + if skippy < 0 { return ErrInvalidLengthDataprocess } if (iNdEx + skippy) > postIndex { @@ -2067,7 +3498,7 @@ if err != nil { return err } - if (skippy < 0) || (iNdEx+skippy) < 0 { + if skippy < 0 { return ErrInvalidLengthDataprocess } if (iNdEx + skippy) > postIndex { @@ -2084,7 +3515,10 @@ if err != nil { return err } - if (skippy < 0) || (iNdEx+skippy) < 0 { + if skippy < 0 { + return ErrInvalidLengthDataprocess + } + if (iNdEx + skippy) < 0 { return ErrInvalidLengthDataprocess } if (iNdEx + skippy) > l { @@ -2281,7 +3715,7 @@ if err != nil { return err } - if (skippy < 0) || (iNdEx+skippy) < 0 { + if skippy < 0 { return ErrInvalidLengthDataprocess } if (iNdEx + skippy) > postIndex { @@ -2334,7 +3768,10 @@ if err != nil { return err } - if (skippy < 0) || (iNdEx+skippy) < 0 { + if skippy < 0 { + return ErrInvalidLengthDataprocess + } + if (iNdEx + skippy) < 0 { return ErrInvalidLengthDataprocess } if (iNdEx + skippy) > l { @@ -2533,7 +3970,7 @@ if err != nil { return err } - if (skippy < 0) || (iNdEx+skippy) < 0 { + if skippy < 0 { return ErrInvalidLengthDataprocess } if (iNdEx + skippy) > postIndex { @@ -2662,7 +4099,7 @@ if err != nil { return err } - if (skippy < 0) || (iNdEx+skippy) < 0 { + if skippy < 0 { return ErrInvalidLengthDataprocess } if (iNdEx + skippy) > postIndex { @@ -2679,7 +4116,10 @@ if err != nil { return err } - if (skippy < 0) || (iNdEx+skippy) < 0 { + if skippy < 0 { + return ErrInvalidLengthDataprocess + } + if (iNdEx + skippy) < 0 { return ErrInvalidLengthDataprocess } if (iNdEx + skippy) > l { @@ -2698,7 +4138,6 @@ func skipDataprocess(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 - depth := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { @@ -2730,8 +4169,10 @@ break } } + return iNdEx, nil case 1: iNdEx += 8 + return iNdEx, nil case 2: var length int for shift := uint(0); ; shift += 7 { @@ -2752,30 +4193,55 @@ return 0, ErrInvalidLengthDataprocess } iNdEx += length - case 3: - depth++ - case 4: - if depth == 0 { - return 0, ErrUnexpectedEndOfGroupDataprocess + if iNdEx < 0 { + return 0, ErrInvalidLengthDataprocess } - depth-- + return iNdEx, nil + case 3: + for { + var innerWire uint64 + var start int = iNdEx + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowDataprocess + } + 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 := skipDataprocess(dAtA[start:]) + if err != nil { + return 0, err + } + iNdEx = start + next + if iNdEx < 0 { + return 0, ErrInvalidLengthDataprocess + } + } + 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) } - if iNdEx < 0 { - return 0, ErrInvalidLengthDataprocess - } - if depth == 0 { - return iNdEx, nil - } } - return 0, io.ErrUnexpectedEOF + panic("unreachable") } var ( - ErrInvalidLengthDataprocess = fmt.Errorf("proto: negative length found during unmarshaling") - ErrIntOverflowDataprocess = fmt.Errorf("proto: integer overflow") - ErrUnexpectedEndOfGroupDataprocess = fmt.Errorf("proto: unexpected end of group") + ErrInvalidLengthDataprocess = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowDataprocess = fmt.Errorf("proto: integer overflow") ) diff --git a/dataprocess.proto b/dataprocess.proto index 111824b..793b789 100644 --- a/dataprocess.proto +++ b/dataprocess.proto @@ -17,13 +17,43 @@ string FileId = 9; // 鏁版嵁鏍堜腑鐨勬枃浠秈d } +message RuleParams { + string SdkArgAlias = 1; + string Operator = 2; + string OperatorType = 3; + string SdkArgValue = 4; +} + +message SoRule { + string Id = 1; + string CameraId = 2; + string PolygonId = 3; + string SdkId = 4; + int32 Sort = 5; + string RuleWithPre = 6; + bool IsSaveAnyhow =7; + string GroupId = 8; + repeated RuleParams Params = 9; +} + +message SOResult { + bool IsEvent = 1; + bool IsEndRecord = 2; + repeated SoTarget Targets = 3; + Image FirstImage = 4; + Image CacheImage = 5; + SoRule SoRule = 6; + GroupRule GroupRule = 7; + string SoType = 8; +} + message SoTarget { Target SrcTarget = 1; - string AreaId = 2; - string AreaName = 3; + string AreaId = 2; + string AreaName = 3; string BelongsTargetID = 4; repeated RuleBaseCompareInfo CompDbInfo = 5; - int64 ImageId = 6; + int64 ImageId = 6; } message EventCache { -- Gitblit v1.8.0