mirror of
https://github.com/anyproto/anytype-heart.git
synced 2025-06-09 17:44:59 +09:00
4253 lines
100 KiB
Go
4253 lines
100 KiB
Go
// Code generated by protoc-gen-gogo. DO NOT EDIT.
|
||
// source: events.proto
|
||
|
||
package pb
|
||
|
||
import (
|
||
fmt "fmt"
|
||
proto "github.com/gogo/protobuf/proto"
|
||
io "io"
|
||
math "math"
|
||
math_bits "math/bits"
|
||
)
|
||
|
||
// Reference imports to suppress errors if they are not otherwise used.
|
||
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.GoGoProtoPackageIsVersion3 // please upgrade the proto package
|
||
|
||
//
|
||
// Event – type of message, that could be sent from a middleware to the corresponding front-end.
|
||
type Event struct {
|
||
// Types that are valid to be assigned to Message:
|
||
// *EventMessageOfAccountShow
|
||
// *EventMessageOfBlockAdd
|
||
// *EventMessageOfBlockShowFullscreen
|
||
// *EventMessageOfBlockUpdate
|
||
// *EventMessageOfBlockDelete
|
||
// *EventMessageOfUserBlockTextRange
|
||
// *EventMessageOfUserBlockJoin
|
||
// *EventMessageOfUserBlockLeft
|
||
// *EventMessageOfUserBlockSelectRange
|
||
// *EventMessageOfFilesUpload
|
||
Message isEventMessage `protobuf_oneof:"message"`
|
||
}
|
||
|
||
func (m *Event) Reset() { *m = Event{} }
|
||
func (m *Event) String() string { return proto.CompactTextString(m) }
|
||
func (*Event) ProtoMessage() {}
|
||
func (*Event) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_8f22242cb04491f9, []int{0}
|
||
}
|
||
func (m *Event) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *Event) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_Event.Marshal(b, m, deterministic)
|
||
} else {
|
||
b = b[:cap(b)]
|
||
n, err := m.MarshalToSizedBuffer(b)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return b[:n], nil
|
||
}
|
||
}
|
||
func (m *Event) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_Event.Merge(m, src)
|
||
}
|
||
func (m *Event) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *Event) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_Event.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_Event proto.InternalMessageInfo
|
||
|
||
type isEventMessage interface {
|
||
isEventMessage()
|
||
MarshalTo([]byte) (int, error)
|
||
Size() int
|
||
}
|
||
|
||
type EventMessageOfAccountShow struct {
|
||
AccountShow *EventAccountShow `protobuf:"bytes,1,opt,name=accountShow,proto3,oneof" json:"accountShow,omitempty"`
|
||
}
|
||
type EventMessageOfBlockAdd struct {
|
||
BlockAdd *EventBlockAdd `protobuf:"bytes,2,opt,name=blockAdd,proto3,oneof" json:"blockAdd,omitempty"`
|
||
}
|
||
type EventMessageOfBlockShowFullscreen struct {
|
||
BlockShowFullscreen *EventBlockShowFullscreen `protobuf:"bytes,3,opt,name=blockShowFullscreen,proto3,oneof" json:"blockShowFullscreen,omitempty"`
|
||
}
|
||
type EventMessageOfBlockUpdate struct {
|
||
BlockUpdate *EventBlockUpdate `protobuf:"bytes,4,opt,name=blockUpdate,proto3,oneof" json:"blockUpdate,omitempty"`
|
||
}
|
||
type EventMessageOfBlockDelete struct {
|
||
BlockDelete *EventBlockDelete `protobuf:"bytes,5,opt,name=blockDelete,proto3,oneof" json:"blockDelete,omitempty"`
|
||
}
|
||
type EventMessageOfUserBlockTextRange struct {
|
||
UserBlockTextRange *EventUserBlockTextRange `protobuf:"bytes,6,opt,name=userBlockTextRange,proto3,oneof" json:"userBlockTextRange,omitempty"`
|
||
}
|
||
type EventMessageOfUserBlockJoin struct {
|
||
UserBlockJoin *EventUserBlockJoin `protobuf:"bytes,7,opt,name=userBlockJoin,proto3,oneof" json:"userBlockJoin,omitempty"`
|
||
}
|
||
type EventMessageOfUserBlockLeft struct {
|
||
UserBlockLeft *EventUserBlockLeft `protobuf:"bytes,8,opt,name=userBlockLeft,proto3,oneof" json:"userBlockLeft,omitempty"`
|
||
}
|
||
type EventMessageOfUserBlockSelectRange struct {
|
||
UserBlockSelectRange *EventUserBlockSelectRange `protobuf:"bytes,9,opt,name=userBlockSelectRange,proto3,oneof" json:"userBlockSelectRange,omitempty"`
|
||
}
|
||
type EventMessageOfFilesUpload struct {
|
||
FilesUpload *EventBlockFilesUpload `protobuf:"bytes,10,opt,name=filesUpload,proto3,oneof" json:"filesUpload,omitempty"`
|
||
}
|
||
|
||
func (*EventMessageOfAccountShow) isEventMessage() {}
|
||
func (*EventMessageOfBlockAdd) isEventMessage() {}
|
||
func (*EventMessageOfBlockShowFullscreen) isEventMessage() {}
|
||
func (*EventMessageOfBlockUpdate) isEventMessage() {}
|
||
func (*EventMessageOfBlockDelete) isEventMessage() {}
|
||
func (*EventMessageOfUserBlockTextRange) isEventMessage() {}
|
||
func (*EventMessageOfUserBlockJoin) isEventMessage() {}
|
||
func (*EventMessageOfUserBlockLeft) isEventMessage() {}
|
||
func (*EventMessageOfUserBlockSelectRange) isEventMessage() {}
|
||
func (*EventMessageOfFilesUpload) isEventMessage() {}
|
||
|
||
func (m *Event) GetMessage() isEventMessage {
|
||
if m != nil {
|
||
return m.Message
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (m *Event) GetAccountShow() *EventAccountShow {
|
||
if x, ok := m.GetMessage().(*EventMessageOfAccountShow); ok {
|
||
return x.AccountShow
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (m *Event) GetBlockAdd() *EventBlockAdd {
|
||
if x, ok := m.GetMessage().(*EventMessageOfBlockAdd); ok {
|
||
return x.BlockAdd
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (m *Event) GetBlockShowFullscreen() *EventBlockShowFullscreen {
|
||
if x, ok := m.GetMessage().(*EventMessageOfBlockShowFullscreen); ok {
|
||
return x.BlockShowFullscreen
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (m *Event) GetBlockUpdate() *EventBlockUpdate {
|
||
if x, ok := m.GetMessage().(*EventMessageOfBlockUpdate); ok {
|
||
return x.BlockUpdate
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (m *Event) GetBlockDelete() *EventBlockDelete {
|
||
if x, ok := m.GetMessage().(*EventMessageOfBlockDelete); ok {
|
||
return x.BlockDelete
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (m *Event) GetUserBlockTextRange() *EventUserBlockTextRange {
|
||
if x, ok := m.GetMessage().(*EventMessageOfUserBlockTextRange); ok {
|
||
return x.UserBlockTextRange
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (m *Event) GetUserBlockJoin() *EventUserBlockJoin {
|
||
if x, ok := m.GetMessage().(*EventMessageOfUserBlockJoin); ok {
|
||
return x.UserBlockJoin
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (m *Event) GetUserBlockLeft() *EventUserBlockLeft {
|
||
if x, ok := m.GetMessage().(*EventMessageOfUserBlockLeft); ok {
|
||
return x.UserBlockLeft
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (m *Event) GetUserBlockSelectRange() *EventUserBlockSelectRange {
|
||
if x, ok := m.GetMessage().(*EventMessageOfUserBlockSelectRange); ok {
|
||
return x.UserBlockSelectRange
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (m *Event) GetFilesUpload() *EventBlockFilesUpload {
|
||
if x, ok := m.GetMessage().(*EventMessageOfFilesUpload); ok {
|
||
return x.FilesUpload
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// XXX_OneofWrappers is for the internal use of the proto package.
|
||
func (*Event) XXX_OneofWrappers() []interface{} {
|
||
return []interface{}{
|
||
(*EventMessageOfAccountShow)(nil),
|
||
(*EventMessageOfBlockAdd)(nil),
|
||
(*EventMessageOfBlockShowFullscreen)(nil),
|
||
(*EventMessageOfBlockUpdate)(nil),
|
||
(*EventMessageOfBlockDelete)(nil),
|
||
(*EventMessageOfUserBlockTextRange)(nil),
|
||
(*EventMessageOfUserBlockJoin)(nil),
|
||
(*EventMessageOfUserBlockLeft)(nil),
|
||
(*EventMessageOfUserBlockSelectRange)(nil),
|
||
(*EventMessageOfFilesUpload)(nil),
|
||
}
|
||
}
|
||
|
||
type EventAccount struct {
|
||
}
|
||
|
||
func (m *EventAccount) Reset() { *m = EventAccount{} }
|
||
func (m *EventAccount) String() string { return proto.CompactTextString(m) }
|
||
func (*EventAccount) ProtoMessage() {}
|
||
func (*EventAccount) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_8f22242cb04491f9, []int{0, 0}
|
||
}
|
||
func (m *EventAccount) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *EventAccount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_EventAccount.Marshal(b, m, deterministic)
|
||
} else {
|
||
b = b[:cap(b)]
|
||
n, err := m.MarshalToSizedBuffer(b)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return b[:n], nil
|
||
}
|
||
}
|
||
func (m *EventAccount) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_EventAccount.Merge(m, src)
|
||
}
|
||
func (m *EventAccount) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *EventAccount) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_EventAccount.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_EventAccount proto.InternalMessageInfo
|
||
|
||
//*
|
||
// Message, that will be sent to the front on each account found after an AccountRecoverRequest
|
||
type EventAccountShow struct {
|
||
Index int64 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
|
||
Account *ModelAccount `protobuf:"bytes,2,opt,name=account,proto3" json:"account,omitempty"`
|
||
}
|
||
|
||
func (m *EventAccountShow) Reset() { *m = EventAccountShow{} }
|
||
func (m *EventAccountShow) String() string { return proto.CompactTextString(m) }
|
||
func (*EventAccountShow) ProtoMessage() {}
|
||
func (*EventAccountShow) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_8f22242cb04491f9, []int{0, 0, 0}
|
||
}
|
||
func (m *EventAccountShow) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *EventAccountShow) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_EventAccountShow.Marshal(b, m, deterministic)
|
||
} else {
|
||
b = b[:cap(b)]
|
||
n, err := m.MarshalToSizedBuffer(b)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return b[:n], nil
|
||
}
|
||
}
|
||
func (m *EventAccountShow) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_EventAccountShow.Merge(m, src)
|
||
}
|
||
func (m *EventAccountShow) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *EventAccountShow) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_EventAccountShow.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_EventAccountShow proto.InternalMessageInfo
|
||
|
||
func (m *EventAccountShow) GetIndex() int64 {
|
||
if m != nil {
|
||
return m.Index
|
||
}
|
||
return 0
|
||
}
|
||
|
||
func (m *EventAccountShow) GetAccount() *ModelAccount {
|
||
if m != nil {
|
||
return m.Account
|
||
}
|
||
return nil
|
||
}
|
||
|
||
type EventBlock struct {
|
||
}
|
||
|
||
func (m *EventBlock) Reset() { *m = EventBlock{} }
|
||
func (m *EventBlock) String() string { return proto.CompactTextString(m) }
|
||
func (*EventBlock) ProtoMessage() {}
|
||
func (*EventBlock) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_8f22242cb04491f9, []int{0, 1}
|
||
}
|
||
func (m *EventBlock) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *EventBlock) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_EventBlock.Marshal(b, m, deterministic)
|
||
} else {
|
||
b = b[:cap(b)]
|
||
n, err := m.MarshalToSizedBuffer(b)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return b[:n], nil
|
||
}
|
||
}
|
||
func (m *EventBlock) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_EventBlock.Merge(m, src)
|
||
}
|
||
func (m *EventBlock) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *EventBlock) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_EventBlock.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_EventBlock proto.InternalMessageInfo
|
||
|
||
//
|
||
// Event to show internal blocks on a client.
|
||
// Example Scenarios
|
||
// A. Block Creation
|
||
// 1. Block A have been created on a client C1
|
||
// 2. Client C2 receives Event.Block.Add(Block A), Event.Block.Update(Page.children)
|
||
// B. Partial block load
|
||
// 1. Client C1 opens Page1, that contains, for example, 133 blocks.
|
||
// 2. M -> F: ShowFullScreen(Root, blocks1-50)
|
||
// 3. M -> F: Block.Add(blocks51-100)
|
||
// 3. M -> F: Block.Add(blocks101-133)
|
||
type EventBlockAdd struct {
|
||
Blocks []*ModelBlock `protobuf:"bytes,1,rep,name=blocks,proto3" json:"blocks,omitempty"`
|
||
ContextId string `protobuf:"bytes,2,opt,name=contextId,proto3" json:"contextId,omitempty"`
|
||
}
|
||
|
||
func (m *EventBlockAdd) Reset() { *m = EventBlockAdd{} }
|
||
func (m *EventBlockAdd) String() string { return proto.CompactTextString(m) }
|
||
func (*EventBlockAdd) ProtoMessage() {}
|
||
func (*EventBlockAdd) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_8f22242cb04491f9, []int{0, 1, 0}
|
||
}
|
||
func (m *EventBlockAdd) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *EventBlockAdd) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_EventBlockAdd.Marshal(b, m, deterministic)
|
||
} else {
|
||
b = b[:cap(b)]
|
||
n, err := m.MarshalToSizedBuffer(b)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return b[:n], nil
|
||
}
|
||
}
|
||
func (m *EventBlockAdd) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_EventBlockAdd.Merge(m, src)
|
||
}
|
||
func (m *EventBlockAdd) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *EventBlockAdd) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_EventBlockAdd.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_EventBlockAdd proto.InternalMessageInfo
|
||
|
||
func (m *EventBlockAdd) GetBlocks() []*ModelBlock {
|
||
if m != nil {
|
||
return m.Blocks
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (m *EventBlockAdd) GetContextId() string {
|
||
if m != nil {
|
||
return m.ContextId
|
||
}
|
||
return ""
|
||
}
|
||
|
||
//
|
||
// Works with a smart blocks: Page, Dashboard
|
||
// Dashboard opened, click on a page, Rpc.Block.open, Block.ShowFullscreen(PageBlock)
|
||
type EventBlockShowFullscreen struct {
|
||
RootId string `protobuf:"bytes,1,opt,name=rootId,proto3" json:"rootId,omitempty"`
|
||
Blocks []*ModelBlock `protobuf:"bytes,2,rep,name=blocks,proto3" json:"blocks,omitempty"`
|
||
ContextId string `protobuf:"bytes,3,opt,name=contextId,proto3" json:"contextId,omitempty"`
|
||
}
|
||
|
||
func (m *EventBlockShowFullscreen) Reset() { *m = EventBlockShowFullscreen{} }
|
||
func (m *EventBlockShowFullscreen) String() string { return proto.CompactTextString(m) }
|
||
func (*EventBlockShowFullscreen) ProtoMessage() {}
|
||
func (*EventBlockShowFullscreen) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_8f22242cb04491f9, []int{0, 1, 1}
|
||
}
|
||
func (m *EventBlockShowFullscreen) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *EventBlockShowFullscreen) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_EventBlockShowFullscreen.Marshal(b, m, deterministic)
|
||
} else {
|
||
b = b[:cap(b)]
|
||
n, err := m.MarshalToSizedBuffer(b)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return b[:n], nil
|
||
}
|
||
}
|
||
func (m *EventBlockShowFullscreen) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_EventBlockShowFullscreen.Merge(m, src)
|
||
}
|
||
func (m *EventBlockShowFullscreen) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *EventBlockShowFullscreen) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_EventBlockShowFullscreen.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_EventBlockShowFullscreen proto.InternalMessageInfo
|
||
|
||
func (m *EventBlockShowFullscreen) GetRootId() string {
|
||
if m != nil {
|
||
return m.RootId
|
||
}
|
||
return ""
|
||
}
|
||
|
||
func (m *EventBlockShowFullscreen) GetBlocks() []*ModelBlock {
|
||
if m != nil {
|
||
return m.Blocks
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (m *EventBlockShowFullscreen) GetContextId() string {
|
||
if m != nil {
|
||
return m.ContextId
|
||
}
|
||
return ""
|
||
}
|
||
|
||
//
|
||
// Updates from different clients, or from the local middleware
|
||
// Example scenarios:
|
||
// Page opened, TextBlock updated on a different client, BlockUpdate(changes)
|
||
type EventBlockUpdate struct {
|
||
Changes *ChangeMultipleBlocksList `protobuf:"bytes,1,opt,name=changes,proto3" json:"changes,omitempty"`
|
||
ContextId string `protobuf:"bytes,2,opt,name=contextId,proto3" json:"contextId,omitempty"`
|
||
}
|
||
|
||
func (m *EventBlockUpdate) Reset() { *m = EventBlockUpdate{} }
|
||
func (m *EventBlockUpdate) String() string { return proto.CompactTextString(m) }
|
||
func (*EventBlockUpdate) ProtoMessage() {}
|
||
func (*EventBlockUpdate) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_8f22242cb04491f9, []int{0, 1, 2}
|
||
}
|
||
func (m *EventBlockUpdate) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *EventBlockUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_EventBlockUpdate.Marshal(b, m, deterministic)
|
||
} else {
|
||
b = b[:cap(b)]
|
||
n, err := m.MarshalToSizedBuffer(b)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return b[:n], nil
|
||
}
|
||
}
|
||
func (m *EventBlockUpdate) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_EventBlockUpdate.Merge(m, src)
|
||
}
|
||
func (m *EventBlockUpdate) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *EventBlockUpdate) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_EventBlockUpdate.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_EventBlockUpdate proto.InternalMessageInfo
|
||
|
||
func (m *EventBlockUpdate) GetChanges() *ChangeMultipleBlocksList {
|
||
if m != nil {
|
||
return m.Changes
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (m *EventBlockUpdate) GetContextId() string {
|
||
if m != nil {
|
||
return m.ContextId
|
||
}
|
||
return ""
|
||
}
|
||
|
||
//*
|
||
// Middleware to front end event message, that will be sent on one of this scenarios:
|
||
// Precondition: user A opened a block
|
||
// 1. User A drops a set of files/pictures/videos
|
||
// 2. User A creates a MediaBlock and drops a single media, that corresponds to its type.
|
||
type EventBlockFilesUpload struct {
|
||
FilePath []string `protobuf:"bytes,1,rep,name=filePath,proto3" json:"filePath,omitempty"`
|
||
BlockId string `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
|
||
ContextId string `protobuf:"bytes,3,opt,name=contextId,proto3" json:"contextId,omitempty"`
|
||
}
|
||
|
||
func (m *EventBlockFilesUpload) Reset() { *m = EventBlockFilesUpload{} }
|
||
func (m *EventBlockFilesUpload) String() string { return proto.CompactTextString(m) }
|
||
func (*EventBlockFilesUpload) ProtoMessage() {}
|
||
func (*EventBlockFilesUpload) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_8f22242cb04491f9, []int{0, 1, 3}
|
||
}
|
||
func (m *EventBlockFilesUpload) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *EventBlockFilesUpload) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_EventBlockFilesUpload.Marshal(b, m, deterministic)
|
||
} else {
|
||
b = b[:cap(b)]
|
||
n, err := m.MarshalToSizedBuffer(b)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return b[:n], nil
|
||
}
|
||
}
|
||
func (m *EventBlockFilesUpload) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_EventBlockFilesUpload.Merge(m, src)
|
||
}
|
||
func (m *EventBlockFilesUpload) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *EventBlockFilesUpload) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_EventBlockFilesUpload.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_EventBlockFilesUpload proto.InternalMessageInfo
|
||
|
||
func (m *EventBlockFilesUpload) GetFilePath() []string {
|
||
if m != nil {
|
||
return m.FilePath
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (m *EventBlockFilesUpload) GetBlockId() string {
|
||
if m != nil {
|
||
return m.BlockId
|
||
}
|
||
return ""
|
||
}
|
||
|
||
func (m *EventBlockFilesUpload) GetContextId() string {
|
||
if m != nil {
|
||
return m.ContextId
|
||
}
|
||
return ""
|
||
}
|
||
|
||
//
|
||
//
|
||
type EventBlockDelete struct {
|
||
BlockId string `protobuf:"bytes,1,opt,name=blockId,proto3" json:"blockId,omitempty"`
|
||
ContextId string `protobuf:"bytes,2,opt,name=contextId,proto3" json:"contextId,omitempty"`
|
||
}
|
||
|
||
func (m *EventBlockDelete) Reset() { *m = EventBlockDelete{} }
|
||
func (m *EventBlockDelete) String() string { return proto.CompactTextString(m) }
|
||
func (*EventBlockDelete) ProtoMessage() {}
|
||
func (*EventBlockDelete) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_8f22242cb04491f9, []int{0, 1, 4}
|
||
}
|
||
func (m *EventBlockDelete) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *EventBlockDelete) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_EventBlockDelete.Marshal(b, m, deterministic)
|
||
} else {
|
||
b = b[:cap(b)]
|
||
n, err := m.MarshalToSizedBuffer(b)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return b[:n], nil
|
||
}
|
||
}
|
||
func (m *EventBlockDelete) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_EventBlockDelete.Merge(m, src)
|
||
}
|
||
func (m *EventBlockDelete) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *EventBlockDelete) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_EventBlockDelete.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_EventBlockDelete proto.InternalMessageInfo
|
||
|
||
func (m *EventBlockDelete) GetBlockId() string {
|
||
if m != nil {
|
||
return m.BlockId
|
||
}
|
||
return ""
|
||
}
|
||
|
||
func (m *EventBlockDelete) GetContextId() string {
|
||
if m != nil {
|
||
return m.ContextId
|
||
}
|
||
return ""
|
||
}
|
||
|
||
type EventUser struct {
|
||
}
|
||
|
||
func (m *EventUser) Reset() { *m = EventUser{} }
|
||
func (m *EventUser) String() string { return proto.CompactTextString(m) }
|
||
func (*EventUser) ProtoMessage() {}
|
||
func (*EventUser) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_8f22242cb04491f9, []int{0, 2}
|
||
}
|
||
func (m *EventUser) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *EventUser) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_EventUser.Marshal(b, m, deterministic)
|
||
} else {
|
||
b = b[:cap(b)]
|
||
n, err := m.MarshalToSizedBuffer(b)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return b[:n], nil
|
||
}
|
||
}
|
||
func (m *EventUser) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_EventUser.Merge(m, src)
|
||
}
|
||
func (m *EventUser) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *EventUser) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_EventUser.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_EventUser proto.InternalMessageInfo
|
||
|
||
type EventUserBlock struct {
|
||
}
|
||
|
||
func (m *EventUserBlock) Reset() { *m = EventUserBlock{} }
|
||
func (m *EventUserBlock) String() string { return proto.CompactTextString(m) }
|
||
func (*EventUserBlock) ProtoMessage() {}
|
||
func (*EventUserBlock) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_8f22242cb04491f9, []int{0, 2, 0}
|
||
}
|
||
func (m *EventUserBlock) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *EventUserBlock) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_EventUserBlock.Marshal(b, m, deterministic)
|
||
} else {
|
||
b = b[:cap(b)]
|
||
n, err := m.MarshalToSizedBuffer(b)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return b[:n], nil
|
||
}
|
||
}
|
||
func (m *EventUserBlock) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_EventUserBlock.Merge(m, src)
|
||
}
|
||
func (m *EventUserBlock) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *EventUserBlock) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_EventUserBlock.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_EventUserBlock proto.InternalMessageInfo
|
||
|
||
//*
|
||
// Middleware to front end event message, that will be sent in this scenario:
|
||
// Precondition: user A opened a block
|
||
// 1. User B opens the same block
|
||
// 2. User A receives a message about p.1
|
||
type EventUserBlockJoin struct {
|
||
Account *EventAccount `protobuf:"bytes,1,opt,name=account,proto3" json:"account,omitempty"`
|
||
ContextId string `protobuf:"bytes,2,opt,name=contextId,proto3" json:"contextId,omitempty"`
|
||
}
|
||
|
||
func (m *EventUserBlockJoin) Reset() { *m = EventUserBlockJoin{} }
|
||
func (m *EventUserBlockJoin) String() string { return proto.CompactTextString(m) }
|
||
func (*EventUserBlockJoin) ProtoMessage() {}
|
||
func (*EventUserBlockJoin) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_8f22242cb04491f9, []int{0, 2, 0, 0}
|
||
}
|
||
func (m *EventUserBlockJoin) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *EventUserBlockJoin) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_EventUserBlockJoin.Marshal(b, m, deterministic)
|
||
} else {
|
||
b = b[:cap(b)]
|
||
n, err := m.MarshalToSizedBuffer(b)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return b[:n], nil
|
||
}
|
||
}
|
||
func (m *EventUserBlockJoin) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_EventUserBlockJoin.Merge(m, src)
|
||
}
|
||
func (m *EventUserBlockJoin) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *EventUserBlockJoin) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_EventUserBlockJoin.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_EventUserBlockJoin proto.InternalMessageInfo
|
||
|
||
func (m *EventUserBlockJoin) GetAccount() *EventAccount {
|
||
if m != nil {
|
||
return m.Account
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (m *EventUserBlockJoin) GetContextId() string {
|
||
if m != nil {
|
||
return m.ContextId
|
||
}
|
||
return ""
|
||
}
|
||
|
||
//*
|
||
// Middleware to front end event message, that will be sent in this scenario:
|
||
// Precondition: user A and user B opened the same block
|
||
// 1. User B closes the block
|
||
// 2. User A receives a message about p.1
|
||
type EventUserBlockLeft struct {
|
||
Account *EventAccount `protobuf:"bytes,1,opt,name=account,proto3" json:"account,omitempty"`
|
||
ContextId string `protobuf:"bytes,2,opt,name=contextId,proto3" json:"contextId,omitempty"`
|
||
}
|
||
|
||
func (m *EventUserBlockLeft) Reset() { *m = EventUserBlockLeft{} }
|
||
func (m *EventUserBlockLeft) String() string { return proto.CompactTextString(m) }
|
||
func (*EventUserBlockLeft) ProtoMessage() {}
|
||
func (*EventUserBlockLeft) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_8f22242cb04491f9, []int{0, 2, 0, 1}
|
||
}
|
||
func (m *EventUserBlockLeft) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *EventUserBlockLeft) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_EventUserBlockLeft.Marshal(b, m, deterministic)
|
||
} else {
|
||
b = b[:cap(b)]
|
||
n, err := m.MarshalToSizedBuffer(b)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return b[:n], nil
|
||
}
|
||
}
|
||
func (m *EventUserBlockLeft) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_EventUserBlockLeft.Merge(m, src)
|
||
}
|
||
func (m *EventUserBlockLeft) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *EventUserBlockLeft) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_EventUserBlockLeft.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_EventUserBlockLeft proto.InternalMessageInfo
|
||
|
||
func (m *EventUserBlockLeft) GetAccount() *EventAccount {
|
||
if m != nil {
|
||
return m.Account
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (m *EventUserBlockLeft) GetContextId() string {
|
||
if m != nil {
|
||
return m.ContextId
|
||
}
|
||
return ""
|
||
}
|
||
|
||
//*
|
||
// Middleware to front end event message, that will be sent in this scenario:
|
||
// Precondition: user A and user B opened the same block
|
||
// 1. User B sets cursor or selects a text region into a text block
|
||
// 2. User A receives a message about p.1
|
||
type EventUserBlockTextRange struct {
|
||
Account *EventAccount `protobuf:"bytes,1,opt,name=account,proto3" json:"account,omitempty"`
|
||
BlockId string `protobuf:"bytes,2,opt,name=blockId,proto3" json:"blockId,omitempty"`
|
||
Range *ModelRange `protobuf:"bytes,3,opt,name=range,proto3" json:"range,omitempty"`
|
||
ContextId string `protobuf:"bytes,4,opt,name=contextId,proto3" json:"contextId,omitempty"`
|
||
}
|
||
|
||
func (m *EventUserBlockTextRange) Reset() { *m = EventUserBlockTextRange{} }
|
||
func (m *EventUserBlockTextRange) String() string { return proto.CompactTextString(m) }
|
||
func (*EventUserBlockTextRange) ProtoMessage() {}
|
||
func (*EventUserBlockTextRange) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_8f22242cb04491f9, []int{0, 2, 0, 2}
|
||
}
|
||
func (m *EventUserBlockTextRange) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *EventUserBlockTextRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_EventUserBlockTextRange.Marshal(b, m, deterministic)
|
||
} else {
|
||
b = b[:cap(b)]
|
||
n, err := m.MarshalToSizedBuffer(b)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return b[:n], nil
|
||
}
|
||
}
|
||
func (m *EventUserBlockTextRange) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_EventUserBlockTextRange.Merge(m, src)
|
||
}
|
||
func (m *EventUserBlockTextRange) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *EventUserBlockTextRange) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_EventUserBlockTextRange.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_EventUserBlockTextRange proto.InternalMessageInfo
|
||
|
||
func (m *EventUserBlockTextRange) GetAccount() *EventAccount {
|
||
if m != nil {
|
||
return m.Account
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (m *EventUserBlockTextRange) GetBlockId() string {
|
||
if m != nil {
|
||
return m.BlockId
|
||
}
|
||
return ""
|
||
}
|
||
|
||
func (m *EventUserBlockTextRange) GetRange() *ModelRange {
|
||
if m != nil {
|
||
return m.Range
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (m *EventUserBlockTextRange) GetContextId() string {
|
||
if m != nil {
|
||
return m.ContextId
|
||
}
|
||
return ""
|
||
}
|
||
|
||
//*
|
||
// Middleware to front end event message, that will be sent in this scenario:
|
||
// Precondition: user A and user B opened the same block
|
||
// 1. User B selects some inner blocks
|
||
// 2. User A receives a message about p.1
|
||
type EventUserBlockSelectRange struct {
|
||
Account *EventAccount `protobuf:"bytes,1,opt,name=account,proto3" json:"account,omitempty"`
|
||
BlockIdsArray []string `protobuf:"bytes,2,rep,name=blockIdsArray,proto3" json:"blockIdsArray,omitempty"`
|
||
ContextId string `protobuf:"bytes,3,opt,name=contextId,proto3" json:"contextId,omitempty"`
|
||
}
|
||
|
||
func (m *EventUserBlockSelectRange) Reset() { *m = EventUserBlockSelectRange{} }
|
||
func (m *EventUserBlockSelectRange) String() string { return proto.CompactTextString(m) }
|
||
func (*EventUserBlockSelectRange) ProtoMessage() {}
|
||
func (*EventUserBlockSelectRange) Descriptor() ([]byte, []int) {
|
||
return fileDescriptor_8f22242cb04491f9, []int{0, 2, 0, 3}
|
||
}
|
||
func (m *EventUserBlockSelectRange) XXX_Unmarshal(b []byte) error {
|
||
return m.Unmarshal(b)
|
||
}
|
||
func (m *EventUserBlockSelectRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
if deterministic {
|
||
return xxx_messageInfo_EventUserBlockSelectRange.Marshal(b, m, deterministic)
|
||
} else {
|
||
b = b[:cap(b)]
|
||
n, err := m.MarshalToSizedBuffer(b)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return b[:n], nil
|
||
}
|
||
}
|
||
func (m *EventUserBlockSelectRange) XXX_Merge(src proto.Message) {
|
||
xxx_messageInfo_EventUserBlockSelectRange.Merge(m, src)
|
||
}
|
||
func (m *EventUserBlockSelectRange) XXX_Size() int {
|
||
return m.Size()
|
||
}
|
||
func (m *EventUserBlockSelectRange) XXX_DiscardUnknown() {
|
||
xxx_messageInfo_EventUserBlockSelectRange.DiscardUnknown(m)
|
||
}
|
||
|
||
var xxx_messageInfo_EventUserBlockSelectRange proto.InternalMessageInfo
|
||
|
||
func (m *EventUserBlockSelectRange) GetAccount() *EventAccount {
|
||
if m != nil {
|
||
return m.Account
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (m *EventUserBlockSelectRange) GetBlockIdsArray() []string {
|
||
if m != nil {
|
||
return m.BlockIdsArray
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (m *EventUserBlockSelectRange) GetContextId() string {
|
||
if m != nil {
|
||
return m.ContextId
|
||
}
|
||
return ""
|
||
}
|
||
|
||
func init() {
|
||
proto.RegisterType((*Event)(nil), "anytype.Event")
|
||
proto.RegisterType((*EventAccount)(nil), "anytype.Event.Account")
|
||
proto.RegisterType((*EventAccountShow)(nil), "anytype.Event.Account.Show")
|
||
proto.RegisterType((*EventBlock)(nil), "anytype.Event.Block")
|
||
proto.RegisterType((*EventBlockAdd)(nil), "anytype.Event.Block.Add")
|
||
proto.RegisterType((*EventBlockShowFullscreen)(nil), "anytype.Event.Block.ShowFullscreen")
|
||
proto.RegisterType((*EventBlockUpdate)(nil), "anytype.Event.Block.Update")
|
||
proto.RegisterType((*EventBlockFilesUpload)(nil), "anytype.Event.Block.FilesUpload")
|
||
proto.RegisterType((*EventBlockDelete)(nil), "anytype.Event.Block.Delete")
|
||
proto.RegisterType((*EventUser)(nil), "anytype.Event.User")
|
||
proto.RegisterType((*EventUserBlock)(nil), "anytype.Event.User.Block")
|
||
proto.RegisterType((*EventUserBlockJoin)(nil), "anytype.Event.User.Block.Join")
|
||
proto.RegisterType((*EventUserBlockLeft)(nil), "anytype.Event.User.Block.Left")
|
||
proto.RegisterType((*EventUserBlockTextRange)(nil), "anytype.Event.User.Block.TextRange")
|
||
proto.RegisterType((*EventUserBlockSelectRange)(nil), "anytype.Event.User.Block.SelectRange")
|
||
}
|
||
|
||
func init() { proto.RegisterFile("events.proto", fileDescriptor_8f22242cb04491f9) }
|
||
|
||
var fileDescriptor_8f22242cb04491f9 = []byte{
|
||
// 677 bytes of a gzipped FileDescriptorProto
|
||
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x95, 0xcf, 0x4f, 0xd4, 0x40,
|
||
0x14, 0xc7, 0x5b, 0xba, 0xbb, 0xa5, 0x6f, 0x81, 0xc3, 0x48, 0xc8, 0xa4, 0x92, 0x86, 0xf8, 0x23,
|
||
0x21, 0xc6, 0x34, 0x06, 0x13, 0x6f, 0x46, 0x17, 0x91, 0xac, 0x06, 0x8c, 0x0e, 0x2e, 0x46, 0x3d,
|
||
0x95, 0x76, 0x80, 0x8d, 0xa5, 0x6d, 0xda, 0x59, 0x85, 0xb3, 0xff, 0x80, 0x37, 0xcf, 0xfe, 0x37,
|
||
0x1e, 0x39, 0x7a, 0xf0, 0xa0, 0x70, 0xf3, 0xaf, 0x30, 0xf3, 0x3a, 0xdb, 0x6d, 0x6b, 0x61, 0x43,
|
||
0xe2, 0x8d, 0x79, 0x7c, 0xdf, 0xe7, 0xbd, 0xd7, 0xf9, 0xbe, 0x59, 0x98, 0xe3, 0x1f, 0x79, 0x24,
|
||
0x32, 0x37, 0x49, 0x63, 0x11, 0x13, 0xd3, 0x8b, 0x4e, 0xc4, 0x49, 0xc2, 0xed, 0xb9, 0xa3, 0x38,
|
||
0xe0, 0xa1, 0x0a, 0xdb, 0xf3, 0xfe, 0xa1, 0x17, 0x1d, 0x70, 0x75, 0xbc, 0xf1, 0x75, 0x01, 0xda,
|
||
0x4f, 0x65, 0x1a, 0x79, 0x04, 0x5d, 0xcf, 0xf7, 0xe3, 0x51, 0x24, 0x76, 0x0e, 0xe3, 0x4f, 0x54,
|
||
0x5f, 0xd1, 0x57, 0xbb, 0x6b, 0xd7, 0x5d, 0x45, 0x71, 0x51, 0xe4, 0xf6, 0x72, 0x85, 0x2b, 0x25,
|
||
0x7d, 0x8d, 0x95, 0x33, 0xc8, 0x03, 0x98, 0xdd, 0x0b, 0x63, 0xff, 0x43, 0x2f, 0x08, 0xe8, 0x0c,
|
||
0x66, 0xd3, 0x5a, 0xf6, 0xba, 0xfc, 0xb7, 0xdb, 0x0b, 0x82, 0xbe, 0xc6, 0x0a, 0x2d, 0x79, 0x03,
|
||
0xd7, 0xf0, 0x6f, 0x09, 0xd9, 0x1c, 0x85, 0x61, 0xe6, 0xa7, 0x9c, 0x47, 0xd4, 0x40, 0xc4, 0xcd,
|
||
0x46, 0x44, 0x55, 0xda, 0xd7, 0x58, 0x13, 0x41, 0x4e, 0x84, 0xe1, 0x41, 0x12, 0x78, 0x82, 0xd3,
|
||
0x56, 0xe3, 0x44, 0x39, 0x30, 0x97, 0xc8, 0x89, 0x4a, 0x19, 0x05, 0x60, 0x83, 0x87, 0x5c, 0x70,
|
||
0xda, 0xbe, 0x04, 0x90, 0x4b, 0x0a, 0x40, 0x7e, 0x24, 0x03, 0x20, 0xa3, 0x8c, 0xa7, 0x28, 0x79,
|
||
0xcd, 0x8f, 0x05, 0x93, 0x9f, 0x9e, 0x76, 0x1a, 0x27, 0x1b, 0x64, 0x3c, 0x55, 0xb0, 0x42, 0xda,
|
||
0xd7, 0x58, 0x03, 0x80, 0x6c, 0xc2, 0x7c, 0x11, 0x7d, 0x1e, 0x0f, 0x23, 0x6a, 0x22, 0xd1, 0xb9,
|
||
0x98, 0x28, 0x55, 0x7d, 0x8d, 0x55, 0xd3, 0x2a, 0x9c, 0x2d, 0xbe, 0x2f, 0xe8, 0xec, 0x34, 0x8e,
|
||
0x54, 0x55, 0x38, 0x32, 0x40, 0xde, 0xc3, 0x62, 0x11, 0xd8, 0xe1, 0x21, 0xf7, 0xd5, 0xa0, 0x16,
|
||
0xe2, 0x6e, 0x5f, 0x8c, 0x2b, 0x89, 0xfb, 0x1a, 0x6b, 0x84, 0x90, 0x0d, 0xe8, 0xee, 0x0f, 0x43,
|
||
0x9e, 0x0d, 0x92, 0x30, 0xf6, 0x02, 0x0a, 0xc8, 0x5c, 0x69, 0xbc, 0x84, 0xcd, 0x89, 0x4e, 0xde,
|
||
0x44, 0x29, 0xcd, 0x7e, 0x0b, 0xa6, 0xf2, 0xae, 0xfd, 0x02, 0x5a, 0xe8, 0xd7, 0x45, 0x68, 0x0f,
|
||
0xa3, 0x80, 0x1f, 0xa3, 0xd5, 0x0d, 0x96, 0x1f, 0xc8, 0x3d, 0x30, 0x95, 0xa9, 0x95, 0x89, 0x97,
|
||
0x8a, 0x52, 0xdb, 0x72, 0x8f, 0xc6, 0x2b, 0xc0, 0xc6, 0x32, 0xfb, 0xa7, 0x01, 0x6d, 0xac, 0x6f,
|
||
0xbf, 0x02, 0x43, 0x1a, 0xfa, 0x2e, 0x74, 0xd0, 0x04, 0x19, 0xd5, 0x57, 0x8c, 0xd5, 0xee, 0xda,
|
||
0x62, 0x8d, 0x80, 0x62, 0xa6, 0x34, 0x64, 0x19, 0x2c, 0x3f, 0x8e, 0x04, 0x3f, 0x16, 0xcf, 0xf2,
|
||
0xbd, 0xb1, 0xd8, 0x24, 0x60, 0x0b, 0x58, 0xa8, 0xb9, 0x7a, 0x09, 0x3a, 0x69, 0x1c, 0x4b, 0xb1,
|
||
0x8e, 0x62, 0x75, 0x2a, 0x55, 0x9d, 0xb9, 0x6a, 0x55, 0xa3, 0x5e, 0x95, 0x43, 0x47, 0xad, 0xc0,
|
||
0x43, 0x30, 0xd5, 0x83, 0xa1, 0x5e, 0x84, 0x89, 0x6d, 0x9f, 0x60, 0xdc, 0xdd, 0x1e, 0x85, 0x62,
|
||
0x98, 0x84, 0x3c, 0x2f, 0x90, 0x6d, 0x0d, 0x33, 0xc1, 0xc6, 0x39, 0x53, 0x86, 0xf3, 0xa0, 0x5b,
|
||
0xba, 0x32, 0x62, 0xc3, 0xac, 0xbc, 0xb2, 0x97, 0x9e, 0x38, 0xc4, 0x2f, 0x67, 0xb1, 0xe2, 0x4c,
|
||
0x28, 0x98, 0xd8, 0x79, 0x81, 0x19, 0x1f, 0xa7, 0x4c, 0xf2, 0x18, 0x3a, 0x6a, 0x17, 0x4b, 0x04,
|
||
0xfd, 0x12, 0xc2, 0x3f, 0x4d, 0xfe, 0x31, 0xa0, 0x25, 0x2d, 0x6b, 0xff, 0x2e, 0xee, 0x79, 0x17,
|
||
0x5a, 0xb8, 0x3f, 0x25, 0xaf, 0xe8, 0x35, 0xaf, 0x54, 0x9e, 0xcb, 0xc2, 0x2b, 0x53, 0x4a, 0xed,
|
||
0x42, 0x0b, 0xf7, 0xe9, 0x7f, 0x73, 0xbf, 0xe9, 0x60, 0x4d, 0x5e, 0x8f, 0xab, 0xd3, 0x2f, 0xfe,
|
||
0xf8, 0x77, 0xa0, 0x9d, 0xe2, 0xaa, 0xe7, 0xaf, 0x75, 0xdd, 0x73, 0x58, 0x90, 0xe5, 0x92, 0x6a,
|
||
0x8f, 0xad, 0x7a, 0x8f, 0x9f, 0x75, 0xe8, 0x96, 0xd7, 0xfe, 0xea, 0x5d, 0xde, 0x82, 0x79, 0xd5,
|
||
0x56, 0xd6, 0x4b, 0x53, 0xef, 0x04, 0xf7, 0xc0, 0x62, 0xd5, 0xe0, 0xe5, 0x76, 0x59, 0xb7, 0xc0,
|
||
0x3c, 0xe2, 0x59, 0xe6, 0x1d, 0xf0, 0xf5, 0xe5, 0xef, 0x67, 0x8e, 0x7e, 0x7a, 0xe6, 0xe8, 0xbf,
|
||
0xce, 0x1c, 0xfd, 0xcb, 0xb9, 0xa3, 0x9d, 0x9e, 0x3b, 0xda, 0x8f, 0x73, 0x47, 0x7b, 0x37, 0x93,
|
||
0xec, 0xed, 0x75, 0xf0, 0xe7, 0xf3, 0xfe, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x66, 0xfd, 0x0a,
|
||
0xe1, 0x74, 0x07, 0x00, 0x00,
|
||
}
|
||
|
||
func (m *Event) Marshal() (dAtA []byte, err error) {
|
||
size := m.Size()
|
||
dAtA = make([]byte, size)
|
||
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return dAtA[:n], nil
|
||
}
|
||
|
||
func (m *Event) MarshalTo(dAtA []byte) (int, error) {
|
||
size := m.Size()
|
||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||
}
|
||
|
||
func (m *Event) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||
i := len(dAtA)
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
if m.Message != nil {
|
||
{
|
||
size := m.Message.Size()
|
||
i -= size
|
||
if _, err := m.Message.MarshalTo(dAtA[i:]); err != nil {
|
||
return 0, err
|
||
}
|
||
}
|
||
}
|
||
return len(dAtA) - i, nil
|
||
}
|
||
|
||
func (m *EventMessageOfAccountShow) MarshalTo(dAtA []byte) (int, error) {
|
||
size := m.Size()
|
||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||
}
|
||
|
||
func (m *EventMessageOfAccountShow) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||
i := len(dAtA)
|
||
if m.AccountShow != nil {
|
||
{
|
||
size, err := m.AccountShow.MarshalToSizedBuffer(dAtA[:i])
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
i -= size
|
||
i = encodeVarintEvents(dAtA, i, uint64(size))
|
||
}
|
||
i--
|
||
dAtA[i] = 0xa
|
||
}
|
||
return len(dAtA) - i, nil
|
||
}
|
||
func (m *EventMessageOfBlockAdd) MarshalTo(dAtA []byte) (int, error) {
|
||
size := m.Size()
|
||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||
}
|
||
|
||
func (m *EventMessageOfBlockAdd) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||
i := len(dAtA)
|
||
if m.BlockAdd != nil {
|
||
{
|
||
size, err := m.BlockAdd.MarshalToSizedBuffer(dAtA[:i])
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
i -= size
|
||
i = encodeVarintEvents(dAtA, i, uint64(size))
|
||
}
|
||
i--
|
||
dAtA[i] = 0x12
|
||
}
|
||
return len(dAtA) - i, nil
|
||
}
|
||
func (m *EventMessageOfBlockShowFullscreen) MarshalTo(dAtA []byte) (int, error) {
|
||
size := m.Size()
|
||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||
}
|
||
|
||
func (m *EventMessageOfBlockShowFullscreen) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||
i := len(dAtA)
|
||
if m.BlockShowFullscreen != nil {
|
||
{
|
||
size, err := m.BlockShowFullscreen.MarshalToSizedBuffer(dAtA[:i])
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
i -= size
|
||
i = encodeVarintEvents(dAtA, i, uint64(size))
|
||
}
|
||
i--
|
||
dAtA[i] = 0x1a
|
||
}
|
||
return len(dAtA) - i, nil
|
||
}
|
||
func (m *EventMessageOfBlockUpdate) MarshalTo(dAtA []byte) (int, error) {
|
||
size := m.Size()
|
||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||
}
|
||
|
||
func (m *EventMessageOfBlockUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||
i := len(dAtA)
|
||
if m.BlockUpdate != nil {
|
||
{
|
||
size, err := m.BlockUpdate.MarshalToSizedBuffer(dAtA[:i])
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
i -= size
|
||
i = encodeVarintEvents(dAtA, i, uint64(size))
|
||
}
|
||
i--
|
||
dAtA[i] = 0x22
|
||
}
|
||
return len(dAtA) - i, nil
|
||
}
|
||
func (m *EventMessageOfBlockDelete) MarshalTo(dAtA []byte) (int, error) {
|
||
size := m.Size()
|
||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||
}
|
||
|
||
func (m *EventMessageOfBlockDelete) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||
i := len(dAtA)
|
||
if m.BlockDelete != nil {
|
||
{
|
||
size, err := m.BlockDelete.MarshalToSizedBuffer(dAtA[:i])
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
i -= size
|
||
i = encodeVarintEvents(dAtA, i, uint64(size))
|
||
}
|
||
i--
|
||
dAtA[i] = 0x2a
|
||
}
|
||
return len(dAtA) - i, nil
|
||
}
|
||
func (m *EventMessageOfUserBlockTextRange) MarshalTo(dAtA []byte) (int, error) {
|
||
size := m.Size()
|
||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||
}
|
||
|
||
func (m *EventMessageOfUserBlockTextRange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||
i := len(dAtA)
|
||
if m.UserBlockTextRange != nil {
|
||
{
|
||
size, err := m.UserBlockTextRange.MarshalToSizedBuffer(dAtA[:i])
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
i -= size
|
||
i = encodeVarintEvents(dAtA, i, uint64(size))
|
||
}
|
||
i--
|
||
dAtA[i] = 0x32
|
||
}
|
||
return len(dAtA) - i, nil
|
||
}
|
||
func (m *EventMessageOfUserBlockJoin) MarshalTo(dAtA []byte) (int, error) {
|
||
size := m.Size()
|
||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||
}
|
||
|
||
func (m *EventMessageOfUserBlockJoin) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||
i := len(dAtA)
|
||
if m.UserBlockJoin != nil {
|
||
{
|
||
size, err := m.UserBlockJoin.MarshalToSizedBuffer(dAtA[:i])
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
i -= size
|
||
i = encodeVarintEvents(dAtA, i, uint64(size))
|
||
}
|
||
i--
|
||
dAtA[i] = 0x3a
|
||
}
|
||
return len(dAtA) - i, nil
|
||
}
|
||
func (m *EventMessageOfUserBlockLeft) MarshalTo(dAtA []byte) (int, error) {
|
||
size := m.Size()
|
||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||
}
|
||
|
||
func (m *EventMessageOfUserBlockLeft) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||
i := len(dAtA)
|
||
if m.UserBlockLeft != nil {
|
||
{
|
||
size, err := m.UserBlockLeft.MarshalToSizedBuffer(dAtA[:i])
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
i -= size
|
||
i = encodeVarintEvents(dAtA, i, uint64(size))
|
||
}
|
||
i--
|
||
dAtA[i] = 0x42
|
||
}
|
||
return len(dAtA) - i, nil
|
||
}
|
||
func (m *EventMessageOfUserBlockSelectRange) MarshalTo(dAtA []byte) (int, error) {
|
||
size := m.Size()
|
||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||
}
|
||
|
||
func (m *EventMessageOfUserBlockSelectRange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||
i := len(dAtA)
|
||
if m.UserBlockSelectRange != nil {
|
||
{
|
||
size, err := m.UserBlockSelectRange.MarshalToSizedBuffer(dAtA[:i])
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
i -= size
|
||
i = encodeVarintEvents(dAtA, i, uint64(size))
|
||
}
|
||
i--
|
||
dAtA[i] = 0x4a
|
||
}
|
||
return len(dAtA) - i, nil
|
||
}
|
||
func (m *EventMessageOfFilesUpload) MarshalTo(dAtA []byte) (int, error) {
|
||
size := m.Size()
|
||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||
}
|
||
|
||
func (m *EventMessageOfFilesUpload) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||
i := len(dAtA)
|
||
if m.FilesUpload != nil {
|
||
{
|
||
size, err := m.FilesUpload.MarshalToSizedBuffer(dAtA[:i])
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
i -= size
|
||
i = encodeVarintEvents(dAtA, i, uint64(size))
|
||
}
|
||
i--
|
||
dAtA[i] = 0x52
|
||
}
|
||
return len(dAtA) - i, nil
|
||
}
|
||
func (m *EventAccount) Marshal() (dAtA []byte, err error) {
|
||
size := m.Size()
|
||
dAtA = make([]byte, size)
|
||
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return dAtA[:n], nil
|
||
}
|
||
|
||
func (m *EventAccount) MarshalTo(dAtA []byte) (int, error) {
|
||
size := m.Size()
|
||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||
}
|
||
|
||
func (m *EventAccount) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||
i := len(dAtA)
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
return len(dAtA) - i, nil
|
||
}
|
||
|
||
func (m *EventAccountShow) Marshal() (dAtA []byte, err error) {
|
||
size := m.Size()
|
||
dAtA = make([]byte, size)
|
||
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return dAtA[:n], nil
|
||
}
|
||
|
||
func (m *EventAccountShow) MarshalTo(dAtA []byte) (int, error) {
|
||
size := m.Size()
|
||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||
}
|
||
|
||
func (m *EventAccountShow) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||
i := len(dAtA)
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
if m.Account != nil {
|
||
{
|
||
size, err := m.Account.MarshalToSizedBuffer(dAtA[:i])
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
i -= size
|
||
i = encodeVarintEvents(dAtA, i, uint64(size))
|
||
}
|
||
i--
|
||
dAtA[i] = 0x12
|
||
}
|
||
if m.Index != 0 {
|
||
i = encodeVarintEvents(dAtA, i, uint64(m.Index))
|
||
i--
|
||
dAtA[i] = 0x8
|
||
}
|
||
return len(dAtA) - i, nil
|
||
}
|
||
|
||
func (m *EventBlock) Marshal() (dAtA []byte, err error) {
|
||
size := m.Size()
|
||
dAtA = make([]byte, size)
|
||
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return dAtA[:n], nil
|
||
}
|
||
|
||
func (m *EventBlock) MarshalTo(dAtA []byte) (int, error) {
|
||
size := m.Size()
|
||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||
}
|
||
|
||
func (m *EventBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||
i := len(dAtA)
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
return len(dAtA) - i, nil
|
||
}
|
||
|
||
func (m *EventBlockAdd) Marshal() (dAtA []byte, err error) {
|
||
size := m.Size()
|
||
dAtA = make([]byte, size)
|
||
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return dAtA[:n], nil
|
||
}
|
||
|
||
func (m *EventBlockAdd) MarshalTo(dAtA []byte) (int, error) {
|
||
size := m.Size()
|
||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||
}
|
||
|
||
func (m *EventBlockAdd) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||
i := len(dAtA)
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
if len(m.ContextId) > 0 {
|
||
i -= len(m.ContextId)
|
||
copy(dAtA[i:], m.ContextId)
|
||
i = encodeVarintEvents(dAtA, i, uint64(len(m.ContextId)))
|
||
i--
|
||
dAtA[i] = 0x12
|
||
}
|
||
if len(m.Blocks) > 0 {
|
||
for iNdEx := len(m.Blocks) - 1; iNdEx >= 0; iNdEx-- {
|
||
{
|
||
size, err := m.Blocks[iNdEx].MarshalToSizedBuffer(dAtA[:i])
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
i -= size
|
||
i = encodeVarintEvents(dAtA, i, uint64(size))
|
||
}
|
||
i--
|
||
dAtA[i] = 0xa
|
||
}
|
||
}
|
||
return len(dAtA) - i, nil
|
||
}
|
||
|
||
func (m *EventBlockShowFullscreen) Marshal() (dAtA []byte, err error) {
|
||
size := m.Size()
|
||
dAtA = make([]byte, size)
|
||
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return dAtA[:n], nil
|
||
}
|
||
|
||
func (m *EventBlockShowFullscreen) MarshalTo(dAtA []byte) (int, error) {
|
||
size := m.Size()
|
||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||
}
|
||
|
||
func (m *EventBlockShowFullscreen) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||
i := len(dAtA)
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
if len(m.ContextId) > 0 {
|
||
i -= len(m.ContextId)
|
||
copy(dAtA[i:], m.ContextId)
|
||
i = encodeVarintEvents(dAtA, i, uint64(len(m.ContextId)))
|
||
i--
|
||
dAtA[i] = 0x1a
|
||
}
|
||
if len(m.Blocks) > 0 {
|
||
for iNdEx := len(m.Blocks) - 1; iNdEx >= 0; iNdEx-- {
|
||
{
|
||
size, err := m.Blocks[iNdEx].MarshalToSizedBuffer(dAtA[:i])
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
i -= size
|
||
i = encodeVarintEvents(dAtA, i, uint64(size))
|
||
}
|
||
i--
|
||
dAtA[i] = 0x12
|
||
}
|
||
}
|
||
if len(m.RootId) > 0 {
|
||
i -= len(m.RootId)
|
||
copy(dAtA[i:], m.RootId)
|
||
i = encodeVarintEvents(dAtA, i, uint64(len(m.RootId)))
|
||
i--
|
||
dAtA[i] = 0xa
|
||
}
|
||
return len(dAtA) - i, nil
|
||
}
|
||
|
||
func (m *EventBlockUpdate) Marshal() (dAtA []byte, err error) {
|
||
size := m.Size()
|
||
dAtA = make([]byte, size)
|
||
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return dAtA[:n], nil
|
||
}
|
||
|
||
func (m *EventBlockUpdate) MarshalTo(dAtA []byte) (int, error) {
|
||
size := m.Size()
|
||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||
}
|
||
|
||
func (m *EventBlockUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||
i := len(dAtA)
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
if len(m.ContextId) > 0 {
|
||
i -= len(m.ContextId)
|
||
copy(dAtA[i:], m.ContextId)
|
||
i = encodeVarintEvents(dAtA, i, uint64(len(m.ContextId)))
|
||
i--
|
||
dAtA[i] = 0x12
|
||
}
|
||
if m.Changes != nil {
|
||
{
|
||
size, err := m.Changes.MarshalToSizedBuffer(dAtA[:i])
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
i -= size
|
||
i = encodeVarintEvents(dAtA, i, uint64(size))
|
||
}
|
||
i--
|
||
dAtA[i] = 0xa
|
||
}
|
||
return len(dAtA) - i, nil
|
||
}
|
||
|
||
func (m *EventBlockFilesUpload) Marshal() (dAtA []byte, err error) {
|
||
size := m.Size()
|
||
dAtA = make([]byte, size)
|
||
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return dAtA[:n], nil
|
||
}
|
||
|
||
func (m *EventBlockFilesUpload) MarshalTo(dAtA []byte) (int, error) {
|
||
size := m.Size()
|
||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||
}
|
||
|
||
func (m *EventBlockFilesUpload) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||
i := len(dAtA)
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
if len(m.ContextId) > 0 {
|
||
i -= len(m.ContextId)
|
||
copy(dAtA[i:], m.ContextId)
|
||
i = encodeVarintEvents(dAtA, i, uint64(len(m.ContextId)))
|
||
i--
|
||
dAtA[i] = 0x1a
|
||
}
|
||
if len(m.BlockId) > 0 {
|
||
i -= len(m.BlockId)
|
||
copy(dAtA[i:], m.BlockId)
|
||
i = encodeVarintEvents(dAtA, i, uint64(len(m.BlockId)))
|
||
i--
|
||
dAtA[i] = 0x12
|
||
}
|
||
if len(m.FilePath) > 0 {
|
||
for iNdEx := len(m.FilePath) - 1; iNdEx >= 0; iNdEx-- {
|
||
i -= len(m.FilePath[iNdEx])
|
||
copy(dAtA[i:], m.FilePath[iNdEx])
|
||
i = encodeVarintEvents(dAtA, i, uint64(len(m.FilePath[iNdEx])))
|
||
i--
|
||
dAtA[i] = 0xa
|
||
}
|
||
}
|
||
return len(dAtA) - i, nil
|
||
}
|
||
|
||
func (m *EventBlockDelete) Marshal() (dAtA []byte, err error) {
|
||
size := m.Size()
|
||
dAtA = make([]byte, size)
|
||
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return dAtA[:n], nil
|
||
}
|
||
|
||
func (m *EventBlockDelete) MarshalTo(dAtA []byte) (int, error) {
|
||
size := m.Size()
|
||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||
}
|
||
|
||
func (m *EventBlockDelete) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||
i := len(dAtA)
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
if len(m.ContextId) > 0 {
|
||
i -= len(m.ContextId)
|
||
copy(dAtA[i:], m.ContextId)
|
||
i = encodeVarintEvents(dAtA, i, uint64(len(m.ContextId)))
|
||
i--
|
||
dAtA[i] = 0x12
|
||
}
|
||
if len(m.BlockId) > 0 {
|
||
i -= len(m.BlockId)
|
||
copy(dAtA[i:], m.BlockId)
|
||
i = encodeVarintEvents(dAtA, i, uint64(len(m.BlockId)))
|
||
i--
|
||
dAtA[i] = 0xa
|
||
}
|
||
return len(dAtA) - i, nil
|
||
}
|
||
|
||
func (m *EventUser) Marshal() (dAtA []byte, err error) {
|
||
size := m.Size()
|
||
dAtA = make([]byte, size)
|
||
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return dAtA[:n], nil
|
||
}
|
||
|
||
func (m *EventUser) MarshalTo(dAtA []byte) (int, error) {
|
||
size := m.Size()
|
||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||
}
|
||
|
||
func (m *EventUser) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||
i := len(dAtA)
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
return len(dAtA) - i, nil
|
||
}
|
||
|
||
func (m *EventUserBlock) Marshal() (dAtA []byte, err error) {
|
||
size := m.Size()
|
||
dAtA = make([]byte, size)
|
||
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return dAtA[:n], nil
|
||
}
|
||
|
||
func (m *EventUserBlock) MarshalTo(dAtA []byte) (int, error) {
|
||
size := m.Size()
|
||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||
}
|
||
|
||
func (m *EventUserBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||
i := len(dAtA)
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
return len(dAtA) - i, nil
|
||
}
|
||
|
||
func (m *EventUserBlockJoin) Marshal() (dAtA []byte, err error) {
|
||
size := m.Size()
|
||
dAtA = make([]byte, size)
|
||
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return dAtA[:n], nil
|
||
}
|
||
|
||
func (m *EventUserBlockJoin) MarshalTo(dAtA []byte) (int, error) {
|
||
size := m.Size()
|
||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||
}
|
||
|
||
func (m *EventUserBlockJoin) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||
i := len(dAtA)
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
if len(m.ContextId) > 0 {
|
||
i -= len(m.ContextId)
|
||
copy(dAtA[i:], m.ContextId)
|
||
i = encodeVarintEvents(dAtA, i, uint64(len(m.ContextId)))
|
||
i--
|
||
dAtA[i] = 0x12
|
||
}
|
||
if m.Account != nil {
|
||
{
|
||
size, err := m.Account.MarshalToSizedBuffer(dAtA[:i])
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
i -= size
|
||
i = encodeVarintEvents(dAtA, i, uint64(size))
|
||
}
|
||
i--
|
||
dAtA[i] = 0xa
|
||
}
|
||
return len(dAtA) - i, nil
|
||
}
|
||
|
||
func (m *EventUserBlockLeft) Marshal() (dAtA []byte, err error) {
|
||
size := m.Size()
|
||
dAtA = make([]byte, size)
|
||
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return dAtA[:n], nil
|
||
}
|
||
|
||
func (m *EventUserBlockLeft) MarshalTo(dAtA []byte) (int, error) {
|
||
size := m.Size()
|
||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||
}
|
||
|
||
func (m *EventUserBlockLeft) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||
i := len(dAtA)
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
if len(m.ContextId) > 0 {
|
||
i -= len(m.ContextId)
|
||
copy(dAtA[i:], m.ContextId)
|
||
i = encodeVarintEvents(dAtA, i, uint64(len(m.ContextId)))
|
||
i--
|
||
dAtA[i] = 0x12
|
||
}
|
||
if m.Account != nil {
|
||
{
|
||
size, err := m.Account.MarshalToSizedBuffer(dAtA[:i])
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
i -= size
|
||
i = encodeVarintEvents(dAtA, i, uint64(size))
|
||
}
|
||
i--
|
||
dAtA[i] = 0xa
|
||
}
|
||
return len(dAtA) - i, nil
|
||
}
|
||
|
||
func (m *EventUserBlockTextRange) Marshal() (dAtA []byte, err error) {
|
||
size := m.Size()
|
||
dAtA = make([]byte, size)
|
||
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return dAtA[:n], nil
|
||
}
|
||
|
||
func (m *EventUserBlockTextRange) MarshalTo(dAtA []byte) (int, error) {
|
||
size := m.Size()
|
||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||
}
|
||
|
||
func (m *EventUserBlockTextRange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||
i := len(dAtA)
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
if len(m.ContextId) > 0 {
|
||
i -= len(m.ContextId)
|
||
copy(dAtA[i:], m.ContextId)
|
||
i = encodeVarintEvents(dAtA, i, uint64(len(m.ContextId)))
|
||
i--
|
||
dAtA[i] = 0x22
|
||
}
|
||
if m.Range != nil {
|
||
{
|
||
size, err := m.Range.MarshalToSizedBuffer(dAtA[:i])
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
i -= size
|
||
i = encodeVarintEvents(dAtA, i, uint64(size))
|
||
}
|
||
i--
|
||
dAtA[i] = 0x1a
|
||
}
|
||
if len(m.BlockId) > 0 {
|
||
i -= len(m.BlockId)
|
||
copy(dAtA[i:], m.BlockId)
|
||
i = encodeVarintEvents(dAtA, i, uint64(len(m.BlockId)))
|
||
i--
|
||
dAtA[i] = 0x12
|
||
}
|
||
if m.Account != nil {
|
||
{
|
||
size, err := m.Account.MarshalToSizedBuffer(dAtA[:i])
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
i -= size
|
||
i = encodeVarintEvents(dAtA, i, uint64(size))
|
||
}
|
||
i--
|
||
dAtA[i] = 0xa
|
||
}
|
||
return len(dAtA) - i, nil
|
||
}
|
||
|
||
func (m *EventUserBlockSelectRange) Marshal() (dAtA []byte, err error) {
|
||
size := m.Size()
|
||
dAtA = make([]byte, size)
|
||
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return dAtA[:n], nil
|
||
}
|
||
|
||
func (m *EventUserBlockSelectRange) MarshalTo(dAtA []byte) (int, error) {
|
||
size := m.Size()
|
||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||
}
|
||
|
||
func (m *EventUserBlockSelectRange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||
i := len(dAtA)
|
||
_ = i
|
||
var l int
|
||
_ = l
|
||
if len(m.ContextId) > 0 {
|
||
i -= len(m.ContextId)
|
||
copy(dAtA[i:], m.ContextId)
|
||
i = encodeVarintEvents(dAtA, i, uint64(len(m.ContextId)))
|
||
i--
|
||
dAtA[i] = 0x1a
|
||
}
|
||
if len(m.BlockIdsArray) > 0 {
|
||
for iNdEx := len(m.BlockIdsArray) - 1; iNdEx >= 0; iNdEx-- {
|
||
i -= len(m.BlockIdsArray[iNdEx])
|
||
copy(dAtA[i:], m.BlockIdsArray[iNdEx])
|
||
i = encodeVarintEvents(dAtA, i, uint64(len(m.BlockIdsArray[iNdEx])))
|
||
i--
|
||
dAtA[i] = 0x12
|
||
}
|
||
}
|
||
if m.Account != nil {
|
||
{
|
||
size, err := m.Account.MarshalToSizedBuffer(dAtA[:i])
|
||
if err != nil {
|
||
return 0, err
|
||
}
|
||
i -= size
|
||
i = encodeVarintEvents(dAtA, i, uint64(size))
|
||
}
|
||
i--
|
||
dAtA[i] = 0xa
|
||
}
|
||
return len(dAtA) - i, nil
|
||
}
|
||
|
||
func encodeVarintEvents(dAtA []byte, offset int, v uint64) int {
|
||
offset -= sovEvents(v)
|
||
base := offset
|
||
for v >= 1<<7 {
|
||
dAtA[offset] = uint8(v&0x7f | 0x80)
|
||
v >>= 7
|
||
offset++
|
||
}
|
||
dAtA[offset] = uint8(v)
|
||
return base
|
||
}
|
||
func (m *Event) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if m.Message != nil {
|
||
n += m.Message.Size()
|
||
}
|
||
return n
|
||
}
|
||
|
||
func (m *EventMessageOfAccountShow) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if m.AccountShow != nil {
|
||
l = m.AccountShow.Size()
|
||
n += 1 + l + sovEvents(uint64(l))
|
||
}
|
||
return n
|
||
}
|
||
func (m *EventMessageOfBlockAdd) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if m.BlockAdd != nil {
|
||
l = m.BlockAdd.Size()
|
||
n += 1 + l + sovEvents(uint64(l))
|
||
}
|
||
return n
|
||
}
|
||
func (m *EventMessageOfBlockShowFullscreen) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if m.BlockShowFullscreen != nil {
|
||
l = m.BlockShowFullscreen.Size()
|
||
n += 1 + l + sovEvents(uint64(l))
|
||
}
|
||
return n
|
||
}
|
||
func (m *EventMessageOfBlockUpdate) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if m.BlockUpdate != nil {
|
||
l = m.BlockUpdate.Size()
|
||
n += 1 + l + sovEvents(uint64(l))
|
||
}
|
||
return n
|
||
}
|
||
func (m *EventMessageOfBlockDelete) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if m.BlockDelete != nil {
|
||
l = m.BlockDelete.Size()
|
||
n += 1 + l + sovEvents(uint64(l))
|
||
}
|
||
return n
|
||
}
|
||
func (m *EventMessageOfUserBlockTextRange) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if m.UserBlockTextRange != nil {
|
||
l = m.UserBlockTextRange.Size()
|
||
n += 1 + l + sovEvents(uint64(l))
|
||
}
|
||
return n
|
||
}
|
||
func (m *EventMessageOfUserBlockJoin) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if m.UserBlockJoin != nil {
|
||
l = m.UserBlockJoin.Size()
|
||
n += 1 + l + sovEvents(uint64(l))
|
||
}
|
||
return n
|
||
}
|
||
func (m *EventMessageOfUserBlockLeft) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if m.UserBlockLeft != nil {
|
||
l = m.UserBlockLeft.Size()
|
||
n += 1 + l + sovEvents(uint64(l))
|
||
}
|
||
return n
|
||
}
|
||
func (m *EventMessageOfUserBlockSelectRange) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if m.UserBlockSelectRange != nil {
|
||
l = m.UserBlockSelectRange.Size()
|
||
n += 1 + l + sovEvents(uint64(l))
|
||
}
|
||
return n
|
||
}
|
||
func (m *EventMessageOfFilesUpload) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if m.FilesUpload != nil {
|
||
l = m.FilesUpload.Size()
|
||
n += 1 + l + sovEvents(uint64(l))
|
||
}
|
||
return n
|
||
}
|
||
func (m *EventAccount) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
return n
|
||
}
|
||
|
||
func (m *EventAccountShow) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if m.Index != 0 {
|
||
n += 1 + sovEvents(uint64(m.Index))
|
||
}
|
||
if m.Account != nil {
|
||
l = m.Account.Size()
|
||
n += 1 + l + sovEvents(uint64(l))
|
||
}
|
||
return n
|
||
}
|
||
|
||
func (m *EventBlock) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
return n
|
||
}
|
||
|
||
func (m *EventBlockAdd) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if len(m.Blocks) > 0 {
|
||
for _, e := range m.Blocks {
|
||
l = e.Size()
|
||
n += 1 + l + sovEvents(uint64(l))
|
||
}
|
||
}
|
||
l = len(m.ContextId)
|
||
if l > 0 {
|
||
n += 1 + l + sovEvents(uint64(l))
|
||
}
|
||
return n
|
||
}
|
||
|
||
func (m *EventBlockShowFullscreen) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
l = len(m.RootId)
|
||
if l > 0 {
|
||
n += 1 + l + sovEvents(uint64(l))
|
||
}
|
||
if len(m.Blocks) > 0 {
|
||
for _, e := range m.Blocks {
|
||
l = e.Size()
|
||
n += 1 + l + sovEvents(uint64(l))
|
||
}
|
||
}
|
||
l = len(m.ContextId)
|
||
if l > 0 {
|
||
n += 1 + l + sovEvents(uint64(l))
|
||
}
|
||
return n
|
||
}
|
||
|
||
func (m *EventBlockUpdate) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if m.Changes != nil {
|
||
l = m.Changes.Size()
|
||
n += 1 + l + sovEvents(uint64(l))
|
||
}
|
||
l = len(m.ContextId)
|
||
if l > 0 {
|
||
n += 1 + l + sovEvents(uint64(l))
|
||
}
|
||
return n
|
||
}
|
||
|
||
func (m *EventBlockFilesUpload) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if len(m.FilePath) > 0 {
|
||
for _, s := range m.FilePath {
|
||
l = len(s)
|
||
n += 1 + l + sovEvents(uint64(l))
|
||
}
|
||
}
|
||
l = len(m.BlockId)
|
||
if l > 0 {
|
||
n += 1 + l + sovEvents(uint64(l))
|
||
}
|
||
l = len(m.ContextId)
|
||
if l > 0 {
|
||
n += 1 + l + sovEvents(uint64(l))
|
||
}
|
||
return n
|
||
}
|
||
|
||
func (m *EventBlockDelete) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
l = len(m.BlockId)
|
||
if l > 0 {
|
||
n += 1 + l + sovEvents(uint64(l))
|
||
}
|
||
l = len(m.ContextId)
|
||
if l > 0 {
|
||
n += 1 + l + sovEvents(uint64(l))
|
||
}
|
||
return n
|
||
}
|
||
|
||
func (m *EventUser) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
return n
|
||
}
|
||
|
||
func (m *EventUserBlock) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
return n
|
||
}
|
||
|
||
func (m *EventUserBlockJoin) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if m.Account != nil {
|
||
l = m.Account.Size()
|
||
n += 1 + l + sovEvents(uint64(l))
|
||
}
|
||
l = len(m.ContextId)
|
||
if l > 0 {
|
||
n += 1 + l + sovEvents(uint64(l))
|
||
}
|
||
return n
|
||
}
|
||
|
||
func (m *EventUserBlockLeft) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if m.Account != nil {
|
||
l = m.Account.Size()
|
||
n += 1 + l + sovEvents(uint64(l))
|
||
}
|
||
l = len(m.ContextId)
|
||
if l > 0 {
|
||
n += 1 + l + sovEvents(uint64(l))
|
||
}
|
||
return n
|
||
}
|
||
|
||
func (m *EventUserBlockTextRange) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if m.Account != nil {
|
||
l = m.Account.Size()
|
||
n += 1 + l + sovEvents(uint64(l))
|
||
}
|
||
l = len(m.BlockId)
|
||
if l > 0 {
|
||
n += 1 + l + sovEvents(uint64(l))
|
||
}
|
||
if m.Range != nil {
|
||
l = m.Range.Size()
|
||
n += 1 + l + sovEvents(uint64(l))
|
||
}
|
||
l = len(m.ContextId)
|
||
if l > 0 {
|
||
n += 1 + l + sovEvents(uint64(l))
|
||
}
|
||
return n
|
||
}
|
||
|
||
func (m *EventUserBlockSelectRange) Size() (n int) {
|
||
if m == nil {
|
||
return 0
|
||
}
|
||
var l int
|
||
_ = l
|
||
if m.Account != nil {
|
||
l = m.Account.Size()
|
||
n += 1 + l + sovEvents(uint64(l))
|
||
}
|
||
if len(m.BlockIdsArray) > 0 {
|
||
for _, s := range m.BlockIdsArray {
|
||
l = len(s)
|
||
n += 1 + l + sovEvents(uint64(l))
|
||
}
|
||
}
|
||
l = len(m.ContextId)
|
||
if l > 0 {
|
||
n += 1 + l + sovEvents(uint64(l))
|
||
}
|
||
return n
|
||
}
|
||
|
||
func sovEvents(x uint64) (n int) {
|
||
return (math_bits.Len64(x|1) + 6) / 7
|
||
}
|
||
func sozEvents(x uint64) (n int) {
|
||
return sovEvents(uint64((x << 1) ^ uint64((int64(x) >> 63))))
|
||
}
|
||
func (m *Event) 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 ErrIntOverflowEvents
|
||
}
|
||
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: Event: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: Event: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
case 1:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field AccountShow", wireType)
|
||
}
|
||
var msglen int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowEvents
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
msglen |= int(b&0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
if msglen < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
postIndex := iNdEx + msglen
|
||
if postIndex < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
v := &EventAccountShow{}
|
||
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||
return err
|
||
}
|
||
m.Message = &EventMessageOfAccountShow{v}
|
||
iNdEx = postIndex
|
||
case 2:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field BlockAdd", wireType)
|
||
}
|
||
var msglen int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowEvents
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
msglen |= int(b&0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
if msglen < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
postIndex := iNdEx + msglen
|
||
if postIndex < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
v := &EventBlockAdd{}
|
||
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||
return err
|
||
}
|
||
m.Message = &EventMessageOfBlockAdd{v}
|
||
iNdEx = postIndex
|
||
case 3:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field BlockShowFullscreen", wireType)
|
||
}
|
||
var msglen int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowEvents
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
msglen |= int(b&0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
if msglen < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
postIndex := iNdEx + msglen
|
||
if postIndex < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
v := &EventBlockShowFullscreen{}
|
||
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||
return err
|
||
}
|
||
m.Message = &EventMessageOfBlockShowFullscreen{v}
|
||
iNdEx = postIndex
|
||
case 4:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field BlockUpdate", wireType)
|
||
}
|
||
var msglen int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowEvents
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
msglen |= int(b&0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
if msglen < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
postIndex := iNdEx + msglen
|
||
if postIndex < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
v := &EventBlockUpdate{}
|
||
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||
return err
|
||
}
|
||
m.Message = &EventMessageOfBlockUpdate{v}
|
||
iNdEx = postIndex
|
||
case 5:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field BlockDelete", wireType)
|
||
}
|
||
var msglen int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowEvents
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
msglen |= int(b&0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
if msglen < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
postIndex := iNdEx + msglen
|
||
if postIndex < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
v := &EventBlockDelete{}
|
||
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||
return err
|
||
}
|
||
m.Message = &EventMessageOfBlockDelete{v}
|
||
iNdEx = postIndex
|
||
case 6:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field UserBlockTextRange", wireType)
|
||
}
|
||
var msglen int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowEvents
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
msglen |= int(b&0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
if msglen < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
postIndex := iNdEx + msglen
|
||
if postIndex < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
v := &EventUserBlockTextRange{}
|
||
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||
return err
|
||
}
|
||
m.Message = &EventMessageOfUserBlockTextRange{v}
|
||
iNdEx = postIndex
|
||
case 7:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field UserBlockJoin", wireType)
|
||
}
|
||
var msglen int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowEvents
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
msglen |= int(b&0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
if msglen < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
postIndex := iNdEx + msglen
|
||
if postIndex < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
v := &EventUserBlockJoin{}
|
||
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||
return err
|
||
}
|
||
m.Message = &EventMessageOfUserBlockJoin{v}
|
||
iNdEx = postIndex
|
||
case 8:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field UserBlockLeft", wireType)
|
||
}
|
||
var msglen int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowEvents
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
msglen |= int(b&0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
if msglen < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
postIndex := iNdEx + msglen
|
||
if postIndex < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
v := &EventUserBlockLeft{}
|
||
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||
return err
|
||
}
|
||
m.Message = &EventMessageOfUserBlockLeft{v}
|
||
iNdEx = postIndex
|
||
case 9:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field UserBlockSelectRange", wireType)
|
||
}
|
||
var msglen int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowEvents
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
msglen |= int(b&0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
if msglen < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
postIndex := iNdEx + msglen
|
||
if postIndex < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
v := &EventUserBlockSelectRange{}
|
||
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||
return err
|
||
}
|
||
m.Message = &EventMessageOfUserBlockSelectRange{v}
|
||
iNdEx = postIndex
|
||
case 10:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field FilesUpload", wireType)
|
||
}
|
||
var msglen int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowEvents
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
msglen |= int(b&0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
if msglen < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
postIndex := iNdEx + msglen
|
||
if postIndex < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
v := &EventBlockFilesUpload{}
|
||
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||
return err
|
||
}
|
||
m.Message = &EventMessageOfFilesUpload{v}
|
||
iNdEx = postIndex
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipEvents(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if (iNdEx + skippy) < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if (iNdEx + skippy) > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
iNdEx += skippy
|
||
}
|
||
}
|
||
|
||
if iNdEx > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
return nil
|
||
}
|
||
func (m *EventAccount) 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 ErrIntOverflowEvents
|
||
}
|
||
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: Account: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: Account: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipEvents(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if (iNdEx + skippy) < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if (iNdEx + skippy) > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
iNdEx += skippy
|
||
}
|
||
}
|
||
|
||
if iNdEx > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
return nil
|
||
}
|
||
func (m *EventAccountShow) 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 ErrIntOverflowEvents
|
||
}
|
||
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: Show: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: Show: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
case 1:
|
||
if wireType != 0 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
|
||
}
|
||
m.Index = 0
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowEvents
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
m.Index |= int64(b&0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
case 2:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Account", wireType)
|
||
}
|
||
var msglen int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowEvents
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
msglen |= int(b&0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
if msglen < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
postIndex := iNdEx + msglen
|
||
if postIndex < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
if m.Account == nil {
|
||
m.Account = &ModelAccount{}
|
||
}
|
||
if err := m.Account.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||
return err
|
||
}
|
||
iNdEx = postIndex
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipEvents(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if (iNdEx + skippy) < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if (iNdEx + skippy) > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
iNdEx += skippy
|
||
}
|
||
}
|
||
|
||
if iNdEx > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
return nil
|
||
}
|
||
func (m *EventBlock) 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 ErrIntOverflowEvents
|
||
}
|
||
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: Block: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: Block: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipEvents(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if (iNdEx + skippy) < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if (iNdEx + skippy) > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
iNdEx += skippy
|
||
}
|
||
}
|
||
|
||
if iNdEx > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
return nil
|
||
}
|
||
func (m *EventBlockAdd) 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 ErrIntOverflowEvents
|
||
}
|
||
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: Add: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: Add: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
case 1:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Blocks", wireType)
|
||
}
|
||
var msglen int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowEvents
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
msglen |= int(b&0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
if msglen < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
postIndex := iNdEx + msglen
|
||
if postIndex < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
m.Blocks = append(m.Blocks, &ModelBlock{})
|
||
if err := m.Blocks[len(m.Blocks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||
return err
|
||
}
|
||
iNdEx = postIndex
|
||
case 2:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
|
||
}
|
||
var stringLen uint64
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowEvents
|
||
}
|
||
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 ErrInvalidLengthEvents
|
||
}
|
||
postIndex := iNdEx + intStringLen
|
||
if postIndex < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
m.ContextId = string(dAtA[iNdEx:postIndex])
|
||
iNdEx = postIndex
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipEvents(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if (iNdEx + skippy) < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if (iNdEx + skippy) > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
iNdEx += skippy
|
||
}
|
||
}
|
||
|
||
if iNdEx > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
return nil
|
||
}
|
||
func (m *EventBlockShowFullscreen) 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 ErrIntOverflowEvents
|
||
}
|
||
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: ShowFullscreen: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: ShowFullscreen: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
case 1:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field RootId", wireType)
|
||
}
|
||
var stringLen uint64
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowEvents
|
||
}
|
||
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 ErrInvalidLengthEvents
|
||
}
|
||
postIndex := iNdEx + intStringLen
|
||
if postIndex < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
m.RootId = string(dAtA[iNdEx:postIndex])
|
||
iNdEx = postIndex
|
||
case 2:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Blocks", wireType)
|
||
}
|
||
var msglen int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowEvents
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
msglen |= int(b&0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
if msglen < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
postIndex := iNdEx + msglen
|
||
if postIndex < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
m.Blocks = append(m.Blocks, &ModelBlock{})
|
||
if err := m.Blocks[len(m.Blocks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||
return err
|
||
}
|
||
iNdEx = postIndex
|
||
case 3:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
|
||
}
|
||
var stringLen uint64
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowEvents
|
||
}
|
||
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 ErrInvalidLengthEvents
|
||
}
|
||
postIndex := iNdEx + intStringLen
|
||
if postIndex < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
m.ContextId = string(dAtA[iNdEx:postIndex])
|
||
iNdEx = postIndex
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipEvents(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if (iNdEx + skippy) < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if (iNdEx + skippy) > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
iNdEx += skippy
|
||
}
|
||
}
|
||
|
||
if iNdEx > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
return nil
|
||
}
|
||
func (m *EventBlockUpdate) 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 ErrIntOverflowEvents
|
||
}
|
||
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: Update: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: Update: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
case 1:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Changes", wireType)
|
||
}
|
||
var msglen int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowEvents
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
msglen |= int(b&0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
if msglen < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
postIndex := iNdEx + msglen
|
||
if postIndex < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
if m.Changes == nil {
|
||
m.Changes = &ChangeMultipleBlocksList{}
|
||
}
|
||
if err := m.Changes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||
return err
|
||
}
|
||
iNdEx = postIndex
|
||
case 2:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
|
||
}
|
||
var stringLen uint64
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowEvents
|
||
}
|
||
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 ErrInvalidLengthEvents
|
||
}
|
||
postIndex := iNdEx + intStringLen
|
||
if postIndex < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
m.ContextId = string(dAtA[iNdEx:postIndex])
|
||
iNdEx = postIndex
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipEvents(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if (iNdEx + skippy) < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if (iNdEx + skippy) > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
iNdEx += skippy
|
||
}
|
||
}
|
||
|
||
if iNdEx > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
return nil
|
||
}
|
||
func (m *EventBlockFilesUpload) 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 ErrIntOverflowEvents
|
||
}
|
||
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: FilesUpload: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: FilesUpload: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
case 1:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field FilePath", wireType)
|
||
}
|
||
var stringLen uint64
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowEvents
|
||
}
|
||
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 ErrInvalidLengthEvents
|
||
}
|
||
postIndex := iNdEx + intStringLen
|
||
if postIndex < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
m.FilePath = append(m.FilePath, string(dAtA[iNdEx:postIndex]))
|
||
iNdEx = postIndex
|
||
case 2:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
|
||
}
|
||
var stringLen uint64
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowEvents
|
||
}
|
||
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 ErrInvalidLengthEvents
|
||
}
|
||
postIndex := iNdEx + intStringLen
|
||
if postIndex < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
m.BlockId = string(dAtA[iNdEx:postIndex])
|
||
iNdEx = postIndex
|
||
case 3:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
|
||
}
|
||
var stringLen uint64
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowEvents
|
||
}
|
||
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 ErrInvalidLengthEvents
|
||
}
|
||
postIndex := iNdEx + intStringLen
|
||
if postIndex < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
m.ContextId = string(dAtA[iNdEx:postIndex])
|
||
iNdEx = postIndex
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipEvents(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if (iNdEx + skippy) < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if (iNdEx + skippy) > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
iNdEx += skippy
|
||
}
|
||
}
|
||
|
||
if iNdEx > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
return nil
|
||
}
|
||
func (m *EventBlockDelete) 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 ErrIntOverflowEvents
|
||
}
|
||
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: Delete: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: Delete: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
case 1:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
|
||
}
|
||
var stringLen uint64
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowEvents
|
||
}
|
||
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 ErrInvalidLengthEvents
|
||
}
|
||
postIndex := iNdEx + intStringLen
|
||
if postIndex < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
m.BlockId = string(dAtA[iNdEx:postIndex])
|
||
iNdEx = postIndex
|
||
case 2:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
|
||
}
|
||
var stringLen uint64
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowEvents
|
||
}
|
||
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 ErrInvalidLengthEvents
|
||
}
|
||
postIndex := iNdEx + intStringLen
|
||
if postIndex < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
m.ContextId = string(dAtA[iNdEx:postIndex])
|
||
iNdEx = postIndex
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipEvents(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if (iNdEx + skippy) < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if (iNdEx + skippy) > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
iNdEx += skippy
|
||
}
|
||
}
|
||
|
||
if iNdEx > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
return nil
|
||
}
|
||
func (m *EventUser) 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 ErrIntOverflowEvents
|
||
}
|
||
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: User: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: User: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipEvents(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if (iNdEx + skippy) < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if (iNdEx + skippy) > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
iNdEx += skippy
|
||
}
|
||
}
|
||
|
||
if iNdEx > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
return nil
|
||
}
|
||
func (m *EventUserBlock) 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 ErrIntOverflowEvents
|
||
}
|
||
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: Block: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: Block: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipEvents(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if (iNdEx + skippy) < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if (iNdEx + skippy) > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
iNdEx += skippy
|
||
}
|
||
}
|
||
|
||
if iNdEx > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
return nil
|
||
}
|
||
func (m *EventUserBlockJoin) 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 ErrIntOverflowEvents
|
||
}
|
||
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: Join: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: Join: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
case 1:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Account", wireType)
|
||
}
|
||
var msglen int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowEvents
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
msglen |= int(b&0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
if msglen < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
postIndex := iNdEx + msglen
|
||
if postIndex < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
if m.Account == nil {
|
||
m.Account = &EventAccount{}
|
||
}
|
||
if err := m.Account.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||
return err
|
||
}
|
||
iNdEx = postIndex
|
||
case 2:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
|
||
}
|
||
var stringLen uint64
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowEvents
|
||
}
|
||
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 ErrInvalidLengthEvents
|
||
}
|
||
postIndex := iNdEx + intStringLen
|
||
if postIndex < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
m.ContextId = string(dAtA[iNdEx:postIndex])
|
||
iNdEx = postIndex
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipEvents(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if (iNdEx + skippy) < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if (iNdEx + skippy) > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
iNdEx += skippy
|
||
}
|
||
}
|
||
|
||
if iNdEx > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
return nil
|
||
}
|
||
func (m *EventUserBlockLeft) 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 ErrIntOverflowEvents
|
||
}
|
||
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: Left: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: Left: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
case 1:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Account", wireType)
|
||
}
|
||
var msglen int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowEvents
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
msglen |= int(b&0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
if msglen < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
postIndex := iNdEx + msglen
|
||
if postIndex < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
if m.Account == nil {
|
||
m.Account = &EventAccount{}
|
||
}
|
||
if err := m.Account.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||
return err
|
||
}
|
||
iNdEx = postIndex
|
||
case 2:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
|
||
}
|
||
var stringLen uint64
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowEvents
|
||
}
|
||
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 ErrInvalidLengthEvents
|
||
}
|
||
postIndex := iNdEx + intStringLen
|
||
if postIndex < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
m.ContextId = string(dAtA[iNdEx:postIndex])
|
||
iNdEx = postIndex
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipEvents(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if (iNdEx + skippy) < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if (iNdEx + skippy) > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
iNdEx += skippy
|
||
}
|
||
}
|
||
|
||
if iNdEx > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
return nil
|
||
}
|
||
func (m *EventUserBlockTextRange) 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 ErrIntOverflowEvents
|
||
}
|
||
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: TextRange: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: TextRange: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
case 1:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Account", wireType)
|
||
}
|
||
var msglen int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowEvents
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
msglen |= int(b&0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
if msglen < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
postIndex := iNdEx + msglen
|
||
if postIndex < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
if m.Account == nil {
|
||
m.Account = &EventAccount{}
|
||
}
|
||
if err := m.Account.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||
return err
|
||
}
|
||
iNdEx = postIndex
|
||
case 2:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field BlockId", wireType)
|
||
}
|
||
var stringLen uint64
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowEvents
|
||
}
|
||
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 ErrInvalidLengthEvents
|
||
}
|
||
postIndex := iNdEx + intStringLen
|
||
if postIndex < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
m.BlockId = string(dAtA[iNdEx:postIndex])
|
||
iNdEx = postIndex
|
||
case 3:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Range", wireType)
|
||
}
|
||
var msglen int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowEvents
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
msglen |= int(b&0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
if msglen < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
postIndex := iNdEx + msglen
|
||
if postIndex < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
if m.Range == nil {
|
||
m.Range = &ModelRange{}
|
||
}
|
||
if err := m.Range.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||
return err
|
||
}
|
||
iNdEx = postIndex
|
||
case 4:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
|
||
}
|
||
var stringLen uint64
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowEvents
|
||
}
|
||
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 ErrInvalidLengthEvents
|
||
}
|
||
postIndex := iNdEx + intStringLen
|
||
if postIndex < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
m.ContextId = string(dAtA[iNdEx:postIndex])
|
||
iNdEx = postIndex
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipEvents(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if (iNdEx + skippy) < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if (iNdEx + skippy) > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
iNdEx += skippy
|
||
}
|
||
}
|
||
|
||
if iNdEx > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
return nil
|
||
}
|
||
func (m *EventUserBlockSelectRange) 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 ErrIntOverflowEvents
|
||
}
|
||
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: SelectRange: wiretype end group for non-group")
|
||
}
|
||
if fieldNum <= 0 {
|
||
return fmt.Errorf("proto: SelectRange: illegal tag %d (wire type %d)", fieldNum, wire)
|
||
}
|
||
switch fieldNum {
|
||
case 1:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field Account", wireType)
|
||
}
|
||
var msglen int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowEvents
|
||
}
|
||
if iNdEx >= l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
msglen |= int(b&0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
if msglen < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
postIndex := iNdEx + msglen
|
||
if postIndex < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
if m.Account == nil {
|
||
m.Account = &EventAccount{}
|
||
}
|
||
if err := m.Account.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||
return err
|
||
}
|
||
iNdEx = postIndex
|
||
case 2:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field BlockIdsArray", wireType)
|
||
}
|
||
var stringLen uint64
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowEvents
|
||
}
|
||
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 ErrInvalidLengthEvents
|
||
}
|
||
postIndex := iNdEx + intStringLen
|
||
if postIndex < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
m.BlockIdsArray = append(m.BlockIdsArray, string(dAtA[iNdEx:postIndex]))
|
||
iNdEx = postIndex
|
||
case 3:
|
||
if wireType != 2 {
|
||
return fmt.Errorf("proto: wrong wireType = %d for field ContextId", wireType)
|
||
}
|
||
var stringLen uint64
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return ErrIntOverflowEvents
|
||
}
|
||
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 ErrInvalidLengthEvents
|
||
}
|
||
postIndex := iNdEx + intStringLen
|
||
if postIndex < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if postIndex > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
m.ContextId = string(dAtA[iNdEx:postIndex])
|
||
iNdEx = postIndex
|
||
default:
|
||
iNdEx = preIndex
|
||
skippy, err := skipEvents(dAtA[iNdEx:])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if skippy < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if (iNdEx + skippy) < 0 {
|
||
return ErrInvalidLengthEvents
|
||
}
|
||
if (iNdEx + skippy) > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
iNdEx += skippy
|
||
}
|
||
}
|
||
|
||
if iNdEx > l {
|
||
return io.ErrUnexpectedEOF
|
||
}
|
||
return nil
|
||
}
|
||
func skipEvents(dAtA []byte) (n int, err error) {
|
||
l := len(dAtA)
|
||
iNdEx := 0
|
||
depth := 0
|
||
for iNdEx < l {
|
||
var wire uint64
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return 0, ErrIntOverflowEvents
|
||
}
|
||
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, ErrIntOverflowEvents
|
||
}
|
||
if iNdEx >= l {
|
||
return 0, io.ErrUnexpectedEOF
|
||
}
|
||
iNdEx++
|
||
if dAtA[iNdEx-1] < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
case 1:
|
||
iNdEx += 8
|
||
case 2:
|
||
var length int
|
||
for shift := uint(0); ; shift += 7 {
|
||
if shift >= 64 {
|
||
return 0, ErrIntOverflowEvents
|
||
}
|
||
if iNdEx >= l {
|
||
return 0, io.ErrUnexpectedEOF
|
||
}
|
||
b := dAtA[iNdEx]
|
||
iNdEx++
|
||
length |= (int(b) & 0x7F) << shift
|
||
if b < 0x80 {
|
||
break
|
||
}
|
||
}
|
||
if length < 0 {
|
||
return 0, ErrInvalidLengthEvents
|
||
}
|
||
iNdEx += length
|
||
case 3:
|
||
depth++
|
||
case 4:
|
||
if depth == 0 {
|
||
return 0, ErrUnexpectedEndOfGroupEvents
|
||
}
|
||
depth--
|
||
case 5:
|
||
iNdEx += 4
|
||
default:
|
||
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
|
||
}
|
||
if iNdEx < 0 {
|
||
return 0, ErrInvalidLengthEvents
|
||
}
|
||
if depth == 0 {
|
||
return iNdEx, nil
|
||
}
|
||
}
|
||
return 0, io.ErrUnexpectedEOF
|
||
}
|
||
|
||
var (
|
||
ErrInvalidLengthEvents = fmt.Errorf("proto: negative length found during unmarshaling")
|
||
ErrIntOverflowEvents = fmt.Errorf("proto: integer overflow")
|
||
ErrUnexpectedEndOfGroupEvents = fmt.Errorf("proto: unexpected end of group")
|
||
)
|