6988 lines
173 KiB
Go
6988 lines
173 KiB
Go
// Code generated by protoc-gen-gogo. DO NOT EDIT.
|
||
// source: app/service/live/xuser/api/grpc/v1/guard.proto
|
||
|
||
package v1
|
||
|
||
import proto "github.com/gogo/protobuf/proto"
|
||
import fmt "fmt"
|
||
import math "math"
|
||
import grpc1 "go-common/app/service/live/xuser/api/grpc"
|
||
import _ "github.com/gogo/protobuf/gogoproto"
|
||
|
||
import (
|
||
context "golang.org/x/net/context"
|
||
grpc "google.golang.org/grpc"
|
||
)
|
||
|
||
import io "io"
|
||
|
||
// Reference imports to suppress errors if they are not otherwise used.
|
||
var _ = proto.Marshal
|
||
var _ = fmt.Errorf
|
||
var _ = math.Inf
|
||
|
||
// This is a compile-time assertion to ensure that this generated file
|
||
// 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.GoGoProtoPackageIsVersion2 // please upgrade the proto package
|
||
|
||
type GuardBuyReq struct {
|
||
OrderId string `protobuf:"bytes,1,opt,name=order_id,json=orderId,proto3" json:"order_id,omitempty" validate:"required"`
|
||
Uid int64 `protobuf:"varint,2,opt,name=uid,proto3" json:"uid,omitempty" validate:"gt=0,required"`
|
||
Ruid int64 `protobuf:"varint,3,opt,name=ruid,proto3" json:"ruid,omitempty" validate:"gt=0,required"`
|
||
GuardLevel int `protobuf:"varint,4,opt,name=guard_level,json=guardLevel,proto3,casttype=int" json:"guard_level,omitempty" validate:"gt=0,required"`
|
||
Num int `protobuf:"varint,5,opt,name=num,proto3,casttype=int" json:"num,omitempty" validate:"gt=0,required"`
|
||
Platform grpc1.Platform `protobuf:"varint,6,opt,name=platform,proto3,enum=live.xuser.Platform" json:"platform,omitempty" validate:"required"`
|
||
Source string `protobuf:"bytes,7,opt,name=source,proto3" json:"source,omitempty" validate:"required"`
|
||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
XXX_unrecognized []byte `json:"-"`
|
||
XXX_sizecache int32 `json:"-"`
|
||
}
|
||
|
||
func (m *GuardBuyReq) Reset() { *m = GuardBuyReq{} }
|
||
func (m *GuardBuyReq) String() string { return proto.CompactTextString(m) }
|
||
func (*GuardBuyReq) ProtoMessage() {}
|
||
func (*GuardBuyReq) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_guard_f5515e6e1476a9e5, []int{0}
|
||
}
|
||
func (m *GuardBuyReq) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *GuardBuyReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_GuardBuyReq.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 (dst *GuardBuyReq) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_GuardBuyReq.Merge(dst, src)
|
||
}
|
||
func (m *GuardBuyReq) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *GuardBuyReq) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_GuardBuyReq.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_GuardBuyReq proto.InternalMessageInfo
|
||
|
||
func (m *GuardBuyReq) GetOrderId() string {
|
||
if m != nil {
|
||
return m.OrderId
|
||
}
|
||
return ""
|
||
}
|
||
|
||
func (m *GuardBuyReq) GetUid() int64 {
|
||
if m != nil {
|
||
return m.Uid
|
||
}
|
||
return 0
|
||
}
|
||
|
||
func (m *GuardBuyReq) GetRuid() int64 {
|
||
if m != nil {
|
||
return m.Ruid
|
||
}
|
||
return 0
|
||
}
|
||
|
||
func (m *GuardBuyReq) GetGuardLevel() int {
|
||
if m != nil {
|
||
return m.GuardLevel
|
||
}
|
||
return 0
|
||
}
|
||
|
||
func (m *GuardBuyReq) GetNum() int {
|
||
if m != nil {
|
||
return m.Num
|
||
}
|
||
return 0
|
||
}
|
||
|
||
func (m *GuardBuyReq) GetPlatform() grpc1.Platform {
|
||
if m != nil {
|
||
return m.Platform
|
||
}
|
||
return grpc1.Platform_UNKNOWN
|
||
}
|
||
|
||
func (m *GuardBuyReq) GetSource() string {
|
||
if m != nil {
|
||
return m.Source
|
||
}
|
||
return ""
|
||
}
|
||
|
||
type GuardBuyReply struct {
|
||
Status int `protobuf:"varint,1,opt,name=status,proto3,casttype=int" json:"status"`
|
||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
XXX_unrecognized []byte `json:"-"`
|
||
XXX_sizecache int32 `json:"-"`
|
||
}
|
||
|
||
func (m *GuardBuyReply) Reset() { *m = GuardBuyReply{} }
|
||
func (m *GuardBuyReply) String() string { return proto.CompactTextString(m) }
|
||
func (*GuardBuyReply) ProtoMessage() {}
|
||
func (*GuardBuyReply) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_guard_f5515e6e1476a9e5, []int{1}
|
||
}
|
||
func (m *GuardBuyReply) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *GuardBuyReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_GuardBuyReply.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 (dst *GuardBuyReply) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_GuardBuyReply.Merge(dst, src)
|
||
}
|
||
func (m *GuardBuyReply) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *GuardBuyReply) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_GuardBuyReply.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_GuardBuyReply proto.InternalMessageInfo
|
||
|
||
func (m *GuardBuyReply) GetStatus() int {
|
||
if m != nil {
|
||
return m.Status
|
||
}
|
||
return 0
|
||
}
|
||
|
||
// GetByUidTargetIdReq 1:1请求
|
||
type ClearUIDCacheReq struct {
|
||
Uid int64 `protobuf:"varint,1,opt,name=uid,proto3" json:"uid,omitempty" form:"uid" validate:"gt=0,required"`
|
||
MagicKey string `protobuf:"bytes,2,opt,name=magic_key,json=magicKey,proto3" json:"magic_key,omitempty" form:"magic_key" validate:"alpha,required"`
|
||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
XXX_unrecognized []byte `json:"-"`
|
||
XXX_sizecache int32 `json:"-"`
|
||
}
|
||
|
||
func (m *ClearUIDCacheReq) Reset() { *m = ClearUIDCacheReq{} }
|
||
func (m *ClearUIDCacheReq) String() string { return proto.CompactTextString(m) }
|
||
func (*ClearUIDCacheReq) ProtoMessage() {}
|
||
func (*ClearUIDCacheReq) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_guard_f5515e6e1476a9e5, []int{2}
|
||
}
|
||
func (m *ClearUIDCacheReq) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *ClearUIDCacheReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_ClearUIDCacheReq.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 (dst *ClearUIDCacheReq) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_ClearUIDCacheReq.Merge(dst, src)
|
||
}
|
||
func (m *ClearUIDCacheReq) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *ClearUIDCacheReq) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_ClearUIDCacheReq.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_ClearUIDCacheReq proto.InternalMessageInfo
|
||
|
||
func (m *ClearUIDCacheReq) GetUid() int64 {
|
||
if m != nil {
|
||
return m.Uid
|
||
}
|
||
return 0
|
||
}
|
||
|
||
func (m *ClearUIDCacheReq) GetMagicKey() string {
|
||
if m != nil {
|
||
return m.MagicKey
|
||
}
|
||
return ""
|
||
}
|
||
|
||
type ClearUIDCacheResp struct {
|
||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
XXX_unrecognized []byte `json:"-"`
|
||
XXX_sizecache int32 `json:"-"`
|
||
}
|
||
|
||
func (m *ClearUIDCacheResp) Reset() { *m = ClearUIDCacheResp{} }
|
||
func (m *ClearUIDCacheResp) String() string { return proto.CompactTextString(m) }
|
||
func (*ClearUIDCacheResp) ProtoMessage() {}
|
||
func (*ClearUIDCacheResp) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_guard_f5515e6e1476a9e5, []int{3}
|
||
}
|
||
func (m *ClearUIDCacheResp) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *ClearUIDCacheResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_ClearUIDCacheResp.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 (dst *ClearUIDCacheResp) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_ClearUIDCacheResp.Merge(dst, src)
|
||
}
|
||
func (m *ClearUIDCacheResp) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *ClearUIDCacheResp) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_ClearUIDCacheResp.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_ClearUIDCacheResp proto.InternalMessageInfo
|
||
|
||
// GetByUidTargetIdReq 1:1请求
|
||
type GetByUidTargetIdReq struct {
|
||
Uid int64 `protobuf:"varint,1,opt,name=uid,proto3" json:"uid,omitempty" form:"uid" validate:"gt=0,required"`
|
||
TargetId int64 `protobuf:"varint,2,opt,name=target_id,json=targetId,proto3" json:"target_id,omitempty" form:"target_id" validate:"required"`
|
||
SortType int64 `protobuf:"varint,3,opt,name=sort_type,json=sortType,proto3" json:"sort_type,omitempty" form:"sort_type" validate:"gte=0"`
|
||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
XXX_unrecognized []byte `json:"-"`
|
||
XXX_sizecache int32 `json:"-"`
|
||
}
|
||
|
||
func (m *GetByUidTargetIdReq) Reset() { *m = GetByUidTargetIdReq{} }
|
||
func (m *GetByUidTargetIdReq) String() string { return proto.CompactTextString(m) }
|
||
func (*GetByUidTargetIdReq) ProtoMessage() {}
|
||
func (*GetByUidTargetIdReq) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_guard_f5515e6e1476a9e5, []int{4}
|
||
}
|
||
func (m *GetByUidTargetIdReq) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *GetByUidTargetIdReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_GetByUidTargetIdReq.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 (dst *GetByUidTargetIdReq) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_GetByUidTargetIdReq.Merge(dst, src)
|
||
}
|
||
func (m *GetByUidTargetIdReq) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *GetByUidTargetIdReq) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_GetByUidTargetIdReq.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_GetByUidTargetIdReq proto.InternalMessageInfo
|
||
|
||
func (m *GetByUidTargetIdReq) GetUid() int64 {
|
||
if m != nil {
|
||
return m.Uid
|
||
}
|
||
return 0
|
||
}
|
||
|
||
func (m *GetByUidTargetIdReq) GetTargetId() int64 {
|
||
if m != nil {
|
||
return m.TargetId
|
||
}
|
||
return 0
|
||
}
|
||
|
||
func (m *GetByUidTargetIdReq) GetSortType() int64 {
|
||
if m != nil {
|
||
return m.SortType
|
||
}
|
||
return 0
|
||
}
|
||
|
||
type GetByUidTargetIdResp struct {
|
||
Data map[int64]*DaHangHaiInfo `protobuf:"bytes,1,rep,name=data" json:"data" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
|
||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
XXX_unrecognized []byte `json:"-"`
|
||
XXX_sizecache int32 `json:"-"`
|
||
}
|
||
|
||
func (m *GetByUidTargetIdResp) Reset() { *m = GetByUidTargetIdResp{} }
|
||
func (m *GetByUidTargetIdResp) String() string { return proto.CompactTextString(m) }
|
||
func (*GetByUidTargetIdResp) ProtoMessage() {}
|
||
func (*GetByUidTargetIdResp) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_guard_f5515e6e1476a9e5, []int{5}
|
||
}
|
||
func (m *GetByUidTargetIdResp) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *GetByUidTargetIdResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_GetByUidTargetIdResp.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 (dst *GetByUidTargetIdResp) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_GetByUidTargetIdResp.Merge(dst, src)
|
||
}
|
||
func (m *GetByUidTargetIdResp) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *GetByUidTargetIdResp) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_GetByUidTargetIdResp.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_GetByUidTargetIdResp proto.InternalMessageInfo
|
||
|
||
func (m *GetByUidTargetIdResp) GetData() map[int64]*DaHangHaiInfo {
|
||
if m != nil {
|
||
return m.Data
|
||
}
|
||
return nil
|
||
}
|
||
|
||
type AllDaHangHaiInfo struct {
|
||
GuardInfo map[int64]*DaHangHaiInfo `protobuf:"bytes,1,rep,name=guardInfo" json:"guardInfo,omitempty" validate:"required" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
|
||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
XXX_unrecognized []byte `json:"-"`
|
||
XXX_sizecache int32 `json:"-"`
|
||
}
|
||
|
||
func (m *AllDaHangHaiInfo) Reset() { *m = AllDaHangHaiInfo{} }
|
||
func (m *AllDaHangHaiInfo) String() string { return proto.CompactTextString(m) }
|
||
func (*AllDaHangHaiInfo) ProtoMessage() {}
|
||
func (*AllDaHangHaiInfo) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_guard_f5515e6e1476a9e5, []int{6}
|
||
}
|
||
func (m *AllDaHangHaiInfo) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *AllDaHangHaiInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_AllDaHangHaiInfo.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 (dst *AllDaHangHaiInfo) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_AllDaHangHaiInfo.Merge(dst, src)
|
||
}
|
||
func (m *AllDaHangHaiInfo) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *AllDaHangHaiInfo) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_AllDaHangHaiInfo.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_AllDaHangHaiInfo proto.InternalMessageInfo
|
||
|
||
func (m *AllDaHangHaiInfo) GetGuardInfo() map[int64]*DaHangHaiInfo {
|
||
if m != nil {
|
||
return m.GuardInfo
|
||
}
|
||
return nil
|
||
}
|
||
|
||
type FilterDaHangHaiInfo struct {
|
||
GuardInfo map[int64]*DaHangHaiInfo `protobuf:"bytes,1,rep,name=guardInfo" json:"guardInfo,omitempty" validate:"required" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
|
||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
XXX_unrecognized []byte `json:"-"`
|
||
XXX_sizecache int32 `json:"-"`
|
||
}
|
||
|
||
func (m *FilterDaHangHaiInfo) Reset() { *m = FilterDaHangHaiInfo{} }
|
||
func (m *FilterDaHangHaiInfo) String() string { return proto.CompactTextString(m) }
|
||
func (*FilterDaHangHaiInfo) ProtoMessage() {}
|
||
func (*FilterDaHangHaiInfo) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_guard_f5515e6e1476a9e5, []int{7}
|
||
}
|
||
func (m *FilterDaHangHaiInfo) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *FilterDaHangHaiInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_FilterDaHangHaiInfo.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 (dst *FilterDaHangHaiInfo) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_FilterDaHangHaiInfo.Merge(dst, src)
|
||
}
|
||
func (m *FilterDaHangHaiInfo) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *FilterDaHangHaiInfo) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_FilterDaHangHaiInfo.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_FilterDaHangHaiInfo proto.InternalMessageInfo
|
||
|
||
func (m *FilterDaHangHaiInfo) GetGuardInfo() map[int64]*DaHangHaiInfo {
|
||
if m != nil {
|
||
return m.GuardInfo
|
||
}
|
||
return nil
|
||
}
|
||
|
||
type DaHangHaiInfo struct {
|
||
// 主键
|
||
Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id"`
|
||
// uid
|
||
Uid int64 `protobuf:"varint,2,opt,name=uid,proto3" json:"uid"`
|
||
// target_id
|
||
TargetId int64 `protobuf:"varint,3,opt,name=target_id,json=targetId,proto3" json:"target_id"`
|
||
// 守护类型 1为总督，2为提督，3为舰长
|
||
PrivilegeType int64 `protobuf:"varint,4,opt,name=privilege_type,json=privilegeType,proto3" json:"privilege_type"`
|
||
// start_time
|
||
StartTime string `protobuf:"bytes,5,opt,name=start_time,json=startTime,proto3" json:"start_time"`
|
||
// expired_time
|
||
ExpiredTime string `protobuf:"bytes,6,opt,name=expired_time,json=expiredTime,proto3" json:"expired_time"`
|
||
// ctime
|
||
Ctime string `protobuf:"bytes,7,opt,name=ctime,proto3" json:"ctime"`
|
||
// utime
|
||
Utime string `protobuf:"bytes,8,opt,name=utime,proto3" json:"utime"`
|
||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
XXX_unrecognized []byte `json:"-"`
|
||
XXX_sizecache int32 `json:"-"`
|
||
}
|
||
|
||
func (m *DaHangHaiInfo) Reset() { *m = DaHangHaiInfo{} }
|
||
func (m *DaHangHaiInfo) String() string { return proto.CompactTextString(m) }
|
||
func (*DaHangHaiInfo) ProtoMessage() {}
|
||
func (*DaHangHaiInfo) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_guard_f5515e6e1476a9e5, []int{8}
|
||
}
|
||
func (m *DaHangHaiInfo) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *DaHangHaiInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_DaHangHaiInfo.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 (dst *DaHangHaiInfo) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_DaHangHaiInfo.Merge(dst, src)
|
||
}
|
||
func (m *DaHangHaiInfo) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *DaHangHaiInfo) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_DaHangHaiInfo.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_DaHangHaiInfo proto.InternalMessageInfo
|
||
|
||
func (m *DaHangHaiInfo) GetId() int64 {
|
||
if m != nil {
|
||
return m.Id
|
||
}
|
||
return 0
|
||
}
|
||
|
||
func (m *DaHangHaiInfo) GetUid() int64 {
|
||
if m != nil {
|
||
return m.Uid
|
||
}
|
||
return 0
|
||
}
|
||
|
||
func (m *DaHangHaiInfo) GetTargetId() int64 {
|
||
if m != nil {
|
||
return m.TargetId
|
||
}
|
||
return 0
|
||
}
|
||
|
||
func (m *DaHangHaiInfo) GetPrivilegeType() int64 {
|
||
if m != nil {
|
||
return m.PrivilegeType
|
||
}
|
||
return 0
|
||
}
|
||
|
||
func (m *DaHangHaiInfo) GetStartTime() string {
|
||
if m != nil {
|
||
return m.StartTime
|
||
}
|
||
return ""
|
||
}
|
||
|
||
func (m *DaHangHaiInfo) GetExpiredTime() string {
|
||
if m != nil {
|
||
return m.ExpiredTime
|
||
}
|
||
return ""
|
||
}
|
||
|
||
func (m *DaHangHaiInfo) GetCtime() string {
|
||
if m != nil {
|
||
return m.Ctime
|
||
}
|
||
return ""
|
||
}
|
||
|
||
func (m *DaHangHaiInfo) GetUtime() string {
|
||
if m != nil {
|
||
return m.Utime
|
||
}
|
||
return ""
|
||
}
|
||
|
||
type DaHangHaiInfoList struct {
|
||
List []*DaHangHaiInfo `protobuf:"bytes,1,rep,name=list" json:"list"`
|
||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
XXX_unrecognized []byte `json:"-"`
|
||
XXX_sizecache int32 `json:"-"`
|
||
}
|
||
|
||
func (m *DaHangHaiInfoList) Reset() { *m = DaHangHaiInfoList{} }
|
||
func (m *DaHangHaiInfoList) String() string { return proto.CompactTextString(m) }
|
||
func (*DaHangHaiInfoList) ProtoMessage() {}
|
||
func (*DaHangHaiInfoList) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_guard_f5515e6e1476a9e5, []int{9}
|
||
}
|
||
func (m *DaHangHaiInfoList) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *DaHangHaiInfoList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_DaHangHaiInfoList.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 (dst *DaHangHaiInfoList) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_DaHangHaiInfoList.Merge(dst, src)
|
||
}
|
||
func (m *DaHangHaiInfoList) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *DaHangHaiInfoList) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_DaHangHaiInfoList.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_DaHangHaiInfoList proto.InternalMessageInfo
|
||
|
||
func (m *DaHangHaiInfoList) GetList() []*DaHangHaiInfo {
|
||
if m != nil {
|
||
return m.List
|
||
}
|
||
return nil
|
||
}
|
||
|
||
type GetByUidTargetIdsReq struct {
|
||
Uid int64 `protobuf:"varint,1,opt,name=uid,proto3" json:"uid,omitempty" form:"uid" validate:"gt=0,required"`
|
||
TargetIDs []*TargetIds `protobuf:"bytes,2,rep,name=targetIDs" json:"targetIDs,omitempty" form:"targetIDs" validate:"required"`
|
||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
XXX_unrecognized []byte `json:"-"`
|
||
XXX_sizecache int32 `json:"-"`
|
||
}
|
||
|
||
func (m *GetByUidTargetIdsReq) Reset() { *m = GetByUidTargetIdsReq{} }
|
||
func (m *GetByUidTargetIdsReq) String() string { return proto.CompactTextString(m) }
|
||
func (*GetByUidTargetIdsReq) ProtoMessage() {}
|
||
func (*GetByUidTargetIdsReq) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_guard_f5515e6e1476a9e5, []int{10}
|
||
}
|
||
func (m *GetByUidTargetIdsReq) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *GetByUidTargetIdsReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_GetByUidTargetIdsReq.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 (dst *GetByUidTargetIdsReq) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_GetByUidTargetIdsReq.Merge(dst, src)
|
||
}
|
||
func (m *GetByUidTargetIdsReq) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *GetByUidTargetIdsReq) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_GetByUidTargetIdsReq.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_GetByUidTargetIdsReq proto.InternalMessageInfo
|
||
|
||
func (m *GetByUidTargetIdsReq) GetUid() int64 {
|
||
if m != nil {
|
||
return m.Uid
|
||
}
|
||
return 0
|
||
}
|
||
|
||
func (m *GetByUidTargetIdsReq) GetTargetIDs() []*TargetIds {
|
||
if m != nil {
|
||
return m.TargetIDs
|
||
}
|
||
return nil
|
||
}
|
||
|
||
type GetByUidTargetIdsResp struct {
|
||
Data map[int64]*DaHangHaiInfo `protobuf:"bytes,1,rep,name=data" json:"data" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
|
||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
XXX_unrecognized []byte `json:"-"`
|
||
XXX_sizecache int32 `json:"-"`
|
||
}
|
||
|
||
func (m *GetByUidTargetIdsResp) Reset() { *m = GetByUidTargetIdsResp{} }
|
||
func (m *GetByUidTargetIdsResp) String() string { return proto.CompactTextString(m) }
|
||
func (*GetByUidTargetIdsResp) ProtoMessage() {}
|
||
func (*GetByUidTargetIdsResp) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_guard_f5515e6e1476a9e5, []int{11}
|
||
}
|
||
func (m *GetByUidTargetIdsResp) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *GetByUidTargetIdsResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_GetByUidTargetIdsResp.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 (dst *GetByUidTargetIdsResp) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_GetByUidTargetIdsResp.Merge(dst, src)
|
||
}
|
||
func (m *GetByUidTargetIdsResp) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *GetByUidTargetIdsResp) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_GetByUidTargetIdsResp.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_GetByUidTargetIdsResp proto.InternalMessageInfo
|
||
|
||
func (m *GetByUidTargetIdsResp) GetData() map[int64]*DaHangHaiInfo {
|
||
if m != nil {
|
||
return m.Data
|
||
}
|
||
return nil
|
||
}
|
||
|
||
type TargetIds struct {
|
||
TargetId int64 `protobuf:"varint,1,opt,name=target_id,json=targetId,proto3" json:"target_id,omitempty" form:"target_id" validate:"gt=0,required"`
|
||
SortType int64 `protobuf:"varint,2,opt,name=sort_type,json=sortType,proto3" json:"sort_type,omitempty" form:"sort_type" validate:"gt=0"`
|
||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
XXX_unrecognized []byte `json:"-"`
|
||
XXX_sizecache int32 `json:"-"`
|
||
}
|
||
|
||
func (m *TargetIds) Reset() { *m = TargetIds{} }
|
||
func (m *TargetIds) String() string { return proto.CompactTextString(m) }
|
||
func (*TargetIds) ProtoMessage() {}
|
||
func (*TargetIds) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_guard_f5515e6e1476a9e5, []int{12}
|
||
}
|
||
func (m *TargetIds) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *TargetIds) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_TargetIds.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 (dst *TargetIds) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_TargetIds.Merge(dst, src)
|
||
}
|
||
func (m *TargetIds) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *TargetIds) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_TargetIds.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_TargetIds proto.InternalMessageInfo
|
||
|
||
func (m *TargetIds) GetTargetId() int64 {
|
||
if m != nil {
|
||
return m.TargetId
|
||
}
|
||
return 0
|
||
}
|
||
|
||
func (m *TargetIds) GetSortType() int64 {
|
||
if m != nil {
|
||
return m.SortType
|
||
}
|
||
return 0
|
||
}
|
||
|
||
// GetByTargetIdsBatchReq 根据uids批量获取所有守护关系
|
||
type GetByTargetIdsReq struct {
|
||
TargetIDs []*TargetIds `protobuf:"bytes,1,rep,name=targetIDs" json:"targetIDs,omitempty" form:"targetIDs" validate:"required"`
|
||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
XXX_unrecognized []byte `json:"-"`
|
||
XXX_sizecache int32 `json:"-"`
|
||
}
|
||
|
||
func (m *GetByTargetIdsReq) Reset() { *m = GetByTargetIdsReq{} }
|
||
func (m *GetByTargetIdsReq) String() string { return proto.CompactTextString(m) }
|
||
func (*GetByTargetIdsReq) ProtoMessage() {}
|
||
func (*GetByTargetIdsReq) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_guard_f5515e6e1476a9e5, []int{13}
|
||
}
|
||
func (m *GetByTargetIdsReq) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *GetByTargetIdsReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_GetByTargetIdsReq.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 (dst *GetByTargetIdsReq) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_GetByTargetIdsReq.Merge(dst, src)
|
||
}
|
||
func (m *GetByTargetIdsReq) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *GetByTargetIdsReq) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_GetByTargetIdsReq.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_GetByTargetIdsReq proto.InternalMessageInfo
|
||
|
||
func (m *GetByTargetIdsReq) GetTargetIDs() []*TargetIds {
|
||
if m != nil {
|
||
return m.TargetIDs
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// TODO 实现
|
||
type GetByTargetIdsResp struct {
|
||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
XXX_unrecognized []byte `json:"-"`
|
||
XXX_sizecache int32 `json:"-"`
|
||
}
|
||
|
||
func (m *GetByTargetIdsResp) Reset() { *m = GetByTargetIdsResp{} }
|
||
func (m *GetByTargetIdsResp) String() string { return proto.CompactTextString(m) }
|
||
func (*GetByTargetIdsResp) ProtoMessage() {}
|
||
func (*GetByTargetIdsResp) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_guard_f5515e6e1476a9e5, []int{14}
|
||
}
|
||
func (m *GetByTargetIdsResp) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *GetByTargetIdsResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_GetByTargetIdsResp.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 (dst *GetByTargetIdsResp) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_GetByTargetIdsResp.Merge(dst, src)
|
||
}
|
||
func (m *GetByTargetIdsResp) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *GetByTargetIdsResp) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_GetByTargetIdsResp.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_GetByTargetIdsResp proto.InternalMessageInfo
|
||
|
||
// GetAllShouHuReq 目标全部守护数据
|
||
type GetByUidReq struct {
|
||
Uid int64 `protobuf:"varint,1,opt,name=uid,proto3" json:"uid,omitempty" form:"uid" validate:"gt=0,required"`
|
||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
XXX_unrecognized []byte `json:"-"`
|
||
XXX_sizecache int32 `json:"-"`
|
||
}
|
||
|
||
func (m *GetByUidReq) Reset() { *m = GetByUidReq{} }
|
||
func (m *GetByUidReq) String() string { return proto.CompactTextString(m) }
|
||
func (*GetByUidReq) ProtoMessage() {}
|
||
func (*GetByUidReq) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_guard_f5515e6e1476a9e5, []int{15}
|
||
}
|
||
func (m *GetByUidReq) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *GetByUidReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_GetByUidReq.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 (dst *GetByUidReq) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_GetByUidReq.Merge(dst, src)
|
||
}
|
||
func (m *GetByUidReq) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *GetByUidReq) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_GetByUidReq.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_GetByUidReq proto.InternalMessageInfo
|
||
|
||
func (m *GetByUidReq) GetUid() int64 {
|
||
if m != nil {
|
||
return m.Uid
|
||
}
|
||
return 0
|
||
}
|
||
|
||
type GetByUidResp struct {
|
||
Data map[int64]*DaHangHaiInfo `protobuf:"bytes,1,rep,name=data" json:"data" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
|
||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
XXX_unrecognized []byte `json:"-"`
|
||
XXX_sizecache int32 `json:"-"`
|
||
}
|
||
|
||
func (m *GetByUidResp) Reset() { *m = GetByUidResp{} }
|
||
func (m *GetByUidResp) String() string { return proto.CompactTextString(m) }
|
||
func (*GetByUidResp) ProtoMessage() {}
|
||
func (*GetByUidResp) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_guard_f5515e6e1476a9e5, []int{16}
|
||
}
|
||
func (m *GetByUidResp) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *GetByUidResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_GetByUidResp.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 (dst *GetByUidResp) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_GetByUidResp.Merge(dst, src)
|
||
}
|
||
func (m *GetByUidResp) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *GetByUidResp) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_GetByUidResp.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_GetByUidResp proto.InternalMessageInfo
|
||
|
||
func (m *GetByUidResp) GetData() map[int64]*DaHangHaiInfo {
|
||
if m != nil {
|
||
return m.Data
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// GetAllShouHuBatchReq 目标全部守护数据(批量)
|
||
type GetByUidBatchReq struct {
|
||
Uids []int64 `protobuf:"varint,1,rep,packed,name=uids" json:"uids,omitempty" form:"uids" validate:"required"`
|
||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
XXX_unrecognized []byte `json:"-"`
|
||
XXX_sizecache int32 `json:"-"`
|
||
}
|
||
|
||
func (m *GetByUidBatchReq) Reset() { *m = GetByUidBatchReq{} }
|
||
func (m *GetByUidBatchReq) String() string { return proto.CompactTextString(m) }
|
||
func (*GetByUidBatchReq) ProtoMessage() {}
|
||
func (*GetByUidBatchReq) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_guard_f5515e6e1476a9e5, []int{17}
|
||
}
|
||
func (m *GetByUidBatchReq) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *GetByUidBatchReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_GetByUidBatchReq.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 (dst *GetByUidBatchReq) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_GetByUidBatchReq.Merge(dst, src)
|
||
}
|
||
func (m *GetByUidBatchReq) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *GetByUidBatchReq) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_GetByUidBatchReq.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_GetByUidBatchReq proto.InternalMessageInfo
|
||
|
||
func (m *GetByUidBatchReq) GetUids() []int64 {
|
||
if m != nil {
|
||
return m.Uids
|
||
}
|
||
return nil
|
||
}
|
||
|
||
type GetByUidBatchResp struct {
|
||
Data map[int64]*DaHangHaiInfoList `protobuf:"bytes,1,rep,name=data" json:"data" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value"`
|
||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
XXX_unrecognized []byte `json:"-"`
|
||
XXX_sizecache int32 `json:"-"`
|
||
}
|
||
|
||
func (m *GetByUidBatchResp) Reset() { *m = GetByUidBatchResp{} }
|
||
func (m *GetByUidBatchResp) String() string { return proto.CompactTextString(m) }
|
||
func (*GetByUidBatchResp) ProtoMessage() {}
|
||
func (*GetByUidBatchResp) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_guard_f5515e6e1476a9e5, []int{18}
|
||
}
|
||
func (m *GetByUidBatchResp) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *GetByUidBatchResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_GetByUidBatchResp.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 (dst *GetByUidBatchResp) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_GetByUidBatchResp.Merge(dst, src)
|
||
}
|
||
func (m *GetByUidBatchResp) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *GetByUidBatchResp) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_GetByUidBatchResp.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_GetByUidBatchResp proto.InternalMessageInfo
|
||
|
||
func (m *GetByUidBatchResp) GetData() map[int64]*DaHangHaiInfoList {
|
||
if m != nil {
|
||
return m.Data
|
||
}
|
||
return nil
|
||
}
|
||
|
||
type GetAnchorRecentTopGuardReq struct {
|
||
Uid int64 `protobuf:"varint,1,opt,name=uid,proto3" json:"uid,omitempty" form:"uid" validate:"gt=0,required"`
|
||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
XXX_unrecognized []byte `json:"-"`
|
||
XXX_sizecache int32 `json:"-"`
|
||
}
|
||
|
||
func (m *GetAnchorRecentTopGuardReq) Reset() { *m = GetAnchorRecentTopGuardReq{} }
|
||
func (m *GetAnchorRecentTopGuardReq) String() string { return proto.CompactTextString(m) }
|
||
func (*GetAnchorRecentTopGuardReq) ProtoMessage() {}
|
||
func (*GetAnchorRecentTopGuardReq) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_guard_f5515e6e1476a9e5, []int{19}
|
||
}
|
||
func (m *GetAnchorRecentTopGuardReq) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *GetAnchorRecentTopGuardReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_GetAnchorRecentTopGuardReq.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 (dst *GetAnchorRecentTopGuardReq) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_GetAnchorRecentTopGuardReq.Merge(dst, src)
|
||
}
|
||
func (m *GetAnchorRecentTopGuardReq) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *GetAnchorRecentTopGuardReq) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_GetAnchorRecentTopGuardReq.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_GetAnchorRecentTopGuardReq proto.InternalMessageInfo
|
||
|
||
func (m *GetAnchorRecentTopGuardReq) GetUid() int64 {
|
||
if m != nil {
|
||
return m.Uid
|
||
}
|
||
return 0
|
||
}
|
||
|
||
type GetAnchorRecentTopGuardResp struct {
|
||
// 主键
|
||
Cnt int64 `protobuf:"varint,1,opt,name=cnt,proto3" json:"cnt"`
|
||
List []*GetAnchorRecentTopGuardList `protobuf:"bytes,2,rep,name=list" json:"list"`
|
||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
XXX_unrecognized []byte `json:"-"`
|
||
XXX_sizecache int32 `json:"-"`
|
||
}
|
||
|
||
func (m *GetAnchorRecentTopGuardResp) Reset() { *m = GetAnchorRecentTopGuardResp{} }
|
||
func (m *GetAnchorRecentTopGuardResp) String() string { return proto.CompactTextString(m) }
|
||
func (*GetAnchorRecentTopGuardResp) ProtoMessage() {}
|
||
func (*GetAnchorRecentTopGuardResp) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_guard_f5515e6e1476a9e5, []int{20}
|
||
}
|
||
func (m *GetAnchorRecentTopGuardResp) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *GetAnchorRecentTopGuardResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_GetAnchorRecentTopGuardResp.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 (dst *GetAnchorRecentTopGuardResp) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_GetAnchorRecentTopGuardResp.Merge(dst, src)
|
||
}
|
||
func (m *GetAnchorRecentTopGuardResp) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *GetAnchorRecentTopGuardResp) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_GetAnchorRecentTopGuardResp.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_GetAnchorRecentTopGuardResp proto.InternalMessageInfo
|
||
|
||
func (m *GetAnchorRecentTopGuardResp) GetCnt() int64 {
|
||
if m != nil {
|
||
return m.Cnt
|
||
}
|
||
return 0
|
||
}
|
||
|
||
func (m *GetAnchorRecentTopGuardResp) GetList() []*GetAnchorRecentTopGuardList {
|
||
if m != nil {
|
||
return m.List
|
||
}
|
||
return nil
|
||
}
|
||
|
||
type GetAnchorRecentTopGuardList struct {
|
||
Uid int64 `protobuf:"varint,1,opt,name=uid,proto3" json:"uid"`
|
||
EndTime int64 `protobuf:"varint,2,opt,name=end_time,json=endTime,proto3" json:"end_time"`
|
||
IsOpen int64 `protobuf:"varint,3,opt,name=is_open,json=isOpen,proto3" json:"is_open"`
|
||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
XXX_unrecognized []byte `json:"-"`
|
||
XXX_sizecache int32 `json:"-"`
|
||
}
|
||
|
||
func (m *GetAnchorRecentTopGuardList) Reset() { *m = GetAnchorRecentTopGuardList{} }
|
||
func (m *GetAnchorRecentTopGuardList) String() string { return proto.CompactTextString(m) }
|
||
func (*GetAnchorRecentTopGuardList) ProtoMessage() {}
|
||
func (*GetAnchorRecentTopGuardList) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_guard_f5515e6e1476a9e5, []int{21}
|
||
}
|
||
func (m *GetAnchorRecentTopGuardList) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *GetAnchorRecentTopGuardList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_GetAnchorRecentTopGuardList.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 (dst *GetAnchorRecentTopGuardList) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_GetAnchorRecentTopGuardList.Merge(dst, src)
|
||
}
|
||
func (m *GetAnchorRecentTopGuardList) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *GetAnchorRecentTopGuardList) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_GetAnchorRecentTopGuardList.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_GetAnchorRecentTopGuardList proto.InternalMessageInfo
|
||
|
||
func (m *GetAnchorRecentTopGuardList) GetUid() int64 {
|
||
if m != nil {
|
||
return m.Uid
|
||
}
|
||
return 0
|
||
}
|
||
|
||
func (m *GetAnchorRecentTopGuardList) GetEndTime() int64 {
|
||
if m != nil {
|
||
return m.EndTime
|
||
}
|
||
return 0
|
||
}
|
||
|
||
func (m *GetAnchorRecentTopGuardList) GetIsOpen() int64 {
|
||
if m != nil {
|
||
return m.IsOpen
|
||
}
|
||
return 0
|
||
}
|
||
|
||
type GetTopListGuardReq struct {
|
||
Uid int64 `protobuf:"varint,1,opt,name=uid,proto3" json:"uid,omitempty" form:"uid" validate:"gt=0,required"`
|
||
Page int64 `protobuf:"varint,2,opt,name=page,proto3" json:"page,omitempty" form:"page" validate:"gte=1"`
|
||
PageSize int64 `protobuf:"varint,3,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty" form:"page_size" validate:"gte=1"`
|
||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
XXX_unrecognized []byte `json:"-"`
|
||
XXX_sizecache int32 `json:"-"`
|
||
}
|
||
|
||
func (m *GetTopListGuardReq) Reset() { *m = GetTopListGuardReq{} }
|
||
func (m *GetTopListGuardReq) String() string { return proto.CompactTextString(m) }
|
||
func (*GetTopListGuardReq) ProtoMessage() {}
|
||
func (*GetTopListGuardReq) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_guard_f5515e6e1476a9e5, []int{22}
|
||
}
|
||
func (m *GetTopListGuardReq) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *GetTopListGuardReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_GetTopListGuardReq.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 (dst *GetTopListGuardReq) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_GetTopListGuardReq.Merge(dst, src)
|
||
}
|
||
func (m *GetTopListGuardReq) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *GetTopListGuardReq) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_GetTopListGuardReq.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_GetTopListGuardReq proto.InternalMessageInfo
|
||
|
||
func (m *GetTopListGuardReq) GetUid() int64 {
|
||
if m != nil {
|
||
return m.Uid
|
||
}
|
||
return 0
|
||
}
|
||
|
||
func (m *GetTopListGuardReq) GetPage() int64 {
|
||
if m != nil {
|
||
return m.Page
|
||
}
|
||
return 0
|
||
}
|
||
|
||
func (m *GetTopListGuardReq) GetPageSize() int64 {
|
||
if m != nil {
|
||
return m.PageSize
|
||
}
|
||
return 0
|
||
}
|
||
|
||
type GetTopListGuardResp struct {
|
||
// 守护总数量
|
||
Num int64 `protobuf:"varint,1,opt,name=num,proto3" json:"num"`
|
||
Page int64 `protobuf:"varint,2,opt,name=page,proto3" json:"page"`
|
||
Now int64 `protobuf:"varint,3,opt,name=now,proto3" json:"now"`
|
||
List []*TopListGuard `protobuf:"bytes,4,rep,name=list" json:"list"`
|
||
Top3 []*TopListGuard `protobuf:"bytes,5,rep,name=top3" json:"top3"`
|
||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
XXX_unrecognized []byte `json:"-"`
|
||
XXX_sizecache int32 `json:"-"`
|
||
}
|
||
|
||
func (m *GetTopListGuardResp) Reset() { *m = GetTopListGuardResp{} }
|
||
func (m *GetTopListGuardResp) String() string { return proto.CompactTextString(m) }
|
||
func (*GetTopListGuardResp) ProtoMessage() {}
|
||
func (*GetTopListGuardResp) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_guard_f5515e6e1476a9e5, []int{23}
|
||
}
|
||
func (m *GetTopListGuardResp) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *GetTopListGuardResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_GetTopListGuardResp.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 (dst *GetTopListGuardResp) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_GetTopListGuardResp.Merge(dst, src)
|
||
}
|
||
func (m *GetTopListGuardResp) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *GetTopListGuardResp) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_GetTopListGuardResp.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_GetTopListGuardResp proto.InternalMessageInfo
|
||
|
||
func (m *GetTopListGuardResp) GetNum() int64 {
|
||
if m != nil {
|
||
return m.Num
|
||
}
|
||
return 0
|
||
}
|
||
|
||
func (m *GetTopListGuardResp) GetPage() int64 {
|
||
if m != nil {
|
||
return m.Page
|
||
}
|
||
return 0
|
||
}
|
||
|
||
func (m *GetTopListGuardResp) GetNow() int64 {
|
||
if m != nil {
|
||
return m.Now
|
||
}
|
||
return 0
|
||
}
|
||
|
||
func (m *GetTopListGuardResp) GetList() []*TopListGuard {
|
||
if m != nil {
|
||
return m.List
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (m *GetTopListGuardResp) GetTop3() []*TopListGuard {
|
||
if m != nil {
|
||
return m.Top3
|
||
}
|
||
return nil
|
||
}
|
||
|
||
type TopListGuard struct {
|
||
Uid int64 `protobuf:"varint,1,opt,name=uid,proto3" json:"uid"`
|
||
Ruid int64 `protobuf:"varint,2,opt,name=ruid,proto3" json:"ruid"`
|
||
Rank int64 `protobuf:"varint,4,opt,name=rank,proto3" json:"rank"`
|
||
GuardLevel int64 `protobuf:"varint,3,opt,name=guard_level,json=guardLevel,proto3" json:"guard_level"`
|
||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
XXX_unrecognized []byte `json:"-"`
|
||
XXX_sizecache int32 `json:"-"`
|
||
}
|
||
|
||
func (m *TopListGuard) Reset() { *m = TopListGuard{} }
|
||
func (m *TopListGuard) String() string { return proto.CompactTextString(m) }
|
||
func (*TopListGuard) ProtoMessage() {}
|
||
func (*TopListGuard) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_guard_f5515e6e1476a9e5, []int{24}
|
||
}
|
||
func (m *TopListGuard) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *TopListGuard) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_TopListGuard.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 (dst *TopListGuard) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_TopListGuard.Merge(dst, src)
|
||
}
|
||
func (m *TopListGuard) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *TopListGuard) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_TopListGuard.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_TopListGuard proto.InternalMessageInfo
|
||
|
||
func (m *TopListGuard) GetUid() int64 {
|
||
if m != nil {
|
||
return m.Uid
|
||
}
|
||
return 0
|
||
}
|
||
|
||
func (m *TopListGuard) GetRuid() int64 {
|
||
if m != nil {
|
||
return m.Ruid
|
||
}
|
||
return 0
|
||
}
|
||
|
||
func (m *TopListGuard) GetRank() int64 {
|
||
if m != nil {
|
||
return m.Rank
|
||
}
|
||
return 0
|
||
}
|
||
|
||
func (m *TopListGuard) GetGuardLevel() int64 {
|
||
if m != nil {
|
||
return m.GuardLevel
|
||
}
|
||
return 0
|
||
}
|
||
|
||
type GetTopListGuardNumReq struct {
|
||
Uid int64 `protobuf:"varint,1,opt,name=uid,proto3" json:"uid,omitempty" form:"uid" validate:"gt=0,required"`
|
||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
XXX_unrecognized []byte `json:"-"`
|
||
XXX_sizecache int32 `json:"-"`
|
||
}
|
||
|
||
func (m *GetTopListGuardNumReq) Reset() { *m = GetTopListGuardNumReq{} }
|
||
func (m *GetTopListGuardNumReq) String() string { return proto.CompactTextString(m) }
|
||
func (*GetTopListGuardNumReq) ProtoMessage() {}
|
||
func (*GetTopListGuardNumReq) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_guard_f5515e6e1476a9e5, []int{25}
|
||
}
|
||
func (m *GetTopListGuardNumReq) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *GetTopListGuardNumReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_GetTopListGuardNumReq.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 (dst *GetTopListGuardNumReq) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_GetTopListGuardNumReq.Merge(dst, src)
|
||
}
|
||
func (m *GetTopListGuardNumReq) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *GetTopListGuardNumReq) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_GetTopListGuardNumReq.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_GetTopListGuardNumReq proto.InternalMessageInfo
|
||
|
||
func (m *GetTopListGuardNumReq) GetUid() int64 {
|
||
if m != nil {
|
||
return m.Uid
|
||
}
|
||
return 0
|
||
}
|
||
|
||
type GetTopListGuardNumResp struct {
|
||
TotalCount int64 `protobuf:"varint,1,opt,name=total_count,json=totalCount,proto3" json:"total_count"`
|
||
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
XXX_unrecognized []byte `json:"-"`
|
||
XXX_sizecache int32 `json:"-"`
|
||
}
|
||
|
||
func (m *GetTopListGuardNumResp) Reset() { *m = GetTopListGuardNumResp{} }
|
||
func (m *GetTopListGuardNumResp) String() string { return proto.CompactTextString(m) }
|
||
func (*GetTopListGuardNumResp) ProtoMessage() {}
|
||
func (*GetTopListGuardNumResp) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_guard_f5515e6e1476a9e5, []int{26}
|
||
}
|
||
func (m *GetTopListGuardNumResp) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *GetTopListGuardNumResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_GetTopListGuardNumResp.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 (dst *GetTopListGuardNumResp) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_GetTopListGuardNumResp.Merge(dst, src)
|
||
}
|
||
func (m *GetTopListGuardNumResp) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *GetTopListGuardNumResp) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_GetTopListGuardNumResp.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_GetTopListGuardNumResp proto.InternalMessageInfo
|
||
|
||
func (m *GetTopListGuardNumResp) GetTotalCount() int64 {
|
||
if m != nil {
|
||
return m.TotalCount
|
||
}
|
||
return 0
|
||
}
|
||
|
||
func init() {
|
||
proto.RegisterType((*GuardBuyReq)(nil), "live.xuser.v1.GuardBuyReq")
|
||
proto.RegisterType((*GuardBuyReply)(nil), "live.xuser.v1.GuardBuyReply")
|
||
proto.RegisterType((*ClearUIDCacheReq)(nil), "live.xuser.v1.ClearUIDCacheReq")
|
||
proto.RegisterType((*ClearUIDCacheResp)(nil), "live.xuser.v1.ClearUIDCacheResp")
|
||
proto.RegisterType((*GetByUidTargetIdReq)(nil), "live.xuser.v1.GetByUidTargetIdReq")
|
||
proto.RegisterType((*GetByUidTargetIdResp)(nil), "live.xuser.v1.GetByUidTargetIdResp")
|
||
proto.RegisterMapType((map[int64]*DaHangHaiInfo)(nil), "live.xuser.v1.GetByUidTargetIdResp.DataEntry")
|
||
proto.RegisterType((*AllDaHangHaiInfo)(nil), "live.xuser.v1.AllDaHangHaiInfo")
|
||
proto.RegisterMapType((map[int64]*DaHangHaiInfo)(nil), "live.xuser.v1.AllDaHangHaiInfo.GuardInfoEntry")
|
||
proto.RegisterType((*FilterDaHangHaiInfo)(nil), "live.xuser.v1.FilterDaHangHaiInfo")
|
||
proto.RegisterMapType((map[int64]*DaHangHaiInfo)(nil), "live.xuser.v1.FilterDaHangHaiInfo.GuardInfoEntry")
|
||
proto.RegisterType((*DaHangHaiInfo)(nil), "live.xuser.v1.DaHangHaiInfo")
|
||
proto.RegisterType((*DaHangHaiInfoList)(nil), "live.xuser.v1.DaHangHaiInfoList")
|
||
proto.RegisterType((*GetByUidTargetIdsReq)(nil), "live.xuser.v1.GetByUidTargetIdsReq")
|
||
proto.RegisterType((*GetByUidTargetIdsResp)(nil), "live.xuser.v1.GetByUidTargetIdsResp")
|
||
proto.RegisterMapType((map[int64]*DaHangHaiInfo)(nil), "live.xuser.v1.GetByUidTargetIdsResp.DataEntry")
|
||
proto.RegisterType((*TargetIds)(nil), "live.xuser.v1.TargetIds")
|
||
proto.RegisterType((*GetByTargetIdsReq)(nil), "live.xuser.v1.GetByTargetIdsReq")
|
||
proto.RegisterType((*GetByTargetIdsResp)(nil), "live.xuser.v1.GetByTargetIdsResp")
|
||
proto.RegisterType((*GetByUidReq)(nil), "live.xuser.v1.GetByUidReq")
|
||
proto.RegisterType((*GetByUidResp)(nil), "live.xuser.v1.GetByUidResp")
|
||
proto.RegisterMapType((map[int64]*DaHangHaiInfo)(nil), "live.xuser.v1.GetByUidResp.DataEntry")
|
||
proto.RegisterType((*GetByUidBatchReq)(nil), "live.xuser.v1.GetByUidBatchReq")
|
||
proto.RegisterType((*GetByUidBatchResp)(nil), "live.xuser.v1.GetByUidBatchResp")
|
||
proto.RegisterMapType((map[int64]*DaHangHaiInfoList)(nil), "live.xuser.v1.GetByUidBatchResp.DataEntry")
|
||
proto.RegisterType((*GetAnchorRecentTopGuardReq)(nil), "live.xuser.v1.GetAnchorRecentTopGuardReq")
|
||
proto.RegisterType((*GetAnchorRecentTopGuardResp)(nil), "live.xuser.v1.GetAnchorRecentTopGuardResp")
|
||
proto.RegisterType((*GetAnchorRecentTopGuardList)(nil), "live.xuser.v1.GetAnchorRecentTopGuardList")
|
||
proto.RegisterType((*GetTopListGuardReq)(nil), "live.xuser.v1.GetTopListGuardReq")
|
||
proto.RegisterType((*GetTopListGuardResp)(nil), "live.xuser.v1.GetTopListGuardResp")
|
||
proto.RegisterType((*TopListGuard)(nil), "live.xuser.v1.TopListGuard")
|
||
proto.RegisterType((*GetTopListGuardNumReq)(nil), "live.xuser.v1.GetTopListGuardNumReq")
|
||
proto.RegisterType((*GetTopListGuardNumResp)(nil), "live.xuser.v1.GetTopListGuardNumResp")
|
||
}
|
||
|
||
// Reference imports to suppress errors if they are not otherwise used.
|
||
var _ context.Context
|
||
var _ grpc.ClientConn
|
||
|
||
// This is a compile-time assertion to ensure that this generated file
|
||
// is compatible with the grpc package it is being compiled against.
|
||
const _ = grpc.SupportPackageIsVersion4
|
||
|
||
// GuardClient is the client API for Guard service.
|
||
//
|
||
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
|
||
type GuardClient interface {
|
||
// Buy 购买大航海
|
||
Buy(ctx context.Context, in *GuardBuyReq, opts ...grpc.CallOption) (*GuardBuyReply, error)
|
||
// GetByUIDTargetID 获取我与目标用户守护关系,不支持批量(P0级)
|
||
GetByUIDTargetID(ctx context.Context, in *GetByUidTargetIdReq, opts ...grpc.CallOption) (*GetByUidTargetIdResp, error)
|
||
// GetByTargetIdsBatch 获取我与目标用户守护关系,支持批量(P2级,必要时刻降级)
|
||
GetByTargetIdsBatch(ctx context.Context, in *GetByTargetIdsReq, opts ...grpc.CallOption) (*GetByTargetIdsResp, error)
|
||
// GetByUIDTargetIds 根据uids批量获取所有守护关系,粉丝勋章使用
|
||
GetByUIDTargetIds(ctx context.Context, in *GetByUidTargetIdsReq, opts ...grpc.CallOption) (*GetByUidTargetIdsResp, error)
|
||
// GetByUID 获取我所有的守护,不支持批量(P0级)
|
||
GetByUIDForGift(ctx context.Context, in *GetByUidReq, opts ...grpc.CallOption) (*GetByUidResp, error)
|
||
// GetByUIDBatch 根据uids获取所有的守护,支持批量(P2级)
|
||
GetByUIDBatch(ctx context.Context, in *GetByUidBatchReq, opts ...grpc.CallOption) (*GetByUidBatchResp, error)
|
||
// GetAnchorRecentTopGuard 获取最近的提督弹窗提醒
|
||
GetAnchorRecentTopGuard(ctx context.Context, in *GetAnchorRecentTopGuardReq, opts ...grpc.CallOption) (*GetAnchorRecentTopGuardResp, error)
|
||
// GetTopListGuard 获取某个up主的守护排行榜
|
||
GetTopListGuard(ctx context.Context, in *GetTopListGuardReq, opts ...grpc.CallOption) (*GetTopListGuardResp, error)
|
||
// GetTopListGuardNum 获取某个up主所有的守护数量,和GetTopListGuard接口的区别是此接口用于房间页首屏,逻辑比较简单,因此拆分开来
|
||
GetTopListGuardNum(ctx context.Context, in *GetTopListGuardNumReq, opts ...grpc.CallOption) (*GetTopListGuardNumResp, error)
|
||
// ClearUIDCache 清除cache
|
||
ClearUIDCache(ctx context.Context, in *ClearUIDCacheReq, opts ...grpc.CallOption) (*ClearUIDCacheResp, error)
|
||
}
|
||
|
||
type guardClient struct {
|
||
cc *grpc.ClientConn
|
||
}
|
||
|
||
func NewGuardClient(cc *grpc.ClientConn) GuardClient {
|
||
return &guardClient{cc}
|
||
}
|
||
|
||
func (c *guardClient) Buy(ctx context.Context, in *GuardBuyReq, opts ...grpc.CallOption) (*GuardBuyReply, error) {
|
||
out := new(GuardBuyReply)
|
||
err := c.cc.Invoke(ctx, "/live.xuser.v1.Guard/Buy", in, out, opts...)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func (c *guardClient) GetByUIDTargetID(ctx context.Context, in *GetByUidTargetIdReq, opts ...grpc.CallOption) (*GetByUidTargetIdResp, error) {
|
||
out := new(GetByUidTargetIdResp)
|
||
err := c.cc.Invoke(ctx, "/live.xuser.v1.Guard/GetByUIDTargetID", in, out, opts...)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func (c *guardClient) GetByTargetIdsBatch(ctx context.Context, in *GetByTargetIdsReq, opts ...grpc.CallOption) (*GetByTargetIdsResp, error) {
|
||
out := new(GetByTargetIdsResp)
|
||
err := c.cc.Invoke(ctx, "/live.xuser.v1.Guard/GetByTargetIdsBatch", in, out, opts...)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func (c *guardClient) GetByUIDTargetIds(ctx context.Context, in *GetByUidTargetIdsReq, opts ...grpc.CallOption) (*GetByUidTargetIdsResp, error) {
|
||
out := new(GetByUidTargetIdsResp)
|
||
err := c.cc.Invoke(ctx, "/live.xuser.v1.Guard/GetByUIDTargetIds", in, out, opts...)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func (c *guardClient) GetByUIDForGift(ctx context.Context, in *GetByUidReq, opts ...grpc.CallOption) (*GetByUidResp, error) {
|
||
out := new(GetByUidResp)
|
||
err := c.cc.Invoke(ctx, "/live.xuser.v1.Guard/GetByUIDForGift", in, out, opts...)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func (c *guardClient) GetByUIDBatch(ctx context.Context, in *GetByUidBatchReq, opts ...grpc.CallOption) (*GetByUidBatchResp, error) {
|
||
out := new(GetByUidBatchResp)
|
||
err := c.cc.Invoke(ctx, "/live.xuser.v1.Guard/GetByUIDBatch", in, out, opts...)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func (c *guardClient) GetAnchorRecentTopGuard(ctx context.Context, in *GetAnchorRecentTopGuardReq, opts ...grpc.CallOption) (*GetAnchorRecentTopGuardResp, error) {
|
||
out := new(GetAnchorRecentTopGuardResp)
|
||
err := c.cc.Invoke(ctx, "/live.xuser.v1.Guard/GetAnchorRecentTopGuard", in, out, opts...)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func (c *guardClient) GetTopListGuard(ctx context.Context, in *GetTopListGuardReq, opts ...grpc.CallOption) (*GetTopListGuardResp, error) {
|
||
out := new(GetTopListGuardResp)
|
||
err := c.cc.Invoke(ctx, "/live.xuser.v1.Guard/GetTopListGuard", in, out, opts...)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func (c *guardClient) GetTopListGuardNum(ctx context.Context, in *GetTopListGuardNumReq, opts ...grpc.CallOption) (*GetTopListGuardNumResp, error) {
|
||
out := new(GetTopListGuardNumResp)
|
||
err := c.cc.Invoke(ctx, "/live.xuser.v1.Guard/GetTopListGuardNum", in, out, opts...)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func (c *guardClient) ClearUIDCache(ctx context.Context, in *ClearUIDCacheReq, opts ...grpc.CallOption) (*ClearUIDCacheResp, error) {
|
||
out := new(ClearUIDCacheResp)
|
||
err := c.cc.Invoke(ctx, "/live.xuser.v1.Guard/ClearUIDCache", in, out, opts...)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
// GuardServer is the server API for Guard service.
|
||
type GuardServer interface {
|
||
// Buy 购买大航海
|
||
Buy(context.Context, *GuardBuyReq) (*GuardBuyReply, error)
|
||
// GetByUIDTargetID 获取我与目标用户守护关系,不支持批量(P0级)
|
||
GetByUIDTargetID(context.Context, *GetByUidTargetIdReq) (*GetByUidTargetIdResp, error)
|
||
// GetByTargetIdsBatch 获取我与目标用户守护关系,支持批量(P2级,必要时刻降级)
|
||
GetByTargetIdsBatch(context.Context, *GetByTargetIdsReq) (*GetByTargetIdsResp, error)
|
||
// GetByUIDTargetIds 根据uids批量获取所有守护关系,粉丝勋章使用
|
||
GetByUIDTargetIds(context.Context, *GetByUidTargetIdsReq) (*GetByUidTargetIdsResp, error)
|
||
// GetByUID 获取我所有的守护,不支持批量(P0级)
|
||
GetByUIDForGift(context.Context, *GetByUidReq) (*GetByUidResp, error)
|
||
// GetByUIDBatch 根据uids获取所有的守护,支持批量(P2级)
|
||
GetByUIDBatch(context.Context, *GetByUidBatchReq) (*GetByUidBatchResp, error)
|
||
// GetAnchorRecentTopGuard 获取最近的提督弹窗提醒
|
||
GetAnchorRecentTopGuard(context.Context, *GetAnchorRecentTopGuardReq) (*GetAnchorRecentTopGuardResp, error)
|
||
// GetTopListGuard 获取某个up主的守护排行榜
|
||
GetTopListGuard(context.Context, *GetTopListGuardReq) (*GetTopListGuardResp, error)
|
||
// GetTopListGuardNum 获取某个up主所有的守护数量,和GetTopListGuard接口的区别是此接口用于房间页首屏,逻辑比较简单,因此拆分开来
|
||
GetTopListGuardNum(context.Context, *GetTopListGuardNumReq) (*GetTopListGuardNumResp, error)
|
||
// ClearUIDCache 清除cache
|
||
ClearUIDCache(context.Context, *ClearUIDCacheReq) (*ClearUIDCacheResp, error)
|
||
}
|
||
|
||
func RegisterGuardServer(s *grpc.Server, srv GuardServer) {
|
||
s.RegisterService(&_Guard_serviceDesc, srv)
|
||
}
|
||
|
||
func _Guard_Buy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||
in := new(GuardBuyReq)
|
||
if err := dec(in); err != nil {
|
||
return nil, err
|
||
}
|
||
if interceptor == nil {
|
||
return srv.(GuardServer).Buy(ctx, in)
|
||
}
|
||
info := &grpc.UnaryServerInfo{
|
||
Server: srv,
|
||
FullMethod: "/live.xuser.v1.Guard/Buy",
|
||
}
|
||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||
return srv.(GuardServer).Buy(ctx, req.(*GuardBuyReq))
|
||
}
|
||
return interceptor(ctx, in, info, handler)
|
||
}
|
||
|
||
func _Guard_GetByUIDTargetID_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||
in := new(GetByUidTargetIdReq)
|
||
if err := dec(in); err != nil {
|
||
return nil, err
|
||
}
|
||
if interceptor == nil {
|
||
return srv.(GuardServer).GetByUIDTargetID(ctx, in)
|
||
}
|
||
info := &grpc.UnaryServerInfo{
|
||
Server: srv,
|
||
FullMethod: "/live.xuser.v1.Guard/GetByUIDTargetID",
|
||
}
|
||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||
return srv.(GuardServer).GetByUIDTargetID(ctx, req.(*GetByUidTargetIdReq))
|
||
}
|
||
return interceptor(ctx, in, info, handler)
|
||
}
|
||
|
||
func _Guard_GetByTargetIdsBatch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||
in := new(GetByTargetIdsReq)
|
||
if err := dec(in); err != nil {
|
||
return nil, err
|
||
}
|
||
if interceptor == nil {
|
||
return srv.(GuardServer).GetByTargetIdsBatch(ctx, in)
|
||
}
|
||
info := &grpc.UnaryServerInfo{
|
||
Server: srv,
|
||
FullMethod: "/live.xuser.v1.Guard/GetByTargetIdsBatch",
|
||
}
|
||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||
return srv.(GuardServer).GetByTargetIdsBatch(ctx, req.(*GetByTargetIdsReq))
|
||
}
|
||
return interceptor(ctx, in, info, handler)
|
||
}
|
||
|
||
func _Guard_GetByUIDTargetIds_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||
in := new(GetByUidTargetIdsReq)
|
||
if err := dec(in); err != nil {
|
||
return nil, err
|
||
}
|
||
if interceptor == nil {
|
||
return srv.(GuardServer).GetByUIDTargetIds(ctx, in)
|
||
}
|
||
info := &grpc.UnaryServerInfo{
|
||
Server: srv,
|
||
FullMethod: "/live.xuser.v1.Guard/GetByUIDTargetIds",
|
||
}
|
||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||
return srv.(GuardServer).GetByUIDTargetIds(ctx, req.(*GetByUidTargetIdsReq))
|
||
}
|
||
return interceptor(ctx, in, info, handler)
|
||
}
|
||
|
||
func _Guard_GetByUIDForGift_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||
in := new(GetByUidReq)
|
||
if err := dec(in); err != nil {
|
||
return nil, err
|
||
}
|
||
if interceptor == nil {
|
||
return srv.(GuardServer).GetByUIDForGift(ctx, in)
|
||
}
|
||
info := &grpc.UnaryServerInfo{
|
||
Server: srv,
|
||
FullMethod: "/live.xuser.v1.Guard/GetByUIDForGift",
|
||
}
|
||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||
return srv.(GuardServer).GetByUIDForGift(ctx, req.(*GetByUidReq))
|
||
}
|
||
return interceptor(ctx, in, info, handler)
|
||
}
|
||
|
||
func _Guard_GetByUIDBatch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||
in := new(GetByUidBatchReq)
|
||
if err := dec(in); err != nil {
|
||
return nil, err
|
||
}
|
||
if interceptor == nil {
|
||
return srv.(GuardServer).GetByUIDBatch(ctx, in)
|
||
}
|
||
info := &grpc.UnaryServerInfo{
|
||
Server: srv,
|
||
FullMethod: "/live.xuser.v1.Guard/GetByUIDBatch",
|
||
}
|
||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||
return srv.(GuardServer).GetByUIDBatch(ctx, req.(*GetByUidBatchReq))
|
||
}
|
||
return interceptor(ctx, in, info, handler)
|
||
}
|
||
|
||
func _Guard_GetAnchorRecentTopGuard_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||
in := new(GetAnchorRecentTopGuardReq)
|
||
if err := dec(in); err != nil {
|
||
return nil, err
|
||
}
|
||
if interceptor == nil {
|
||
return srv.(GuardServer).GetAnchorRecentTopGuard(ctx, in)
|
||
}
|
||
info := &grpc.UnaryServerInfo{
|
||
Server: srv,
|
||
FullMethod: "/live.xuser.v1.Guard/GetAnchorRecentTopGuard",
|
||
}
|
||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||
return srv.(GuardServer).GetAnchorRecentTopGuard(ctx, req.(*GetAnchorRecentTopGuardReq))
|
||
}
|
||
return interceptor(ctx, in, info, handler)
|
||
}
|
||
|
||
func _Guard_GetTopListGuard_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||
in := new(GetTopListGuardReq)
|
||
if err := dec(in); err != nil {
|
||
return nil, err
|
||
}
|
||
if interceptor == nil {
|
||
return srv.(GuardServer).GetTopListGuard(ctx, in)
|
||
}
|
||
info := &grpc.UnaryServerInfo{
|
||
Server: srv,
|
||
FullMethod: "/live.xuser.v1.Guard/GetTopListGuard",
|
||
}
|
||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||
return srv.(GuardServer).GetTopListGuard(ctx, req.(*GetTopListGuardReq))
|
||
}
|
||
return interceptor(ctx, in, info, handler)
|
||
}
|
||
|
||
func _Guard_GetTopListGuardNum_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||
in := new(GetTopListGuardNumReq)
|
||
if err := dec(in); err != nil {
|
||
return nil, err
|
||
}
|
||
if interceptor == nil {
|
||
return srv.(GuardServer).GetTopListGuardNum(ctx, in)
|
||
}
|
||
info := &grpc.UnaryServerInfo{
|
||
Server: srv,
|
||
FullMethod: "/live.xuser.v1.Guard/GetTopListGuardNum",
|
||
}
|
||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||
return srv.(GuardServer).GetTopListGuardNum(ctx, req.(*GetTopListGuardNumReq))
|
||
}
|
||
return interceptor(ctx, in, info, handler)
|
||
}
|
||
|
||
func _Guard_ClearUIDCache_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||
in := new(ClearUIDCacheReq)
|
||
if err := dec(in); err != nil {
|
||
return nil, err
|
||
}
|
||
if interceptor == nil {
|
||
return srv.(GuardServer).ClearUIDCache(ctx, in)
|
||
}
|
||
info := &grpc.UnaryServerInfo{
|
||
Server: srv,
|
||
FullMethod: "/live.xuser.v1.Guard/ClearUIDCache",
|
||
}
|
||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||
return srv.(GuardServer).ClearUIDCache(ctx, req.(*ClearUIDCacheReq))
|
||
}
|
||
return interceptor(ctx, in, info, handler)
|
||
}
|
||
|
||
var _Guard_serviceDesc = grpc.ServiceDesc{
|
||
ServiceName: "live.xuser.v1.Guard",
|
||
HandlerType: (*GuardServer)(nil),
|
||
Methods: []grpc.MethodDesc{
|
||
{
|
||
MethodName: "Buy",
|
||
Handler: _Guard_Buy_Handler,
|
||
},
|
||
{
|
||
MethodName: "GetByUIDTargetID",
|
||
Handler: _Guard_GetByUIDTargetID_Handler,
|
||
},
|
||
{
|
||
MethodName: "GetByTargetIdsBatch",
|
||
Handler: _Guard_GetByTargetIdsBatch_Handler,
|
||
},
|
||
{
|
||
MethodName: "GetByUIDTargetIds",
|
||
Handler: _Guard_GetByUIDTargetIds_Handler,
|
||
},
|
||
{
|
||
MethodName: "GetByUIDForGift",
|
||
Handler: _Guard_GetByUIDForGift_Handler,
|
||
},
|
||
{
|
||
MethodName: "GetByUIDBatch",
|
||
Handler: _Guard_GetByUIDBatch_Handler,
|
||
},
|
||
{
|
||
MethodName: "GetAnchorRecentTopGuard",
|
||
Handler: _Guard_GetAnchorRecentTopGuard_Handler,
|
||
},
|
||
{
|
||
MethodName: "GetTopListGuard",
|
||
Handler: _Guard_GetTopListGuard_Handler,
|
||
},
|
||
{
|
||
MethodName: "GetTopListGuardNum",
|
||
Handler: _Guard_GetTopListGuardNum_Handler,
|
||
},
|
||
{
|
||
MethodName: "ClearUIDCache",
|
||
Handler: _Guard_ClearUIDCache_Handler,
|
||
},
|
||
},
|
||
Streams: []grpc.StreamDesc{},
|
||
Metadata: "app/service/live/xuser/api/grpc/v1/guard.proto",
|
||
}
|
||
|
||
func (m *GuardBuyReq) 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 *GuardBuyReq) MarshalTo(dAtA []byte) (int, error) {
|
||
var i int
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
if len(m.OrderId) > 0 {
|
||
dAtA[i] = 0xa
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(len(m.OrderId)))
|
||
i += copy(dAtA[i:], m.OrderId)
|
||
}
|
||
if m.Uid != 0 {
|
||
dAtA[i] = 0x10
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(m.Uid))
|
||
}
|
||
if m.Ruid != 0 {
|
||
dAtA[i] = 0x18
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(m.Ruid))
|
||
}
|
||
if m.GuardLevel != 0 {
|
||
dAtA[i] = 0x20
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(m.GuardLevel))
|
||
}
|
||
if m.Num != 0 {
|
||
dAtA[i] = 0x28
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(m.Num))
|
||
}
|
||
if m.Platform != 0 {
|
||
dAtA[i] = 0x30
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(m.Platform))
|
||
}
|
||
if len(m.Source) > 0 {
|
||
dAtA[i] = 0x3a
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(len(m.Source)))
|
||
i += copy(dAtA[i:], m.Source)
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
i += copy(dAtA[i:], m.XXX_unrecognized)
|
||
}
|
||
return i, nil
|
||
}
|
||
|
||
func (m *GuardBuyReply) 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 *GuardBuyReply) MarshalTo(dAtA []byte) (int, error) {
|
||
var i int
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
if m.Status != 0 {
|
||
dAtA[i] = 0x8
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(m.Status))
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
i += copy(dAtA[i:], m.XXX_unrecognized)
|
||
}
|
||
return i, nil
|
||
}
|
||
|
||
func (m *ClearUIDCacheReq) 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 *ClearUIDCacheReq) MarshalTo(dAtA []byte) (int, error) {
|
||
var i int
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
if m.Uid != 0 {
|
||
dAtA[i] = 0x8
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(m.Uid))
|
||
}
|
||
if len(m.MagicKey) > 0 {
|
||
dAtA[i] = 0x12
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(len(m.MagicKey)))
|
||
i += copy(dAtA[i:], m.MagicKey)
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
i += copy(dAtA[i:], m.XXX_unrecognized)
|
||
}
|
||
return i, nil
|
||
}
|
||
|
||
func (m *ClearUIDCacheResp) 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 *ClearUIDCacheResp) MarshalTo(dAtA []byte) (int, error) {
|
||
var i int
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
if m.XXX_unrecognized != nil {
|
||
i += copy(dAtA[i:], m.XXX_unrecognized)
|
||
}
|
||
return i, nil
|
||
}
|
||
|
||
func (m *GetByUidTargetIdReq) 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 *GetByUidTargetIdReq) MarshalTo(dAtA []byte) (int, error) {
|
||
var i int
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
if m.Uid != 0 {
|
||
dAtA[i] = 0x8
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(m.Uid))
|
||
}
|
||
if m.TargetId != 0 {
|
||
dAtA[i] = 0x10
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(m.TargetId))
|
||
}
|
||
if m.SortType != 0 {
|
||
dAtA[i] = 0x18
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(m.SortType))
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
i += copy(dAtA[i:], m.XXX_unrecognized)
|
||
}
|
||
return i, nil
|
||
}
|
||
|
||
func (m *GetByUidTargetIdResp) 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 *GetByUidTargetIdResp) MarshalTo(dAtA []byte) (int, error) {
|
||
var i int
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
if len(m.Data) > 0 {
|
||
for k, _ := range m.Data {
|
||
dAtA[i] = 0xa
|
||
i++
|
||
v := m.Data[k]
|
||
msgSize := 0
|
||
if v != nil {
|
||
msgSize = v.Size()
|
||
msgSize += 1 + sovGuard(uint64(msgSize))
|
||
}
|
||
mapSize := 1 + sovGuard(uint64(k)) + msgSize
|
||
i = encodeVarintGuard(dAtA, i, uint64(mapSize))
|
||
dAtA[i] = 0x8
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(k))
|
||
if v != nil {
|
||
dAtA[i] = 0x12
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(v.Size()))
|
||
n1, err := v.MarshalTo(dAtA[i:])
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
i += n1
|
||
}
|
||
}
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
i += copy(dAtA[i:], m.XXX_unrecognized)
|
||
}
|
||
return i, nil
|
||
}
|
||
|
||
func (m *AllDaHangHaiInfo) 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 *AllDaHangHaiInfo) MarshalTo(dAtA []byte) (int, error) {
|
||
var i int
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
if len(m.GuardInfo) > 0 {
|
||
for k, _ := range m.GuardInfo {
|
||
dAtA[i] = 0xa
|
||
i++
|
||
v := m.GuardInfo[k]
|
||
msgSize := 0
|
||
if v != nil {
|
||
msgSize = v.Size()
|
||
msgSize += 1 + sovGuard(uint64(msgSize))
|
||
}
|
||
mapSize := 1 + sovGuard(uint64(k)) + msgSize
|
||
i = encodeVarintGuard(dAtA, i, uint64(mapSize))
|
||
dAtA[i] = 0x8
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(k))
|
||
if v != nil {
|
||
dAtA[i] = 0x12
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(v.Size()))
|
||
n2, err := v.MarshalTo(dAtA[i:])
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
i += n2
|
||
}
|
||
}
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
i += copy(dAtA[i:], m.XXX_unrecognized)
|
||
}
|
||
return i, nil
|
||
}
|
||
|
||
func (m *FilterDaHangHaiInfo) 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 *FilterDaHangHaiInfo) MarshalTo(dAtA []byte) (int, error) {
|
||
var i int
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
if len(m.GuardInfo) > 0 {
|
||
for k, _ := range m.GuardInfo {
|
||
dAtA[i] = 0xa
|
||
i++
|
||
v := m.GuardInfo[k]
|
||
msgSize := 0
|
||
if v != nil {
|
||
msgSize = v.Size()
|
||
msgSize += 1 + sovGuard(uint64(msgSize))
|
||
}
|
||
mapSize := 1 + sovGuard(uint64(k)) + msgSize
|
||
i = encodeVarintGuard(dAtA, i, uint64(mapSize))
|
||
dAtA[i] = 0x8
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(k))
|
||
if v != nil {
|
||
dAtA[i] = 0x12
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(v.Size()))
|
||
n3, err := v.MarshalTo(dAtA[i:])
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
i += n3
|
||
}
|
||
}
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
i += copy(dAtA[i:], m.XXX_unrecognized)
|
||
}
|
||
return i, nil
|
||
}
|
||
|
||
func (m *DaHangHaiInfo) 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 *DaHangHaiInfo) MarshalTo(dAtA []byte) (int, error) {
|
||
var i int
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
if m.Id != 0 {
|
||
dAtA[i] = 0x8
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(m.Id))
|
||
}
|
||
if m.Uid != 0 {
|
||
dAtA[i] = 0x10
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(m.Uid))
|
||
}
|
||
if m.TargetId != 0 {
|
||
dAtA[i] = 0x18
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(m.TargetId))
|
||
}
|
||
if m.PrivilegeType != 0 {
|
||
dAtA[i] = 0x20
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(m.PrivilegeType))
|
||
}
|
||
if len(m.StartTime) > 0 {
|
||
dAtA[i] = 0x2a
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(len(m.StartTime)))
|
||
i += copy(dAtA[i:], m.StartTime)
|
||
}
|
||
if len(m.ExpiredTime) > 0 {
|
||
dAtA[i] = 0x32
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(len(m.ExpiredTime)))
|
||
i += copy(dAtA[i:], m.ExpiredTime)
|
||
}
|
||
if len(m.Ctime) > 0 {
|
||
dAtA[i] = 0x3a
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(len(m.Ctime)))
|
||
i += copy(dAtA[i:], m.Ctime)
|
||
}
|
||
if len(m.Utime) > 0 {
|
||
dAtA[i] = 0x42
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(len(m.Utime)))
|
||
i += copy(dAtA[i:], m.Utime)
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
i += copy(dAtA[i:], m.XXX_unrecognized)
|
||
}
|
||
return i, nil
|
||
}
|
||
|
||
func (m *DaHangHaiInfoList) 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 *DaHangHaiInfoList) MarshalTo(dAtA []byte) (int, error) {
|
||
var i int
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
if len(m.List) > 0 {
|
||
for _, msg := range m.List {
|
||
dAtA[i] = 0xa
|
||
i++
|
||
i = encodeVarintGuard(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 *GetByUidTargetIdsReq) 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 *GetByUidTargetIdsReq) MarshalTo(dAtA []byte) (int, error) {
|
||
var i int
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
if m.Uid != 0 {
|
||
dAtA[i] = 0x8
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(m.Uid))
|
||
}
|
||
if len(m.TargetIDs) > 0 {
|
||
for _, msg := range m.TargetIDs {
|
||
dAtA[i] = 0x12
|
||
i++
|
||
i = encodeVarintGuard(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 *GetByUidTargetIdsResp) 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 *GetByUidTargetIdsResp) MarshalTo(dAtA []byte) (int, error) {
|
||
var i int
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
if len(m.Data) > 0 {
|
||
for k, _ := range m.Data {
|
||
dAtA[i] = 0xa
|
||
i++
|
||
v := m.Data[k]
|
||
msgSize := 0
|
||
if v != nil {
|
||
msgSize = v.Size()
|
||
msgSize += 1 + sovGuard(uint64(msgSize))
|
||
}
|
||
mapSize := 1 + sovGuard(uint64(k)) + msgSize
|
||
i = encodeVarintGuard(dAtA, i, uint64(mapSize))
|
||
dAtA[i] = 0x8
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(k))
|
||
if v != nil {
|
||
dAtA[i] = 0x12
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(v.Size()))
|
||
n4, err := v.MarshalTo(dAtA[i:])
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
i += n4
|
||
}
|
||
}
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
i += copy(dAtA[i:], m.XXX_unrecognized)
|
||
}
|
||
return i, nil
|
||
}
|
||
|
||
func (m *TargetIds) 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 *TargetIds) MarshalTo(dAtA []byte) (int, error) {
|
||
var i int
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
if m.TargetId != 0 {
|
||
dAtA[i] = 0x8
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(m.TargetId))
|
||
}
|
||
if m.SortType != 0 {
|
||
dAtA[i] = 0x10
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(m.SortType))
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
i += copy(dAtA[i:], m.XXX_unrecognized)
|
||
}
|
||
return i, nil
|
||
}
|
||
|
||
func (m *GetByTargetIdsReq) 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 *GetByTargetIdsReq) MarshalTo(dAtA []byte) (int, error) {
|
||
var i int
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
if len(m.TargetIDs) > 0 {
|
||
for _, msg := range m.TargetIDs {
|
||
dAtA[i] = 0xa
|
||
i++
|
||
i = encodeVarintGuard(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 *GetByTargetIdsResp) 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 *GetByTargetIdsResp) MarshalTo(dAtA []byte) (int, error) {
|
||
var i int
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
if m.XXX_unrecognized != nil {
|
||
i += copy(dAtA[i:], m.XXX_unrecognized)
|
||
}
|
||
return i, nil
|
||
}
|
||
|
||
func (m *GetByUidReq) 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 *GetByUidReq) MarshalTo(dAtA []byte) (int, error) {
|
||
var i int
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
if m.Uid != 0 {
|
||
dAtA[i] = 0x8
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(m.Uid))
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
i += copy(dAtA[i:], m.XXX_unrecognized)
|
||
}
|
||
return i, nil
|
||
}
|
||
|
||
func (m *GetByUidResp) 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 *GetByUidResp) MarshalTo(dAtA []byte) (int, error) {
|
||
var i int
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
if len(m.Data) > 0 {
|
||
for k, _ := range m.Data {
|
||
dAtA[i] = 0xa
|
||
i++
|
||
v := m.Data[k]
|
||
msgSize := 0
|
||
if v != nil {
|
||
msgSize = v.Size()
|
||
msgSize += 1 + sovGuard(uint64(msgSize))
|
||
}
|
||
mapSize := 1 + sovGuard(uint64(k)) + msgSize
|
||
i = encodeVarintGuard(dAtA, i, uint64(mapSize))
|
||
dAtA[i] = 0x8
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(k))
|
||
if v != nil {
|
||
dAtA[i] = 0x12
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(v.Size()))
|
||
n5, err := v.MarshalTo(dAtA[i:])
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
i += n5
|
||
}
|
||
}
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
i += copy(dAtA[i:], m.XXX_unrecognized)
|
||
}
|
||
return i, nil
|
||
}
|
||
|
||
func (m *GetByUidBatchReq) 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 *GetByUidBatchReq) MarshalTo(dAtA []byte) (int, error) {
|
||
var i int
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
if len(m.Uids) > 0 {
|
||
dAtA7 := make([]byte, len(m.Uids)*10)
|
||
var j6 int
|
||
for _, num1 := range m.Uids {
|
||
num := uint64(num1)
|
||
for num >= 1<<7 {
|
||
dAtA7[j6] = uint8(uint64(num)&0x7f | 0x80)
|
||
num >>= 7
|
||
j6++
|
||
}
|
||
dAtA7[j6] = uint8(num)
|
||
j6++
|
||
}
|
||
dAtA[i] = 0xa
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(j6))
|
||
i += copy(dAtA[i:], dAtA7[:j6])
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
i += copy(dAtA[i:], m.XXX_unrecognized)
|
||
}
|
||
return i, nil
|
||
}
|
||
|
||
func (m *GetByUidBatchResp) 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 *GetByUidBatchResp) MarshalTo(dAtA []byte) (int, error) {
|
||
var i int
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
if len(m.Data) > 0 {
|
||
for k, _ := range m.Data {
|
||
dAtA[i] = 0xa
|
||
i++
|
||
v := m.Data[k]
|
||
msgSize := 0
|
||
if v != nil {
|
||
msgSize = v.Size()
|
||
msgSize += 1 + sovGuard(uint64(msgSize))
|
||
}
|
||
mapSize := 1 + sovGuard(uint64(k)) + msgSize
|
||
i = encodeVarintGuard(dAtA, i, uint64(mapSize))
|
||
dAtA[i] = 0x8
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(k))
|
||
if v != nil {
|
||
dAtA[i] = 0x12
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(v.Size()))
|
||
n8, err := v.MarshalTo(dAtA[i:])
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
i += n8
|
||
}
|
||
}
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
i += copy(dAtA[i:], m.XXX_unrecognized)
|
||
}
|
||
return i, nil
|
||
}
|
||
|
||
func (m *GetAnchorRecentTopGuardReq) 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 *GetAnchorRecentTopGuardReq) MarshalTo(dAtA []byte) (int, error) {
|
||
var i int
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
if m.Uid != 0 {
|
||
dAtA[i] = 0x8
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(m.Uid))
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
i += copy(dAtA[i:], m.XXX_unrecognized)
|
||
}
|
||
return i, nil
|
||
}
|
||
|
||
func (m *GetAnchorRecentTopGuardResp) 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 *GetAnchorRecentTopGuardResp) MarshalTo(dAtA []byte) (int, error) {
|
||
var i int
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
if m.Cnt != 0 {
|
||
dAtA[i] = 0x8
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(m.Cnt))
|
||
}
|
||
if len(m.List) > 0 {
|
||
for _, msg := range m.List {
|
||
dAtA[i] = 0x12
|
||
i++
|
||
i = encodeVarintGuard(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 *GetAnchorRecentTopGuardList) 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 *GetAnchorRecentTopGuardList) MarshalTo(dAtA []byte) (int, error) {
|
||
var i int
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
if m.Uid != 0 {
|
||
dAtA[i] = 0x8
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(m.Uid))
|
||
}
|
||
if m.EndTime != 0 {
|
||
dAtA[i] = 0x10
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(m.EndTime))
|
||
}
|
||
if m.IsOpen != 0 {
|
||
dAtA[i] = 0x18
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(m.IsOpen))
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
i += copy(dAtA[i:], m.XXX_unrecognized)
|
||
}
|
||
return i, nil
|
||
}
|
||
|
||
func (m *GetTopListGuardReq) 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 *GetTopListGuardReq) MarshalTo(dAtA []byte) (int, error) {
|
||
var i int
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
if m.Uid != 0 {
|
||
dAtA[i] = 0x8
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(m.Uid))
|
||
}
|
||
if m.Page != 0 {
|
||
dAtA[i] = 0x10
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(m.Page))
|
||
}
|
||
if m.PageSize != 0 {
|
||
dAtA[i] = 0x18
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(m.PageSize))
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
i += copy(dAtA[i:], m.XXX_unrecognized)
|
||
}
|
||
return i, nil
|
||
}
|
||
|
||
func (m *GetTopListGuardResp) 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 *GetTopListGuardResp) MarshalTo(dAtA []byte) (int, error) {
|
||
var i int
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
if m.Num != 0 {
|
||
dAtA[i] = 0x8
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(m.Num))
|
||
}
|
||
if m.Page != 0 {
|
||
dAtA[i] = 0x10
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(m.Page))
|
||
}
|
||
if m.Now != 0 {
|
||
dAtA[i] = 0x18
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(m.Now))
|
||
}
|
||
if len(m.List) > 0 {
|
||
for _, msg := range m.List {
|
||
dAtA[i] = 0x22
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(msg.Size()))
|
||
n, err := msg.MarshalTo(dAtA[i:])
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
i += n
|
||
}
|
||
}
|
||
if len(m.Top3) > 0 {
|
||
for _, msg := range m.Top3 {
|
||
dAtA[i] = 0x2a
|
||
i++
|
||
i = encodeVarintGuard(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 *TopListGuard) 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 *TopListGuard) MarshalTo(dAtA []byte) (int, error) {
|
||
var i int
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
if m.Uid != 0 {
|
||
dAtA[i] = 0x8
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(m.Uid))
|
||
}
|
||
if m.Ruid != 0 {
|
||
dAtA[i] = 0x10
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(m.Ruid))
|
||
}
|
||
if m.GuardLevel != 0 {
|
||
dAtA[i] = 0x18
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(m.GuardLevel))
|
||
}
|
||
if m.Rank != 0 {
|
||
dAtA[i] = 0x20
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(m.Rank))
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
i += copy(dAtA[i:], m.XXX_unrecognized)
|
||
}
|
||
return i, nil
|
||
}
|
||
|
||
func (m *GetTopListGuardNumReq) 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 *GetTopListGuardNumReq) MarshalTo(dAtA []byte) (int, error) {
|
||
var i int
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
if m.Uid != 0 {
|
||
dAtA[i] = 0x8
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(m.Uid))
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
i += copy(dAtA[i:], m.XXX_unrecognized)
|
||
}
|
||
return i, nil
|
||
}
|
||
|
||
func (m *GetTopListGuardNumResp) 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 *GetTopListGuardNumResp) MarshalTo(dAtA []byte) (int, error) {
|
||
var i int
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
if m.TotalCount != 0 {
|
||
dAtA[i] = 0x8
|
||
i++
|
||
i = encodeVarintGuard(dAtA, i, uint64(m.TotalCount))
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
i += copy(dAtA[i:], m.XXX_unrecognized)
|
||
}
|
||
return i, nil
|
||
}
|
||
|
||
func encodeVarintGuard(dAtA []byte, offset int, v uint64) int {
|
||
for v >= 1<<7 {
|
||
dAtA[offset] = uint8(v&0x7f | 0x80)
|
||
v >>= 7
|
||
offset++
|
||
}
|
||
dAtA[offset] = uint8(v)
|
||
return offset + 1
|
||
}
|
||
func (m *GuardBuyReq) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
l = len(m.OrderId)
|
||
if l > 0 {
|
||
n += 1 + l + sovGuard(uint64(l))
|
||
}
|
||
if m.Uid != 0 {
|
||
n += 1 + sovGuard(uint64(m.Uid))
|
||
}
|
||
if m.Ruid != 0 {
|
||
n += 1 + sovGuard(uint64(m.Ruid))
|
||
}
|
||
if m.GuardLevel != 0 {
|
||
n += 1 + sovGuard(uint64(m.GuardLevel))
|
||
}
|
||
if m.Num != 0 {
|
||
n += 1 + sovGuard(uint64(m.Num))
|
||
}
|
||
if m.Platform != 0 {
|
||
n += 1 + sovGuard(uint64(m.Platform))
|
||
}
|
||
l = len(m.Source)
|
||
if l > 0 {
|
||
n += 1 + l + sovGuard(uint64(l))
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
n += len(m.XXX_unrecognized)
|
||
}
|
||
return n
|
||
}
|
||
|
||
func (m *GuardBuyReply) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if m.Status != 0 {
|
||
n += 1 + sovGuard(uint64(m.Status))
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
n += len(m.XXX_unrecognized)
|
||
}
|
||
return n
|
||
}
|
||
|
||
func (m *ClearUIDCacheReq) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if m.Uid != 0 {
|
||
n += 1 + sovGuard(uint64(m.Uid))
|
||
}
|
||
l = len(m.MagicKey)
|
||
if l > 0 {
|
||
n += 1 + l + sovGuard(uint64(l))
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
n += len(m.XXX_unrecognized)
|
||
}
|
||
return n
|
||
}
|
||
|
||
func (m *ClearUIDCacheResp) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if m.XXX_unrecognized != nil {
|
||
n += len(m.XXX_unrecognized)
|
||
}
|
||
return n
|
||
}
|
||
|
||
func (m *GetByUidTargetIdReq) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if m.Uid != 0 {
|
||
n += 1 + sovGuard(uint64(m.Uid))
|
||
}
|
||
if m.TargetId != 0 {
|
||
n += 1 + sovGuard(uint64(m.TargetId))
|
||
}
|
||
if m.SortType != 0 {
|
||
n += 1 + sovGuard(uint64(m.SortType))
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
n += len(m.XXX_unrecognized)
|
||
}
|
||
return n
|
||
}
|
||
|
||
func (m *GetByUidTargetIdResp) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if len(m.Data) > 0 {
|
||
for k, v := range m.Data {
|
||
_ = k
|
||
_ = v
|
||
l = 0
|
||
if v != nil {
|
||
l = v.Size()
|
||
l += 1 + sovGuard(uint64(l))
|
||
}
|
||
mapEntrySize := 1 + sovGuard(uint64(k)) + l
|
||
n += mapEntrySize + 1 + sovGuard(uint64(mapEntrySize))
|
||
}
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
n += len(m.XXX_unrecognized)
|
||
}
|
||
return n
|
||
}
|
||
|
||
func (m *AllDaHangHaiInfo) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if len(m.GuardInfo) > 0 {
|
||
for k, v := range m.GuardInfo {
|
||
_ = k
|
||
_ = v
|
||
l = 0
|
||
if v != nil {
|
||
l = v.Size()
|
||
l += 1 + sovGuard(uint64(l))
|
||
}
|
||
mapEntrySize := 1 + sovGuard(uint64(k)) + l
|
||
n += mapEntrySize + 1 + sovGuard(uint64(mapEntrySize))
|
||
}
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
n += len(m.XXX_unrecognized)
|
||
}
|
||
return n
|
||
}
|
||
|
||
func (m *FilterDaHangHaiInfo) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if len(m.GuardInfo) > 0 {
|
||
for k, v := range m.GuardInfo {
|
||
_ = k
|
||
_ = v
|
||
l = 0
|
||
if v != nil {
|
||
l = v.Size()
|
||
l += 1 + sovGuard(uint64(l))
|
||
}
|
||
mapEntrySize := 1 + sovGuard(uint64(k)) + l
|
||
n += mapEntrySize + 1 + sovGuard(uint64(mapEntrySize))
|
||
}
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
n += len(m.XXX_unrecognized)
|
||
}
|
||
return n
|
||
}
|
||
|
||
func (m *DaHangHaiInfo) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if m.Id != 0 {
|
||
n += 1 + sovGuard(uint64(m.Id))
|
||
}
|
||
if m.Uid != 0 {
|
||
n += 1 + sovGuard(uint64(m.Uid))
|
||
}
|
||
if m.TargetId != 0 {
|
||
n += 1 + sovGuard(uint64(m.TargetId))
|
||
}
|
||
if m.PrivilegeType != 0 {
|
||
n += 1 + sovGuard(uint64(m.PrivilegeType))
|
||
}
|
||
l = len(m.StartTime)
|
||
if l > 0 {
|
||
n += 1 + l + sovGuard(uint64(l))
|
||
}
|
||
l = len(m.ExpiredTime)
|
||
if l > 0 {
|
||
n += 1 + l + sovGuard(uint64(l))
|
||
}
|
||
l = len(m.Ctime)
|
||
if l > 0 {
|
||
n += 1 + l + sovGuard(uint64(l))
|
||
}
|
||
l = len(m.Utime)
|
||
if l > 0 {
|
||
n += 1 + l + sovGuard(uint64(l))
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
n += len(m.XXX_unrecognized)
|
||
}
|
||
return n
|
||
}
|
||
|
||
func (m *DaHangHaiInfoList) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if len(m.List) > 0 {
|
||
for _, e := range m.List {
|
||
l = e.Size()
|
||
n += 1 + l + sovGuard(uint64(l))
|
||
}
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
n += len(m.XXX_unrecognized)
|
||
}
|
||
return n
|
||
}
|
||
|
||
func (m *GetByUidTargetIdsReq) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if m.Uid != 0 {
|
||
n += 1 + sovGuard(uint64(m.Uid))
|
||
}
|
||
if len(m.TargetIDs) > 0 {
|
||
for _, e := range m.TargetIDs {
|
||
l = e.Size()
|
||
n += 1 + l + sovGuard(uint64(l))
|
||
}
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
n += len(m.XXX_unrecognized)
|
||
}
|
||
return n
|
||
}
|
||
|
||
func (m *GetByUidTargetIdsResp) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if len(m.Data) > 0 {
|
||
for k, v := range m.Data {
|
||
_ = k
|
||
_ = v
|
||
l = 0
|
||
if v != nil {
|
||
l = v.Size()
|
||
l += 1 + sovGuard(uint64(l))
|
||
}
|
||
mapEntrySize := 1 + sovGuard(uint64(k)) + l
|
||
n += mapEntrySize + 1 + sovGuard(uint64(mapEntrySize))
|
||
}
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
n += len(m.XXX_unrecognized)
|
||
}
|
||
return n
|
||
}
|
||
|
||
func (m *TargetIds) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if m.TargetId != 0 {
|
||
n += 1 + sovGuard(uint64(m.TargetId))
|
||
}
|
||
if m.SortType != 0 {
|
||
n += 1 + sovGuard(uint64(m.SortType))
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
n += len(m.XXX_unrecognized)
|
||
}
|
||
return n
|
||
}
|
||
|
||
func (m *GetByTargetIdsReq) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if len(m.TargetIDs) > 0 {
|
||
for _, e := range m.TargetIDs {
|
||
l = e.Size()
|
||
n += 1 + l + sovGuard(uint64(l))
|
||
}
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
n += len(m.XXX_unrecognized)
|
||
}
|
||
return n
|
||
}
|
||
|
||
func (m *GetByTargetIdsResp) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if m.XXX_unrecognized != nil {
|
||
n += len(m.XXX_unrecognized)
|
||
}
|
||
return n
|
||
}
|
||
|
||
func (m *GetByUidReq) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if m.Uid != 0 {
|
||
n += 1 + sovGuard(uint64(m.Uid))
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
n += len(m.XXX_unrecognized)
|
||
}
|
||
return n
|
||
}
|
||
|
||
func (m *GetByUidResp) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if len(m.Data) > 0 {
|
||
for k, v := range m.Data {
|
||
_ = k
|
||
_ = v
|
||
l = 0
|
||
if v != nil {
|
||
l = v.Size()
|
||
l += 1 + sovGuard(uint64(l))
|
||
}
|
||
mapEntrySize := 1 + sovGuard(uint64(k)) + l
|
||
n += mapEntrySize + 1 + sovGuard(uint64(mapEntrySize))
|
||
}
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
n += len(m.XXX_unrecognized)
|
||
}
|
||
return n
|
||
}
|
||
|
||
func (m *GetByUidBatchReq) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if len(m.Uids) > 0 {
|
||
l = 0
|
||
for _, e := range m.Uids {
|
||
l += sovGuard(uint64(e))
|
||
}
|
||
n += 1 + sovGuard(uint64(l)) + l
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
n += len(m.XXX_unrecognized)
|
||
}
|
||
return n
|
||
}
|
||
|
||
func (m *GetByUidBatchResp) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if len(m.Data) > 0 {
|
||
for k, v := range m.Data {
|
||
_ = k
|
||
_ = v
|
||
l = 0
|
||
if v != nil {
|
||
l = v.Size()
|
||
l += 1 + sovGuard(uint64(l))
|
||
}
|
||
mapEntrySize := 1 + sovGuard(uint64(k)) + l
|
||
n += mapEntrySize + 1 + sovGuard(uint64(mapEntrySize))
|
||
}
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
n += len(m.XXX_unrecognized)
|
||
}
|
||
return n
|
||
}
|
||
|
||
func (m *GetAnchorRecentTopGuardReq) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if m.Uid != 0 {
|
||
n += 1 + sovGuard(uint64(m.Uid))
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
n += len(m.XXX_unrecognized)
|
||
}
|
||
return n
|
||
}
|
||
|
||
func (m *GetAnchorRecentTopGuardResp) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if m.Cnt != 0 {
|
||
n += 1 + sovGuard(uint64(m.Cnt))
|
||
}
|
||
if len(m.List) > 0 {
|
||
for _, e := range m.List {
|
||
l = e.Size()
|
||
n += 1 + l + sovGuard(uint64(l))
|
||
}
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
n += len(m.XXX_unrecognized)
|
||
}
|
||
return n
|
||
}
|
||
|
||
func (m *GetAnchorRecentTopGuardList) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if m.Uid != 0 {
|
||
n += 1 + sovGuard(uint64(m.Uid))
|
||
}
|
||
if m.EndTime != 0 {
|
||
n += 1 + sovGuard(uint64(m.EndTime))
|
||
}
|
||
if m.IsOpen != 0 {
|
||
n += 1 + sovGuard(uint64(m.IsOpen))
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
n += len(m.XXX_unrecognized)
|
||
}
|
||
return n
|
||
}
|
||
|
||
func (m *GetTopListGuardReq) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if m.Uid != 0 {
|
||
n += 1 + sovGuard(uint64(m.Uid))
|
||
}
|
||
if m.Page != 0 {
|
||
n += 1 + sovGuard(uint64(m.Page))
|
||
}
|
||
if m.PageSize != 0 {
|
||
n += 1 + sovGuard(uint64(m.PageSize))
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
n += len(m.XXX_unrecognized)
|
||
}
|
||
return n
|
||
}
|
||
|
||
func (m *GetTopListGuardResp) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if m.Num != 0 {
|
||
n += 1 + sovGuard(uint64(m.Num))
|
||
}
|
||
if m.Page != 0 {
|
||
n += 1 + sovGuard(uint64(m.Page))
|
||
}
|
||
if m.Now != 0 {
|
||
n += 1 + sovGuard(uint64(m.Now))
|
||
}
|
||
if len(m.List) > 0 {
|
||
for _, e := range m.List {
|
||
l = e.Size()
|
||
n += 1 + l + sovGuard(uint64(l))
|
||
}
|
||
}
|
||
if len(m.Top3) > 0 {
|
||
for _, e := range m.Top3 {
|
||
l = e.Size()
|
||
n += 1 + l + sovGuard(uint64(l))
|
||
}
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
n += len(m.XXX_unrecognized)
|
||
}
|
||
return n
|
||
}
|
||
|
||
func (m *TopListGuard) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if m.Uid != 0 {
|
||
n += 1 + sovGuard(uint64(m.Uid))
|
||
}
|
||
if m.Ruid != 0 {
|
||
n += 1 + sovGuard(uint64(m.Ruid))
|
||
}
|
||
if m.GuardLevel != 0 {
|
||
n += 1 + sovGuard(uint64(m.GuardLevel))
|
||
}
|
||
if m.Rank != 0 {
|
||
n += 1 + sovGuard(uint64(m.Rank))
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
n += len(m.XXX_unrecognized)
|
||
}
|
||
return n
|
||
}
|
||
|
||
func (m *GetTopListGuardNumReq) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if m.Uid != 0 {
|
||
n += 1 + sovGuard(uint64(m.Uid))
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
n += len(m.XXX_unrecognized)
|
||
}
|
||
return n
|
||
}
|
||
|
||
func (m *GetTopListGuardNumResp) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if m.TotalCount != 0 {
|
||
n += 1 + sovGuard(uint64(m.TotalCount))
|
||
}
|
||
if m.XXX_unrecognized != nil {
|
||
n += len(m.XXX_unrecognized)
|
||
}
|
||
return n
|
||
}
|
||
|
||
func sovGuard(x uint64) (n int) {
|
||
for {
|
||
n++
|
||
x >>= 7
|
||
if x == 0 {
|
||
break
|
||
}
|
||
}
|
||
return n
|
||
}
|
||
func sozGuard(x uint64) (n int) {
|
||
return sovGuard(uint64((x << 1) ^ uint64((int64(x) >> 63))))
|
||
}
|
||
func (m *GuardBuyReq) 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 ErrIntOverflowGuard
|
||
}
|
||
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: GuardBuyReq: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: GuardBuyReq: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
case 1:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field OrderId", wireType)
|
||
}
|
||
var stringLen uint64
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
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 ErrInvalidLengthGuard
|
||
}
|
||
postIndex := iNdEx + intStringLen
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
m.OrderId = string(dAtA[iNdEx:postIndex])
|
||
iNdEx = postIndex
|
||
case 2:
|
||
if wireType != 0 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Uid", wireType)
|
||
}
|
||
m.Uid = 0
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
m.Uid |= (int64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
case 3:
|
||
if wireType != 0 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Ruid", wireType)
|
||
}
|
||
m.Ruid = 0
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
m.Ruid |= (int64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
case 4:
|
||
if wireType != 0 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field GuardLevel", wireType)
|
||
}
|
||
m.GuardLevel = 0
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
m.GuardLevel |= (int(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
case 5:
|
||
if wireType != 0 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Num", wireType)
|
||
}
|
||
m.Num = 0
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
m.Num |= (int(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
case 6:
|
||
if wireType != 0 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Platform", wireType)
|
||
}
|
||
m.Platform = 0
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
m.Platform |= (grpc1.Platform(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
case 7:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
|
||
}
|
||
var stringLen uint64
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
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 ErrInvalidLengthGuard
|
||
}
|
||
postIndex := iNdEx + intStringLen
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
m.Source = string(dAtA[iNdEx:postIndex])
|
||
iNdEx = postIndex
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipGuard(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
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 *GuardBuyReply) 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 ErrIntOverflowGuard
|
||
}
|
||
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: GuardBuyReply: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: GuardBuyReply: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
case 1:
|
||
if wireType != 0 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
|
||
}
|
||
m.Status = 0
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
m.Status |= (int(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipGuard(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
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 *ClearUIDCacheReq) 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 ErrIntOverflowGuard
|
||
}
|
||
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: ClearUIDCacheReq: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: ClearUIDCacheReq: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
case 1:
|
||
if wireType != 0 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Uid", wireType)
|
||
}
|
||
m.Uid = 0
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
m.Uid |= (int64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
case 2:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field MagicKey", wireType)
|
||
}
|
||
var stringLen uint64
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
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 ErrInvalidLengthGuard
|
||
}
|
||
postIndex := iNdEx + intStringLen
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
m.MagicKey = string(dAtA[iNdEx:postIndex])
|
||
iNdEx = postIndex
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipGuard(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
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 *ClearUIDCacheResp) 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 ErrIntOverflowGuard
|
||
}
|
||
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: ClearUIDCacheResp: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: ClearUIDCacheResp: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipGuard(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
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 *GetByUidTargetIdReq) 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 ErrIntOverflowGuard
|
||
}
|
||
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: GetByUidTargetIdReq: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: GetByUidTargetIdReq: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
case 1:
|
||
if wireType != 0 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Uid", wireType)
|
||
}
|
||
m.Uid = 0
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
m.Uid |= (int64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
case 2:
|
||
if wireType != 0 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field TargetId", wireType)
|
||
}
|
||
m.TargetId = 0
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
m.TargetId |= (int64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
case 3:
|
||
if wireType != 0 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field SortType", wireType)
|
||
}
|
||
m.SortType = 0
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
m.SortType |= (int64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipGuard(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
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 *GetByUidTargetIdResp) 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 ErrIntOverflowGuard
|
||
}
|
||
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: GetByUidTargetIdResp: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: GetByUidTargetIdResp: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
case 1:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
|
||
}
|
||
var msglen int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
msglen |= (int(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
if msglen < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
postIndex := iNdEx + msglen
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
if m.Data == nil {
|
||
m.Data = make(map[int64]*DaHangHaiInfo)
|
||
}
|
||
var mapkey int64
|
||
var mapvalue *DaHangHaiInfo
|
||
for iNdEx < postIndex {
|
||
entryPreIndex := iNdEx
|
||
var wire uint64
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
wire |= (uint64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
fieldNum := int32(wire >> 3)
|
||
if fieldNum == 1 {
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
mapkey |= (int64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
} else if fieldNum == 2 {
|
||
var mapmsglen int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
mapmsglen |= (int(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
if mapmsglen < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
postmsgIndex := iNdEx + mapmsglen
|
||
if mapmsglen < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
if postmsgIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
mapvalue = &DaHangHaiInfo{}
|
||
if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
|
||
return err
|
||
}
|
||
iNdEx = postmsgIndex
|
||
} else {
|
||
iNdEx = entryPreIndex
|
||
skippy, err := skipGuard(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
if (iNdEx + skippy) > postIndex {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
iNdEx += skippy
|
||
}
|
||
}
|
||
m.Data[mapkey] = mapvalue
|
||
iNdEx = postIndex
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipGuard(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
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 *AllDaHangHaiInfo) 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 ErrIntOverflowGuard
|
||
}
|
||
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: AllDaHangHaiInfo: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: AllDaHangHaiInfo: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
case 1:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field GuardInfo", wireType)
|
||
}
|
||
var msglen int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
msglen |= (int(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
if msglen < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
postIndex := iNdEx + msglen
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
if m.GuardInfo == nil {
|
||
m.GuardInfo = make(map[int64]*DaHangHaiInfo)
|
||
}
|
||
var mapkey int64
|
||
var mapvalue *DaHangHaiInfo
|
||
for iNdEx < postIndex {
|
||
entryPreIndex := iNdEx
|
||
var wire uint64
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
wire |= (uint64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
fieldNum := int32(wire >> 3)
|
||
if fieldNum == 1 {
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
mapkey |= (int64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
} else if fieldNum == 2 {
|
||
var mapmsglen int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
mapmsglen |= (int(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
if mapmsglen < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
postmsgIndex := iNdEx + mapmsglen
|
||
if mapmsglen < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
if postmsgIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
mapvalue = &DaHangHaiInfo{}
|
||
if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
|
||
return err
|
||
}
|
||
iNdEx = postmsgIndex
|
||
} else {
|
||
iNdEx = entryPreIndex
|
||
skippy, err := skipGuard(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
if (iNdEx + skippy) > postIndex {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
iNdEx += skippy
|
||
}
|
||
}
|
||
m.GuardInfo[mapkey] = mapvalue
|
||
iNdEx = postIndex
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipGuard(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
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 *FilterDaHangHaiInfo) 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 ErrIntOverflowGuard
|
||
}
|
||
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: FilterDaHangHaiInfo: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: FilterDaHangHaiInfo: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
case 1:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field GuardInfo", wireType)
|
||
}
|
||
var msglen int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
msglen |= (int(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
if msglen < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
postIndex := iNdEx + msglen
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
if m.GuardInfo == nil {
|
||
m.GuardInfo = make(map[int64]*DaHangHaiInfo)
|
||
}
|
||
var mapkey int64
|
||
var mapvalue *DaHangHaiInfo
|
||
for iNdEx < postIndex {
|
||
entryPreIndex := iNdEx
|
||
var wire uint64
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
wire |= (uint64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
fieldNum := int32(wire >> 3)
|
||
if fieldNum == 1 {
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
mapkey |= (int64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
} else if fieldNum == 2 {
|
||
var mapmsglen int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
mapmsglen |= (int(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
if mapmsglen < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
postmsgIndex := iNdEx + mapmsglen
|
||
if mapmsglen < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
if postmsgIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
mapvalue = &DaHangHaiInfo{}
|
||
if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
|
||
return err
|
||
}
|
||
iNdEx = postmsgIndex
|
||
} else {
|
||
iNdEx = entryPreIndex
|
||
skippy, err := skipGuard(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
if (iNdEx + skippy) > postIndex {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
iNdEx += skippy
|
||
}
|
||
}
|
||
m.GuardInfo[mapkey] = mapvalue
|
||
iNdEx = postIndex
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipGuard(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
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 *DaHangHaiInfo) 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 ErrIntOverflowGuard
|
||
}
|
||
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: DaHangHaiInfo: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: DaHangHaiInfo: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
case 1:
|
||
if wireType != 0 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
|
||
}
|
||
m.Id = 0
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
m.Id |= (int64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
case 2:
|
||
if wireType != 0 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Uid", wireType)
|
||
}
|
||
m.Uid = 0
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
m.Uid |= (int64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
case 3:
|
||
if wireType != 0 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field TargetId", wireType)
|
||
}
|
||
m.TargetId = 0
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
m.TargetId |= (int64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
case 4:
|
||
if wireType != 0 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field PrivilegeType", wireType)
|
||
}
|
||
m.PrivilegeType = 0
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
m.PrivilegeType |= (int64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
case 5:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field StartTime", wireType)
|
||
}
|
||
var stringLen uint64
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
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 ErrInvalidLengthGuard
|
||
}
|
||
postIndex := iNdEx + intStringLen
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
m.StartTime = string(dAtA[iNdEx:postIndex])
|
||
iNdEx = postIndex
|
||
case 6:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field ExpiredTime", wireType)
|
||
}
|
||
var stringLen uint64
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
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 ErrInvalidLengthGuard
|
||
}
|
||
postIndex := iNdEx + intStringLen
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
m.ExpiredTime = string(dAtA[iNdEx:postIndex])
|
||
iNdEx = postIndex
|
||
case 7:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Ctime", wireType)
|
||
}
|
||
var stringLen uint64
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
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 ErrInvalidLengthGuard
|
||
}
|
||
postIndex := iNdEx + intStringLen
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
m.Ctime = string(dAtA[iNdEx:postIndex])
|
||
iNdEx = postIndex
|
||
case 8:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Utime", wireType)
|
||
}
|
||
var stringLen uint64
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
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 ErrInvalidLengthGuard
|
||
}
|
||
postIndex := iNdEx + intStringLen
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
m.Utime = string(dAtA[iNdEx:postIndex])
|
||
iNdEx = postIndex
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipGuard(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
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 *DaHangHaiInfoList) 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 ErrIntOverflowGuard
|
||
}
|
||
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: DaHangHaiInfoList: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: DaHangHaiInfoList: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
case 1:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field List", wireType)
|
||
}
|
||
var msglen int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
msglen |= (int(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
if msglen < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
postIndex := iNdEx + msglen
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
m.List = append(m.List, &DaHangHaiInfo{})
|
||
if err := m.List[len(m.List)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||
return err
|
||
}
|
||
iNdEx = postIndex
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipGuard(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
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 *GetByUidTargetIdsReq) 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 ErrIntOverflowGuard
|
||
}
|
||
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: GetByUidTargetIdsReq: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: GetByUidTargetIdsReq: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
case 1:
|
||
if wireType != 0 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Uid", wireType)
|
||
}
|
||
m.Uid = 0
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
m.Uid |= (int64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
case 2:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field TargetIDs", wireType)
|
||
}
|
||
var msglen int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
msglen |= (int(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
if msglen < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
postIndex := iNdEx + msglen
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
m.TargetIDs = append(m.TargetIDs, &TargetIds{})
|
||
if err := m.TargetIDs[len(m.TargetIDs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||
return err
|
||
}
|
||
iNdEx = postIndex
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipGuard(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
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 *GetByUidTargetIdsResp) 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 ErrIntOverflowGuard
|
||
}
|
||
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: GetByUidTargetIdsResp: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: GetByUidTargetIdsResp: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
case 1:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
|
||
}
|
||
var msglen int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
msglen |= (int(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
if msglen < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
postIndex := iNdEx + msglen
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
if m.Data == nil {
|
||
m.Data = make(map[int64]*DaHangHaiInfo)
|
||
}
|
||
var mapkey int64
|
||
var mapvalue *DaHangHaiInfo
|
||
for iNdEx < postIndex {
|
||
entryPreIndex := iNdEx
|
||
var wire uint64
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
wire |= (uint64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
fieldNum := int32(wire >> 3)
|
||
if fieldNum == 1 {
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
mapkey |= (int64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
} else if fieldNum == 2 {
|
||
var mapmsglen int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
mapmsglen |= (int(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
if mapmsglen < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
postmsgIndex := iNdEx + mapmsglen
|
||
if mapmsglen < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
if postmsgIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
mapvalue = &DaHangHaiInfo{}
|
||
if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
|
||
return err
|
||
}
|
||
iNdEx = postmsgIndex
|
||
} else {
|
||
iNdEx = entryPreIndex
|
||
skippy, err := skipGuard(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
if (iNdEx + skippy) > postIndex {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
iNdEx += skippy
|
||
}
|
||
}
|
||
m.Data[mapkey] = mapvalue
|
||
iNdEx = postIndex
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipGuard(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
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 *TargetIds) 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 ErrIntOverflowGuard
|
||
}
|
||
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: TargetIds: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: TargetIds: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
case 1:
|
||
if wireType != 0 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field TargetId", wireType)
|
||
}
|
||
m.TargetId = 0
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
m.TargetId |= (int64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
case 2:
|
||
if wireType != 0 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field SortType", wireType)
|
||
}
|
||
m.SortType = 0
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
m.SortType |= (int64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipGuard(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
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 *GetByTargetIdsReq) 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 ErrIntOverflowGuard
|
||
}
|
||
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: GetByTargetIdsReq: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: GetByTargetIdsReq: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
case 1:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field TargetIDs", wireType)
|
||
}
|
||
var msglen int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
msglen |= (int(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
if msglen < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
postIndex := iNdEx + msglen
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
m.TargetIDs = append(m.TargetIDs, &TargetIds{})
|
||
if err := m.TargetIDs[len(m.TargetIDs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||
return err
|
||
}
|
||
iNdEx = postIndex
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipGuard(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
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 *GetByTargetIdsResp) 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 ErrIntOverflowGuard
|
||
}
|
||
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: GetByTargetIdsResp: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: GetByTargetIdsResp: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipGuard(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
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 *GetByUidReq) 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 ErrIntOverflowGuard
|
||
}
|
||
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: GetByUidReq: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: GetByUidReq: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
case 1:
|
||
if wireType != 0 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Uid", wireType)
|
||
}
|
||
m.Uid = 0
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
m.Uid |= (int64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipGuard(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
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 *GetByUidResp) 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 ErrIntOverflowGuard
|
||
}
|
||
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: GetByUidResp: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: GetByUidResp: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
case 1:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
|
||
}
|
||
var msglen int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
msglen |= (int(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
if msglen < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
postIndex := iNdEx + msglen
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
if m.Data == nil {
|
||
m.Data = make(map[int64]*DaHangHaiInfo)
|
||
}
|
||
var mapkey int64
|
||
var mapvalue *DaHangHaiInfo
|
||
for iNdEx < postIndex {
|
||
entryPreIndex := iNdEx
|
||
var wire uint64
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
wire |= (uint64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
fieldNum := int32(wire >> 3)
|
||
if fieldNum == 1 {
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
mapkey |= (int64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
} else if fieldNum == 2 {
|
||
var mapmsglen int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
mapmsglen |= (int(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
if mapmsglen < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
postmsgIndex := iNdEx + mapmsglen
|
||
if mapmsglen < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
if postmsgIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
mapvalue = &DaHangHaiInfo{}
|
||
if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
|
||
return err
|
||
}
|
||
iNdEx = postmsgIndex
|
||
} else {
|
||
iNdEx = entryPreIndex
|
||
skippy, err := skipGuard(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
if (iNdEx + skippy) > postIndex {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
iNdEx += skippy
|
||
}
|
||
}
|
||
m.Data[mapkey] = mapvalue
|
||
iNdEx = postIndex
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipGuard(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
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 *GetByUidBatchReq) 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 ErrIntOverflowGuard
|
||
}
|
||
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: GetByUidBatchReq: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: GetByUidBatchReq: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
case 1:
|
||
if wireType == 0 {
|
||
var v int64
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
v |= (int64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
m.Uids = append(m.Uids, v)
|
||
} else if wireType == 2 {
|
||
var packedLen int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
packedLen |= (int(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
if packedLen < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
postIndex := iNdEx + packedLen
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
var elementCount int
|
||
var count int
|
||
for _, integer := range dAtA {
|
||
if integer < 128 {
|
||
count++
|
||
}
|
||
}
|
||
elementCount = count
|
||
if elementCount != 0 && len(m.Uids) == 0 {
|
||
m.Uids = make([]int64, 0, elementCount)
|
||
}
|
||
for iNdEx < postIndex {
|
||
var v int64
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
v |= (int64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
m.Uids = append(m.Uids, v)
|
||
}
|
||
} else {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Uids", wireType)
|
||
}
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipGuard(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
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 *GetByUidBatchResp) 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 ErrIntOverflowGuard
|
||
}
|
||
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: GetByUidBatchResp: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: GetByUidBatchResp: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
case 1:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
|
||
}
|
||
var msglen int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
msglen |= (int(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
if msglen < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
postIndex := iNdEx + msglen
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
if m.Data == nil {
|
||
m.Data = make(map[int64]*DaHangHaiInfoList)
|
||
}
|
||
var mapkey int64
|
||
var mapvalue *DaHangHaiInfoList
|
||
for iNdEx < postIndex {
|
||
entryPreIndex := iNdEx
|
||
var wire uint64
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
wire |= (uint64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
fieldNum := int32(wire >> 3)
|
||
if fieldNum == 1 {
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
mapkey |= (int64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
} else if fieldNum == 2 {
|
||
var mapmsglen int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
mapmsglen |= (int(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
if mapmsglen < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
postmsgIndex := iNdEx + mapmsglen
|
||
if mapmsglen < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
if postmsgIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
mapvalue = &DaHangHaiInfoList{}
|
||
if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
|
||
return err
|
||
}
|
||
iNdEx = postmsgIndex
|
||
} else {
|
||
iNdEx = entryPreIndex
|
||
skippy, err := skipGuard(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
if (iNdEx + skippy) > postIndex {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
iNdEx += skippy
|
||
}
|
||
}
|
||
m.Data[mapkey] = mapvalue
|
||
iNdEx = postIndex
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipGuard(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
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 *GetAnchorRecentTopGuardReq) 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 ErrIntOverflowGuard
|
||
}
|
||
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: GetAnchorRecentTopGuardReq: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: GetAnchorRecentTopGuardReq: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
case 1:
|
||
if wireType != 0 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Uid", wireType)
|
||
}
|
||
m.Uid = 0
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
m.Uid |= (int64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipGuard(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
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 *GetAnchorRecentTopGuardResp) 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 ErrIntOverflowGuard
|
||
}
|
||
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: GetAnchorRecentTopGuardResp: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: GetAnchorRecentTopGuardResp: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
case 1:
|
||
if wireType != 0 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Cnt", wireType)
|
||
}
|
||
m.Cnt = 0
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
m.Cnt |= (int64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
case 2:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field List", wireType)
|
||
}
|
||
var msglen int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
msglen |= (int(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
if msglen < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
postIndex := iNdEx + msglen
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
m.List = append(m.List, &GetAnchorRecentTopGuardList{})
|
||
if err := m.List[len(m.List)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||
return err
|
||
}
|
||
iNdEx = postIndex
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipGuard(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
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 *GetAnchorRecentTopGuardList) 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 ErrIntOverflowGuard
|
||
}
|
||
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: GetAnchorRecentTopGuardList: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: GetAnchorRecentTopGuardList: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
case 1:
|
||
if wireType != 0 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Uid", wireType)
|
||
}
|
||
m.Uid = 0
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
m.Uid |= (int64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
case 2:
|
||
if wireType != 0 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field EndTime", wireType)
|
||
}
|
||
m.EndTime = 0
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
m.EndTime |= (int64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
case 3:
|
||
if wireType != 0 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field IsOpen", wireType)
|
||
}
|
||
m.IsOpen = 0
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
m.IsOpen |= (int64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipGuard(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
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 *GetTopListGuardReq) 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 ErrIntOverflowGuard
|
||
}
|
||
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: GetTopListGuardReq: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: GetTopListGuardReq: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
case 1:
|
||
if wireType != 0 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Uid", wireType)
|
||
}
|
||
m.Uid = 0
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
m.Uid |= (int64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
case 2:
|
||
if wireType != 0 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Page", wireType)
|
||
}
|
||
m.Page = 0
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
m.Page |= (int64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
case 3:
|
||
if wireType != 0 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field PageSize", wireType)
|
||
}
|
||
m.PageSize = 0
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
m.PageSize |= (int64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipGuard(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
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 *GetTopListGuardResp) 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 ErrIntOverflowGuard
|
||
}
|
||
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: GetTopListGuardResp: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: GetTopListGuardResp: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
case 1:
|
||
if wireType != 0 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Num", wireType)
|
||
}
|
||
m.Num = 0
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
m.Num |= (int64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
case 2:
|
||
if wireType != 0 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Page", wireType)
|
||
}
|
||
m.Page = 0
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
m.Page |= (int64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
case 3:
|
||
if wireType != 0 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Now", wireType)
|
||
}
|
||
m.Now = 0
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
m.Now |= (int64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
case 4:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field List", wireType)
|
||
}
|
||
var msglen int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
msglen |= (int(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
if msglen < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
postIndex := iNdEx + msglen
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
m.List = append(m.List, &TopListGuard{})
|
||
if err := m.List[len(m.List)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||
return err
|
||
}
|
||
iNdEx = postIndex
|
||
case 5:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Top3", wireType)
|
||
}
|
||
var msglen int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
msglen |= (int(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
if msglen < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
postIndex := iNdEx + msglen
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
m.Top3 = append(m.Top3, &TopListGuard{})
|
||
if err := m.Top3[len(m.Top3)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||
return err
|
||
}
|
||
iNdEx = postIndex
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipGuard(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
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 *TopListGuard) 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 ErrIntOverflowGuard
|
||
}
|
||
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: TopListGuard: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: TopListGuard: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
case 1:
|
||
if wireType != 0 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Uid", wireType)
|
||
}
|
||
m.Uid = 0
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
m.Uid |= (int64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
case 2:
|
||
if wireType != 0 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Ruid", wireType)
|
||
}
|
||
m.Ruid = 0
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
m.Ruid |= (int64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
case 3:
|
||
if wireType != 0 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field GuardLevel", wireType)
|
||
}
|
||
m.GuardLevel = 0
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
m.GuardLevel |= (int64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
case 4:
|
||
if wireType != 0 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Rank", wireType)
|
||
}
|
||
m.Rank = 0
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
m.Rank |= (int64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipGuard(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
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 *GetTopListGuardNumReq) 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 ErrIntOverflowGuard
|
||
}
|
||
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: GetTopListGuardNumReq: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: GetTopListGuardNumReq: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
case 1:
|
||
if wireType != 0 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Uid", wireType)
|
||
}
|
||
m.Uid = 0
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
m.Uid |= (int64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipGuard(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
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 *GetTopListGuardNumResp) 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 ErrIntOverflowGuard
|
||
}
|
||
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: GetTopListGuardNumResp: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: GetTopListGuardNumResp: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
case 1:
|
||
if wireType != 0 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field TotalCount", wireType)
|
||
}
|
||
m.TotalCount = 0
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
m.TotalCount |= (int64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipGuard(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthGuard
|
||
}
|
||
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 skipGuard(dAtA []byte) (n int, err error) {
|
||
l := len(dAtA)
|
||
iNdEx := 0
|
||
for iNdEx < l {
|
||
var wire uint64
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return 0, ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return 0, io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
wire |= (uint64(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
wireType := int(wire & 0x7)
|
||
switch wireType {
|
||
case 0:
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return 0, ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return 0, io.ErrUnexpectedEOF
|
||
}
|
||
iNdEx++
|
||
if dAtA[iNdEx-1] < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
return iNdEx, nil
|
||
case 1:
|
||
iNdEx += 8
|
||
return iNdEx, nil
|
||
case 2:
|
||
var length int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return 0, ErrIntOverflowGuard
|
||
}
|
||
if iNdEx >= l {
|
||
return 0, io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
length |= (int(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
iNdEx += length
|
||
if length < 0 {
|
||
return 0, ErrInvalidLengthGuard
|
||
}
|
||
return iNdEx, nil
|
||
case 3:
|
||
for {
|
||
var innerWire uint64
|
||
var start int = iNdEx
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return 0, ErrIntOverflowGuard
|
||
}
|
||
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 := skipGuard(dAtA[start:])
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
iNdEx = start + next
|
||
}
|
||
return iNdEx, nil
|
||
case 4:
|
||
return iNdEx, nil
|
||
case 5:
|
||
iNdEx += 4
|
||
return iNdEx, nil
|
||
default:
|
||
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
|
||
}
|
||
}
|
||
panic("unreachable")
|
||
}
|
||
|
||
var (
|
||
ErrInvalidLengthGuard = fmt.Errorf("proto: negative length found during unmarshaling")
|
||
ErrIntOverflowGuard = fmt.Errorf("proto: integer overflow")
|
||
)
|
||
|
||
func init() {
|
||
proto.RegisterFile("app/service/live/xuser/api/grpc/v1/guard.proto", fileDescriptor_guard_f5515e6e1476a9e5)
|
||
}
|
||
|
||
var fileDescriptor_guard_f5515e6e1476a9e5 = []byte{
|
||
// 1589 bytes of a gzipped FileDescriptorProto
|
||
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0xcb, 0x6f, 0xdb, 0x36,
|
||
0x18, 0x87, 0x6c, 0x27, 0xb1, 0x99, 0x47, 0x13, 0xb6, 0x6b, 0x5d, 0x37, 0xa8, 0x5c, 0x25, 0x45,
|
||
0xd3, 0x6c, 0xb1, 0x93, 0x74, 0xaf, 0x06, 0x28, 0x86, 0x3a, 0x6e, 0x13, 0x37, 0x45, 0x3b, 0x68,
|
||
0x29, 0xb6, 0x75, 0xc0, 0x3c, 0xd5, 0x62, 0x1c, 0xa1, 0xb2, 0xc4, 0x88, 0x94, 0x5b, 0xef, 0x38,
|
||
0x0c, 0xd8, 0x9f, 0x30, 0xa0, 0xd8, 0x5f, 0xb0, 0xeb, 0x2e, 0xc3, 0xb0, 0x3f, 0x60, 0x3b, 0x6d,
|
||
0x97, 0x9d, 0x06, 0x68, 0x43, 0x8f, 0x3e, 0xfa, 0xb8, 0xd3, 0x40, 0x52, 0x96, 0x25, 0xf9, 0x09,
|
||
0xa4, 0x43, 0x77, 0x91, 0x44, 0xf2, 0xfb, 0x7d, 0xfc, 0xde, 0x1f, 0x29, 0x50, 0xd0, 0x30, 0x2e,
|
||
0x12, 0xe4, 0x34, 0x8d, 0x1a, 0x2a, 0x9a, 0x46, 0x13, 0x15, 0x9f, 0xbb, 0x04, 0x39, 0x45, 0x0d,
|
||
0x1b, 0xc5, 0xba, 0x83, 0x6b, 0xc5, 0xe6, 0x56, 0xb1, 0xee, 0x6a, 0x8e, 0x5e, 0xc0, 0x8e, 0x4d,
|
||
0x6d, 0x38, 0xcf, 0x68, 0x0a, 0x9c, 0xa6, 0xd0, 0xdc, 0xca, 0x6d, 0xd4, 0x0d, 0x7a, 0xec, 0x3e,
|
||
0x29, 0xd4, 0xec, 0x46, 0xb1, 0x6e, 0xd7, 0xed, 0x22, 0xa7, 0x7a, 0xe2, 0x1e, 0xf1, 0x11, 0x1f,
|
||
0xf0, 0x2f, 0x81, 0xce, 0xbd, 0x39, 0x6e, 0x37, 0xc1, 0x98, 0x13, 0x2b, 0xdf, 0x25, 0xc1, 0xec,
|
||
0x1e, 0xdb, 0xba, 0xe4, 0xb6, 0x54, 0x74, 0x02, 0xb7, 0x41, 0xda, 0x76, 0x74, 0xe4, 0x54, 0x0d,
|
||
0x3d, 0x2b, 0xe5, 0xa5, 0xb5, 0x4c, 0xe9, 0x42, 0xc7, 0x93, 0xcf, 0x36, 0x35, 0xd3, 0xd0, 0x35,
|
||
0x8a, 0x76, 0x14, 0x07, 0x9d, 0xb8, 0x86, 0x83, 0x74, 0x45, 0x9d, 0xe1, 0x84, 0x15, 0x1d, 0x16,
|
||
0x40, 0xd2, 0x35, 0xf4, 0x6c, 0x22, 0x2f, 0xad, 0x25, 0x4b, 0xcb, 0x1d, 0x4f, 0xce, 0xf6, 0xc8,
|
||
0xeb, 0xf4, 0xd6, 0xe6, 0x5b, 0x3d, 0x0c, 0x23, 0x84, 0x9b, 0x20, 0xe5, 0x30, 0x40, 0x72, 0x02,
|
||
0x00, 0xa7, 0x84, 0x65, 0x30, 0xcb, 0xed, 0x53, 0x35, 0x51, 0x13, 0x99, 0xd9, 0x54, 0x5e, 0x5a,
|
||
0x9b, 0x2a, 0xad, 0x8c, 0x02, 0xfe, 0xe3, 0xc9, 0x49, 0xc3, 0xa2, 0x2a, 0xe0, 0xb8, 0xfb, 0x0c,
|
||
0x06, 0xdf, 0x01, 0x49, 0xcb, 0x6d, 0x64, 0xa7, 0x26, 0x47, 0x33, 0x7a, 0x58, 0x01, 0x69, 0x6c,
|
||
0x6a, 0xf4, 0xc8, 0x76, 0x1a, 0xd9, 0xe9, 0xbc, 0xb4, 0xb6, 0xb0, 0x7d, 0xae, 0x10, 0x72, 0xd0,
|
||
0x87, 0xfe, 0xda, 0x70, 0x43, 0x05, 0x70, 0x58, 0x04, 0xd3, 0xc4, 0x76, 0x9d, 0x1a, 0xca, 0xce,
|
||
0x8c, 0xb6, 0xad, 0x4f, 0xa6, 0xec, 0x80, 0xf9, 0x9e, 0x77, 0xb0, 0xd9, 0x82, 0xd7, 0xc1, 0x34,
|
||
0xa1, 0x1a, 0x75, 0x09, 0xf7, 0xce, 0x54, 0x69, 0xa9, 0xed, 0xc9, 0xfe, 0x4c, 0x57, 0x68, 0x7f,
|
||
0xa8, 0xbc, 0x90, 0xc0, 0xe2, 0xae, 0x89, 0x34, 0xe7, 0x51, 0xa5, 0xbc, 0xab, 0xd5, 0x8e, 0x11,
|
||
0xf3, 0xef, 0x4d, 0xe1, 0x2b, 0x89, 0x9b, 0xfe, 0x5a, 0xc7, 0x93, 0x57, 0x98, 0x60, 0x3b, 0x8a,
|
||
0x6b, 0xe8, 0x4a, 0x7e, 0xb4, 0xdb, 0x0e, 0x40, 0xa6, 0xa1, 0xd5, 0x8d, 0x5a, 0xf5, 0x29, 0x6a,
|
||
0x71, 0x67, 0x67, 0x4a, 0x85, 0x8e, 0x27, 0xaf, 0x0b, 0x06, 0xc1, 0x52, 0x98, 0x8d, 0x66, 0xe2,
|
||
0x63, 0x2d, 0xc4, 0x27, 0xcd, 0xa9, 0x0e, 0x50, 0x4b, 0x39, 0x0b, 0x96, 0x62, 0xb2, 0x11, 0xac,
|
||
0xfc, 0x29, 0x81, 0xb3, 0x7b, 0x88, 0x96, 0x5a, 0x8f, 0x0c, 0xfd, 0x50, 0x73, 0xea, 0x88, 0x56,
|
||
0xf4, 0x53, 0x0a, 0x7d, 0x07, 0x64, 0x28, 0xe7, 0x54, 0x0d, 0x22, 0x74, 0xad, 0xe3, 0xc9, 0xab,
|
||
0x82, 0x41, 0xb0, 0x14, 0x66, 0x13, 0x12, 0x97, 0xfa, 0x42, 0xc0, 0x12, 0xc8, 0x10, 0xdb, 0xa1,
|
||
0x55, 0xda, 0xc2, 0xc8, 0x8f, 0xdb, 0xab, 0x1d, 0x4f, 0xbe, 0x22, 0xd8, 0x04, 0x4b, 0x51, 0x69,
|
||
0xd0, 0xad, 0x4d, 0x45, 0x4d, 0xb3, 0xc5, 0x43, 0xb6, 0xf6, 0x93, 0x04, 0xce, 0xf5, 0x6b, 0x47,
|
||
0x30, 0x3c, 0x00, 0x29, 0x5d, 0xa3, 0x5a, 0x56, 0xca, 0x27, 0xd7, 0x66, 0xb7, 0x37, 0x0a, 0x91,
|
||
0xec, 0x2f, 0x0c, 0x82, 0x14, 0xca, 0x1a, 0xd5, 0xee, 0x58, 0xd4, 0x69, 0x95, 0xd2, 0x6d, 0x4f,
|
||
0xe6, 0x70, 0x95, 0x3f, 0x73, 0x8f, 0x40, 0x26, 0x58, 0x84, 0x8b, 0x20, 0xc9, 0x9c, 0xc5, 0x0d,
|
||
0xa7, 0xb2, 0x4f, 0xb8, 0x0d, 0xa6, 0x9a, 0x9a, 0xe9, 0x22, 0x6e, 0x8b, 0xd9, 0xed, 0xe5, 0xd8,
|
||
0x66, 0x65, 0x6d, 0x5f, 0xb3, 0xea, 0xfb, 0x9a, 0x51, 0xb1, 0x8e, 0x6c, 0x55, 0x90, 0xee, 0x24,
|
||
0xde, 0x97, 0x94, 0x3f, 0x24, 0xb0, 0x78, 0xdb, 0x34, 0x23, 0xeb, 0x10, 0x81, 0x0c, 0x4f, 0x2f,
|
||
0x36, 0xf0, 0xa5, 0x2f, 0xc4, 0x18, 0xc6, 0x31, 0x85, 0xbd, 0x2e, 0x40, 0x88, 0x3f, 0x34, 0x03,
|
||
0x7a, 0x9c, 0x73, 0x8f, 0xc1, 0x42, 0x14, 0xf5, 0x0a, 0xf5, 0x62, 0x21, 0x77, 0xd7, 0x30, 0x29,
|
||
0x72, 0xa2, 0xaa, 0x1d, 0xf7, 0xab, 0xb6, 0x15, 0xe3, 0x39, 0x00, 0xf6, 0x7f, 0xd3, 0xee, 0xb7,
|
||
0x04, 0x98, 0x8f, 0xea, 0x75, 0x1e, 0x24, 0x82, 0x4c, 0x9a, 0x6e, 0x7b, 0x72, 0xc2, 0xd0, 0xd5,
|
||
0x84, 0xa1, 0xc3, 0x8b, 0xe1, 0x1a, 0x3e, 0xd3, 0xf6, 0x64, 0x36, 0x14, 0x29, 0xb4, 0x1e, 0x4e,
|
||
0x21, 0x11, 0xfb, 0xf3, 0x6d, 0x4f, 0xee, 0x4d, 0x86, 0xf2, 0xe4, 0x26, 0x58, 0xc0, 0x8e, 0xd1,
|
||
0x34, 0x4c, 0x54, 0x47, 0x22, 0x59, 0x52, 0x1c, 0x00, 0xdb, 0x9e, 0x1c, 0x5b, 0x51, 0xe7, 0x83,
|
||
0x31, 0x4b, 0x0f, 0xb8, 0x01, 0x00, 0xa1, 0x1a, 0x4b, 0x24, 0xa3, 0x81, 0x78, 0x91, 0xce, 0x94,
|
||
0x16, 0xda, 0x9e, 0x1c, 0x9a, 0x55, 0x33, 0xfc, 0xfb, 0xd0, 0x68, 0x20, 0x78, 0x03, 0xcc, 0xa1,
|
||
0xe7, 0x98, 0x59, 0x53, 0x00, 0xa6, 0x39, 0x60, 0xb1, 0xed, 0xc9, 0x91, 0x79, 0x75, 0xd6, 0x1f,
|
||
0x71, 0x90, 0x0c, 0xa6, 0x6a, 0x9c, 0x5a, 0x94, 0xdf, 0x4c, 0xdb, 0x93, 0xc5, 0x84, 0x2a, 0x5e,
|
||
0x8c, 0xc0, 0xe5, 0x04, 0xe9, 0x1e, 0x81, 0x2b, 0x08, 0xf8, 0x4b, 0x79, 0x08, 0x96, 0x22, 0x06,
|
||
0xbd, 0x6f, 0x10, 0x0a, 0x77, 0x40, 0xca, 0x34, 0x08, 0xf5, 0xe3, 0x64, 0xa4, 0x77, 0x44, 0xbe,
|
||
0x32, 0x6a, 0x95, 0x3f, 0x95, 0x1f, 0x06, 0x54, 0x05, 0x72, 0xca, 0xa2, 0xf7, 0x45, 0xd7, 0x63,
|
||
0x95, 0x32, 0xc9, 0x26, 0xb8, 0x50, 0xd9, 0x98, 0x50, 0xc1, 0x56, 0xfd, 0xe5, 0xb0, 0x52, 0x26,
|
||
0x83, 0xcb, 0x61, 0x8f, 0xa9, 0xf2, 0xb3, 0x04, 0xde, 0x18, 0x20, 0x35, 0xc1, 0xf0, 0x7e, 0xa4,
|
||
0x98, 0x15, 0xc6, 0x14, 0x33, 0xf2, 0x7a, 0xaa, 0xd9, 0x0b, 0x09, 0x64, 0x02, 0x11, 0xe0, 0xbd,
|
||
0x70, 0x80, 0x0b, 0x7b, 0x6f, 0x74, 0x3c, 0xf9, 0xfa, 0x88, 0x1e, 0x11, 0xb3, 0x7a, 0x2f, 0x01,
|
||
0x6e, 0x87, 0x1b, 0x85, 0xc8, 0xa6, 0xd5, 0x8e, 0x27, 0xe7, 0x47, 0x36, 0x8a, 0x68, 0x9f, 0x70,
|
||
0xc1, 0x12, 0x37, 0x53, 0x24, 0x1a, 0x22, 0x2e, 0x95, 0xfe, 0x0b, 0x97, 0x9e, 0x03, 0x30, 0xbe,
|
||
0x2d, 0xc1, 0xca, 0x3e, 0x98, 0xed, 0xfa, 0xec, 0x74, 0x41, 0xa9, 0x7c, 0x2f, 0x81, 0xb9, 0x1e,
|
||
0x2b, 0x82, 0xe1, 0x6e, 0x24, 0x52, 0xae, 0x0e, 0x89, 0x94, 0xd7, 0x13, 0x20, 0x07, 0x60, 0xb1,
|
||
0x2b, 0x40, 0x49, 0xa3, 0xb5, 0x63, 0xa6, 0xfb, 0x7b, 0x20, 0xe5, 0x1a, 0xba, 0xb0, 0x7e, 0x92,
|
||
0x9f, 0x1f, 0xe5, 0x40, 0xf9, 0x21, 0xe6, 0xe5, 0x00, 0xe5, 0x47, 0xc9, 0xf7, 0x68, 0x8f, 0x1b,
|
||
0xc1, 0x70, 0x3f, 0xa2, 0xfe, 0xfa, 0x10, 0xf5, 0x03, 0xfa, 0x11, 0x36, 0xf8, 0x74, 0xb4, 0x0d,
|
||
0xde, 0x8d, 0xda, 0x20, 0x3f, 0xca, 0x06, 0xac, 0x9c, 0x85, 0xed, 0xf0, 0x31, 0xc8, 0xed, 0x21,
|
||
0x7a, 0xdb, 0xaa, 0x1d, 0xdb, 0x8e, 0x8a, 0x6a, 0xc8, 0xa2, 0x87, 0x36, 0xe6, 0xed, 0xea, 0x94,
|
||
0xd1, 0xf0, 0x95, 0x04, 0x2e, 0x0d, 0xe5, 0x4c, 0x30, 0xeb, 0x47, 0x35, 0x8b, 0xfa, 0xac, 0x79,
|
||
0x3f, 0xaa, 0xb1, 0xf3, 0x78, 0xcd, 0xa2, 0xcc, 0x70, 0xbc, 0xda, 0x26, 0x86, 0x19, 0x6e, 0x10,
|
||
0x53, 0xa6, 0x58, 0x5f, 0xed, 0xfd, 0x66, 0xb8, 0x10, 0xbc, 0xae, 0x5f, 0x0c, 0xeb, 0x17, 0x6d,
|
||
0x8a, 0xd7, 0x40, 0x1a, 0x59, 0x7e, 0xeb, 0x11, 0x69, 0x3e, 0xd7, 0xf6, 0xe4, 0x60, 0x4e, 0x9d,
|
||
0x41, 0x96, 0x68, 0x39, 0xab, 0x60, 0xc6, 0x20, 0x55, 0x1b, 0x23, 0xcb, 0xef, 0x9d, 0xb3, 0x6d,
|
||
0x4f, 0xee, 0x4e, 0xa9, 0xd3, 0x06, 0x79, 0x88, 0x91, 0xa5, 0xfc, 0x2a, 0xf1, 0xec, 0x3b, 0xb4,
|
||
0x31, 0xdb, 0xf8, 0x15, 0x18, 0x18, 0xbe, 0x0d, 0x52, 0x58, 0xab, 0x77, 0x85, 0xcb, 0x77, 0x3c,
|
||
0x79, 0x59, 0x60, 0xd9, 0x6c, 0xfc, 0x9c, 0xba, 0xa5, 0xa8, 0x9c, 0x9a, 0x9d, 0x73, 0xd9, 0xbb,
|
||
0x4a, 0x8c, 0x2f, 0x07, 0x9c, 0x73, 0x83, 0xa5, 0x01, 0xf8, 0x34, 0x5b, 0xfc, 0x88, 0xad, 0xfd,
|
||
0x25, 0x4e, 0xf1, 0x51, 0x5d, 0x84, 0x4b, 0xd9, 0xf5, 0x2b, 0x64, 0x4d, 0xcb, 0x6d, 0x88, 0x2b,
|
||
0xd6, 0x72, 0x44, 0x58, 0xee, 0x26, 0x36, 0xf6, 0x85, 0x62, 0x40, 0xfb, 0x99, 0x2f, 0x8e, 0x00,
|
||
0xda, 0xcf, 0x54, 0xf6, 0x80, 0x37, 0xfd, 0x58, 0x48, 0xf1, 0x58, 0xb8, 0x14, 0xaf, 0x88, 0x21,
|
||
0x11, 0xe2, 0xce, 0x67, 0x50, 0x6a, 0xe3, 0x1b, 0xd9, 0xa9, 0x09, 0xa1, 0x8c, 0x58, 0xe5, 0x4f,
|
||
0xe5, 0x5b, 0x09, 0xcc, 0x85, 0x09, 0x46, 0x05, 0xca, 0xb2, 0x7f, 0xd9, 0x0d, 0xa9, 0xc6, 0xc6,
|
||
0xfe, 0xc5, 0x76, 0x33, 0x7a, 0xb1, 0x15, 0x2a, 0x9e, 0x69, 0x7b, 0x72, 0x78, 0x3a, 0x72, 0x89,
|
||
0x65, 0xfc, 0x34, 0xeb, 0xa9, 0x7f, 0xae, 0x12, 0xfc, 0x34, 0xeb, 0xa9, 0xca, 0x9f, 0x8a, 0xca,
|
||
0xdb, 0x72, 0x58, 0xb6, 0x07, 0x6e, 0xe3, 0x94, 0xa9, 0x7a, 0x0f, 0x9c, 0x1f, 0xc4, 0x93, 0x60,
|
||
0x26, 0x3d, 0xb5, 0xa9, 0x66, 0x56, 0x6b, 0xb6, 0x1b, 0x24, 0x2b, 0x97, 0x3e, 0x34, 0xad, 0x02,
|
||
0x3e, 0xd8, 0x65, 0xdf, 0xdb, 0x5f, 0xcf, 0x80, 0x29, 0x61, 0xb2, 0x0f, 0x40, 0xb2, 0xe4, 0xb6,
|
||
0x60, 0x2e, 0x9e, 0xbe, 0xbd, 0x7f, 0x11, 0xb9, 0xe5, 0xa1, 0x6b, 0xec, 0x26, 0xfc, 0x59, 0xb7,
|
||
0x44, 0x57, 0xca, 0x7e, 0xcb, 0x2a, 0x43, 0x65, 0xec, 0xdd, 0xe9, 0x24, 0xb7, 0x32, 0xc1, 0xfd,
|
||
0x0a, 0x3e, 0xf6, 0x2f, 0xa2, 0xbd, 0x9e, 0xca, 0xea, 0x30, 0xcc, 0x0f, 0xc2, 0x86, 0xfb, 0x74,
|
||
0xee, 0xca, 0x18, 0x0a, 0x82, 0xe1, 0xe7, 0xdd, 0x6e, 0x10, 0x08, 0xae, 0x13, 0xb8, 0x32, 0xfe,
|
||
0xa0, 0x74, 0x92, 0x5b, 0x9d, 0xe4, 0x34, 0x05, 0xef, 0x81, 0x33, 0x5d, 0xfe, 0x77, 0x6d, 0x67,
|
||
0xcf, 0x38, 0xa2, 0xfd, 0x56, 0xee, 0xb5, 0xf4, 0xdc, 0xa5, 0x11, 0x8d, 0x17, 0xaa, 0x60, 0xbe,
|
||
0xcb, 0x4b, 0x58, 0x40, 0x1e, 0xdd, 0xa7, 0x4e, 0x72, 0xf9, 0x71, 0x8d, 0x0c, 0x62, 0x70, 0x61,
|
||
0x48, 0xd1, 0x85, 0xd7, 0x27, 0x2b, 0xe6, 0x6c, 0x9f, 0xf5, 0x49, 0x49, 0x09, 0x86, 0x9f, 0x70,
|
||
0x8b, 0x44, 0x32, 0x76, 0x80, 0x9f, 0x62, 0xc5, 0x37, 0xa7, 0x8c, 0x23, 0x21, 0x18, 0x6a, 0x7d,
|
||
0x65, 0xfb, 0x81, 0xdb, 0x80, 0xab, 0xa3, 0x91, 0x22, 0x25, 0x73, 0x57, 0x27, 0xa0, 0x12, 0x2e,
|
||
0x88, 0xfc, 0x29, 0xe9, 0x73, 0x41, 0xfc, 0x1f, 0x4f, 0x9f, 0x0b, 0xfa, 0x7e, 0xb4, 0x94, 0x16,
|
||
0x7f, 0x79, 0x79, 0x59, 0xfa, 0xfd, 0xe5, 0x65, 0xe9, 0xef, 0x97, 0x97, 0xa5, 0xc7, 0x89, 0xe6,
|
||
0xd6, 0x93, 0x69, 0xfe, 0x3b, 0xf0, 0xc6, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x3f, 0xe0, 0xb4,
|
||
0x3b, 0xab, 0x14, 0x00, 0x00,
|
||
}
|