You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
5402 lines
124 KiB
5402 lines
124 KiB
// Code generated by protoc-gen-gogo. DO NOT EDIT. |
|
// source: api.proto |
|
|
|
/* |
|
Package v1 is a generated protocol buffer package. |
|
|
|
It is generated from these files: |
|
api.proto |
|
|
|
It has these top-level messages: |
|
AddPointReply |
|
AddPointReq |
|
AllConfigReply |
|
AllConfigReq |
|
CloseReply |
|
CloseReq |
|
ConfigReply |
|
ConfigReq |
|
ConsumePointReply |
|
ConsumePointReq |
|
ModelArgPoint |
|
ModelArgPointAdd |
|
ModelArgPointConsume |
|
ModelOldPointHistory |
|
ModelPointHistory |
|
ModelPointInfo |
|
OldPointHistoryReply |
|
OldPointHistoryReq |
|
PingReply |
|
PingReq |
|
PointAddByBpReply |
|
PointAddByBpReq |
|
PointHistoryReply |
|
PointHistoryReq |
|
PointInfoReply |
|
PointInfoReq |
|
*/ |
|
package v1 |
|
|
|
import proto "github.com/gogo/protobuf/proto" |
|
import fmt "fmt" |
|
import math "math" |
|
|
|
import context "golang.org/x/net/context" |
|
import grpc "google.golang.org/grpc" |
|
|
|
import binary "encoding/binary" |
|
|
|
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 AddPointReply struct { |
|
Status int32 `protobuf:"varint,1,opt,name=status,proto3" json:"status,omitempty"` |
|
} |
|
|
|
func (m *AddPointReply) Reset() { *m = AddPointReply{} } |
|
func (m *AddPointReply) String() string { return proto.CompactTextString(m) } |
|
func (*AddPointReply) ProtoMessage() {} |
|
func (*AddPointReply) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{0} } |
|
|
|
func (m *AddPointReply) GetStatus() int32 { |
|
if m != nil { |
|
return m.Status |
|
} |
|
return 0 |
|
} |
|
|
|
type AddPointReq struct { |
|
Pc *ModelArgPoint `protobuf:"bytes,2,opt,name=pc" json:"pc,omitempty"` |
|
} |
|
|
|
func (m *AddPointReq) Reset() { *m = AddPointReq{} } |
|
func (m *AddPointReq) String() string { return proto.CompactTextString(m) } |
|
func (*AddPointReq) ProtoMessage() {} |
|
func (*AddPointReq) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{1} } |
|
|
|
func (m *AddPointReq) GetPc() *ModelArgPoint { |
|
if m != nil { |
|
return m.Pc |
|
} |
|
return nil |
|
} |
|
|
|
type AllConfigReply struct { |
|
Data_0 map[string]int64 `protobuf:"bytes,1,rep,name=data_0,json=data0" json:"data_0,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` |
|
} |
|
|
|
func (m *AllConfigReply) Reset() { *m = AllConfigReply{} } |
|
func (m *AllConfigReply) String() string { return proto.CompactTextString(m) } |
|
func (*AllConfigReply) ProtoMessage() {} |
|
func (*AllConfigReply) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{2} } |
|
|
|
func (m *AllConfigReply) GetData_0() map[string]int64 { |
|
if m != nil { |
|
return m.Data_0 |
|
} |
|
return nil |
|
} |
|
|
|
type AllConfigReq struct { |
|
} |
|
|
|
func (m *AllConfigReq) Reset() { *m = AllConfigReq{} } |
|
func (m *AllConfigReq) String() string { return proto.CompactTextString(m) } |
|
func (*AllConfigReq) ProtoMessage() {} |
|
func (*AllConfigReq) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{3} } |
|
|
|
type CloseReply struct { |
|
} |
|
|
|
func (m *CloseReply) Reset() { *m = CloseReply{} } |
|
func (m *CloseReply) String() string { return proto.CompactTextString(m) } |
|
func (*CloseReply) ProtoMessage() {} |
|
func (*CloseReply) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{4} } |
|
|
|
type CloseReq struct { |
|
} |
|
|
|
func (m *CloseReq) Reset() { *m = CloseReq{} } |
|
func (m *CloseReq) String() string { return proto.CompactTextString(m) } |
|
func (*CloseReq) ProtoMessage() {} |
|
func (*CloseReq) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{5} } |
|
|
|
type ConfigReply struct { |
|
Point int64 `protobuf:"varint,1,opt,name=point,proto3" json:"point,omitempty"` |
|
} |
|
|
|
func (m *ConfigReply) Reset() { *m = ConfigReply{} } |
|
func (m *ConfigReply) String() string { return proto.CompactTextString(m) } |
|
func (*ConfigReply) ProtoMessage() {} |
|
func (*ConfigReply) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{6} } |
|
|
|
func (m *ConfigReply) GetPoint() int64 { |
|
if m != nil { |
|
return m.Point |
|
} |
|
return 0 |
|
} |
|
|
|
type ConfigReq struct { |
|
ChangeType int32 `protobuf:"varint,2,opt,name=change_type,json=changeType,proto3" json:"change_type,omitempty"` |
|
Mid int64 `protobuf:"varint,3,opt,name=mid,proto3" json:"mid,omitempty"` |
|
Bp float64 `protobuf:"fixed64,4,opt,name=bp,proto3" json:"bp,omitempty"` |
|
} |
|
|
|
func (m *ConfigReq) Reset() { *m = ConfigReq{} } |
|
func (m *ConfigReq) String() string { return proto.CompactTextString(m) } |
|
func (*ConfigReq) ProtoMessage() {} |
|
func (*ConfigReq) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{7} } |
|
|
|
func (m *ConfigReq) GetChangeType() int32 { |
|
if m != nil { |
|
return m.ChangeType |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *ConfigReq) GetMid() int64 { |
|
if m != nil { |
|
return m.Mid |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *ConfigReq) GetBp() float64 { |
|
if m != nil { |
|
return m.Bp |
|
} |
|
return 0 |
|
} |
|
|
|
type ConsumePointReply struct { |
|
Status int32 `protobuf:"varint,1,opt,name=status,proto3" json:"status,omitempty"` |
|
} |
|
|
|
func (m *ConsumePointReply) Reset() { *m = ConsumePointReply{} } |
|
func (m *ConsumePointReply) String() string { return proto.CompactTextString(m) } |
|
func (*ConsumePointReply) ProtoMessage() {} |
|
func (*ConsumePointReply) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{8} } |
|
|
|
func (m *ConsumePointReply) GetStatus() int32 { |
|
if m != nil { |
|
return m.Status |
|
} |
|
return 0 |
|
} |
|
|
|
type ConsumePointReq struct { |
|
Pc *ModelArgPointConsume `protobuf:"bytes,2,opt,name=pc" json:"pc,omitempty"` |
|
} |
|
|
|
func (m *ConsumePointReq) Reset() { *m = ConsumePointReq{} } |
|
func (m *ConsumePointReq) String() string { return proto.CompactTextString(m) } |
|
func (*ConsumePointReq) ProtoMessage() {} |
|
func (*ConsumePointReq) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{9} } |
|
|
|
func (m *ConsumePointReq) GetPc() *ModelArgPointConsume { |
|
if m != nil { |
|
return m.Pc |
|
} |
|
return nil |
|
} |
|
|
|
type ModelArgPoint struct { |
|
Mid int64 `protobuf:"varint,1,opt,name=mid,proto3" json:"mid,omitempty"` |
|
ChangeType int64 `protobuf:"varint,2,opt,name=change_type,json=changeType,proto3" json:"change_type,omitempty"` |
|
Point int64 `protobuf:"varint,3,opt,name=point,proto3" json:"point,omitempty"` |
|
Remark string `protobuf:"bytes,4,opt,name=remark,proto3" json:"remark,omitempty"` |
|
Operator string `protobuf:"bytes,5,opt,name=operator,proto3" json:"operator,omitempty"` |
|
} |
|
|
|
func (m *ModelArgPoint) Reset() { *m = ModelArgPoint{} } |
|
func (m *ModelArgPoint) String() string { return proto.CompactTextString(m) } |
|
func (*ModelArgPoint) ProtoMessage() {} |
|
func (*ModelArgPoint) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{10} } |
|
|
|
func (m *ModelArgPoint) GetMid() int64 { |
|
if m != nil { |
|
return m.Mid |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *ModelArgPoint) GetChangeType() int64 { |
|
if m != nil { |
|
return m.ChangeType |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *ModelArgPoint) GetPoint() int64 { |
|
if m != nil { |
|
return m.Point |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *ModelArgPoint) GetRemark() string { |
|
if m != nil { |
|
return m.Remark |
|
} |
|
return "" |
|
} |
|
|
|
func (m *ModelArgPoint) GetOperator() string { |
|
if m != nil { |
|
return m.Operator |
|
} |
|
return "" |
|
} |
|
|
|
type ModelArgPointAdd struct { |
|
Mid int64 `protobuf:"varint,1,opt,name=mid,proto3" json:"mid,omitempty"` |
|
ChangeType int32 `protobuf:"varint,2,opt,name=change_type,json=changeType,proto3" json:"change_type,omitempty"` |
|
RelationId string `protobuf:"bytes,3,opt,name=relation_id,json=relationId,proto3" json:"relation_id,omitempty"` |
|
Bcoin float64 `protobuf:"fixed64,4,opt,name=bcoin,proto3" json:"bcoin,omitempty"` |
|
Remark string `protobuf:"bytes,5,opt,name=remark,proto3" json:"remark,omitempty"` |
|
OrderId string `protobuf:"bytes,6,opt,name=order_id,json=orderId,proto3" json:"order_id,omitempty"` |
|
} |
|
|
|
func (m *ModelArgPointAdd) Reset() { *m = ModelArgPointAdd{} } |
|
func (m *ModelArgPointAdd) String() string { return proto.CompactTextString(m) } |
|
func (*ModelArgPointAdd) ProtoMessage() {} |
|
func (*ModelArgPointAdd) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{11} } |
|
|
|
func (m *ModelArgPointAdd) GetMid() int64 { |
|
if m != nil { |
|
return m.Mid |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *ModelArgPointAdd) GetChangeType() int32 { |
|
if m != nil { |
|
return m.ChangeType |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *ModelArgPointAdd) GetRelationId() string { |
|
if m != nil { |
|
return m.RelationId |
|
} |
|
return "" |
|
} |
|
|
|
func (m *ModelArgPointAdd) GetBcoin() float64 { |
|
if m != nil { |
|
return m.Bcoin |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *ModelArgPointAdd) GetRemark() string { |
|
if m != nil { |
|
return m.Remark |
|
} |
|
return "" |
|
} |
|
|
|
func (m *ModelArgPointAdd) GetOrderId() string { |
|
if m != nil { |
|
return m.OrderId |
|
} |
|
return "" |
|
} |
|
|
|
type ModelArgPointConsume struct { |
|
Mid int64 `protobuf:"varint,1,opt,name=mid,proto3" json:"mid,omitempty"` |
|
ChangeType int64 `protobuf:"varint,2,opt,name=change_type,json=changeType,proto3" json:"change_type,omitempty"` |
|
RelationId string `protobuf:"bytes,3,opt,name=relation_id,json=relationId,proto3" json:"relation_id,omitempty"` |
|
Point int64 `protobuf:"varint,4,opt,name=point,proto3" json:"point,omitempty"` |
|
Remark string `protobuf:"bytes,5,opt,name=remark,proto3" json:"remark,omitempty"` |
|
} |
|
|
|
func (m *ModelArgPointConsume) Reset() { *m = ModelArgPointConsume{} } |
|
func (m *ModelArgPointConsume) String() string { return proto.CompactTextString(m) } |
|
func (*ModelArgPointConsume) ProtoMessage() {} |
|
func (*ModelArgPointConsume) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{12} } |
|
|
|
func (m *ModelArgPointConsume) GetMid() int64 { |
|
if m != nil { |
|
return m.Mid |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *ModelArgPointConsume) GetChangeType() int64 { |
|
if m != nil { |
|
return m.ChangeType |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *ModelArgPointConsume) GetRelationId() string { |
|
if m != nil { |
|
return m.RelationId |
|
} |
|
return "" |
|
} |
|
|
|
func (m *ModelArgPointConsume) GetPoint() int64 { |
|
if m != nil { |
|
return m.Point |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *ModelArgPointConsume) GetRemark() string { |
|
if m != nil { |
|
return m.Remark |
|
} |
|
return "" |
|
} |
|
|
|
type ModelOldPointHistory struct { |
|
Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` |
|
Mid int64 `protobuf:"varint,2,opt,name=mid,proto3" json:"mid,omitempty"` |
|
Point int64 `protobuf:"varint,3,opt,name=point,proto3" json:"point,omitempty"` |
|
OrderId string `protobuf:"bytes,4,opt,name=order_id,json=orderId,proto3" json:"order_id,omitempty"` |
|
ChangeType int32 `protobuf:"varint,5,opt,name=change_type,json=changeType,proto3" json:"change_type,omitempty"` |
|
ChangeTime int64 `protobuf:"varint,6,opt,name=change_time,json=changeTime,proto3" json:"change_time,omitempty"` |
|
RelationId string `protobuf:"bytes,7,opt,name=relation_id,json=relationId,proto3" json:"relation_id,omitempty"` |
|
PointBalance int64 `protobuf:"varint,8,opt,name=point_balance,json=pointBalance,proto3" json:"point_balance,omitempty"` |
|
Remark string `protobuf:"bytes,9,opt,name=remark,proto3" json:"remark,omitempty"` |
|
Operator string `protobuf:"bytes,10,opt,name=operator,proto3" json:"operator,omitempty"` |
|
} |
|
|
|
func (m *ModelOldPointHistory) Reset() { *m = ModelOldPointHistory{} } |
|
func (m *ModelOldPointHistory) String() string { return proto.CompactTextString(m) } |
|
func (*ModelOldPointHistory) ProtoMessage() {} |
|
func (*ModelOldPointHistory) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{13} } |
|
|
|
func (m *ModelOldPointHistory) GetId() int64 { |
|
if m != nil { |
|
return m.Id |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *ModelOldPointHistory) GetMid() int64 { |
|
if m != nil { |
|
return m.Mid |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *ModelOldPointHistory) GetPoint() int64 { |
|
if m != nil { |
|
return m.Point |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *ModelOldPointHistory) GetOrderId() string { |
|
if m != nil { |
|
return m.OrderId |
|
} |
|
return "" |
|
} |
|
|
|
func (m *ModelOldPointHistory) GetChangeType() int32 { |
|
if m != nil { |
|
return m.ChangeType |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *ModelOldPointHistory) GetChangeTime() int64 { |
|
if m != nil { |
|
return m.ChangeTime |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *ModelOldPointHistory) GetRelationId() string { |
|
if m != nil { |
|
return m.RelationId |
|
} |
|
return "" |
|
} |
|
|
|
func (m *ModelOldPointHistory) GetPointBalance() int64 { |
|
if m != nil { |
|
return m.PointBalance |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *ModelOldPointHistory) GetRemark() string { |
|
if m != nil { |
|
return m.Remark |
|
} |
|
return "" |
|
} |
|
|
|
func (m *ModelOldPointHistory) GetOperator() string { |
|
if m != nil { |
|
return m.Operator |
|
} |
|
return "" |
|
} |
|
|
|
type ModelPointHistory struct { |
|
Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` |
|
Mid int64 `protobuf:"varint,2,opt,name=mid,proto3" json:"mid,omitempty"` |
|
Point int64 `protobuf:"varint,3,opt,name=point,proto3" json:"point,omitempty"` |
|
OrderId string `protobuf:"bytes,4,opt,name=order_id,json=orderId,proto3" json:"order_id,omitempty"` |
|
ChangeType int32 `protobuf:"varint,5,opt,name=change_type,json=changeType,proto3" json:"change_type,omitempty"` |
|
ChangeTime int64 `protobuf:"varint,6,opt,name=change_time,json=changeTime,proto3" json:"change_time,omitempty"` |
|
RelationId string `protobuf:"bytes,7,opt,name=relation_id,json=relationId,proto3" json:"relation_id,omitempty"` |
|
PointBalance int64 `protobuf:"varint,8,opt,name=point_balance,json=pointBalance,proto3" json:"point_balance,omitempty"` |
|
Remark string `protobuf:"bytes,9,opt,name=remark,proto3" json:"remark,omitempty"` |
|
Operator string `protobuf:"bytes,10,opt,name=operator,proto3" json:"operator,omitempty"` |
|
} |
|
|
|
func (m *ModelPointHistory) Reset() { *m = ModelPointHistory{} } |
|
func (m *ModelPointHistory) String() string { return proto.CompactTextString(m) } |
|
func (*ModelPointHistory) ProtoMessage() {} |
|
func (*ModelPointHistory) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{14} } |
|
|
|
func (m *ModelPointHistory) GetId() int64 { |
|
if m != nil { |
|
return m.Id |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *ModelPointHistory) GetMid() int64 { |
|
if m != nil { |
|
return m.Mid |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *ModelPointHistory) GetPoint() int64 { |
|
if m != nil { |
|
return m.Point |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *ModelPointHistory) GetOrderId() string { |
|
if m != nil { |
|
return m.OrderId |
|
} |
|
return "" |
|
} |
|
|
|
func (m *ModelPointHistory) GetChangeType() int32 { |
|
if m != nil { |
|
return m.ChangeType |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *ModelPointHistory) GetChangeTime() int64 { |
|
if m != nil { |
|
return m.ChangeTime |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *ModelPointHistory) GetRelationId() string { |
|
if m != nil { |
|
return m.RelationId |
|
} |
|
return "" |
|
} |
|
|
|
func (m *ModelPointHistory) GetPointBalance() int64 { |
|
if m != nil { |
|
return m.PointBalance |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *ModelPointHistory) GetRemark() string { |
|
if m != nil { |
|
return m.Remark |
|
} |
|
return "" |
|
} |
|
|
|
func (m *ModelPointHistory) GetOperator() string { |
|
if m != nil { |
|
return m.Operator |
|
} |
|
return "" |
|
} |
|
|
|
type ModelPointInfo struct { |
|
Mid int64 `protobuf:"varint,1,opt,name=mid,proto3" json:"mid,omitempty"` |
|
PointBalance int64 `protobuf:"varint,2,opt,name=point_balance,json=pointBalance,proto3" json:"point_balance,omitempty"` |
|
Ver int64 `protobuf:"varint,3,opt,name=ver,proto3" json:"ver,omitempty"` |
|
} |
|
|
|
func (m *ModelPointInfo) Reset() { *m = ModelPointInfo{} } |
|
func (m *ModelPointInfo) String() string { return proto.CompactTextString(m) } |
|
func (*ModelPointInfo) ProtoMessage() {} |
|
func (*ModelPointInfo) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{15} } |
|
|
|
func (m *ModelPointInfo) GetMid() int64 { |
|
if m != nil { |
|
return m.Mid |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *ModelPointInfo) GetPointBalance() int64 { |
|
if m != nil { |
|
return m.PointBalance |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *ModelPointInfo) GetVer() int64 { |
|
if m != nil { |
|
return m.Ver |
|
} |
|
return 0 |
|
} |
|
|
|
type OldPointHistoryReply struct { |
|
Phs []*ModelOldPointHistory `protobuf:"bytes,1,rep,name=phs" json:"phs,omitempty"` |
|
Total int32 `protobuf:"varint,2,opt,name=total,proto3" json:"total,omitempty"` |
|
} |
|
|
|
func (m *OldPointHistoryReply) Reset() { *m = OldPointHistoryReply{} } |
|
func (m *OldPointHistoryReply) String() string { return proto.CompactTextString(m) } |
|
func (*OldPointHistoryReply) ProtoMessage() {} |
|
func (*OldPointHistoryReply) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{16} } |
|
|
|
func (m *OldPointHistoryReply) GetPhs() []*ModelOldPointHistory { |
|
if m != nil { |
|
return m.Phs |
|
} |
|
return nil |
|
} |
|
|
|
func (m *OldPointHistoryReply) GetTotal() int32 { |
|
if m != nil { |
|
return m.Total |
|
} |
|
return 0 |
|
} |
|
|
|
type OldPointHistoryReq struct { |
|
Mid int64 `protobuf:"varint,2,opt,name=mid,proto3" json:"mid,omitempty"` |
|
Pn int32 `protobuf:"varint,3,opt,name=pn,proto3" json:"pn,omitempty"` |
|
Ps int32 `protobuf:"varint,4,opt,name=ps,proto3" json:"ps,omitempty"` |
|
} |
|
|
|
func (m *OldPointHistoryReq) Reset() { *m = OldPointHistoryReq{} } |
|
func (m *OldPointHistoryReq) String() string { return proto.CompactTextString(m) } |
|
func (*OldPointHistoryReq) ProtoMessage() {} |
|
func (*OldPointHistoryReq) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{17} } |
|
|
|
func (m *OldPointHistoryReq) GetMid() int64 { |
|
if m != nil { |
|
return m.Mid |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *OldPointHistoryReq) GetPn() int32 { |
|
if m != nil { |
|
return m.Pn |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *OldPointHistoryReq) GetPs() int32 { |
|
if m != nil { |
|
return m.Ps |
|
} |
|
return 0 |
|
} |
|
|
|
type PingReply struct { |
|
} |
|
|
|
func (m *PingReply) Reset() { *m = PingReply{} } |
|
func (m *PingReply) String() string { return proto.CompactTextString(m) } |
|
func (*PingReply) ProtoMessage() {} |
|
func (*PingReply) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{18} } |
|
|
|
type PingReq struct { |
|
} |
|
|
|
func (m *PingReq) Reset() { *m = PingReq{} } |
|
func (m *PingReq) String() string { return proto.CompactTextString(m) } |
|
func (*PingReq) ProtoMessage() {} |
|
func (*PingReq) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{19} } |
|
|
|
type PointAddByBpReply struct { |
|
P int64 `protobuf:"varint,1,opt,name=p,proto3" json:"p,omitempty"` |
|
} |
|
|
|
func (m *PointAddByBpReply) Reset() { *m = PointAddByBpReply{} } |
|
func (m *PointAddByBpReply) String() string { return proto.CompactTextString(m) } |
|
func (*PointAddByBpReply) ProtoMessage() {} |
|
func (*PointAddByBpReply) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{20} } |
|
|
|
func (m *PointAddByBpReply) GetP() int64 { |
|
if m != nil { |
|
return m.P |
|
} |
|
return 0 |
|
} |
|
|
|
type PointAddByBpReq struct { |
|
Pa *ModelArgPointAdd `protobuf:"bytes,2,opt,name=pa" json:"pa,omitempty"` |
|
} |
|
|
|
func (m *PointAddByBpReq) Reset() { *m = PointAddByBpReq{} } |
|
func (m *PointAddByBpReq) String() string { return proto.CompactTextString(m) } |
|
func (*PointAddByBpReq) ProtoMessage() {} |
|
func (*PointAddByBpReq) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{21} } |
|
|
|
func (m *PointAddByBpReq) GetPa() *ModelArgPointAdd { |
|
if m != nil { |
|
return m.Pa |
|
} |
|
return nil |
|
} |
|
|
|
type PointHistoryReply struct { |
|
Phs []*ModelPointHistory `protobuf:"bytes,1,rep,name=phs" json:"phs,omitempty"` |
|
Total int32 `protobuf:"varint,2,opt,name=total,proto3" json:"total,omitempty"` |
|
Ncursor int32 `protobuf:"varint,3,opt,name=ncursor,proto3" json:"ncursor,omitempty"` |
|
} |
|
|
|
func (m *PointHistoryReply) Reset() { *m = PointHistoryReply{} } |
|
func (m *PointHistoryReply) String() string { return proto.CompactTextString(m) } |
|
func (*PointHistoryReply) ProtoMessage() {} |
|
func (*PointHistoryReply) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{22} } |
|
|
|
func (m *PointHistoryReply) GetPhs() []*ModelPointHistory { |
|
if m != nil { |
|
return m.Phs |
|
} |
|
return nil |
|
} |
|
|
|
func (m *PointHistoryReply) GetTotal() int32 { |
|
if m != nil { |
|
return m.Total |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *PointHistoryReply) GetNcursor() int32 { |
|
if m != nil { |
|
return m.Ncursor |
|
} |
|
return 0 |
|
} |
|
|
|
type PointHistoryReq struct { |
|
Mid int64 `protobuf:"varint,2,opt,name=mid,proto3" json:"mid,omitempty"` |
|
Cursor int32 `protobuf:"varint,3,opt,name=cursor,proto3" json:"cursor,omitempty"` |
|
Ps int32 `protobuf:"varint,4,opt,name=ps,proto3" json:"ps,omitempty"` |
|
} |
|
|
|
func (m *PointHistoryReq) Reset() { *m = PointHistoryReq{} } |
|
func (m *PointHistoryReq) String() string { return proto.CompactTextString(m) } |
|
func (*PointHistoryReq) ProtoMessage() {} |
|
func (*PointHistoryReq) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{23} } |
|
|
|
func (m *PointHistoryReq) GetMid() int64 { |
|
if m != nil { |
|
return m.Mid |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *PointHistoryReq) GetCursor() int32 { |
|
if m != nil { |
|
return m.Cursor |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *PointHistoryReq) GetPs() int32 { |
|
if m != nil { |
|
return m.Ps |
|
} |
|
return 0 |
|
} |
|
|
|
type PointInfoReply struct { |
|
Pi *ModelPointInfo `protobuf:"bytes,1,opt,name=pi" json:"pi,omitempty"` |
|
} |
|
|
|
func (m *PointInfoReply) Reset() { *m = PointInfoReply{} } |
|
func (m *PointInfoReply) String() string { return proto.CompactTextString(m) } |
|
func (*PointInfoReply) ProtoMessage() {} |
|
func (*PointInfoReply) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{24} } |
|
|
|
func (m *PointInfoReply) GetPi() *ModelPointInfo { |
|
if m != nil { |
|
return m.Pi |
|
} |
|
return nil |
|
} |
|
|
|
type PointInfoReq struct { |
|
Mid int64 `protobuf:"varint,2,opt,name=mid,proto3" json:"mid,omitempty"` |
|
} |
|
|
|
func (m *PointInfoReq) Reset() { *m = PointInfoReq{} } |
|
func (m *PointInfoReq) String() string { return proto.CompactTextString(m) } |
|
func (*PointInfoReq) ProtoMessage() {} |
|
func (*PointInfoReq) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{25} } |
|
|
|
func (m *PointInfoReq) GetMid() int64 { |
|
if m != nil { |
|
return m.Mid |
|
} |
|
return 0 |
|
} |
|
|
|
func init() { |
|
proto.RegisterType((*AddPointReply)(nil), "account.point.AddPointReply") |
|
proto.RegisterType((*AddPointReq)(nil), "account.point.AddPointReq") |
|
proto.RegisterType((*AllConfigReply)(nil), "account.point.AllConfigReply") |
|
proto.RegisterType((*AllConfigReq)(nil), "account.point.AllConfigReq") |
|
proto.RegisterType((*CloseReply)(nil), "account.point.CloseReply") |
|
proto.RegisterType((*CloseReq)(nil), "account.point.CloseReq") |
|
proto.RegisterType((*ConfigReply)(nil), "account.point.ConfigReply") |
|
proto.RegisterType((*ConfigReq)(nil), "account.point.ConfigReq") |
|
proto.RegisterType((*ConsumePointReply)(nil), "account.point.ConsumePointReply") |
|
proto.RegisterType((*ConsumePointReq)(nil), "account.point.ConsumePointReq") |
|
proto.RegisterType((*ModelArgPoint)(nil), "account.point.ModelArgPoint") |
|
proto.RegisterType((*ModelArgPointAdd)(nil), "account.point.ModelArgPointAdd") |
|
proto.RegisterType((*ModelArgPointConsume)(nil), "account.point.ModelArgPointConsume") |
|
proto.RegisterType((*ModelOldPointHistory)(nil), "account.point.ModelOldPointHistory") |
|
proto.RegisterType((*ModelPointHistory)(nil), "account.point.ModelPointHistory") |
|
proto.RegisterType((*ModelPointInfo)(nil), "account.point.ModelPointInfo") |
|
proto.RegisterType((*OldPointHistoryReply)(nil), "account.point.OldPointHistoryReply") |
|
proto.RegisterType((*OldPointHistoryReq)(nil), "account.point.OldPointHistoryReq") |
|
proto.RegisterType((*PingReply)(nil), "account.point.PingReply") |
|
proto.RegisterType((*PingReq)(nil), "account.point.PingReq") |
|
proto.RegisterType((*PointAddByBpReply)(nil), "account.point.PointAddByBpReply") |
|
proto.RegisterType((*PointAddByBpReq)(nil), "account.point.PointAddByBpReq") |
|
proto.RegisterType((*PointHistoryReply)(nil), "account.point.PointHistoryReply") |
|
proto.RegisterType((*PointHistoryReq)(nil), "account.point.PointHistoryReq") |
|
proto.RegisterType((*PointInfoReply)(nil), "account.point.PointInfoReply") |
|
proto.RegisterType((*PointInfoReq)(nil), "account.point.PointInfoReq") |
|
} |
|
|
|
// 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 |
|
|
|
// Client API for Point service |
|
|
|
type PointClient interface { |
|
// Config get point config. |
|
Config(ctx context.Context, in *ConfigReq, opts ...grpc.CallOption) (*ConfigReply, error) |
|
// AllConfig all point config |
|
AllConfig(ctx context.Context, in *AllConfigReq, opts ...grpc.CallOption) (*AllConfigReply, error) |
|
// Ping Service |
|
Ping(ctx context.Context, in *PingReq, opts ...grpc.CallOption) (*PingReply, error) |
|
// Close Service |
|
Close(ctx context.Context, in *CloseReq, opts ...grpc.CallOption) (*CloseReply, error) |
|
// PointInfo . |
|
PointInfo(ctx context.Context, in *PointInfoReq, opts ...grpc.CallOption) (*PointInfoReply, error) |
|
// PointHistory . |
|
PointHistory(ctx context.Context, in *PointHistoryReq, opts ...grpc.CallOption) (*PointHistoryReply, error) |
|
// OldPointHistory old point history . |
|
OldPointHistory(ctx context.Context, in *OldPointHistoryReq, opts ...grpc.CallOption) (*OldPointHistoryReply, error) |
|
// PointAddByBp by bp. |
|
PointAddByBp(ctx context.Context, in *PointAddByBpReq, opts ...grpc.CallOption) (*PointAddByBpReply, error) |
|
// ConsumePoint . |
|
ConsumePoint(ctx context.Context, in *ConsumePointReq, opts ...grpc.CallOption) (*ConsumePointReply, error) |
|
// AddPoint . |
|
AddPoint(ctx context.Context, in *AddPointReq, opts ...grpc.CallOption) (*AddPointReply, error) |
|
} |
|
|
|
type pointClient struct { |
|
cc *grpc.ClientConn |
|
} |
|
|
|
func NewPointClient(cc *grpc.ClientConn) PointClient { |
|
return &pointClient{cc} |
|
} |
|
|
|
func (c *pointClient) Config(ctx context.Context, in *ConfigReq, opts ...grpc.CallOption) (*ConfigReply, error) { |
|
out := new(ConfigReply) |
|
err := grpc.Invoke(ctx, "/account.point.Point/Config", in, out, c.cc, opts...) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return out, nil |
|
} |
|
|
|
func (c *pointClient) AllConfig(ctx context.Context, in *AllConfigReq, opts ...grpc.CallOption) (*AllConfigReply, error) { |
|
out := new(AllConfigReply) |
|
err := grpc.Invoke(ctx, "/account.point.Point/AllConfig", in, out, c.cc, opts...) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return out, nil |
|
} |
|
|
|
func (c *pointClient) Ping(ctx context.Context, in *PingReq, opts ...grpc.CallOption) (*PingReply, error) { |
|
out := new(PingReply) |
|
err := grpc.Invoke(ctx, "/account.point.Point/Ping", in, out, c.cc, opts...) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return out, nil |
|
} |
|
|
|
func (c *pointClient) Close(ctx context.Context, in *CloseReq, opts ...grpc.CallOption) (*CloseReply, error) { |
|
out := new(CloseReply) |
|
err := grpc.Invoke(ctx, "/account.point.Point/Close", in, out, c.cc, opts...) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return out, nil |
|
} |
|
|
|
func (c *pointClient) PointInfo(ctx context.Context, in *PointInfoReq, opts ...grpc.CallOption) (*PointInfoReply, error) { |
|
out := new(PointInfoReply) |
|
err := grpc.Invoke(ctx, "/account.point.Point/PointInfo", in, out, c.cc, opts...) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return out, nil |
|
} |
|
|
|
func (c *pointClient) PointHistory(ctx context.Context, in *PointHistoryReq, opts ...grpc.CallOption) (*PointHistoryReply, error) { |
|
out := new(PointHistoryReply) |
|
err := grpc.Invoke(ctx, "/account.point.Point/PointHistory", in, out, c.cc, opts...) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return out, nil |
|
} |
|
|
|
func (c *pointClient) OldPointHistory(ctx context.Context, in *OldPointHistoryReq, opts ...grpc.CallOption) (*OldPointHistoryReply, error) { |
|
out := new(OldPointHistoryReply) |
|
err := grpc.Invoke(ctx, "/account.point.Point/OldPointHistory", in, out, c.cc, opts...) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return out, nil |
|
} |
|
|
|
func (c *pointClient) PointAddByBp(ctx context.Context, in *PointAddByBpReq, opts ...grpc.CallOption) (*PointAddByBpReply, error) { |
|
out := new(PointAddByBpReply) |
|
err := grpc.Invoke(ctx, "/account.point.Point/PointAddByBp", in, out, c.cc, opts...) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return out, nil |
|
} |
|
|
|
func (c *pointClient) ConsumePoint(ctx context.Context, in *ConsumePointReq, opts ...grpc.CallOption) (*ConsumePointReply, error) { |
|
out := new(ConsumePointReply) |
|
err := grpc.Invoke(ctx, "/account.point.Point/ConsumePoint", in, out, c.cc, opts...) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return out, nil |
|
} |
|
|
|
func (c *pointClient) AddPoint(ctx context.Context, in *AddPointReq, opts ...grpc.CallOption) (*AddPointReply, error) { |
|
out := new(AddPointReply) |
|
err := grpc.Invoke(ctx, "/account.point.Point/AddPoint", in, out, c.cc, opts...) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return out, nil |
|
} |
|
|
|
// Server API for Point service |
|
|
|
type PointServer interface { |
|
// Config get point config. |
|
Config(context.Context, *ConfigReq) (*ConfigReply, error) |
|
// AllConfig all point config |
|
AllConfig(context.Context, *AllConfigReq) (*AllConfigReply, error) |
|
// Ping Service |
|
Ping(context.Context, *PingReq) (*PingReply, error) |
|
// Close Service |
|
Close(context.Context, *CloseReq) (*CloseReply, error) |
|
// PointInfo . |
|
PointInfo(context.Context, *PointInfoReq) (*PointInfoReply, error) |
|
// PointHistory . |
|
PointHistory(context.Context, *PointHistoryReq) (*PointHistoryReply, error) |
|
// OldPointHistory old point history . |
|
OldPointHistory(context.Context, *OldPointHistoryReq) (*OldPointHistoryReply, error) |
|
// PointAddByBp by bp. |
|
PointAddByBp(context.Context, *PointAddByBpReq) (*PointAddByBpReply, error) |
|
// ConsumePoint . |
|
ConsumePoint(context.Context, *ConsumePointReq) (*ConsumePointReply, error) |
|
// AddPoint . |
|
AddPoint(context.Context, *AddPointReq) (*AddPointReply, error) |
|
} |
|
|
|
func RegisterPointServer(s *grpc.Server, srv PointServer) { |
|
s.RegisterService(&_Point_serviceDesc, srv) |
|
} |
|
|
|
func _Point_Config_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { |
|
in := new(ConfigReq) |
|
if err := dec(in); err != nil { |
|
return nil, err |
|
} |
|
if interceptor == nil { |
|
return srv.(PointServer).Config(ctx, in) |
|
} |
|
info := &grpc.UnaryServerInfo{ |
|
Server: srv, |
|
FullMethod: "/account.point.Point/Config", |
|
} |
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) { |
|
return srv.(PointServer).Config(ctx, req.(*ConfigReq)) |
|
} |
|
return interceptor(ctx, in, info, handler) |
|
} |
|
|
|
func _Point_AllConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { |
|
in := new(AllConfigReq) |
|
if err := dec(in); err != nil { |
|
return nil, err |
|
} |
|
if interceptor == nil { |
|
return srv.(PointServer).AllConfig(ctx, in) |
|
} |
|
info := &grpc.UnaryServerInfo{ |
|
Server: srv, |
|
FullMethod: "/account.point.Point/AllConfig", |
|
} |
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) { |
|
return srv.(PointServer).AllConfig(ctx, req.(*AllConfigReq)) |
|
} |
|
return interceptor(ctx, in, info, handler) |
|
} |
|
|
|
func _Point_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { |
|
in := new(PingReq) |
|
if err := dec(in); err != nil { |
|
return nil, err |
|
} |
|
if interceptor == nil { |
|
return srv.(PointServer).Ping(ctx, in) |
|
} |
|
info := &grpc.UnaryServerInfo{ |
|
Server: srv, |
|
FullMethod: "/account.point.Point/Ping", |
|
} |
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) { |
|
return srv.(PointServer).Ping(ctx, req.(*PingReq)) |
|
} |
|
return interceptor(ctx, in, info, handler) |
|
} |
|
|
|
func _Point_Close_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { |
|
in := new(CloseReq) |
|
if err := dec(in); err != nil { |
|
return nil, err |
|
} |
|
if interceptor == nil { |
|
return srv.(PointServer).Close(ctx, in) |
|
} |
|
info := &grpc.UnaryServerInfo{ |
|
Server: srv, |
|
FullMethod: "/account.point.Point/Close", |
|
} |
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) { |
|
return srv.(PointServer).Close(ctx, req.(*CloseReq)) |
|
} |
|
return interceptor(ctx, in, info, handler) |
|
} |
|
|
|
func _Point_PointInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { |
|
in := new(PointInfoReq) |
|
if err := dec(in); err != nil { |
|
return nil, err |
|
} |
|
if interceptor == nil { |
|
return srv.(PointServer).PointInfo(ctx, in) |
|
} |
|
info := &grpc.UnaryServerInfo{ |
|
Server: srv, |
|
FullMethod: "/account.point.Point/PointInfo", |
|
} |
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) { |
|
return srv.(PointServer).PointInfo(ctx, req.(*PointInfoReq)) |
|
} |
|
return interceptor(ctx, in, info, handler) |
|
} |
|
|
|
func _Point_PointHistory_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { |
|
in := new(PointHistoryReq) |
|
if err := dec(in); err != nil { |
|
return nil, err |
|
} |
|
if interceptor == nil { |
|
return srv.(PointServer).PointHistory(ctx, in) |
|
} |
|
info := &grpc.UnaryServerInfo{ |
|
Server: srv, |
|
FullMethod: "/account.point.Point/PointHistory", |
|
} |
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) { |
|
return srv.(PointServer).PointHistory(ctx, req.(*PointHistoryReq)) |
|
} |
|
return interceptor(ctx, in, info, handler) |
|
} |
|
|
|
func _Point_OldPointHistory_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { |
|
in := new(OldPointHistoryReq) |
|
if err := dec(in); err != nil { |
|
return nil, err |
|
} |
|
if interceptor == nil { |
|
return srv.(PointServer).OldPointHistory(ctx, in) |
|
} |
|
info := &grpc.UnaryServerInfo{ |
|
Server: srv, |
|
FullMethod: "/account.point.Point/OldPointHistory", |
|
} |
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) { |
|
return srv.(PointServer).OldPointHistory(ctx, req.(*OldPointHistoryReq)) |
|
} |
|
return interceptor(ctx, in, info, handler) |
|
} |
|
|
|
func _Point_PointAddByBp_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { |
|
in := new(PointAddByBpReq) |
|
if err := dec(in); err != nil { |
|
return nil, err |
|
} |
|
if interceptor == nil { |
|
return srv.(PointServer).PointAddByBp(ctx, in) |
|
} |
|
info := &grpc.UnaryServerInfo{ |
|
Server: srv, |
|
FullMethod: "/account.point.Point/PointAddByBp", |
|
} |
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) { |
|
return srv.(PointServer).PointAddByBp(ctx, req.(*PointAddByBpReq)) |
|
} |
|
return interceptor(ctx, in, info, handler) |
|
} |
|
|
|
func _Point_ConsumePoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { |
|
in := new(ConsumePointReq) |
|
if err := dec(in); err != nil { |
|
return nil, err |
|
} |
|
if interceptor == nil { |
|
return srv.(PointServer).ConsumePoint(ctx, in) |
|
} |
|
info := &grpc.UnaryServerInfo{ |
|
Server: srv, |
|
FullMethod: "/account.point.Point/ConsumePoint", |
|
} |
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) { |
|
return srv.(PointServer).ConsumePoint(ctx, req.(*ConsumePointReq)) |
|
} |
|
return interceptor(ctx, in, info, handler) |
|
} |
|
|
|
func _Point_AddPoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { |
|
in := new(AddPointReq) |
|
if err := dec(in); err != nil { |
|
return nil, err |
|
} |
|
if interceptor == nil { |
|
return srv.(PointServer).AddPoint(ctx, in) |
|
} |
|
info := &grpc.UnaryServerInfo{ |
|
Server: srv, |
|
FullMethod: "/account.point.Point/AddPoint", |
|
} |
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) { |
|
return srv.(PointServer).AddPoint(ctx, req.(*AddPointReq)) |
|
} |
|
return interceptor(ctx, in, info, handler) |
|
} |
|
|
|
var _Point_serviceDesc = grpc.ServiceDesc{ |
|
ServiceName: "account.point.Point", |
|
HandlerType: (*PointServer)(nil), |
|
Methods: []grpc.MethodDesc{ |
|
{ |
|
MethodName: "Config", |
|
Handler: _Point_Config_Handler, |
|
}, |
|
{ |
|
MethodName: "AllConfig", |
|
Handler: _Point_AllConfig_Handler, |
|
}, |
|
{ |
|
MethodName: "Ping", |
|
Handler: _Point_Ping_Handler, |
|
}, |
|
{ |
|
MethodName: "Close", |
|
Handler: _Point_Close_Handler, |
|
}, |
|
{ |
|
MethodName: "PointInfo", |
|
Handler: _Point_PointInfo_Handler, |
|
}, |
|
{ |
|
MethodName: "PointHistory", |
|
Handler: _Point_PointHistory_Handler, |
|
}, |
|
{ |
|
MethodName: "OldPointHistory", |
|
Handler: _Point_OldPointHistory_Handler, |
|
}, |
|
{ |
|
MethodName: "PointAddByBp", |
|
Handler: _Point_PointAddByBp_Handler, |
|
}, |
|
{ |
|
MethodName: "ConsumePoint", |
|
Handler: _Point_ConsumePoint_Handler, |
|
}, |
|
{ |
|
MethodName: "AddPoint", |
|
Handler: _Point_AddPoint_Handler, |
|
}, |
|
}, |
|
Streams: []grpc.StreamDesc{}, |
|
Metadata: "api.proto", |
|
} |
|
|
|
func (m *AddPointReply) 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 *AddPointReply) MarshalTo(dAtA []byte) (int, error) { |
|
var i int |
|
_ = i |
|
var l int |
|
_ = l |
|
if m.Status != 0 { |
|
dAtA[i] = 0x8 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.Status)) |
|
} |
|
return i, nil |
|
} |
|
|
|
func (m *AddPointReq) 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 *AddPointReq) MarshalTo(dAtA []byte) (int, error) { |
|
var i int |
|
_ = i |
|
var l int |
|
_ = l |
|
if m.Pc != nil { |
|
dAtA[i] = 0x12 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.Pc.Size())) |
|
n1, err := m.Pc.MarshalTo(dAtA[i:]) |
|
if err != nil { |
|
return 0, err |
|
} |
|
i += n1 |
|
} |
|
return i, nil |
|
} |
|
|
|
func (m *AllConfigReply) 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 *AllConfigReply) MarshalTo(dAtA []byte) (int, error) { |
|
var i int |
|
_ = i |
|
var l int |
|
_ = l |
|
if len(m.Data_0) > 0 { |
|
for k, _ := range m.Data_0 { |
|
dAtA[i] = 0xa |
|
i++ |
|
v := m.Data_0[k] |
|
mapSize := 1 + len(k) + sovApi(uint64(len(k))) + 1 + sovApi(uint64(v)) |
|
i = encodeVarintApi(dAtA, i, uint64(mapSize)) |
|
dAtA[i] = 0xa |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(len(k))) |
|
i += copy(dAtA[i:], k) |
|
dAtA[i] = 0x10 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(v)) |
|
} |
|
} |
|
return i, nil |
|
} |
|
|
|
func (m *AllConfigReq) 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 *AllConfigReq) MarshalTo(dAtA []byte) (int, error) { |
|
var i int |
|
_ = i |
|
var l int |
|
_ = l |
|
return i, nil |
|
} |
|
|
|
func (m *CloseReply) 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 *CloseReply) MarshalTo(dAtA []byte) (int, error) { |
|
var i int |
|
_ = i |
|
var l int |
|
_ = l |
|
return i, nil |
|
} |
|
|
|
func (m *CloseReq) 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 *CloseReq) MarshalTo(dAtA []byte) (int, error) { |
|
var i int |
|
_ = i |
|
var l int |
|
_ = l |
|
return i, nil |
|
} |
|
|
|
func (m *ConfigReply) 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 *ConfigReply) MarshalTo(dAtA []byte) (int, error) { |
|
var i int |
|
_ = i |
|
var l int |
|
_ = l |
|
if m.Point != 0 { |
|
dAtA[i] = 0x8 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.Point)) |
|
} |
|
return i, nil |
|
} |
|
|
|
func (m *ConfigReq) 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 *ConfigReq) MarshalTo(dAtA []byte) (int, error) { |
|
var i int |
|
_ = i |
|
var l int |
|
_ = l |
|
if m.ChangeType != 0 { |
|
dAtA[i] = 0x10 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.ChangeType)) |
|
} |
|
if m.Mid != 0 { |
|
dAtA[i] = 0x18 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.Mid)) |
|
} |
|
if m.Bp != 0 { |
|
dAtA[i] = 0x21 |
|
i++ |
|
binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Bp)))) |
|
i += 8 |
|
} |
|
return i, nil |
|
} |
|
|
|
func (m *ConsumePointReply) 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 *ConsumePointReply) MarshalTo(dAtA []byte) (int, error) { |
|
var i int |
|
_ = i |
|
var l int |
|
_ = l |
|
if m.Status != 0 { |
|
dAtA[i] = 0x8 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.Status)) |
|
} |
|
return i, nil |
|
} |
|
|
|
func (m *ConsumePointReq) 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 *ConsumePointReq) MarshalTo(dAtA []byte) (int, error) { |
|
var i int |
|
_ = i |
|
var l int |
|
_ = l |
|
if m.Pc != nil { |
|
dAtA[i] = 0x12 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.Pc.Size())) |
|
n2, err := m.Pc.MarshalTo(dAtA[i:]) |
|
if err != nil { |
|
return 0, err |
|
} |
|
i += n2 |
|
} |
|
return i, nil |
|
} |
|
|
|
func (m *ModelArgPoint) 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 *ModelArgPoint) MarshalTo(dAtA []byte) (int, error) { |
|
var i int |
|
_ = i |
|
var l int |
|
_ = l |
|
if m.Mid != 0 { |
|
dAtA[i] = 0x8 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.Mid)) |
|
} |
|
if m.ChangeType != 0 { |
|
dAtA[i] = 0x10 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.ChangeType)) |
|
} |
|
if m.Point != 0 { |
|
dAtA[i] = 0x18 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.Point)) |
|
} |
|
if len(m.Remark) > 0 { |
|
dAtA[i] = 0x22 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(len(m.Remark))) |
|
i += copy(dAtA[i:], m.Remark) |
|
} |
|
if len(m.Operator) > 0 { |
|
dAtA[i] = 0x2a |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(len(m.Operator))) |
|
i += copy(dAtA[i:], m.Operator) |
|
} |
|
return i, nil |
|
} |
|
|
|
func (m *ModelArgPointAdd) 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 *ModelArgPointAdd) MarshalTo(dAtA []byte) (int, error) { |
|
var i int |
|
_ = i |
|
var l int |
|
_ = l |
|
if m.Mid != 0 { |
|
dAtA[i] = 0x8 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.Mid)) |
|
} |
|
if m.ChangeType != 0 { |
|
dAtA[i] = 0x10 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.ChangeType)) |
|
} |
|
if len(m.RelationId) > 0 { |
|
dAtA[i] = 0x1a |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(len(m.RelationId))) |
|
i += copy(dAtA[i:], m.RelationId) |
|
} |
|
if m.Bcoin != 0 { |
|
dAtA[i] = 0x21 |
|
i++ |
|
binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Bcoin)))) |
|
i += 8 |
|
} |
|
if len(m.Remark) > 0 { |
|
dAtA[i] = 0x2a |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(len(m.Remark))) |
|
i += copy(dAtA[i:], m.Remark) |
|
} |
|
if len(m.OrderId) > 0 { |
|
dAtA[i] = 0x32 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(len(m.OrderId))) |
|
i += copy(dAtA[i:], m.OrderId) |
|
} |
|
return i, nil |
|
} |
|
|
|
func (m *ModelArgPointConsume) 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 *ModelArgPointConsume) MarshalTo(dAtA []byte) (int, error) { |
|
var i int |
|
_ = i |
|
var l int |
|
_ = l |
|
if m.Mid != 0 { |
|
dAtA[i] = 0x8 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.Mid)) |
|
} |
|
if m.ChangeType != 0 { |
|
dAtA[i] = 0x10 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.ChangeType)) |
|
} |
|
if len(m.RelationId) > 0 { |
|
dAtA[i] = 0x1a |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(len(m.RelationId))) |
|
i += copy(dAtA[i:], m.RelationId) |
|
} |
|
if m.Point != 0 { |
|
dAtA[i] = 0x20 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.Point)) |
|
} |
|
if len(m.Remark) > 0 { |
|
dAtA[i] = 0x2a |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(len(m.Remark))) |
|
i += copy(dAtA[i:], m.Remark) |
|
} |
|
return i, nil |
|
} |
|
|
|
func (m *ModelOldPointHistory) 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 *ModelOldPointHistory) MarshalTo(dAtA []byte) (int, error) { |
|
var i int |
|
_ = i |
|
var l int |
|
_ = l |
|
if m.Id != 0 { |
|
dAtA[i] = 0x8 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.Id)) |
|
} |
|
if m.Mid != 0 { |
|
dAtA[i] = 0x10 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.Mid)) |
|
} |
|
if m.Point != 0 { |
|
dAtA[i] = 0x18 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.Point)) |
|
} |
|
if len(m.OrderId) > 0 { |
|
dAtA[i] = 0x22 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(len(m.OrderId))) |
|
i += copy(dAtA[i:], m.OrderId) |
|
} |
|
if m.ChangeType != 0 { |
|
dAtA[i] = 0x28 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.ChangeType)) |
|
} |
|
if m.ChangeTime != 0 { |
|
dAtA[i] = 0x30 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.ChangeTime)) |
|
} |
|
if len(m.RelationId) > 0 { |
|
dAtA[i] = 0x3a |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(len(m.RelationId))) |
|
i += copy(dAtA[i:], m.RelationId) |
|
} |
|
if m.PointBalance != 0 { |
|
dAtA[i] = 0x40 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.PointBalance)) |
|
} |
|
if len(m.Remark) > 0 { |
|
dAtA[i] = 0x4a |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(len(m.Remark))) |
|
i += copy(dAtA[i:], m.Remark) |
|
} |
|
if len(m.Operator) > 0 { |
|
dAtA[i] = 0x52 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(len(m.Operator))) |
|
i += copy(dAtA[i:], m.Operator) |
|
} |
|
return i, nil |
|
} |
|
|
|
func (m *ModelPointHistory) 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 *ModelPointHistory) MarshalTo(dAtA []byte) (int, error) { |
|
var i int |
|
_ = i |
|
var l int |
|
_ = l |
|
if m.Id != 0 { |
|
dAtA[i] = 0x8 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.Id)) |
|
} |
|
if m.Mid != 0 { |
|
dAtA[i] = 0x10 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.Mid)) |
|
} |
|
if m.Point != 0 { |
|
dAtA[i] = 0x18 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.Point)) |
|
} |
|
if len(m.OrderId) > 0 { |
|
dAtA[i] = 0x22 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(len(m.OrderId))) |
|
i += copy(dAtA[i:], m.OrderId) |
|
} |
|
if m.ChangeType != 0 { |
|
dAtA[i] = 0x28 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.ChangeType)) |
|
} |
|
if m.ChangeTime != 0 { |
|
dAtA[i] = 0x30 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.ChangeTime)) |
|
} |
|
if len(m.RelationId) > 0 { |
|
dAtA[i] = 0x3a |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(len(m.RelationId))) |
|
i += copy(dAtA[i:], m.RelationId) |
|
} |
|
if m.PointBalance != 0 { |
|
dAtA[i] = 0x40 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.PointBalance)) |
|
} |
|
if len(m.Remark) > 0 { |
|
dAtA[i] = 0x4a |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(len(m.Remark))) |
|
i += copy(dAtA[i:], m.Remark) |
|
} |
|
if len(m.Operator) > 0 { |
|
dAtA[i] = 0x52 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(len(m.Operator))) |
|
i += copy(dAtA[i:], m.Operator) |
|
} |
|
return i, nil |
|
} |
|
|
|
func (m *ModelPointInfo) 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 *ModelPointInfo) MarshalTo(dAtA []byte) (int, error) { |
|
var i int |
|
_ = i |
|
var l int |
|
_ = l |
|
if m.Mid != 0 { |
|
dAtA[i] = 0x8 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.Mid)) |
|
} |
|
if m.PointBalance != 0 { |
|
dAtA[i] = 0x10 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.PointBalance)) |
|
} |
|
if m.Ver != 0 { |
|
dAtA[i] = 0x18 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.Ver)) |
|
} |
|
return i, nil |
|
} |
|
|
|
func (m *OldPointHistoryReply) 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 *OldPointHistoryReply) MarshalTo(dAtA []byte) (int, error) { |
|
var i int |
|
_ = i |
|
var l int |
|
_ = l |
|
if len(m.Phs) > 0 { |
|
for _, msg := range m.Phs { |
|
dAtA[i] = 0xa |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(msg.Size())) |
|
n, err := msg.MarshalTo(dAtA[i:]) |
|
if err != nil { |
|
return 0, err |
|
} |
|
i += n |
|
} |
|
} |
|
if m.Total != 0 { |
|
dAtA[i] = 0x10 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.Total)) |
|
} |
|
return i, nil |
|
} |
|
|
|
func (m *OldPointHistoryReq) 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 *OldPointHistoryReq) MarshalTo(dAtA []byte) (int, error) { |
|
var i int |
|
_ = i |
|
var l int |
|
_ = l |
|
if m.Mid != 0 { |
|
dAtA[i] = 0x10 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.Mid)) |
|
} |
|
if m.Pn != 0 { |
|
dAtA[i] = 0x18 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.Pn)) |
|
} |
|
if m.Ps != 0 { |
|
dAtA[i] = 0x20 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.Ps)) |
|
} |
|
return i, nil |
|
} |
|
|
|
func (m *PingReply) 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 *PingReply) MarshalTo(dAtA []byte) (int, error) { |
|
var i int |
|
_ = i |
|
var l int |
|
_ = l |
|
return i, nil |
|
} |
|
|
|
func (m *PingReq) 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 *PingReq) MarshalTo(dAtA []byte) (int, error) { |
|
var i int |
|
_ = i |
|
var l int |
|
_ = l |
|
return i, nil |
|
} |
|
|
|
func (m *PointAddByBpReply) 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 *PointAddByBpReply) MarshalTo(dAtA []byte) (int, error) { |
|
var i int |
|
_ = i |
|
var l int |
|
_ = l |
|
if m.P != 0 { |
|
dAtA[i] = 0x8 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.P)) |
|
} |
|
return i, nil |
|
} |
|
|
|
func (m *PointAddByBpReq) 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 *PointAddByBpReq) MarshalTo(dAtA []byte) (int, error) { |
|
var i int |
|
_ = i |
|
var l int |
|
_ = l |
|
if m.Pa != nil { |
|
dAtA[i] = 0x12 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.Pa.Size())) |
|
n3, err := m.Pa.MarshalTo(dAtA[i:]) |
|
if err != nil { |
|
return 0, err |
|
} |
|
i += n3 |
|
} |
|
return i, nil |
|
} |
|
|
|
func (m *PointHistoryReply) 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 *PointHistoryReply) MarshalTo(dAtA []byte) (int, error) { |
|
var i int |
|
_ = i |
|
var l int |
|
_ = l |
|
if len(m.Phs) > 0 { |
|
for _, msg := range m.Phs { |
|
dAtA[i] = 0xa |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(msg.Size())) |
|
n, err := msg.MarshalTo(dAtA[i:]) |
|
if err != nil { |
|
return 0, err |
|
} |
|
i += n |
|
} |
|
} |
|
if m.Total != 0 { |
|
dAtA[i] = 0x10 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.Total)) |
|
} |
|
if m.Ncursor != 0 { |
|
dAtA[i] = 0x18 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.Ncursor)) |
|
} |
|
return i, nil |
|
} |
|
|
|
func (m *PointHistoryReq) 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 *PointHistoryReq) MarshalTo(dAtA []byte) (int, error) { |
|
var i int |
|
_ = i |
|
var l int |
|
_ = l |
|
if m.Mid != 0 { |
|
dAtA[i] = 0x10 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.Mid)) |
|
} |
|
if m.Cursor != 0 { |
|
dAtA[i] = 0x18 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.Cursor)) |
|
} |
|
if m.Ps != 0 { |
|
dAtA[i] = 0x20 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.Ps)) |
|
} |
|
return i, nil |
|
} |
|
|
|
func (m *PointInfoReply) 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 *PointInfoReply) MarshalTo(dAtA []byte) (int, error) { |
|
var i int |
|
_ = i |
|
var l int |
|
_ = l |
|
if m.Pi != nil { |
|
dAtA[i] = 0xa |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.Pi.Size())) |
|
n4, err := m.Pi.MarshalTo(dAtA[i:]) |
|
if err != nil { |
|
return 0, err |
|
} |
|
i += n4 |
|
} |
|
return i, nil |
|
} |
|
|
|
func (m *PointInfoReq) 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 *PointInfoReq) MarshalTo(dAtA []byte) (int, error) { |
|
var i int |
|
_ = i |
|
var l int |
|
_ = l |
|
if m.Mid != 0 { |
|
dAtA[i] = 0x10 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.Mid)) |
|
} |
|
return i, nil |
|
} |
|
|
|
func encodeVarintApi(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 *AddPointReply) Size() (n int) { |
|
var l int |
|
_ = l |
|
if m.Status != 0 { |
|
n += 1 + sovApi(uint64(m.Status)) |
|
} |
|
return n |
|
} |
|
|
|
func (m *AddPointReq) Size() (n int) { |
|
var l int |
|
_ = l |
|
if m.Pc != nil { |
|
l = m.Pc.Size() |
|
n += 1 + l + sovApi(uint64(l)) |
|
} |
|
return n |
|
} |
|
|
|
func (m *AllConfigReply) Size() (n int) { |
|
var l int |
|
_ = l |
|
if len(m.Data_0) > 0 { |
|
for k, v := range m.Data_0 { |
|
_ = k |
|
_ = v |
|
mapEntrySize := 1 + len(k) + sovApi(uint64(len(k))) + 1 + sovApi(uint64(v)) |
|
n += mapEntrySize + 1 + sovApi(uint64(mapEntrySize)) |
|
} |
|
} |
|
return n |
|
} |
|
|
|
func (m *AllConfigReq) Size() (n int) { |
|
var l int |
|
_ = l |
|
return n |
|
} |
|
|
|
func (m *CloseReply) Size() (n int) { |
|
var l int |
|
_ = l |
|
return n |
|
} |
|
|
|
func (m *CloseReq) Size() (n int) { |
|
var l int |
|
_ = l |
|
return n |
|
} |
|
|
|
func (m *ConfigReply) Size() (n int) { |
|
var l int |
|
_ = l |
|
if m.Point != 0 { |
|
n += 1 + sovApi(uint64(m.Point)) |
|
} |
|
return n |
|
} |
|
|
|
func (m *ConfigReq) Size() (n int) { |
|
var l int |
|
_ = l |
|
if m.ChangeType != 0 { |
|
n += 1 + sovApi(uint64(m.ChangeType)) |
|
} |
|
if m.Mid != 0 { |
|
n += 1 + sovApi(uint64(m.Mid)) |
|
} |
|
if m.Bp != 0 { |
|
n += 9 |
|
} |
|
return n |
|
} |
|
|
|
func (m *ConsumePointReply) Size() (n int) { |
|
var l int |
|
_ = l |
|
if m.Status != 0 { |
|
n += 1 + sovApi(uint64(m.Status)) |
|
} |
|
return n |
|
} |
|
|
|
func (m *ConsumePointReq) Size() (n int) { |
|
var l int |
|
_ = l |
|
if m.Pc != nil { |
|
l = m.Pc.Size() |
|
n += 1 + l + sovApi(uint64(l)) |
|
} |
|
return n |
|
} |
|
|
|
func (m *ModelArgPoint) Size() (n int) { |
|
var l int |
|
_ = l |
|
if m.Mid != 0 { |
|
n += 1 + sovApi(uint64(m.Mid)) |
|
} |
|
if m.ChangeType != 0 { |
|
n += 1 + sovApi(uint64(m.ChangeType)) |
|
} |
|
if m.Point != 0 { |
|
n += 1 + sovApi(uint64(m.Point)) |
|
} |
|
l = len(m.Remark) |
|
if l > 0 { |
|
n += 1 + l + sovApi(uint64(l)) |
|
} |
|
l = len(m.Operator) |
|
if l > 0 { |
|
n += 1 + l + sovApi(uint64(l)) |
|
} |
|
return n |
|
} |
|
|
|
func (m *ModelArgPointAdd) Size() (n int) { |
|
var l int |
|
_ = l |
|
if m.Mid != 0 { |
|
n += 1 + sovApi(uint64(m.Mid)) |
|
} |
|
if m.ChangeType != 0 { |
|
n += 1 + sovApi(uint64(m.ChangeType)) |
|
} |
|
l = len(m.RelationId) |
|
if l > 0 { |
|
n += 1 + l + sovApi(uint64(l)) |
|
} |
|
if m.Bcoin != 0 { |
|
n += 9 |
|
} |
|
l = len(m.Remark) |
|
if l > 0 { |
|
n += 1 + l + sovApi(uint64(l)) |
|
} |
|
l = len(m.OrderId) |
|
if l > 0 { |
|
n += 1 + l + sovApi(uint64(l)) |
|
} |
|
return n |
|
} |
|
|
|
func (m *ModelArgPointConsume) Size() (n int) { |
|
var l int |
|
_ = l |
|
if m.Mid != 0 { |
|
n += 1 + sovApi(uint64(m.Mid)) |
|
} |
|
if m.ChangeType != 0 { |
|
n += 1 + sovApi(uint64(m.ChangeType)) |
|
} |
|
l = len(m.RelationId) |
|
if l > 0 { |
|
n += 1 + l + sovApi(uint64(l)) |
|
} |
|
if m.Point != 0 { |
|
n += 1 + sovApi(uint64(m.Point)) |
|
} |
|
l = len(m.Remark) |
|
if l > 0 { |
|
n += 1 + l + sovApi(uint64(l)) |
|
} |
|
return n |
|
} |
|
|
|
func (m *ModelOldPointHistory) Size() (n int) { |
|
var l int |
|
_ = l |
|
if m.Id != 0 { |
|
n += 1 + sovApi(uint64(m.Id)) |
|
} |
|
if m.Mid != 0 { |
|
n += 1 + sovApi(uint64(m.Mid)) |
|
} |
|
if m.Point != 0 { |
|
n += 1 + sovApi(uint64(m.Point)) |
|
} |
|
l = len(m.OrderId) |
|
if l > 0 { |
|
n += 1 + l + sovApi(uint64(l)) |
|
} |
|
if m.ChangeType != 0 { |
|
n += 1 + sovApi(uint64(m.ChangeType)) |
|
} |
|
if m.ChangeTime != 0 { |
|
n += 1 + sovApi(uint64(m.ChangeTime)) |
|
} |
|
l = len(m.RelationId) |
|
if l > 0 { |
|
n += 1 + l + sovApi(uint64(l)) |
|
} |
|
if m.PointBalance != 0 { |
|
n += 1 + sovApi(uint64(m.PointBalance)) |
|
} |
|
l = len(m.Remark) |
|
if l > 0 { |
|
n += 1 + l + sovApi(uint64(l)) |
|
} |
|
l = len(m.Operator) |
|
if l > 0 { |
|
n += 1 + l + sovApi(uint64(l)) |
|
} |
|
return n |
|
} |
|
|
|
func (m *ModelPointHistory) Size() (n int) { |
|
var l int |
|
_ = l |
|
if m.Id != 0 { |
|
n += 1 + sovApi(uint64(m.Id)) |
|
} |
|
if m.Mid != 0 { |
|
n += 1 + sovApi(uint64(m.Mid)) |
|
} |
|
if m.Point != 0 { |
|
n += 1 + sovApi(uint64(m.Point)) |
|
} |
|
l = len(m.OrderId) |
|
if l > 0 { |
|
n += 1 + l + sovApi(uint64(l)) |
|
} |
|
if m.ChangeType != 0 { |
|
n += 1 + sovApi(uint64(m.ChangeType)) |
|
} |
|
if m.ChangeTime != 0 { |
|
n += 1 + sovApi(uint64(m.ChangeTime)) |
|
} |
|
l = len(m.RelationId) |
|
if l > 0 { |
|
n += 1 + l + sovApi(uint64(l)) |
|
} |
|
if m.PointBalance != 0 { |
|
n += 1 + sovApi(uint64(m.PointBalance)) |
|
} |
|
l = len(m.Remark) |
|
if l > 0 { |
|
n += 1 + l + sovApi(uint64(l)) |
|
} |
|
l = len(m.Operator) |
|
if l > 0 { |
|
n += 1 + l + sovApi(uint64(l)) |
|
} |
|
return n |
|
} |
|
|
|
func (m *ModelPointInfo) Size() (n int) { |
|
var l int |
|
_ = l |
|
if m.Mid != 0 { |
|
n += 1 + sovApi(uint64(m.Mid)) |
|
} |
|
if m.PointBalance != 0 { |
|
n += 1 + sovApi(uint64(m.PointBalance)) |
|
} |
|
if m.Ver != 0 { |
|
n += 1 + sovApi(uint64(m.Ver)) |
|
} |
|
return n |
|
} |
|
|
|
func (m *OldPointHistoryReply) Size() (n int) { |
|
var l int |
|
_ = l |
|
if len(m.Phs) > 0 { |
|
for _, e := range m.Phs { |
|
l = e.Size() |
|
n += 1 + l + sovApi(uint64(l)) |
|
} |
|
} |
|
if m.Total != 0 { |
|
n += 1 + sovApi(uint64(m.Total)) |
|
} |
|
return n |
|
} |
|
|
|
func (m *OldPointHistoryReq) Size() (n int) { |
|
var l int |
|
_ = l |
|
if m.Mid != 0 { |
|
n += 1 + sovApi(uint64(m.Mid)) |
|
} |
|
if m.Pn != 0 { |
|
n += 1 + sovApi(uint64(m.Pn)) |
|
} |
|
if m.Ps != 0 { |
|
n += 1 + sovApi(uint64(m.Ps)) |
|
} |
|
return n |
|
} |
|
|
|
func (m *PingReply) Size() (n int) { |
|
var l int |
|
_ = l |
|
return n |
|
} |
|
|
|
func (m *PingReq) Size() (n int) { |
|
var l int |
|
_ = l |
|
return n |
|
} |
|
|
|
func (m *PointAddByBpReply) Size() (n int) { |
|
var l int |
|
_ = l |
|
if m.P != 0 { |
|
n += 1 + sovApi(uint64(m.P)) |
|
} |
|
return n |
|
} |
|
|
|
func (m *PointAddByBpReq) Size() (n int) { |
|
var l int |
|
_ = l |
|
if m.Pa != nil { |
|
l = m.Pa.Size() |
|
n += 1 + l + sovApi(uint64(l)) |
|
} |
|
return n |
|
} |
|
|
|
func (m *PointHistoryReply) Size() (n int) { |
|
var l int |
|
_ = l |
|
if len(m.Phs) > 0 { |
|
for _, e := range m.Phs { |
|
l = e.Size() |
|
n += 1 + l + sovApi(uint64(l)) |
|
} |
|
} |
|
if m.Total != 0 { |
|
n += 1 + sovApi(uint64(m.Total)) |
|
} |
|
if m.Ncursor != 0 { |
|
n += 1 + sovApi(uint64(m.Ncursor)) |
|
} |
|
return n |
|
} |
|
|
|
func (m *PointHistoryReq) Size() (n int) { |
|
var l int |
|
_ = l |
|
if m.Mid != 0 { |
|
n += 1 + sovApi(uint64(m.Mid)) |
|
} |
|
if m.Cursor != 0 { |
|
n += 1 + sovApi(uint64(m.Cursor)) |
|
} |
|
if m.Ps != 0 { |
|
n += 1 + sovApi(uint64(m.Ps)) |
|
} |
|
return n |
|
} |
|
|
|
func (m *PointInfoReply) Size() (n int) { |
|
var l int |
|
_ = l |
|
if m.Pi != nil { |
|
l = m.Pi.Size() |
|
n += 1 + l + sovApi(uint64(l)) |
|
} |
|
return n |
|
} |
|
|
|
func (m *PointInfoReq) Size() (n int) { |
|
var l int |
|
_ = l |
|
if m.Mid != 0 { |
|
n += 1 + sovApi(uint64(m.Mid)) |
|
} |
|
return n |
|
} |
|
|
|
func sovApi(x uint64) (n int) { |
|
for { |
|
n++ |
|
x >>= 7 |
|
if x == 0 { |
|
break |
|
} |
|
} |
|
return n |
|
} |
|
func sozApi(x uint64) (n int) { |
|
return sovApi(uint64((x << 1) ^ uint64((int64(x) >> 63)))) |
|
} |
|
func (m *AddPointReply) 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 ErrIntOverflowApi |
|
} |
|
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: AddPointReply: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: AddPointReply: 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 ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.Status |= (int32(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *AddPointReq) 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 ErrIntOverflowApi |
|
} |
|
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: AddPointReq: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: AddPointReq: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
case 2: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Pc", wireType) |
|
} |
|
var msglen int |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
msglen |= (int(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
if msglen < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
postIndex := iNdEx + msglen |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
if m.Pc == nil { |
|
m.Pc = &ModelArgPoint{} |
|
} |
|
if err := m.Pc.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
|
return err |
|
} |
|
iNdEx = postIndex |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *AllConfigReply) 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 ErrIntOverflowApi |
|
} |
|
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: AllConfigReply: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: AllConfigReply: 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_0", wireType) |
|
} |
|
var msglen int |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
msglen |= (int(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
if msglen < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
postIndex := iNdEx + msglen |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
if m.Data_0 == nil { |
|
m.Data_0 = make(map[string]int64) |
|
} |
|
var mapkey string |
|
var mapvalue int64 |
|
for iNdEx < postIndex { |
|
entryPreIndex := iNdEx |
|
var wire uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
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 { |
|
var stringLenmapkey uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
stringLenmapkey |= (uint64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
intStringLenmapkey := int(stringLenmapkey) |
|
if intStringLenmapkey < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
postStringIndexmapkey := iNdEx + intStringLenmapkey |
|
if postStringIndexmapkey > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) |
|
iNdEx = postStringIndexmapkey |
|
} else if fieldNum == 2 { |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
mapvalue |= (int64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
} else { |
|
iNdEx = entryPreIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > postIndex { |
|
return io.ErrUnexpectedEOF |
|
} |
|
iNdEx += skippy |
|
} |
|
} |
|
m.Data_0[mapkey] = mapvalue |
|
iNdEx = postIndex |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *AllConfigReq) 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 ErrIntOverflowApi |
|
} |
|
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: AllConfigReq: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: AllConfigReq: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *CloseReply) 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 ErrIntOverflowApi |
|
} |
|
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: CloseReply: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: CloseReply: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *CloseReq) 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 ErrIntOverflowApi |
|
} |
|
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: CloseReq: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: CloseReq: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *ConfigReply) 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 ErrIntOverflowApi |
|
} |
|
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: ConfigReply: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: ConfigReply: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
case 1: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Point", wireType) |
|
} |
|
m.Point = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.Point |= (int64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *ConfigReq) 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 ErrIntOverflowApi |
|
} |
|
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: ConfigReq: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: ConfigReq: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
case 2: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field ChangeType", wireType) |
|
} |
|
m.ChangeType = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.ChangeType |= (int32(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
case 3: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Mid", wireType) |
|
} |
|
m.Mid = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.Mid |= (int64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
case 4: |
|
if wireType != 1 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Bp", wireType) |
|
} |
|
var v uint64 |
|
if (iNdEx + 8) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:])) |
|
iNdEx += 8 |
|
m.Bp = float64(math.Float64frombits(v)) |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *ConsumePointReply) 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 ErrIntOverflowApi |
|
} |
|
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: ConsumePointReply: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: ConsumePointReply: 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 ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.Status |= (int32(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *ConsumePointReq) 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 ErrIntOverflowApi |
|
} |
|
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: ConsumePointReq: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: ConsumePointReq: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
case 2: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Pc", wireType) |
|
} |
|
var msglen int |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
msglen |= (int(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
if msglen < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
postIndex := iNdEx + msglen |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
if m.Pc == nil { |
|
m.Pc = &ModelArgPointConsume{} |
|
} |
|
if err := m.Pc.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
|
return err |
|
} |
|
iNdEx = postIndex |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *ModelArgPoint) 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 ErrIntOverflowApi |
|
} |
|
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: ModelArgPoint: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: ModelArgPoint: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
case 1: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Mid", wireType) |
|
} |
|
m.Mid = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.Mid |= (int64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
case 2: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field ChangeType", wireType) |
|
} |
|
m.ChangeType = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.ChangeType |= (int64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
case 3: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Point", wireType) |
|
} |
|
m.Point = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.Point |= (int64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
case 4: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Remark", wireType) |
|
} |
|
var stringLen uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
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 ErrInvalidLengthApi |
|
} |
|
postIndex := iNdEx + intStringLen |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.Remark = string(dAtA[iNdEx:postIndex]) |
|
iNdEx = postIndex |
|
case 5: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Operator", wireType) |
|
} |
|
var stringLen uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
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 ErrInvalidLengthApi |
|
} |
|
postIndex := iNdEx + intStringLen |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.Operator = string(dAtA[iNdEx:postIndex]) |
|
iNdEx = postIndex |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *ModelArgPointAdd) 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 ErrIntOverflowApi |
|
} |
|
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: ModelArgPointAdd: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: ModelArgPointAdd: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
case 1: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Mid", wireType) |
|
} |
|
m.Mid = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.Mid |= (int64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
case 2: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field ChangeType", wireType) |
|
} |
|
m.ChangeType = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.ChangeType |= (int32(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
case 3: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field RelationId", wireType) |
|
} |
|
var stringLen uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
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 ErrInvalidLengthApi |
|
} |
|
postIndex := iNdEx + intStringLen |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.RelationId = string(dAtA[iNdEx:postIndex]) |
|
iNdEx = postIndex |
|
case 4: |
|
if wireType != 1 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Bcoin", wireType) |
|
} |
|
var v uint64 |
|
if (iNdEx + 8) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:])) |
|
iNdEx += 8 |
|
m.Bcoin = float64(math.Float64frombits(v)) |
|
case 5: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Remark", wireType) |
|
} |
|
var stringLen uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
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 ErrInvalidLengthApi |
|
} |
|
postIndex := iNdEx + intStringLen |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.Remark = string(dAtA[iNdEx:postIndex]) |
|
iNdEx = postIndex |
|
case 6: |
|
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 ErrIntOverflowApi |
|
} |
|
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 ErrInvalidLengthApi |
|
} |
|
postIndex := iNdEx + intStringLen |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.OrderId = string(dAtA[iNdEx:postIndex]) |
|
iNdEx = postIndex |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *ModelArgPointConsume) 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 ErrIntOverflowApi |
|
} |
|
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: ModelArgPointConsume: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: ModelArgPointConsume: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
case 1: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Mid", wireType) |
|
} |
|
m.Mid = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.Mid |= (int64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
case 2: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field ChangeType", wireType) |
|
} |
|
m.ChangeType = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.ChangeType |= (int64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
case 3: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field RelationId", wireType) |
|
} |
|
var stringLen uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
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 ErrInvalidLengthApi |
|
} |
|
postIndex := iNdEx + intStringLen |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.RelationId = string(dAtA[iNdEx:postIndex]) |
|
iNdEx = postIndex |
|
case 4: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Point", wireType) |
|
} |
|
m.Point = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.Point |= (int64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
case 5: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Remark", wireType) |
|
} |
|
var stringLen uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
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 ErrInvalidLengthApi |
|
} |
|
postIndex := iNdEx + intStringLen |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.Remark = string(dAtA[iNdEx:postIndex]) |
|
iNdEx = postIndex |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *ModelOldPointHistory) 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 ErrIntOverflowApi |
|
} |
|
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: ModelOldPointHistory: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: ModelOldPointHistory: 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 ErrIntOverflowApi |
|
} |
|
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 Mid", wireType) |
|
} |
|
m.Mid = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.Mid |= (int64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
case 3: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Point", wireType) |
|
} |
|
m.Point = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.Point |= (int64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
case 4: |
|
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 ErrIntOverflowApi |
|
} |
|
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 ErrInvalidLengthApi |
|
} |
|
postIndex := iNdEx + intStringLen |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.OrderId = string(dAtA[iNdEx:postIndex]) |
|
iNdEx = postIndex |
|
case 5: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field ChangeType", wireType) |
|
} |
|
m.ChangeType = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.ChangeType |= (int32(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
case 6: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field ChangeTime", wireType) |
|
} |
|
m.ChangeTime = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.ChangeTime |= (int64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
case 7: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field RelationId", wireType) |
|
} |
|
var stringLen uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
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 ErrInvalidLengthApi |
|
} |
|
postIndex := iNdEx + intStringLen |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.RelationId = string(dAtA[iNdEx:postIndex]) |
|
iNdEx = postIndex |
|
case 8: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field PointBalance", wireType) |
|
} |
|
m.PointBalance = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.PointBalance |= (int64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
case 9: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Remark", wireType) |
|
} |
|
var stringLen uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
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 ErrInvalidLengthApi |
|
} |
|
postIndex := iNdEx + intStringLen |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.Remark = string(dAtA[iNdEx:postIndex]) |
|
iNdEx = postIndex |
|
case 10: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Operator", wireType) |
|
} |
|
var stringLen uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
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 ErrInvalidLengthApi |
|
} |
|
postIndex := iNdEx + intStringLen |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.Operator = string(dAtA[iNdEx:postIndex]) |
|
iNdEx = postIndex |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *ModelPointHistory) 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 ErrIntOverflowApi |
|
} |
|
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: ModelPointHistory: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: ModelPointHistory: 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 ErrIntOverflowApi |
|
} |
|
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 Mid", wireType) |
|
} |
|
m.Mid = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.Mid |= (int64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
case 3: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Point", wireType) |
|
} |
|
m.Point = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.Point |= (int64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
case 4: |
|
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 ErrIntOverflowApi |
|
} |
|
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 ErrInvalidLengthApi |
|
} |
|
postIndex := iNdEx + intStringLen |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.OrderId = string(dAtA[iNdEx:postIndex]) |
|
iNdEx = postIndex |
|
case 5: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field ChangeType", wireType) |
|
} |
|
m.ChangeType = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.ChangeType |= (int32(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
case 6: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field ChangeTime", wireType) |
|
} |
|
m.ChangeTime = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.ChangeTime |= (int64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
case 7: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field RelationId", wireType) |
|
} |
|
var stringLen uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
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 ErrInvalidLengthApi |
|
} |
|
postIndex := iNdEx + intStringLen |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.RelationId = string(dAtA[iNdEx:postIndex]) |
|
iNdEx = postIndex |
|
case 8: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field PointBalance", wireType) |
|
} |
|
m.PointBalance = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.PointBalance |= (int64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
case 9: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Remark", wireType) |
|
} |
|
var stringLen uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
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 ErrInvalidLengthApi |
|
} |
|
postIndex := iNdEx + intStringLen |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.Remark = string(dAtA[iNdEx:postIndex]) |
|
iNdEx = postIndex |
|
case 10: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Operator", wireType) |
|
} |
|
var stringLen uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
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 ErrInvalidLengthApi |
|
} |
|
postIndex := iNdEx + intStringLen |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.Operator = string(dAtA[iNdEx:postIndex]) |
|
iNdEx = postIndex |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *ModelPointInfo) 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 ErrIntOverflowApi |
|
} |
|
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: ModelPointInfo: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: ModelPointInfo: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
case 1: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Mid", wireType) |
|
} |
|
m.Mid = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.Mid |= (int64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
case 2: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field PointBalance", wireType) |
|
} |
|
m.PointBalance = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.PointBalance |= (int64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
case 3: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Ver", wireType) |
|
} |
|
m.Ver = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.Ver |= (int64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *OldPointHistoryReply) 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 ErrIntOverflowApi |
|
} |
|
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: OldPointHistoryReply: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: OldPointHistoryReply: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
case 1: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Phs", wireType) |
|
} |
|
var msglen int |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
msglen |= (int(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
if msglen < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
postIndex := iNdEx + msglen |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.Phs = append(m.Phs, &ModelOldPointHistory{}) |
|
if err := m.Phs[len(m.Phs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
|
return err |
|
} |
|
iNdEx = postIndex |
|
case 2: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Total", wireType) |
|
} |
|
m.Total = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.Total |= (int32(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *OldPointHistoryReq) 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 ErrIntOverflowApi |
|
} |
|
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: OldPointHistoryReq: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: OldPointHistoryReq: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
case 2: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Mid", wireType) |
|
} |
|
m.Mid = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.Mid |= (int64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
case 3: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Pn", wireType) |
|
} |
|
m.Pn = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.Pn |= (int32(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
case 4: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Ps", wireType) |
|
} |
|
m.Ps = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.Ps |= (int32(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *PingReply) 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 ErrIntOverflowApi |
|
} |
|
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: PingReply: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: PingReply: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *PingReq) 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 ErrIntOverflowApi |
|
} |
|
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: PingReq: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: PingReq: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *PointAddByBpReply) 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 ErrIntOverflowApi |
|
} |
|
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: PointAddByBpReply: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: PointAddByBpReply: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
case 1: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field P", wireType) |
|
} |
|
m.P = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.P |= (int64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *PointAddByBpReq) 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 ErrIntOverflowApi |
|
} |
|
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: PointAddByBpReq: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: PointAddByBpReq: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
case 2: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Pa", wireType) |
|
} |
|
var msglen int |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
msglen |= (int(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
if msglen < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
postIndex := iNdEx + msglen |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
if m.Pa == nil { |
|
m.Pa = &ModelArgPointAdd{} |
|
} |
|
if err := m.Pa.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
|
return err |
|
} |
|
iNdEx = postIndex |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *PointHistoryReply) 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 ErrIntOverflowApi |
|
} |
|
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: PointHistoryReply: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: PointHistoryReply: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
case 1: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Phs", wireType) |
|
} |
|
var msglen int |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
msglen |= (int(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
if msglen < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
postIndex := iNdEx + msglen |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.Phs = append(m.Phs, &ModelPointHistory{}) |
|
if err := m.Phs[len(m.Phs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
|
return err |
|
} |
|
iNdEx = postIndex |
|
case 2: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Total", wireType) |
|
} |
|
m.Total = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.Total |= (int32(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
case 3: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Ncursor", wireType) |
|
} |
|
m.Ncursor = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.Ncursor |= (int32(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *PointHistoryReq) 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 ErrIntOverflowApi |
|
} |
|
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: PointHistoryReq: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: PointHistoryReq: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
case 2: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Mid", wireType) |
|
} |
|
m.Mid = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.Mid |= (int64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
case 3: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Cursor", wireType) |
|
} |
|
m.Cursor = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.Cursor |= (int32(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
case 4: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Ps", wireType) |
|
} |
|
m.Ps = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.Ps |= (int32(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *PointInfoReply) 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 ErrIntOverflowApi |
|
} |
|
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: PointInfoReply: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: PointInfoReply: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
case 1: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Pi", wireType) |
|
} |
|
var msglen int |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
msglen |= (int(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
if msglen < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
postIndex := iNdEx + msglen |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
if m.Pi == nil { |
|
m.Pi = &ModelPointInfo{} |
|
} |
|
if err := m.Pi.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
|
return err |
|
} |
|
iNdEx = postIndex |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *PointInfoReq) 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 ErrIntOverflowApi |
|
} |
|
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: PointInfoReq: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: PointInfoReq: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
case 2: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Mid", wireType) |
|
} |
|
m.Mid = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.Mid |= (int64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func skipApi(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, ErrIntOverflowApi |
|
} |
|
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, ErrIntOverflowApi |
|
} |
|
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, ErrIntOverflowApi |
|
} |
|
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, ErrInvalidLengthApi |
|
} |
|
return iNdEx, nil |
|
case 3: |
|
for { |
|
var innerWire uint64 |
|
var start int = iNdEx |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return 0, ErrIntOverflowApi |
|
} |
|
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 := skipApi(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 ( |
|
ErrInvalidLengthApi = fmt.Errorf("proto: negative length found during unmarshaling") |
|
ErrIntOverflowApi = fmt.Errorf("proto: integer overflow") |
|
) |
|
|
|
func init() { proto.RegisterFile("api.proto", fileDescriptorApi) } |
|
|
|
var fileDescriptorApi = []byte{ |
|
// 960 bytes of a gzipped FileDescriptorProto |
|
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x56, 0xcf, 0x6e, 0x23, 0x45, |
|
0x13, 0xd7, 0xf4, 0x64, 0x1c, 0x4f, 0xd9, 0x71, 0x92, 0x56, 0x94, 0x6f, 0x76, 0xbe, 0xdd, 0xc4, |
|
0xdb, 0x39, 0x60, 0x09, 0x30, 0xc1, 0x2b, 0xa4, 0x88, 0x95, 0x58, 0xd9, 0x59, 0x16, 0x22, 0x04, |
|
0x44, 0x23, 0x2e, 0xcb, 0x25, 0x6a, 0xcf, 0xcc, 0x66, 0x47, 0x3b, 0x9e, 0x6e, 0xcf, 0x8c, 0x83, |
|
0xfc, 0x0c, 0xf0, 0x00, 0x9c, 0x91, 0x38, 0xf3, 0x1a, 0x1c, 0x79, 0x04, 0x94, 0x0b, 0xaf, 0x81, |
|
0xa6, 0xbb, 0xed, 0xf9, 0x6b, 0x13, 0x71, 0xe6, 0xd6, 0xd5, 0x5d, 0x5d, 0xf5, 0xab, 0x5f, 0x55, |
|
0x57, 0x17, 0x98, 0x94, 0x07, 0x43, 0x1e, 0xb3, 0x94, 0xe1, 0x3d, 0xea, 0xba, 0x6c, 0x11, 0xa5, |
|
0x43, 0xce, 0x82, 0x28, 0x25, 0xef, 0xc1, 0xde, 0xd8, 0xf3, 0xae, 0xb3, 0xb5, 0xe3, 0xf3, 0x70, |
|
0x89, 0x8f, 0xa1, 0x95, 0xa4, 0x34, 0x5d, 0x24, 0x96, 0xd6, 0xd7, 0x06, 0x86, 0xa3, 0x24, 0xf2, |
|
0x1c, 0x3a, 0xb9, 0xe2, 0x1c, 0x7f, 0x00, 0x88, 0xbb, 0x16, 0xea, 0x6b, 0x83, 0xce, 0xe8, 0xf1, |
|
0xb0, 0x64, 0x73, 0xf8, 0x35, 0xf3, 0xfc, 0x70, 0x1c, 0xdf, 0x4a, 0x65, 0xc4, 0x5d, 0xf2, 0xa3, |
|
0x06, 0xbd, 0x71, 0x18, 0x5e, 0xb2, 0xe8, 0x4d, 0x70, 0x2b, 0xfd, 0xbc, 0x80, 0x96, 0x47, 0x53, |
|
0x7a, 0x73, 0x6e, 0x69, 0x7d, 0x7d, 0xd0, 0x19, 0x0d, 0x2a, 0x46, 0xca, 0xea, 0xc3, 0x97, 0x34, |
|
0xa5, 0xe7, 0x9f, 0x47, 0x69, 0xbc, 0x74, 0x8c, 0xec, 0xde, 0xb9, 0x7d, 0x01, 0x90, 0x6f, 0xe2, |
|
0x03, 0xd0, 0xdf, 0xf9, 0x4b, 0x81, 0xd9, 0x74, 0xb2, 0x25, 0x3e, 0x02, 0xe3, 0x8e, 0x86, 0x0b, |
|
0x5f, 0x80, 0xd4, 0x1d, 0x29, 0x7c, 0x8a, 0x2e, 0x34, 0xd2, 0x83, 0x6e, 0xc1, 0xfa, 0x9c, 0x74, |
|
0x01, 0x2e, 0x43, 0x96, 0xf8, 0xc2, 0x13, 0x01, 0x68, 0x2b, 0x69, 0x4e, 0xce, 0xa0, 0x53, 0xc4, |
|
0x7c, 0x04, 0x86, 0x00, 0x27, 0xdc, 0xe8, 0x8e, 0x14, 0xc8, 0x37, 0x60, 0xae, 0x6d, 0xe1, 0x53, |
|
0xe8, 0xb8, 0x6f, 0x69, 0x74, 0xeb, 0xdf, 0xa4, 0x4b, 0x2e, 0x7d, 0x1b, 0x0e, 0xc8, 0xad, 0xef, |
|
0x96, 0xdc, 0xcf, 0x80, 0xce, 0x02, 0xcf, 0xd2, 0x85, 0x85, 0x6c, 0x89, 0x7b, 0x80, 0xa6, 0xdc, |
|
0xda, 0xe9, 0x6b, 0x03, 0xcd, 0x41, 0x53, 0x4e, 0xde, 0x87, 0xc3, 0x4b, 0x16, 0x25, 0x8b, 0x99, |
|
0xff, 0x80, 0xb4, 0xbc, 0x82, 0xfd, 0xb2, 0xf2, 0x1c, 0x3f, 0x2b, 0xa4, 0xe6, 0x6c, 0x5b, 0x6a, |
|
0xd4, 0x45, 0x91, 0xa1, 0x9f, 0x34, 0xd8, 0x2b, 0x1d, 0xae, 0x80, 0x6a, 0x39, 0xd0, 0x86, 0xd8, |
|
0xf4, 0x52, 0x6c, 0x6b, 0x7e, 0xf4, 0x02, 0x3f, 0x19, 0xf4, 0xd8, 0x9f, 0xd1, 0xf8, 0x9d, 0x88, |
|
0xd1, 0x74, 0x94, 0x84, 0x6d, 0x68, 0x33, 0xee, 0xc7, 0x34, 0x65, 0xb1, 0x65, 0x88, 0x93, 0xb5, |
|
0x4c, 0x7e, 0xd3, 0xe0, 0xa0, 0x04, 0x67, 0xec, 0x79, 0x0f, 0x43, 0x54, 0x66, 0xfb, 0x14, 0x3a, |
|
0xb1, 0x1f, 0xd2, 0x34, 0x60, 0xd1, 0x8d, 0x62, 0xdd, 0x74, 0x60, 0xb5, 0x75, 0xe5, 0x65, 0x90, |
|
0xa7, 0x2e, 0x0b, 0x22, 0xc5, 0xbf, 0x14, 0x0a, 0x90, 0x8d, 0x12, 0xe4, 0x47, 0xd0, 0x66, 0xb1, |
|
0xe7, 0xc7, 0x99, 0xad, 0x96, 0x38, 0xd9, 0x15, 0xf2, 0x95, 0x47, 0x7e, 0xd6, 0xe0, 0xa8, 0x89, |
|
0xdd, 0x7f, 0xc3, 0xe3, 0x43, 0x50, 0x4b, 0xa2, 0x77, 0x9a, 0x89, 0x2e, 0xa1, 0x26, 0xbf, 0x22, |
|
0x05, 0xed, 0xdb, 0x50, 0x3e, 0xe0, 0x2f, 0x83, 0x24, 0x65, 0xf1, 0x32, 0xab, 0xbc, 0x35, 0x32, |
|
0x14, 0xac, 0x09, 0x46, 0x39, 0xd4, 0xe6, 0x8c, 0x16, 0x69, 0xd8, 0x29, 0xd1, 0x50, 0x8d, 0xcd, |
|
0x68, 0xca, 0xc8, 0x4a, 0x21, 0x98, 0xf9, 0x82, 0xc5, 0x3c, 0xf8, 0x60, 0x56, 0x0b, 0x7e, 0xb7, |
|
0x16, 0xfc, 0x19, 0xec, 0x09, 0x18, 0x37, 0x53, 0x1a, 0xd2, 0xc8, 0xf5, 0xad, 0xb6, 0xb0, 0xd1, |
|
0x15, 0x9b, 0x13, 0xb9, 0x57, 0xe0, 0xc2, 0xdc, 0x58, 0x74, 0x50, 0x29, 0xba, 0x5f, 0x10, 0x1c, |
|
0x0a, 0x9e, 0xfe, 0x23, 0x69, 0x33, 0x49, 0xaf, 0xa1, 0x97, 0x73, 0x74, 0x15, 0xbd, 0x61, 0x0d, |
|
0x05, 0x5e, 0x73, 0x8e, 0x1a, 0x9c, 0x1f, 0x80, 0x7e, 0xe7, 0xc7, 0xab, 0x46, 0x78, 0xe7, 0xc7, |
|
0xc4, 0x85, 0xa3, 0x4a, 0x85, 0xca, 0xde, 0xf7, 0x09, 0xe8, 0xfc, 0x6d, 0xa2, 0xfe, 0x89, 0xc6, |
|
0x8e, 0x56, 0xbd, 0x96, 0xe9, 0x67, 0x69, 0x49, 0x59, 0x4a, 0x43, 0xd5, 0x16, 0xa4, 0x40, 0x5e, |
|
0x01, 0xae, 0x39, 0x99, 0x37, 0x24, 0xb5, 0x07, 0x88, 0x47, 0x02, 0x9d, 0xe1, 0x20, 0x1e, 0x09, |
|
0x39, 0x11, 0x89, 0xcc, 0xe4, 0x84, 0x74, 0xc0, 0xbc, 0x0e, 0x22, 0xf9, 0x31, 0x10, 0x13, 0x76, |
|
0xa5, 0x30, 0x27, 0x4f, 0xe1, 0x70, 0xd5, 0xb0, 0x26, 0xcb, 0x09, 0x97, 0x11, 0x74, 0x41, 0xe3, |
|
0x8a, 0x20, 0x8d, 0x93, 0x09, 0xec, 0x97, 0x55, 0xe6, 0xf8, 0x23, 0x40, 0x9c, 0xaa, 0x9e, 0x7d, |
|
0xba, 0xad, 0x67, 0x8f, 0x3d, 0xcf, 0x41, 0x9c, 0x92, 0x1f, 0x94, 0x9b, 0x12, 0x51, 0xa3, 0x22, |
|
0x51, 0xfd, 0x26, 0x33, 0x0f, 0x64, 0x09, 0x5b, 0xb0, 0x1b, 0xb9, 0x8b, 0x38, 0x61, 0xb1, 0xa2, |
|
0x60, 0x25, 0x92, 0xaf, 0x14, 0xf8, 0xad, 0xe4, 0x1d, 0x43, 0xab, 0x74, 0x5b, 0x49, 0x35, 0x12, |
|
0x5f, 0x40, 0x6f, 0x5d, 0x47, 0x32, 0x84, 0x0f, 0x01, 0xf1, 0x40, 0x50, 0xd5, 0x19, 0x3d, 0xd9, |
|
0x18, 0x81, 0xd0, 0x47, 0x3c, 0x20, 0x7d, 0xe8, 0x16, 0x0c, 0x34, 0x40, 0x19, 0xfd, 0x65, 0x80, |
|
0x21, 0x3f, 0xb4, 0xcf, 0xa0, 0x25, 0xff, 0x69, 0x6c, 0x55, 0x0c, 0xaf, 0xbf, 0x6f, 0xdb, 0xde, |
|
0x70, 0x92, 0x41, 0xfb, 0x02, 0xcc, 0xf5, 0xd8, 0x80, 0xff, 0xbf, 0x79, 0x5c, 0x99, 0xdb, 0x4f, |
|
0xb6, 0xce, 0x32, 0xf8, 0x02, 0x76, 0xb2, 0x6a, 0xc1, 0xc7, 0x15, 0x35, 0x55, 0x42, 0xb6, 0xd5, |
|
0xb8, 0x9f, 0xdd, 0x7c, 0x0e, 0x86, 0x98, 0x4d, 0xf0, 0xff, 0xaa, 0x38, 0xd5, 0xc4, 0x62, 0x3f, |
|
0x6a, 0x3e, 0x50, 0xf8, 0xf3, 0x47, 0x5b, 0xc5, 0x5f, 0x64, 0xb1, 0x86, 0xbf, 0x92, 0xa3, 0x6b, |
|
0x45, 0xfa, 0xaa, 0x43, 0x9e, 0x34, 0xa9, 0xe7, 0xf5, 0x61, 0xf7, 0xb7, 0x9e, 0x67, 0x16, 0x5f, |
|
0xc3, 0x7e, 0xf5, 0x6f, 0x7a, 0x5a, 0xb9, 0x54, 0x7f, 0xb4, 0xf6, 0xd9, 0x3f, 0xa9, 0x14, 0xc1, |
|
0xaa, 0xc7, 0xd6, 0x0c, 0x36, 0x7f, 0x89, 0xcd, 0x60, 0x4b, 0x8f, 0xf9, 0x1a, 0xba, 0xc5, 0x91, |
|
0xab, 0x66, 0xb1, 0x32, 0x8f, 0xd5, 0x2c, 0xd6, 0x87, 0xbb, 0x97, 0xd0, 0x5e, 0xcd, 0xd6, 0xb8, |
|
0x5a, 0x81, 0x85, 0xa1, 0xdb, 0x7e, 0xbc, 0xf1, 0x8c, 0x87, 0xcb, 0xc9, 0xc1, 0xef, 0xf7, 0x27, |
|
0xda, 0x1f, 0xf7, 0x27, 0xda, 0x9f, 0xf7, 0x27, 0xda, 0xf7, 0xe8, 0xee, 0xe3, 0x69, 0x4b, 0x8c, |
|
0xfc, 0xcf, 0xfe, 0x0e, 0x00, 0x00, 0xff, 0xff, 0xc6, 0x4b, 0xee, 0x6e, 0xff, 0x0b, 0x00, 0x00, |
|
}
|
|
|