mirror of
https://github.com/anyproto/anytype-heart.git
synced 2025-06-11 02:13:41 +09:00
9494 lines
222 KiB
Go
9494 lines
222 KiB
Go
// Code generated by protoc-gen-gogo. DO NOT EDIT.
|
|
// source: block.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
|
|
|
|
type BlockType int32
|
|
|
|
const (
|
|
BlockType_DASHBOARD BlockType = 0
|
|
BlockType_PAGE BlockType = 1
|
|
BlockType_DATAVIEW BlockType = 2
|
|
BlockType_TEXT BlockType = 3
|
|
BlockType_FILE BlockType = 4
|
|
BlockType_PICTURE BlockType = 5
|
|
BlockType_VIDEO BlockType = 6
|
|
)
|
|
|
|
var BlockType_name = map[int32]string{
|
|
0: "DASHBOARD",
|
|
1: "PAGE",
|
|
2: "DATAVIEW",
|
|
3: "TEXT",
|
|
4: "FILE",
|
|
5: "PICTURE",
|
|
6: "VIDEO",
|
|
}
|
|
|
|
var BlockType_value = map[string]int32{
|
|
"DASHBOARD": 0,
|
|
"PAGE": 1,
|
|
"DATAVIEW": 2,
|
|
"TEXT": 3,
|
|
"FILE": 4,
|
|
"PICTURE": 5,
|
|
"VIDEO": 6,
|
|
}
|
|
|
|
func (x BlockType) String() string {
|
|
return proto.EnumName(BlockType_name, int32(x))
|
|
}
|
|
|
|
func (BlockType) EnumDescriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{0}
|
|
}
|
|
|
|
type BlockOpenResponse_Error_Code int32
|
|
|
|
const (
|
|
BlockOpenResponse_Error_NULL BlockOpenResponse_Error_Code = 0
|
|
BlockOpenResponse_Error_UNKNOWN_ERROR BlockOpenResponse_Error_Code = 1
|
|
BlockOpenResponse_Error_BAD_INPUT BlockOpenResponse_Error_Code = 2
|
|
)
|
|
|
|
var BlockOpenResponse_Error_Code_name = map[int32]string{
|
|
0: "NULL",
|
|
1: "UNKNOWN_ERROR",
|
|
2: "BAD_INPUT",
|
|
}
|
|
|
|
var BlockOpenResponse_Error_Code_value = map[string]int32{
|
|
"NULL": 0,
|
|
"UNKNOWN_ERROR": 1,
|
|
"BAD_INPUT": 2,
|
|
}
|
|
|
|
func (x BlockOpenResponse_Error_Code) String() string {
|
|
return proto.EnumName(BlockOpenResponse_Error_Code_name, int32(x))
|
|
}
|
|
|
|
func (BlockOpenResponse_Error_Code) EnumDescriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{1, 0, 0}
|
|
}
|
|
|
|
type BlockCreateResponse_Error_Code int32
|
|
|
|
const (
|
|
BlockCreateResponse_Error_NULL BlockCreateResponse_Error_Code = 0
|
|
BlockCreateResponse_Error_UNKNOWN_ERROR BlockCreateResponse_Error_Code = 1
|
|
BlockCreateResponse_Error_BAD_INPUT BlockCreateResponse_Error_Code = 2
|
|
)
|
|
|
|
var BlockCreateResponse_Error_Code_name = map[int32]string{
|
|
0: "NULL",
|
|
1: "UNKNOWN_ERROR",
|
|
2: "BAD_INPUT",
|
|
}
|
|
|
|
var BlockCreateResponse_Error_Code_value = map[string]int32{
|
|
"NULL": 0,
|
|
"UNKNOWN_ERROR": 1,
|
|
"BAD_INPUT": 2,
|
|
}
|
|
|
|
func (x BlockCreateResponse_Error_Code) String() string {
|
|
return proto.EnumName(BlockCreateResponse_Error_Code_name, int32(x))
|
|
}
|
|
|
|
func (BlockCreateResponse_Error_Code) EnumDescriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{3, 0, 0}
|
|
}
|
|
|
|
type BlockUpdateResponse_Error_Code int32
|
|
|
|
const (
|
|
BlockUpdateResponse_Error_NULL BlockUpdateResponse_Error_Code = 0
|
|
BlockUpdateResponse_Error_UNKNOWN_ERROR BlockUpdateResponse_Error_Code = 1
|
|
BlockUpdateResponse_Error_BAD_INPUT BlockUpdateResponse_Error_Code = 2
|
|
)
|
|
|
|
var BlockUpdateResponse_Error_Code_name = map[int32]string{
|
|
0: "NULL",
|
|
1: "UNKNOWN_ERROR",
|
|
2: "BAD_INPUT",
|
|
}
|
|
|
|
var BlockUpdateResponse_Error_Code_value = map[string]int32{
|
|
"NULL": 0,
|
|
"UNKNOWN_ERROR": 1,
|
|
"BAD_INPUT": 2,
|
|
}
|
|
|
|
func (x BlockUpdateResponse_Error_Code) String() string {
|
|
return proto.EnumName(BlockUpdateResponse_Error_Code_name, int32(x))
|
|
}
|
|
|
|
func (BlockUpdateResponse_Error_Code) EnumDescriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{5, 0, 0}
|
|
}
|
|
|
|
type BlockContentPage_Style int32
|
|
|
|
const (
|
|
BlockContentPage_EMPTY BlockContentPage_Style = 0
|
|
BlockContentPage_TASK BlockContentPage_Style = 1
|
|
BlockContentPage_BOOKMARK BlockContentPage_Style = 2
|
|
BlockContentPage_SET BlockContentPage_Style = 3
|
|
)
|
|
|
|
var BlockContentPage_Style_name = map[int32]string{
|
|
0: "EMPTY",
|
|
1: "TASK",
|
|
2: "BOOKMARK",
|
|
3: "SET",
|
|
}
|
|
|
|
var BlockContentPage_Style_value = map[string]int32{
|
|
"EMPTY": 0,
|
|
"TASK": 1,
|
|
"BOOKMARK": 2,
|
|
"SET": 3,
|
|
}
|
|
|
|
func (x BlockContentPage_Style) String() string {
|
|
return proto.EnumName(BlockContentPage_Style_name, int32(x))
|
|
}
|
|
|
|
func (BlockContentPage_Style) EnumDescriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{22, 0}
|
|
}
|
|
|
|
type BlockContentDashboard_Style int32
|
|
|
|
const (
|
|
BlockContentDashboard_MAIN_SCREEN BlockContentDashboard_Style = 0
|
|
)
|
|
|
|
var BlockContentDashboard_Style_name = map[int32]string{
|
|
0: "MAIN_SCREEN",
|
|
}
|
|
|
|
var BlockContentDashboard_Style_value = map[string]int32{
|
|
"MAIN_SCREEN": 0,
|
|
}
|
|
|
|
func (x BlockContentDashboard_Style) String() string {
|
|
return proto.EnumName(BlockContentDashboard_Style_name, int32(x))
|
|
}
|
|
|
|
func (BlockContentDashboard_Style) EnumDescriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{23, 0}
|
|
}
|
|
|
|
type BlockContentText_Style int32
|
|
|
|
const (
|
|
BlockContentText_p BlockContentText_Style = 0
|
|
BlockContentText_h1 BlockContentText_Style = 1
|
|
BlockContentText_h2 BlockContentText_Style = 2
|
|
BlockContentText_h3 BlockContentText_Style = 3
|
|
BlockContentText_h4 BlockContentText_Style = 4
|
|
BlockContentText_quote BlockContentText_Style = 5
|
|
)
|
|
|
|
var BlockContentText_Style_name = map[int32]string{
|
|
0: "p",
|
|
1: "h1",
|
|
2: "h2",
|
|
3: "h3",
|
|
4: "h4",
|
|
5: "quote",
|
|
}
|
|
|
|
var BlockContentText_Style_value = map[string]int32{
|
|
"p": 0,
|
|
"h1": 1,
|
|
"h2": 2,
|
|
"h3": 3,
|
|
"h4": 4,
|
|
"quote": 5,
|
|
}
|
|
|
|
func (x BlockContentText_Style) String() string {
|
|
return proto.EnumName(BlockContentText_Style_name, int32(x))
|
|
}
|
|
|
|
func (BlockContentText_Style) EnumDescriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{25, 0}
|
|
}
|
|
|
|
type BlockContentText_MarkerType int32
|
|
|
|
const (
|
|
BlockContentText_none BlockContentText_MarkerType = 0
|
|
BlockContentText_number BlockContentText_MarkerType = 1
|
|
BlockContentText_bullet BlockContentText_MarkerType = 2
|
|
)
|
|
|
|
var BlockContentText_MarkerType_name = map[int32]string{
|
|
0: "none",
|
|
1: "number",
|
|
2: "bullet",
|
|
}
|
|
|
|
var BlockContentText_MarkerType_value = map[string]int32{
|
|
"none": 0,
|
|
"number": 1,
|
|
"bullet": 2,
|
|
}
|
|
|
|
func (x BlockContentText_MarkerType) String() string {
|
|
return proto.EnumName(BlockContentText_MarkerType_name, int32(x))
|
|
}
|
|
|
|
func (BlockContentText_MarkerType) EnumDescriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{25, 1}
|
|
}
|
|
|
|
type BlockContentText_Mark_Type int32
|
|
|
|
const (
|
|
BlockContentText_Mark_STRIKETHROUGH BlockContentText_Mark_Type = 0
|
|
BlockContentText_Mark_KEYBOARD BlockContentText_Mark_Type = 1
|
|
BlockContentText_Mark_ITALIC BlockContentText_Mark_Type = 2
|
|
BlockContentText_Mark_BOLD BlockContentText_Mark_Type = 3
|
|
BlockContentText_Mark_LINK BlockContentText_Mark_Type = 4
|
|
)
|
|
|
|
var BlockContentText_Mark_Type_name = map[int32]string{
|
|
0: "STRIKETHROUGH",
|
|
1: "KEYBOARD",
|
|
2: "ITALIC",
|
|
3: "BOLD",
|
|
4: "LINK",
|
|
}
|
|
|
|
var BlockContentText_Mark_Type_value = map[string]int32{
|
|
"STRIKETHROUGH": 0,
|
|
"KEYBOARD": 1,
|
|
"ITALIC": 2,
|
|
"BOLD": 3,
|
|
"LINK": 4,
|
|
}
|
|
|
|
func (x BlockContentText_Mark_Type) String() string {
|
|
return proto.EnumName(BlockContentText_Mark_Type_name, int32(x))
|
|
}
|
|
|
|
func (BlockContentText_Mark_Type) EnumDescriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{25, 1, 0}
|
|
}
|
|
|
|
// commands
|
|
//
|
|
type BlockOpenRequest struct {
|
|
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
|
|
}
|
|
|
|
func (m *BlockOpenRequest) Reset() { *m = BlockOpenRequest{} }
|
|
func (m *BlockOpenRequest) String() string { return proto.CompactTextString(m) }
|
|
func (*BlockOpenRequest) ProtoMessage() {}
|
|
func (*BlockOpenRequest) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{0}
|
|
}
|
|
func (m *BlockOpenRequest) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *BlockOpenRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_BlockOpenRequest.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 *BlockOpenRequest) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_BlockOpenRequest.Merge(m, src)
|
|
}
|
|
func (m *BlockOpenRequest) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *BlockOpenRequest) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_BlockOpenRequest.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_BlockOpenRequest proto.InternalMessageInfo
|
|
|
|
func (m *BlockOpenRequest) GetId() string {
|
|
if m != nil {
|
|
return m.Id
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type BlockOpenResponse struct {
|
|
Error *BlockOpenResponse_Error `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
|
|
BlockHeader *BlockHeader `protobuf:"bytes,2,opt,name=blockHeader,proto3" json:"blockHeader,omitempty"`
|
|
}
|
|
|
|
func (m *BlockOpenResponse) Reset() { *m = BlockOpenResponse{} }
|
|
func (m *BlockOpenResponse) String() string { return proto.CompactTextString(m) }
|
|
func (*BlockOpenResponse) ProtoMessage() {}
|
|
func (*BlockOpenResponse) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{1}
|
|
}
|
|
func (m *BlockOpenResponse) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *BlockOpenResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_BlockOpenResponse.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 *BlockOpenResponse) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_BlockOpenResponse.Merge(m, src)
|
|
}
|
|
func (m *BlockOpenResponse) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *BlockOpenResponse) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_BlockOpenResponse.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_BlockOpenResponse proto.InternalMessageInfo
|
|
|
|
func (m *BlockOpenResponse) GetError() *BlockOpenResponse_Error {
|
|
if m != nil {
|
|
return m.Error
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *BlockOpenResponse) GetBlockHeader() *BlockHeader {
|
|
if m != nil {
|
|
return m.BlockHeader
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type BlockOpenResponse_Error struct {
|
|
Code BlockOpenResponse_Error_Code `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.BlockOpenResponse_Error_Code" json:"code,omitempty"`
|
|
Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
|
|
}
|
|
|
|
func (m *BlockOpenResponse_Error) Reset() { *m = BlockOpenResponse_Error{} }
|
|
func (m *BlockOpenResponse_Error) String() string { return proto.CompactTextString(m) }
|
|
func (*BlockOpenResponse_Error) ProtoMessage() {}
|
|
func (*BlockOpenResponse_Error) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{1, 0}
|
|
}
|
|
func (m *BlockOpenResponse_Error) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *BlockOpenResponse_Error) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_BlockOpenResponse_Error.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 *BlockOpenResponse_Error) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_BlockOpenResponse_Error.Merge(m, src)
|
|
}
|
|
func (m *BlockOpenResponse_Error) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *BlockOpenResponse_Error) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_BlockOpenResponse_Error.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_BlockOpenResponse_Error proto.InternalMessageInfo
|
|
|
|
func (m *BlockOpenResponse_Error) GetCode() BlockOpenResponse_Error_Code {
|
|
if m != nil {
|
|
return m.Code
|
|
}
|
|
return BlockOpenResponse_Error_NULL
|
|
}
|
|
|
|
func (m *BlockOpenResponse_Error) GetDescription() string {
|
|
if m != nil {
|
|
return m.Description
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type BlockCreateRequest struct {
|
|
Type BlockType `protobuf:"varint,1,opt,name=type,proto3,enum=anytype.BlockType" json:"type,omitempty"`
|
|
}
|
|
|
|
func (m *BlockCreateRequest) Reset() { *m = BlockCreateRequest{} }
|
|
func (m *BlockCreateRequest) String() string { return proto.CompactTextString(m) }
|
|
func (*BlockCreateRequest) ProtoMessage() {}
|
|
func (*BlockCreateRequest) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{2}
|
|
}
|
|
func (m *BlockCreateRequest) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *BlockCreateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_BlockCreateRequest.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 *BlockCreateRequest) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_BlockCreateRequest.Merge(m, src)
|
|
}
|
|
func (m *BlockCreateRequest) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *BlockCreateRequest) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_BlockCreateRequest.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_BlockCreateRequest proto.InternalMessageInfo
|
|
|
|
func (m *BlockCreateRequest) GetType() BlockType {
|
|
if m != nil {
|
|
return m.Type
|
|
}
|
|
return BlockType_DASHBOARD
|
|
}
|
|
|
|
type BlockCreateResponse struct {
|
|
Error *BlockCreateResponse_Error `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
|
|
}
|
|
|
|
func (m *BlockCreateResponse) Reset() { *m = BlockCreateResponse{} }
|
|
func (m *BlockCreateResponse) String() string { return proto.CompactTextString(m) }
|
|
func (*BlockCreateResponse) ProtoMessage() {}
|
|
func (*BlockCreateResponse) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{3}
|
|
}
|
|
func (m *BlockCreateResponse) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *BlockCreateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_BlockCreateResponse.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 *BlockCreateResponse) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_BlockCreateResponse.Merge(m, src)
|
|
}
|
|
func (m *BlockCreateResponse) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *BlockCreateResponse) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_BlockCreateResponse.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_BlockCreateResponse proto.InternalMessageInfo
|
|
|
|
func (m *BlockCreateResponse) GetError() *BlockCreateResponse_Error {
|
|
if m != nil {
|
|
return m.Error
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type BlockCreateResponse_Error struct {
|
|
Code BlockCreateResponse_Error_Code `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.BlockCreateResponse_Error_Code" json:"code,omitempty"`
|
|
Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
|
|
}
|
|
|
|
func (m *BlockCreateResponse_Error) Reset() { *m = BlockCreateResponse_Error{} }
|
|
func (m *BlockCreateResponse_Error) String() string { return proto.CompactTextString(m) }
|
|
func (*BlockCreateResponse_Error) ProtoMessage() {}
|
|
func (*BlockCreateResponse_Error) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{3, 0}
|
|
}
|
|
func (m *BlockCreateResponse_Error) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *BlockCreateResponse_Error) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_BlockCreateResponse_Error.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 *BlockCreateResponse_Error) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_BlockCreateResponse_Error.Merge(m, src)
|
|
}
|
|
func (m *BlockCreateResponse_Error) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *BlockCreateResponse_Error) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_BlockCreateResponse_Error.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_BlockCreateResponse_Error proto.InternalMessageInfo
|
|
|
|
func (m *BlockCreateResponse_Error) GetCode() BlockCreateResponse_Error_Code {
|
|
if m != nil {
|
|
return m.Code
|
|
}
|
|
return BlockCreateResponse_Error_NULL
|
|
}
|
|
|
|
func (m *BlockCreateResponse_Error) GetDescription() string {
|
|
if m != nil {
|
|
return m.Description
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type BlockUpdateRequest struct {
|
|
Changes *BlockChanges `protobuf:"bytes,1,opt,name=changes,proto3" json:"changes,omitempty"`
|
|
}
|
|
|
|
func (m *BlockUpdateRequest) Reset() { *m = BlockUpdateRequest{} }
|
|
func (m *BlockUpdateRequest) String() string { return proto.CompactTextString(m) }
|
|
func (*BlockUpdateRequest) ProtoMessage() {}
|
|
func (*BlockUpdateRequest) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{4}
|
|
}
|
|
func (m *BlockUpdateRequest) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *BlockUpdateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_BlockUpdateRequest.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 *BlockUpdateRequest) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_BlockUpdateRequest.Merge(m, src)
|
|
}
|
|
func (m *BlockUpdateRequest) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *BlockUpdateRequest) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_BlockUpdateRequest.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_BlockUpdateRequest proto.InternalMessageInfo
|
|
|
|
func (m *BlockUpdateRequest) GetChanges() *BlockChanges {
|
|
if m != nil {
|
|
return m.Changes
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type BlockUpdateResponse struct {
|
|
Error *BlockUpdateResponse_Error `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
|
|
}
|
|
|
|
func (m *BlockUpdateResponse) Reset() { *m = BlockUpdateResponse{} }
|
|
func (m *BlockUpdateResponse) String() string { return proto.CompactTextString(m) }
|
|
func (*BlockUpdateResponse) ProtoMessage() {}
|
|
func (*BlockUpdateResponse) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{5}
|
|
}
|
|
func (m *BlockUpdateResponse) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *BlockUpdateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_BlockUpdateResponse.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 *BlockUpdateResponse) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_BlockUpdateResponse.Merge(m, src)
|
|
}
|
|
func (m *BlockUpdateResponse) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *BlockUpdateResponse) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_BlockUpdateResponse.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_BlockUpdateResponse proto.InternalMessageInfo
|
|
|
|
func (m *BlockUpdateResponse) GetError() *BlockUpdateResponse_Error {
|
|
if m != nil {
|
|
return m.Error
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type BlockUpdateResponse_Error struct {
|
|
Code BlockUpdateResponse_Error_Code `protobuf:"varint,1,opt,name=code,proto3,enum=anytype.BlockUpdateResponse_Error_Code" json:"code,omitempty"`
|
|
Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
|
|
}
|
|
|
|
func (m *BlockUpdateResponse_Error) Reset() { *m = BlockUpdateResponse_Error{} }
|
|
func (m *BlockUpdateResponse_Error) String() string { return proto.CompactTextString(m) }
|
|
func (*BlockUpdateResponse_Error) ProtoMessage() {}
|
|
func (*BlockUpdateResponse_Error) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{5, 0}
|
|
}
|
|
func (m *BlockUpdateResponse_Error) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *BlockUpdateResponse_Error) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_BlockUpdateResponse_Error.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 *BlockUpdateResponse_Error) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_BlockUpdateResponse_Error.Merge(m, src)
|
|
}
|
|
func (m *BlockUpdateResponse_Error) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *BlockUpdateResponse_Error) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_BlockUpdateResponse_Error.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_BlockUpdateResponse_Error proto.InternalMessageInfo
|
|
|
|
func (m *BlockUpdateResponse_Error) GetCode() BlockUpdateResponse_Error_Code {
|
|
if m != nil {
|
|
return m.Code
|
|
}
|
|
return BlockUpdateResponse_Error_NULL
|
|
}
|
|
|
|
func (m *BlockUpdateResponse_Error) GetDescription() string {
|
|
if m != nil {
|
|
return m.Description
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// call
|
|
type BlockShow struct {
|
|
Block *Block `protobuf:"bytes,1,opt,name=block,proto3" json:"block,omitempty"`
|
|
}
|
|
|
|
func (m *BlockShow) Reset() { *m = BlockShow{} }
|
|
func (m *BlockShow) String() string { return proto.CompactTextString(m) }
|
|
func (*BlockShow) ProtoMessage() {}
|
|
func (*BlockShow) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{6}
|
|
}
|
|
func (m *BlockShow) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *BlockShow) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_BlockShow.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 *BlockShow) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_BlockShow.Merge(m, src)
|
|
}
|
|
func (m *BlockShow) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *BlockShow) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_BlockShow.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_BlockShow proto.InternalMessageInfo
|
|
|
|
func (m *BlockShow) GetBlock() *Block {
|
|
if m != nil {
|
|
return m.Block
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type BlockUpdate struct {
|
|
Changes *BlockChanges `protobuf:"bytes,1,opt,name=changes,proto3" json:"changes,omitempty"`
|
|
}
|
|
|
|
func (m *BlockUpdate) Reset() { *m = BlockUpdate{} }
|
|
func (m *BlockUpdate) String() string { return proto.CompactTextString(m) }
|
|
func (*BlockUpdate) ProtoMessage() {}
|
|
func (*BlockUpdate) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{7}
|
|
}
|
|
func (m *BlockUpdate) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *BlockUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_BlockUpdate.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 *BlockUpdate) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_BlockUpdate.Merge(m, src)
|
|
}
|
|
func (m *BlockUpdate) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *BlockUpdate) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_BlockUpdate.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_BlockUpdate proto.InternalMessageInfo
|
|
|
|
func (m *BlockUpdate) GetChanges() *BlockChanges {
|
|
if m != nil {
|
|
return m.Changes
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type BlockCreate struct {
|
|
Block *Block `protobuf:"bytes,1,opt,name=block,proto3" json:"block,omitempty"`
|
|
}
|
|
|
|
func (m *BlockCreate) Reset() { *m = BlockCreate{} }
|
|
func (m *BlockCreate) String() string { return proto.CompactTextString(m) }
|
|
func (*BlockCreate) ProtoMessage() {}
|
|
func (*BlockCreate) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{8}
|
|
}
|
|
func (m *BlockCreate) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *BlockCreate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_BlockCreate.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 *BlockCreate) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_BlockCreate.Merge(m, src)
|
|
}
|
|
func (m *BlockCreate) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *BlockCreate) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_BlockCreate.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_BlockCreate proto.InternalMessageInfo
|
|
|
|
func (m *BlockCreate) GetBlock() *Block {
|
|
if m != nil {
|
|
return m.Block
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type BlockContentTextChange struct {
|
|
// Types that are valid to be assigned to Change:
|
|
// *BlockContentTextChange_Text
|
|
// *BlockContentTextChange_Style
|
|
// *BlockContentTextChange_Marks
|
|
// *BlockContentTextChange_Toggleable
|
|
// *BlockContentTextChange_MarkerType
|
|
// *BlockContentTextChange_Checkable
|
|
// *BlockContentTextChange_Checked
|
|
Change isBlockContentTextChange_Change `protobuf_oneof:"change"`
|
|
}
|
|
|
|
func (m *BlockContentTextChange) Reset() { *m = BlockContentTextChange{} }
|
|
func (m *BlockContentTextChange) String() string { return proto.CompactTextString(m) }
|
|
func (*BlockContentTextChange) ProtoMessage() {}
|
|
func (*BlockContentTextChange) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{9}
|
|
}
|
|
func (m *BlockContentTextChange) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *BlockContentTextChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_BlockContentTextChange.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 *BlockContentTextChange) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_BlockContentTextChange.Merge(m, src)
|
|
}
|
|
func (m *BlockContentTextChange) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *BlockContentTextChange) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_BlockContentTextChange.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_BlockContentTextChange proto.InternalMessageInfo
|
|
|
|
type isBlockContentTextChange_Change interface {
|
|
isBlockContentTextChange_Change()
|
|
MarshalTo([]byte) (int, error)
|
|
Size() int
|
|
}
|
|
|
|
type BlockContentTextChange_Text struct {
|
|
Text string `protobuf:"bytes,1,opt,name=text,proto3,oneof" json:"text,omitempty"`
|
|
}
|
|
type BlockContentTextChange_Style struct {
|
|
Style BlockContentText_Style `protobuf:"varint,2,opt,name=style,proto3,enum=anytype.BlockContentText_Style,oneof" json:"style,omitempty"`
|
|
}
|
|
type BlockContentTextChange_Marks struct {
|
|
Marks *BlockContentText_Marks `protobuf:"bytes,3,opt,name=marks,proto3,oneof" json:"marks,omitempty"`
|
|
}
|
|
type BlockContentTextChange_Toggleable struct {
|
|
Toggleable bool `protobuf:"varint,4,opt,name=toggleable,proto3,oneof" json:"toggleable,omitempty"`
|
|
}
|
|
type BlockContentTextChange_MarkerType struct {
|
|
MarkerType BlockContentText_MarkerType `protobuf:"varint,5,opt,name=markerType,proto3,enum=anytype.BlockContentText_MarkerType,oneof" json:"markerType,omitempty"`
|
|
}
|
|
type BlockContentTextChange_Checkable struct {
|
|
Checkable bool `protobuf:"varint,6,opt,name=checkable,proto3,oneof" json:"checkable,omitempty"`
|
|
}
|
|
type BlockContentTextChange_Checked struct {
|
|
Checked bool `protobuf:"varint,7,opt,name=checked,proto3,oneof" json:"checked,omitempty"`
|
|
}
|
|
|
|
func (*BlockContentTextChange_Text) isBlockContentTextChange_Change() {}
|
|
func (*BlockContentTextChange_Style) isBlockContentTextChange_Change() {}
|
|
func (*BlockContentTextChange_Marks) isBlockContentTextChange_Change() {}
|
|
func (*BlockContentTextChange_Toggleable) isBlockContentTextChange_Change() {}
|
|
func (*BlockContentTextChange_MarkerType) isBlockContentTextChange_Change() {}
|
|
func (*BlockContentTextChange_Checkable) isBlockContentTextChange_Change() {}
|
|
func (*BlockContentTextChange_Checked) isBlockContentTextChange_Change() {}
|
|
|
|
func (m *BlockContentTextChange) GetChange() isBlockContentTextChange_Change {
|
|
if m != nil {
|
|
return m.Change
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *BlockContentTextChange) GetText() string {
|
|
if x, ok := m.GetChange().(*BlockContentTextChange_Text); ok {
|
|
return x.Text
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *BlockContentTextChange) GetStyle() BlockContentText_Style {
|
|
if x, ok := m.GetChange().(*BlockContentTextChange_Style); ok {
|
|
return x.Style
|
|
}
|
|
return BlockContentText_p
|
|
}
|
|
|
|
func (m *BlockContentTextChange) GetMarks() *BlockContentText_Marks {
|
|
if x, ok := m.GetChange().(*BlockContentTextChange_Marks); ok {
|
|
return x.Marks
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *BlockContentTextChange) GetToggleable() bool {
|
|
if x, ok := m.GetChange().(*BlockContentTextChange_Toggleable); ok {
|
|
return x.Toggleable
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *BlockContentTextChange) GetMarkerType() BlockContentText_MarkerType {
|
|
if x, ok := m.GetChange().(*BlockContentTextChange_MarkerType); ok {
|
|
return x.MarkerType
|
|
}
|
|
return BlockContentText_none
|
|
}
|
|
|
|
func (m *BlockContentTextChange) GetCheckable() bool {
|
|
if x, ok := m.GetChange().(*BlockContentTextChange_Checkable); ok {
|
|
return x.Checkable
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *BlockContentTextChange) GetChecked() bool {
|
|
if x, ok := m.GetChange().(*BlockContentTextChange_Checked); ok {
|
|
return x.Checked
|
|
}
|
|
return false
|
|
}
|
|
|
|
// XXX_OneofWrappers is for the internal use of the proto package.
|
|
func (*BlockContentTextChange) XXX_OneofWrappers() []interface{} {
|
|
return []interface{}{
|
|
(*BlockContentTextChange_Text)(nil),
|
|
(*BlockContentTextChange_Style)(nil),
|
|
(*BlockContentTextChange_Marks)(nil),
|
|
(*BlockContentTextChange_Toggleable)(nil),
|
|
(*BlockContentTextChange_MarkerType)(nil),
|
|
(*BlockContentTextChange_Checkable)(nil),
|
|
(*BlockContentTextChange_Checked)(nil),
|
|
}
|
|
}
|
|
|
|
type BlockContentPageChange struct {
|
|
// Types that are valid to be assigned to Change:
|
|
// *BlockContentPageChange_Style
|
|
// *BlockContentPageChange_Structure
|
|
// *BlockContentPageChange_Blocks
|
|
Change isBlockContentPageChange_Change `protobuf_oneof:"change"`
|
|
}
|
|
|
|
func (m *BlockContentPageChange) Reset() { *m = BlockContentPageChange{} }
|
|
func (m *BlockContentPageChange) String() string { return proto.CompactTextString(m) }
|
|
func (*BlockContentPageChange) ProtoMessage() {}
|
|
func (*BlockContentPageChange) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{10}
|
|
}
|
|
func (m *BlockContentPageChange) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *BlockContentPageChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_BlockContentPageChange.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 *BlockContentPageChange) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_BlockContentPageChange.Merge(m, src)
|
|
}
|
|
func (m *BlockContentPageChange) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *BlockContentPageChange) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_BlockContentPageChange.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_BlockContentPageChange proto.InternalMessageInfo
|
|
|
|
type isBlockContentPageChange_Change interface {
|
|
isBlockContentPageChange_Change()
|
|
MarshalTo([]byte) (int, error)
|
|
Size() int
|
|
}
|
|
|
|
type BlockContentPageChange_Style struct {
|
|
Style BlockContentPage_Style `protobuf:"varint,1,opt,name=style,proto3,enum=anytype.BlockContentPage_Style,oneof" json:"style,omitempty"`
|
|
}
|
|
type BlockContentPageChange_Structure struct {
|
|
Structure *BlockConnectionsList `protobuf:"bytes,2,opt,name=structure,proto3,oneof" json:"structure,omitempty"`
|
|
}
|
|
type BlockContentPageChange_Blocks struct {
|
|
Blocks *BlocksList `protobuf:"bytes,3,opt,name=blocks,proto3,oneof" json:"blocks,omitempty"`
|
|
}
|
|
|
|
func (*BlockContentPageChange_Style) isBlockContentPageChange_Change() {}
|
|
func (*BlockContentPageChange_Structure) isBlockContentPageChange_Change() {}
|
|
func (*BlockContentPageChange_Blocks) isBlockContentPageChange_Change() {}
|
|
|
|
func (m *BlockContentPageChange) GetChange() isBlockContentPageChange_Change {
|
|
if m != nil {
|
|
return m.Change
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *BlockContentPageChange) GetStyle() BlockContentPage_Style {
|
|
if x, ok := m.GetChange().(*BlockContentPageChange_Style); ok {
|
|
return x.Style
|
|
}
|
|
return BlockContentPage_EMPTY
|
|
}
|
|
|
|
func (m *BlockContentPageChange) GetStructure() *BlockConnectionsList {
|
|
if x, ok := m.GetChange().(*BlockContentPageChange_Structure); ok {
|
|
return x.Structure
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *BlockContentPageChange) GetBlocks() *BlocksList {
|
|
if x, ok := m.GetChange().(*BlockContentPageChange_Blocks); ok {
|
|
return x.Blocks
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// XXX_OneofWrappers is for the internal use of the proto package.
|
|
func (*BlockContentPageChange) XXX_OneofWrappers() []interface{} {
|
|
return []interface{}{
|
|
(*BlockContentPageChange_Style)(nil),
|
|
(*BlockContentPageChange_Structure)(nil),
|
|
(*BlockContentPageChange_Blocks)(nil),
|
|
}
|
|
}
|
|
|
|
type BlockHeaderChange struct {
|
|
// Types that are valid to be assigned to Change:
|
|
// *BlockHeaderChange_Id
|
|
// *BlockHeaderChange_Type
|
|
// *BlockHeaderChange_Name
|
|
// *BlockHeaderChange_Icon
|
|
// *BlockHeaderChange_Permissions
|
|
Change isBlockHeaderChange_Change `protobuf_oneof:"change"`
|
|
}
|
|
|
|
func (m *BlockHeaderChange) Reset() { *m = BlockHeaderChange{} }
|
|
func (m *BlockHeaderChange) String() string { return proto.CompactTextString(m) }
|
|
func (*BlockHeaderChange) ProtoMessage() {}
|
|
func (*BlockHeaderChange) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{11}
|
|
}
|
|
func (m *BlockHeaderChange) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *BlockHeaderChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_BlockHeaderChange.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 *BlockHeaderChange) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_BlockHeaderChange.Merge(m, src)
|
|
}
|
|
func (m *BlockHeaderChange) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *BlockHeaderChange) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_BlockHeaderChange.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_BlockHeaderChange proto.InternalMessageInfo
|
|
|
|
type isBlockHeaderChange_Change interface {
|
|
isBlockHeaderChange_Change()
|
|
MarshalTo([]byte) (int, error)
|
|
Size() int
|
|
}
|
|
|
|
type BlockHeaderChange_Id struct {
|
|
Id string `protobuf:"bytes,1,opt,name=id,proto3,oneof" json:"id,omitempty"`
|
|
}
|
|
type BlockHeaderChange_Type struct {
|
|
Type BlockType `protobuf:"varint,2,opt,name=type,proto3,enum=anytype.BlockType,oneof" json:"type,omitempty"`
|
|
}
|
|
type BlockHeaderChange_Name struct {
|
|
Name string `protobuf:"bytes,3,opt,name=name,proto3,oneof" json:"name,omitempty"`
|
|
}
|
|
type BlockHeaderChange_Icon struct {
|
|
Icon string `protobuf:"bytes,4,opt,name=icon,proto3,oneof" json:"icon,omitempty"`
|
|
}
|
|
type BlockHeaderChange_Permissions struct {
|
|
Permissions *BlockPermissions `protobuf:"bytes,5,opt,name=permissions,proto3,oneof" json:"permissions,omitempty"`
|
|
}
|
|
|
|
func (*BlockHeaderChange_Id) isBlockHeaderChange_Change() {}
|
|
func (*BlockHeaderChange_Type) isBlockHeaderChange_Change() {}
|
|
func (*BlockHeaderChange_Name) isBlockHeaderChange_Change() {}
|
|
func (*BlockHeaderChange_Icon) isBlockHeaderChange_Change() {}
|
|
func (*BlockHeaderChange_Permissions) isBlockHeaderChange_Change() {}
|
|
|
|
func (m *BlockHeaderChange) GetChange() isBlockHeaderChange_Change {
|
|
if m != nil {
|
|
return m.Change
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *BlockHeaderChange) GetId() string {
|
|
if x, ok := m.GetChange().(*BlockHeaderChange_Id); ok {
|
|
return x.Id
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *BlockHeaderChange) GetType() BlockType {
|
|
if x, ok := m.GetChange().(*BlockHeaderChange_Type); ok {
|
|
return x.Type
|
|
}
|
|
return BlockType_DASHBOARD
|
|
}
|
|
|
|
func (m *BlockHeaderChange) GetName() string {
|
|
if x, ok := m.GetChange().(*BlockHeaderChange_Name); ok {
|
|
return x.Name
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *BlockHeaderChange) GetIcon() string {
|
|
if x, ok := m.GetChange().(*BlockHeaderChange_Icon); ok {
|
|
return x.Icon
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *BlockHeaderChange) GetPermissions() *BlockPermissions {
|
|
if x, ok := m.GetChange().(*BlockHeaderChange_Permissions); ok {
|
|
return x.Permissions
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// XXX_OneofWrappers is for the internal use of the proto package.
|
|
func (*BlockHeaderChange) XXX_OneofWrappers() []interface{} {
|
|
return []interface{}{
|
|
(*BlockHeaderChange_Id)(nil),
|
|
(*BlockHeaderChange_Type)(nil),
|
|
(*BlockHeaderChange_Name)(nil),
|
|
(*BlockHeaderChange_Icon)(nil),
|
|
(*BlockHeaderChange_Permissions)(nil),
|
|
}
|
|
}
|
|
|
|
type BlockContentDashboardChange struct {
|
|
// Types that are valid to be assigned to Change:
|
|
// *BlockContentDashboardChange_Style
|
|
// *BlockContentDashboardChange_Structure
|
|
// *BlockContentDashboardChange_Headers
|
|
Change isBlockContentDashboardChange_Change `protobuf_oneof:"change"`
|
|
}
|
|
|
|
func (m *BlockContentDashboardChange) Reset() { *m = BlockContentDashboardChange{} }
|
|
func (m *BlockContentDashboardChange) String() string { return proto.CompactTextString(m) }
|
|
func (*BlockContentDashboardChange) ProtoMessage() {}
|
|
func (*BlockContentDashboardChange) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{12}
|
|
}
|
|
func (m *BlockContentDashboardChange) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *BlockContentDashboardChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_BlockContentDashboardChange.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 *BlockContentDashboardChange) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_BlockContentDashboardChange.Merge(m, src)
|
|
}
|
|
func (m *BlockContentDashboardChange) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *BlockContentDashboardChange) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_BlockContentDashboardChange.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_BlockContentDashboardChange proto.InternalMessageInfo
|
|
|
|
type isBlockContentDashboardChange_Change interface {
|
|
isBlockContentDashboardChange_Change()
|
|
MarshalTo([]byte) (int, error)
|
|
Size() int
|
|
}
|
|
|
|
type BlockContentDashboardChange_Style struct {
|
|
Style BlockContentDashboard_Style `protobuf:"varint,1,opt,name=style,proto3,enum=anytype.BlockContentDashboard_Style,oneof" json:"style,omitempty"`
|
|
}
|
|
type BlockContentDashboardChange_Structure struct {
|
|
Structure *BlockConnectionsList `protobuf:"bytes,2,opt,name=structure,proto3,oneof" json:"structure,omitempty"`
|
|
}
|
|
type BlockContentDashboardChange_Headers struct {
|
|
Headers *BlockHeadersList `protobuf:"bytes,3,opt,name=headers,proto3,oneof" json:"headers,omitempty"`
|
|
}
|
|
|
|
func (*BlockContentDashboardChange_Style) isBlockContentDashboardChange_Change() {}
|
|
func (*BlockContentDashboardChange_Structure) isBlockContentDashboardChange_Change() {}
|
|
func (*BlockContentDashboardChange_Headers) isBlockContentDashboardChange_Change() {}
|
|
|
|
func (m *BlockContentDashboardChange) GetChange() isBlockContentDashboardChange_Change {
|
|
if m != nil {
|
|
return m.Change
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *BlockContentDashboardChange) GetStyle() BlockContentDashboard_Style {
|
|
if x, ok := m.GetChange().(*BlockContentDashboardChange_Style); ok {
|
|
return x.Style
|
|
}
|
|
return BlockContentDashboard_MAIN_SCREEN
|
|
}
|
|
|
|
func (m *BlockContentDashboardChange) GetStructure() *BlockConnectionsList {
|
|
if x, ok := m.GetChange().(*BlockContentDashboardChange_Structure); ok {
|
|
return x.Structure
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *BlockContentDashboardChange) GetHeaders() *BlockHeadersList {
|
|
if x, ok := m.GetChange().(*BlockContentDashboardChange_Headers); ok {
|
|
return x.Headers
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// XXX_OneofWrappers is for the internal use of the proto package.
|
|
func (*BlockContentDashboardChange) XXX_OneofWrappers() []interface{} {
|
|
return []interface{}{
|
|
(*BlockContentDashboardChange_Style)(nil),
|
|
(*BlockContentDashboardChange_Structure)(nil),
|
|
(*BlockContentDashboardChange_Headers)(nil),
|
|
}
|
|
}
|
|
|
|
type BlockAtomicChange struct {
|
|
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
|
|
// Types that are valid to be assigned to Change:
|
|
// *BlockAtomicChange_Text
|
|
// *BlockAtomicChange_BlockHeader
|
|
// *BlockAtomicChange_Page
|
|
// *BlockAtomicChange_Dashboard
|
|
Change isBlockAtomicChange_Change `protobuf_oneof:"change"`
|
|
}
|
|
|
|
func (m *BlockAtomicChange) Reset() { *m = BlockAtomicChange{} }
|
|
func (m *BlockAtomicChange) String() string { return proto.CompactTextString(m) }
|
|
func (*BlockAtomicChange) ProtoMessage() {}
|
|
func (*BlockAtomicChange) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{13}
|
|
}
|
|
func (m *BlockAtomicChange) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *BlockAtomicChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_BlockAtomicChange.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 *BlockAtomicChange) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_BlockAtomicChange.Merge(m, src)
|
|
}
|
|
func (m *BlockAtomicChange) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *BlockAtomicChange) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_BlockAtomicChange.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_BlockAtomicChange proto.InternalMessageInfo
|
|
|
|
type isBlockAtomicChange_Change interface {
|
|
isBlockAtomicChange_Change()
|
|
MarshalTo([]byte) (int, error)
|
|
Size() int
|
|
}
|
|
|
|
type BlockAtomicChange_Text struct {
|
|
Text *BlockContentTextChange `protobuf:"bytes,2,opt,name=text,proto3,oneof" json:"text,omitempty"`
|
|
}
|
|
type BlockAtomicChange_BlockHeader struct {
|
|
BlockHeader *BlockHeaderChange `protobuf:"bytes,3,opt,name=blockHeader,proto3,oneof" json:"blockHeader,omitempty"`
|
|
}
|
|
type BlockAtomicChange_Page struct {
|
|
Page *BlockContentPageChange `protobuf:"bytes,4,opt,name=page,proto3,oneof" json:"page,omitempty"`
|
|
}
|
|
type BlockAtomicChange_Dashboard struct {
|
|
Dashboard *BlockContentDashboardChange `protobuf:"bytes,5,opt,name=dashboard,proto3,oneof" json:"dashboard,omitempty"`
|
|
}
|
|
|
|
func (*BlockAtomicChange_Text) isBlockAtomicChange_Change() {}
|
|
func (*BlockAtomicChange_BlockHeader) isBlockAtomicChange_Change() {}
|
|
func (*BlockAtomicChange_Page) isBlockAtomicChange_Change() {}
|
|
func (*BlockAtomicChange_Dashboard) isBlockAtomicChange_Change() {}
|
|
|
|
func (m *BlockAtomicChange) GetChange() isBlockAtomicChange_Change {
|
|
if m != nil {
|
|
return m.Change
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *BlockAtomicChange) GetId() string {
|
|
if m != nil {
|
|
return m.Id
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *BlockAtomicChange) GetText() *BlockContentTextChange {
|
|
if x, ok := m.GetChange().(*BlockAtomicChange_Text); ok {
|
|
return x.Text
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *BlockAtomicChange) GetBlockHeader() *BlockHeaderChange {
|
|
if x, ok := m.GetChange().(*BlockAtomicChange_BlockHeader); ok {
|
|
return x.BlockHeader
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *BlockAtomicChange) GetPage() *BlockContentPageChange {
|
|
if x, ok := m.GetChange().(*BlockAtomicChange_Page); ok {
|
|
return x.Page
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *BlockAtomicChange) GetDashboard() *BlockContentDashboardChange {
|
|
if x, ok := m.GetChange().(*BlockAtomicChange_Dashboard); ok {
|
|
return x.Dashboard
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// XXX_OneofWrappers is for the internal use of the proto package.
|
|
func (*BlockAtomicChange) XXX_OneofWrappers() []interface{} {
|
|
return []interface{}{
|
|
(*BlockAtomicChange_Text)(nil),
|
|
(*BlockAtomicChange_BlockHeader)(nil),
|
|
(*BlockAtomicChange_Page)(nil),
|
|
(*BlockAtomicChange_Dashboard)(nil),
|
|
}
|
|
}
|
|
|
|
type BlockChanges struct {
|
|
Changes []*BlockAtomicChange `protobuf:"bytes,1,rep,name=changes,proto3" json:"changes,omitempty"`
|
|
}
|
|
|
|
func (m *BlockChanges) Reset() { *m = BlockChanges{} }
|
|
func (m *BlockChanges) String() string { return proto.CompactTextString(m) }
|
|
func (*BlockChanges) ProtoMessage() {}
|
|
func (*BlockChanges) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{14}
|
|
}
|
|
func (m *BlockChanges) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *BlockChanges) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_BlockChanges.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 *BlockChanges) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_BlockChanges.Merge(m, src)
|
|
}
|
|
func (m *BlockChanges) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *BlockChanges) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_BlockChanges.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_BlockChanges proto.InternalMessageInfo
|
|
|
|
func (m *BlockChanges) GetChanges() []*BlockAtomicChange {
|
|
if m != nil {
|
|
return m.Changes
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type Block struct {
|
|
Header *BlockHeader `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
|
|
// Types that are valid to be assigned to Content:
|
|
// *Block_Dashboard
|
|
// *Block_Page
|
|
// *Block_Dataview
|
|
// *Block_Text
|
|
// *Block_Media
|
|
Content isBlock_Content `protobuf_oneof:"content"`
|
|
}
|
|
|
|
func (m *Block) Reset() { *m = Block{} }
|
|
func (m *Block) String() string { return proto.CompactTextString(m) }
|
|
func (*Block) ProtoMessage() {}
|
|
func (*Block) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{15}
|
|
}
|
|
func (m *Block) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *Block) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_Block.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 *Block) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_Block.Merge(m, src)
|
|
}
|
|
func (m *Block) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *Block) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_Block.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_Block proto.InternalMessageInfo
|
|
|
|
type isBlock_Content interface {
|
|
isBlock_Content()
|
|
MarshalTo([]byte) (int, error)
|
|
Size() int
|
|
}
|
|
|
|
type Block_Dashboard struct {
|
|
Dashboard *BlockContentDashboard `protobuf:"bytes,11,opt,name=dashboard,proto3,oneof" json:"dashboard,omitempty"`
|
|
}
|
|
type Block_Page struct {
|
|
Page *BlockContentPage `protobuf:"bytes,12,opt,name=page,proto3,oneof" json:"page,omitempty"`
|
|
}
|
|
type Block_Dataview struct {
|
|
Dataview *BlockContentDataview `protobuf:"bytes,13,opt,name=dataview,proto3,oneof" json:"dataview,omitempty"`
|
|
}
|
|
type Block_Text struct {
|
|
Text *BlockContentText `protobuf:"bytes,14,opt,name=text,proto3,oneof" json:"text,omitempty"`
|
|
}
|
|
type Block_Media struct {
|
|
Media *BlockContentMedia `protobuf:"bytes,15,opt,name=media,proto3,oneof" json:"media,omitempty"`
|
|
}
|
|
|
|
func (*Block_Dashboard) isBlock_Content() {}
|
|
func (*Block_Page) isBlock_Content() {}
|
|
func (*Block_Dataview) isBlock_Content() {}
|
|
func (*Block_Text) isBlock_Content() {}
|
|
func (*Block_Media) isBlock_Content() {}
|
|
|
|
func (m *Block) GetContent() isBlock_Content {
|
|
if m != nil {
|
|
return m.Content
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Block) GetHeader() *BlockHeader {
|
|
if m != nil {
|
|
return m.Header
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Block) GetDashboard() *BlockContentDashboard {
|
|
if x, ok := m.GetContent().(*Block_Dashboard); ok {
|
|
return x.Dashboard
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Block) GetPage() *BlockContentPage {
|
|
if x, ok := m.GetContent().(*Block_Page); ok {
|
|
return x.Page
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Block) GetDataview() *BlockContentDataview {
|
|
if x, ok := m.GetContent().(*Block_Dataview); ok {
|
|
return x.Dataview
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Block) GetText() *BlockContentText {
|
|
if x, ok := m.GetContent().(*Block_Text); ok {
|
|
return x.Text
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *Block) GetMedia() *BlockContentMedia {
|
|
if x, ok := m.GetContent().(*Block_Media); ok {
|
|
return x.Media
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// XXX_OneofWrappers is for the internal use of the proto package.
|
|
func (*Block) XXX_OneofWrappers() []interface{} {
|
|
return []interface{}{
|
|
(*Block_Dashboard)(nil),
|
|
(*Block_Page)(nil),
|
|
(*Block_Dataview)(nil),
|
|
(*Block_Text)(nil),
|
|
(*Block_Media)(nil),
|
|
}
|
|
}
|
|
|
|
type BlockHeader struct {
|
|
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
|
|
Type BlockType `protobuf:"varint,2,opt,name=type,proto3,enum=anytype.BlockType" json:"type,omitempty"`
|
|
Fields *Struct `protobuf:"bytes,3,opt,name=fields,proto3" json:"fields,omitempty"`
|
|
Permissions *BlockPermissions `protobuf:"bytes,4,opt,name=permissions,proto3" json:"permissions,omitempty"`
|
|
}
|
|
|
|
func (m *BlockHeader) Reset() { *m = BlockHeader{} }
|
|
func (m *BlockHeader) String() string { return proto.CompactTextString(m) }
|
|
func (*BlockHeader) ProtoMessage() {}
|
|
func (*BlockHeader) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{16}
|
|
}
|
|
func (m *BlockHeader) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *BlockHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_BlockHeader.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 *BlockHeader) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_BlockHeader.Merge(m, src)
|
|
}
|
|
func (m *BlockHeader) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *BlockHeader) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_BlockHeader.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_BlockHeader proto.InternalMessageInfo
|
|
|
|
func (m *BlockHeader) GetId() string {
|
|
if m != nil {
|
|
return m.Id
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *BlockHeader) GetType() BlockType {
|
|
if m != nil {
|
|
return m.Type
|
|
}
|
|
return BlockType_DASHBOARD
|
|
}
|
|
|
|
func (m *BlockHeader) GetFields() *Struct {
|
|
if m != nil {
|
|
return m.Fields
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *BlockHeader) GetPermissions() *BlockPermissions {
|
|
if m != nil {
|
|
return m.Permissions
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type BlockPermissions struct {
|
|
Read bool `protobuf:"varint,1,opt,name=read,proto3" json:"read,omitempty"`
|
|
Edit bool `protobuf:"varint,2,opt,name=edit,proto3" json:"edit,omitempty"`
|
|
Remove bool `protobuf:"varint,3,opt,name=remove,proto3" json:"remove,omitempty"`
|
|
Drag bool `protobuf:"varint,4,opt,name=drag,proto3" json:"drag,omitempty"`
|
|
DropOn bool `protobuf:"varint,5,opt,name=dropOn,proto3" json:"dropOn,omitempty"`
|
|
}
|
|
|
|
func (m *BlockPermissions) Reset() { *m = BlockPermissions{} }
|
|
func (m *BlockPermissions) String() string { return proto.CompactTextString(m) }
|
|
func (*BlockPermissions) ProtoMessage() {}
|
|
func (*BlockPermissions) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{17}
|
|
}
|
|
func (m *BlockPermissions) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *BlockPermissions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_BlockPermissions.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 *BlockPermissions) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_BlockPermissions.Merge(m, src)
|
|
}
|
|
func (m *BlockPermissions) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *BlockPermissions) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_BlockPermissions.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_BlockPermissions proto.InternalMessageInfo
|
|
|
|
func (m *BlockPermissions) GetRead() bool {
|
|
if m != nil {
|
|
return m.Read
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *BlockPermissions) GetEdit() bool {
|
|
if m != nil {
|
|
return m.Edit
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *BlockPermissions) GetRemove() bool {
|
|
if m != nil {
|
|
return m.Remove
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *BlockPermissions) GetDrag() bool {
|
|
if m != nil {
|
|
return m.Drag
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *BlockPermissions) GetDropOn() bool {
|
|
if m != nil {
|
|
return m.DropOn
|
|
}
|
|
return false
|
|
}
|
|
|
|
type BlockConnections struct {
|
|
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
|
|
Next string `protobuf:"bytes,2,opt,name=next,proto3" json:"next,omitempty"`
|
|
ColumnBottom string `protobuf:"bytes,3,opt,name=columnBottom,proto3" json:"columnBottom,omitempty"`
|
|
RowRight string `protobuf:"bytes,4,opt,name=rowRight,proto3" json:"rowRight,omitempty"`
|
|
Inner string `protobuf:"bytes,5,opt,name=inner,proto3" json:"inner,omitempty"`
|
|
}
|
|
|
|
func (m *BlockConnections) Reset() { *m = BlockConnections{} }
|
|
func (m *BlockConnections) String() string { return proto.CompactTextString(m) }
|
|
func (*BlockConnections) ProtoMessage() {}
|
|
func (*BlockConnections) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{18}
|
|
}
|
|
func (m *BlockConnections) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *BlockConnections) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_BlockConnections.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 *BlockConnections) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_BlockConnections.Merge(m, src)
|
|
}
|
|
func (m *BlockConnections) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *BlockConnections) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_BlockConnections.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_BlockConnections proto.InternalMessageInfo
|
|
|
|
func (m *BlockConnections) GetId() string {
|
|
if m != nil {
|
|
return m.Id
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *BlockConnections) GetNext() string {
|
|
if m != nil {
|
|
return m.Next
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *BlockConnections) GetColumnBottom() string {
|
|
if m != nil {
|
|
return m.ColumnBottom
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *BlockConnections) GetRowRight() string {
|
|
if m != nil {
|
|
return m.RowRight
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *BlockConnections) GetInner() string {
|
|
if m != nil {
|
|
return m.Inner
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type BlockConnectionsList struct {
|
|
Structure []*BlockConnections `protobuf:"bytes,1,rep,name=structure,proto3" json:"structure,omitempty"`
|
|
}
|
|
|
|
func (m *BlockConnectionsList) Reset() { *m = BlockConnectionsList{} }
|
|
func (m *BlockConnectionsList) String() string { return proto.CompactTextString(m) }
|
|
func (*BlockConnectionsList) ProtoMessage() {}
|
|
func (*BlockConnectionsList) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{19}
|
|
}
|
|
func (m *BlockConnectionsList) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *BlockConnectionsList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_BlockConnectionsList.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 *BlockConnectionsList) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_BlockConnectionsList.Merge(m, src)
|
|
}
|
|
func (m *BlockConnectionsList) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *BlockConnectionsList) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_BlockConnectionsList.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_BlockConnectionsList proto.InternalMessageInfo
|
|
|
|
func (m *BlockConnectionsList) GetStructure() []*BlockConnections {
|
|
if m != nil {
|
|
return m.Structure
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type BlockHeadersList struct {
|
|
Headers []*BlockHeader `protobuf:"bytes,1,rep,name=headers,proto3" json:"headers,omitempty"`
|
|
}
|
|
|
|
func (m *BlockHeadersList) Reset() { *m = BlockHeadersList{} }
|
|
func (m *BlockHeadersList) String() string { return proto.CompactTextString(m) }
|
|
func (*BlockHeadersList) ProtoMessage() {}
|
|
func (*BlockHeadersList) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{20}
|
|
}
|
|
func (m *BlockHeadersList) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *BlockHeadersList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_BlockHeadersList.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 *BlockHeadersList) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_BlockHeadersList.Merge(m, src)
|
|
}
|
|
func (m *BlockHeadersList) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *BlockHeadersList) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_BlockHeadersList.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_BlockHeadersList proto.InternalMessageInfo
|
|
|
|
func (m *BlockHeadersList) GetHeaders() []*BlockHeader {
|
|
if m != nil {
|
|
return m.Headers
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type BlocksList struct {
|
|
Blocks []*Block `protobuf:"bytes,1,rep,name=blocks,proto3" json:"blocks,omitempty"`
|
|
}
|
|
|
|
func (m *BlocksList) Reset() { *m = BlocksList{} }
|
|
func (m *BlocksList) String() string { return proto.CompactTextString(m) }
|
|
func (*BlocksList) ProtoMessage() {}
|
|
func (*BlocksList) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{21}
|
|
}
|
|
func (m *BlocksList) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *BlocksList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_BlocksList.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 *BlocksList) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_BlocksList.Merge(m, src)
|
|
}
|
|
func (m *BlocksList) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *BlocksList) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_BlocksList.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_BlocksList proto.InternalMessageInfo
|
|
|
|
func (m *BlocksList) GetBlocks() []*Block {
|
|
if m != nil {
|
|
return m.Blocks
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type BlockContentPage struct {
|
|
Style BlockContentPage_Style `protobuf:"varint,1,opt,name=style,proto3,enum=anytype.BlockContentPage_Style" json:"style,omitempty"`
|
|
Structure *BlockConnectionsList `protobuf:"bytes,2,opt,name=structure,proto3" json:"structure,omitempty"`
|
|
Blocks *BlocksList `protobuf:"bytes,3,opt,name=blocks,proto3" json:"blocks,omitempty"`
|
|
}
|
|
|
|
func (m *BlockContentPage) Reset() { *m = BlockContentPage{} }
|
|
func (m *BlockContentPage) String() string { return proto.CompactTextString(m) }
|
|
func (*BlockContentPage) ProtoMessage() {}
|
|
func (*BlockContentPage) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{22}
|
|
}
|
|
func (m *BlockContentPage) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *BlockContentPage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_BlockContentPage.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 *BlockContentPage) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_BlockContentPage.Merge(m, src)
|
|
}
|
|
func (m *BlockContentPage) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *BlockContentPage) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_BlockContentPage.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_BlockContentPage proto.InternalMessageInfo
|
|
|
|
func (m *BlockContentPage) GetStyle() BlockContentPage_Style {
|
|
if m != nil {
|
|
return m.Style
|
|
}
|
|
return BlockContentPage_EMPTY
|
|
}
|
|
|
|
func (m *BlockContentPage) GetStructure() *BlockConnectionsList {
|
|
if m != nil {
|
|
return m.Structure
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *BlockContentPage) GetBlocks() *BlocksList {
|
|
if m != nil {
|
|
return m.Blocks
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type BlockContentDashboard struct {
|
|
Style BlockContentDashboard_Style `protobuf:"varint,1,opt,name=style,proto3,enum=anytype.BlockContentDashboard_Style" json:"style,omitempty"`
|
|
Structure *BlockConnectionsList `protobuf:"bytes,2,opt,name=structure,proto3" json:"structure,omitempty"`
|
|
Headers *BlockHeadersList `protobuf:"bytes,3,opt,name=headers,proto3" json:"headers,omitempty"`
|
|
}
|
|
|
|
func (m *BlockContentDashboard) Reset() { *m = BlockContentDashboard{} }
|
|
func (m *BlockContentDashboard) String() string { return proto.CompactTextString(m) }
|
|
func (*BlockContentDashboard) ProtoMessage() {}
|
|
func (*BlockContentDashboard) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{23}
|
|
}
|
|
func (m *BlockContentDashboard) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *BlockContentDashboard) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_BlockContentDashboard.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 *BlockContentDashboard) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_BlockContentDashboard.Merge(m, src)
|
|
}
|
|
func (m *BlockContentDashboard) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *BlockContentDashboard) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_BlockContentDashboard.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_BlockContentDashboard proto.InternalMessageInfo
|
|
|
|
func (m *BlockContentDashboard) GetStyle() BlockContentDashboard_Style {
|
|
if m != nil {
|
|
return m.Style
|
|
}
|
|
return BlockContentDashboard_MAIN_SCREEN
|
|
}
|
|
|
|
func (m *BlockContentDashboard) GetStructure() *BlockConnectionsList {
|
|
if m != nil {
|
|
return m.Structure
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *BlockContentDashboard) GetHeaders() *BlockHeadersList {
|
|
if m != nil {
|
|
return m.Headers
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type BlockContentDataview struct {
|
|
}
|
|
|
|
func (m *BlockContentDataview) Reset() { *m = BlockContentDataview{} }
|
|
func (m *BlockContentDataview) String() string { return proto.CompactTextString(m) }
|
|
func (*BlockContentDataview) ProtoMessage() {}
|
|
func (*BlockContentDataview) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{24}
|
|
}
|
|
func (m *BlockContentDataview) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *BlockContentDataview) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_BlockContentDataview.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 *BlockContentDataview) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_BlockContentDataview.Merge(m, src)
|
|
}
|
|
func (m *BlockContentDataview) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *BlockContentDataview) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_BlockContentDataview.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_BlockContentDataview proto.InternalMessageInfo
|
|
|
|
type BlockContentText struct {
|
|
Text string `protobuf:"bytes,1,opt,name=text,proto3" json:"text,omitempty"`
|
|
Style BlockContentText_Style `protobuf:"varint,2,opt,name=style,proto3,enum=anytype.BlockContentText_Style" json:"style,omitempty"`
|
|
MarksList *BlockContentText_Marks `protobuf:"bytes,3,opt,name=marksList,proto3" json:"marksList,omitempty"`
|
|
Toggleable bool `protobuf:"varint,4,opt,name=toggleable,proto3" json:"toggleable,omitempty"`
|
|
MarkerType BlockContentText_MarkerType `protobuf:"varint,5,opt,name=markerType,proto3,enum=anytype.BlockContentText_MarkerType" json:"markerType,omitempty"`
|
|
Checkable bool `protobuf:"varint,6,opt,name=checkable,proto3" json:"checkable,omitempty"`
|
|
Checked bool `protobuf:"varint,7,opt,name=checked,proto3" json:"checked,omitempty"`
|
|
}
|
|
|
|
func (m *BlockContentText) Reset() { *m = BlockContentText{} }
|
|
func (m *BlockContentText) String() string { return proto.CompactTextString(m) }
|
|
func (*BlockContentText) ProtoMessage() {}
|
|
func (*BlockContentText) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{25}
|
|
}
|
|
func (m *BlockContentText) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *BlockContentText) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_BlockContentText.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 *BlockContentText) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_BlockContentText.Merge(m, src)
|
|
}
|
|
func (m *BlockContentText) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *BlockContentText) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_BlockContentText.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_BlockContentText proto.InternalMessageInfo
|
|
|
|
func (m *BlockContentText) GetText() string {
|
|
if m != nil {
|
|
return m.Text
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *BlockContentText) GetStyle() BlockContentText_Style {
|
|
if m != nil {
|
|
return m.Style
|
|
}
|
|
return BlockContentText_p
|
|
}
|
|
|
|
func (m *BlockContentText) GetMarksList() *BlockContentText_Marks {
|
|
if m != nil {
|
|
return m.MarksList
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *BlockContentText) GetToggleable() bool {
|
|
if m != nil {
|
|
return m.Toggleable
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *BlockContentText) GetMarkerType() BlockContentText_MarkerType {
|
|
if m != nil {
|
|
return m.MarkerType
|
|
}
|
|
return BlockContentText_none
|
|
}
|
|
|
|
func (m *BlockContentText) GetCheckable() bool {
|
|
if m != nil {
|
|
return m.Checkable
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (m *BlockContentText) GetChecked() bool {
|
|
if m != nil {
|
|
return m.Checked
|
|
}
|
|
return false
|
|
}
|
|
|
|
type BlockContentText_Marks struct {
|
|
Marks []*BlockContentText_Mark `protobuf:"bytes,1,rep,name=marks,proto3" json:"marks,omitempty"`
|
|
}
|
|
|
|
func (m *BlockContentText_Marks) Reset() { *m = BlockContentText_Marks{} }
|
|
func (m *BlockContentText_Marks) String() string { return proto.CompactTextString(m) }
|
|
func (*BlockContentText_Marks) ProtoMessage() {}
|
|
func (*BlockContentText_Marks) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{25, 0}
|
|
}
|
|
func (m *BlockContentText_Marks) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *BlockContentText_Marks) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_BlockContentText_Marks.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 *BlockContentText_Marks) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_BlockContentText_Marks.Merge(m, src)
|
|
}
|
|
func (m *BlockContentText_Marks) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *BlockContentText_Marks) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_BlockContentText_Marks.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_BlockContentText_Marks proto.InternalMessageInfo
|
|
|
|
func (m *BlockContentText_Marks) GetMarks() []*BlockContentText_Mark {
|
|
if m != nil {
|
|
return m.Marks
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type BlockContentText_Mark struct {
|
|
Range *Range `protobuf:"bytes,1,opt,name=range,proto3" json:"range,omitempty"`
|
|
Type BlockContentText_Mark_Type `protobuf:"varint,2,opt,name=type,proto3,enum=anytype.BlockContentText_Mark_Type" json:"type,omitempty"`
|
|
Param string `protobuf:"bytes,3,opt,name=param,proto3" json:"param,omitempty"`
|
|
}
|
|
|
|
func (m *BlockContentText_Mark) Reset() { *m = BlockContentText_Mark{} }
|
|
func (m *BlockContentText_Mark) String() string { return proto.CompactTextString(m) }
|
|
func (*BlockContentText_Mark) ProtoMessage() {}
|
|
func (*BlockContentText_Mark) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{25, 1}
|
|
}
|
|
func (m *BlockContentText_Mark) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *BlockContentText_Mark) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_BlockContentText_Mark.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 *BlockContentText_Mark) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_BlockContentText_Mark.Merge(m, src)
|
|
}
|
|
func (m *BlockContentText_Mark) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *BlockContentText_Mark) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_BlockContentText_Mark.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_BlockContentText_Mark proto.InternalMessageInfo
|
|
|
|
func (m *BlockContentText_Mark) GetRange() *Range {
|
|
if m != nil {
|
|
return m.Range
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *BlockContentText_Mark) GetType() BlockContentText_Mark_Type {
|
|
if m != nil {
|
|
return m.Type
|
|
}
|
|
return BlockContentText_Mark_STRIKETHROUGH
|
|
}
|
|
|
|
func (m *BlockContentText_Mark) GetParam() string {
|
|
if m != nil {
|
|
return m.Param
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type BlockContentMedia struct {
|
|
Link string `protobuf:"bytes,1,opt,name=link,proto3" json:"link,omitempty"`
|
|
}
|
|
|
|
func (m *BlockContentMedia) Reset() { *m = BlockContentMedia{} }
|
|
func (m *BlockContentMedia) String() string { return proto.CompactTextString(m) }
|
|
func (*BlockContentMedia) ProtoMessage() {}
|
|
func (*BlockContentMedia) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{26}
|
|
}
|
|
func (m *BlockContentMedia) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *BlockContentMedia) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_BlockContentMedia.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 *BlockContentMedia) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_BlockContentMedia.Merge(m, src)
|
|
}
|
|
func (m *BlockContentMedia) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *BlockContentMedia) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_BlockContentMedia.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_BlockContentMedia proto.InternalMessageInfo
|
|
|
|
func (m *BlockContentMedia) GetLink() string {
|
|
if m != nil {
|
|
return m.Link
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type Range struct {
|
|
From int32 `protobuf:"varint,1,opt,name=from,proto3" json:"from,omitempty"`
|
|
To int32 `protobuf:"varint,2,opt,name=to,proto3" json:"to,omitempty"`
|
|
}
|
|
|
|
func (m *Range) Reset() { *m = Range{} }
|
|
func (m *Range) String() string { return proto.CompactTextString(m) }
|
|
func (*Range) ProtoMessage() {}
|
|
func (*Range) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_8e550b1f5926e92d, []int{27}
|
|
}
|
|
func (m *Range) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *Range) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_Range.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 *Range) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_Range.Merge(m, src)
|
|
}
|
|
func (m *Range) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *Range) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_Range.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_Range proto.InternalMessageInfo
|
|
|
|
func (m *Range) GetFrom() int32 {
|
|
if m != nil {
|
|
return m.From
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *Range) GetTo() int32 {
|
|
if m != nil {
|
|
return m.To
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func init() {
|
|
proto.RegisterEnum("anytype.BlockType", BlockType_name, BlockType_value)
|
|
proto.RegisterEnum("anytype.BlockOpenResponse_Error_Code", BlockOpenResponse_Error_Code_name, BlockOpenResponse_Error_Code_value)
|
|
proto.RegisterEnum("anytype.BlockCreateResponse_Error_Code", BlockCreateResponse_Error_Code_name, BlockCreateResponse_Error_Code_value)
|
|
proto.RegisterEnum("anytype.BlockUpdateResponse_Error_Code", BlockUpdateResponse_Error_Code_name, BlockUpdateResponse_Error_Code_value)
|
|
proto.RegisterEnum("anytype.BlockContentPage_Style", BlockContentPage_Style_name, BlockContentPage_Style_value)
|
|
proto.RegisterEnum("anytype.BlockContentDashboard_Style", BlockContentDashboard_Style_name, BlockContentDashboard_Style_value)
|
|
proto.RegisterEnum("anytype.BlockContentText_Style", BlockContentText_Style_name, BlockContentText_Style_value)
|
|
proto.RegisterEnum("anytype.BlockContentText_MarkerType", BlockContentText_MarkerType_name, BlockContentText_MarkerType_value)
|
|
proto.RegisterEnum("anytype.BlockContentText_Mark_Type", BlockContentText_Mark_Type_name, BlockContentText_Mark_Type_value)
|
|
proto.RegisterType((*BlockOpenRequest)(nil), "anytype.BlockOpenRequest")
|
|
proto.RegisterType((*BlockOpenResponse)(nil), "anytype.BlockOpenResponse")
|
|
proto.RegisterType((*BlockOpenResponse_Error)(nil), "anytype.BlockOpenResponse.Error")
|
|
proto.RegisterType((*BlockCreateRequest)(nil), "anytype.BlockCreateRequest")
|
|
proto.RegisterType((*BlockCreateResponse)(nil), "anytype.BlockCreateResponse")
|
|
proto.RegisterType((*BlockCreateResponse_Error)(nil), "anytype.BlockCreateResponse.Error")
|
|
proto.RegisterType((*BlockUpdateRequest)(nil), "anytype.BlockUpdateRequest")
|
|
proto.RegisterType((*BlockUpdateResponse)(nil), "anytype.BlockUpdateResponse")
|
|
proto.RegisterType((*BlockUpdateResponse_Error)(nil), "anytype.BlockUpdateResponse.Error")
|
|
proto.RegisterType((*BlockShow)(nil), "anytype.BlockShow")
|
|
proto.RegisterType((*BlockUpdate)(nil), "anytype.BlockUpdate")
|
|
proto.RegisterType((*BlockCreate)(nil), "anytype.BlockCreate")
|
|
proto.RegisterType((*BlockContentTextChange)(nil), "anytype.BlockContentTextChange")
|
|
proto.RegisterType((*BlockContentPageChange)(nil), "anytype.BlockContentPageChange")
|
|
proto.RegisterType((*BlockHeaderChange)(nil), "anytype.BlockHeaderChange")
|
|
proto.RegisterType((*BlockContentDashboardChange)(nil), "anytype.BlockContentDashboardChange")
|
|
proto.RegisterType((*BlockAtomicChange)(nil), "anytype.BlockAtomicChange")
|
|
proto.RegisterType((*BlockChanges)(nil), "anytype.BlockChanges")
|
|
proto.RegisterType((*Block)(nil), "anytype.Block")
|
|
proto.RegisterType((*BlockHeader)(nil), "anytype.BlockHeader")
|
|
proto.RegisterType((*BlockPermissions)(nil), "anytype.BlockPermissions")
|
|
proto.RegisterType((*BlockConnections)(nil), "anytype.BlockConnections")
|
|
proto.RegisterType((*BlockConnectionsList)(nil), "anytype.BlockConnectionsList")
|
|
proto.RegisterType((*BlockHeadersList)(nil), "anytype.BlockHeadersList")
|
|
proto.RegisterType((*BlocksList)(nil), "anytype.BlocksList")
|
|
proto.RegisterType((*BlockContentPage)(nil), "anytype.BlockContentPage")
|
|
proto.RegisterType((*BlockContentDashboard)(nil), "anytype.BlockContentDashboard")
|
|
proto.RegisterType((*BlockContentDataview)(nil), "anytype.BlockContentDataview")
|
|
proto.RegisterType((*BlockContentText)(nil), "anytype.BlockContentText")
|
|
proto.RegisterType((*BlockContentText_Marks)(nil), "anytype.BlockContentText.Marks")
|
|
proto.RegisterType((*BlockContentText_Mark)(nil), "anytype.BlockContentText.Mark")
|
|
proto.RegisterType((*BlockContentMedia)(nil), "anytype.BlockContentMedia")
|
|
proto.RegisterType((*Range)(nil), "anytype.Range")
|
|
}
|
|
|
|
func init() { proto.RegisterFile("block.proto", fileDescriptor_8e550b1f5926e92d) }
|
|
|
|
var fileDescriptor_8e550b1f5926e92d = []byte{
|
|
// 1633 bytes of a gzipped FileDescriptorProto
|
|
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x58, 0x4f, 0x6f, 0x13, 0xd7,
|
|
0x16, 0xf7, 0x4c, 0x3c, 0x8e, 0x7d, 0x9c, 0x84, 0xe1, 0x12, 0x90, 0xf1, 0xe3, 0xf9, 0x45, 0xf3,
|
|
0x28, 0xa0, 0xd2, 0x1a, 0x91, 0x3f, 0x50, 0x1a, 0x40, 0xb2, 0xe3, 0x01, 0x5b, 0x49, 0xec, 0xe8,
|
|
0xda, 0x81, 0xd2, 0x45, 0xd1, 0xc4, 0x73, 0x49, 0x46, 0xb1, 0x67, 0xcc, 0x78, 0x02, 0x64, 0xd3,
|
|
0x4f, 0xd0, 0x45, 0x97, 0x55, 0x17, 0x95, 0xba, 0xe6, 0x6b, 0xb0, 0x68, 0x77, 0x48, 0xdd, 0x54,
|
|
0xea, 0xa2, 0x15, 0x6c, 0xba, 0xe8, 0x87, 0xa8, 0xee, 0x9f, 0x99, 0xb9, 0x93, 0x18, 0x27, 0x41,
|
|
0xb0, 0xca, 0xdc, 0x7b, 0xcf, 0xb9, 0xe7, 0x9c, 0xdf, 0x3d, 0xe7, 0x77, 0x8e, 0x03, 0xf9, 0xad,
|
|
0x9e, 0xd7, 0xdd, 0x2d, 0x0f, 0x7c, 0x2f, 0xf0, 0xd0, 0xa4, 0xe5, 0xee, 0x07, 0xfb, 0x03, 0x52,
|
|
0x9c, 0x1a, 0x06, 0xfe, 0x5e, 0x37, 0xe0, 0xdb, 0x86, 0x01, 0x7a, 0x95, 0x4a, 0xb5, 0x06, 0xc4,
|
|
0xc5, 0xe4, 0xe9, 0x1e, 0x19, 0x06, 0x68, 0x06, 0x54, 0xc7, 0x2e, 0x28, 0x73, 0xca, 0x95, 0x1c,
|
|
0x56, 0x1d, 0xdb, 0xf8, 0x49, 0x85, 0xd3, 0x92, 0xd0, 0x70, 0xe0, 0xb9, 0x43, 0x82, 0x6e, 0x80,
|
|
0x46, 0x7c, 0xdf, 0xf3, 0x99, 0x60, 0x7e, 0x7e, 0xae, 0x2c, 0x0c, 0x94, 0x0f, 0x89, 0x96, 0x4d,
|
|
0x2a, 0x87, 0xb9, 0x38, 0xba, 0x21, 0xfc, 0xaa, 0x13, 0xcb, 0x26, 0x7e, 0x41, 0x65, 0xda, 0xb3,
|
|
0x49, 0x6d, 0x7e, 0x86, 0x65, 0xc1, 0xe2, 0x0f, 0x0a, 0x68, 0xec, 0x22, 0x74, 0x0b, 0xd2, 0x5d,
|
|
0xcf, 0x26, 0xcc, 0xf0, 0xcc, 0xfc, 0x27, 0x47, 0x19, 0x2e, 0xaf, 0x78, 0x36, 0xc1, 0x4c, 0x05,
|
|
0xcd, 0x41, 0xde, 0x26, 0xc3, 0xae, 0xef, 0x0c, 0x02, 0xc7, 0x73, 0x99, 0xf1, 0x1c, 0x96, 0xb7,
|
|
0x8c, 0x79, 0x48, 0x53, 0x79, 0x94, 0x85, 0x74, 0x73, 0x73, 0x6d, 0x4d, 0x4f, 0xa1, 0xd3, 0x30,
|
|
0xbd, 0xd9, 0x5c, 0x6d, 0xb6, 0x1e, 0x36, 0x1f, 0x9b, 0x18, 0xb7, 0xb0, 0xae, 0xa0, 0x69, 0xc8,
|
|
0x55, 0x2b, 0xb5, 0xc7, 0x8d, 0xe6, 0xc6, 0x66, 0x47, 0x57, 0x8d, 0xdb, 0x80, 0x98, 0xed, 0x15,
|
|
0x9f, 0x58, 0x01, 0x09, 0x61, 0xbc, 0x04, 0x69, 0xea, 0x96, 0x70, 0x13, 0x25, 0xdd, 0xec, 0xec,
|
|
0x0f, 0x08, 0x66, 0xe7, 0xc6, 0x3f, 0x0a, 0x9c, 0x49, 0xa8, 0x0b, 0x80, 0xbf, 0x48, 0x02, 0x6c,
|
|
0x24, 0x2f, 0x48, 0x0a, 0x27, 0x20, 0x2e, 0xfe, 0x18, 0x41, 0xb5, 0x9c, 0x80, 0xea, 0xf2, 0xd1,
|
|
0x57, 0x7c, 0x7c, 0xb0, 0x4c, 0x01, 0xd6, 0xe6, 0xc0, 0x96, 0xc0, 0xba, 0x06, 0x93, 0xdd, 0x1d,
|
|
0xcb, 0xdd, 0x26, 0x43, 0x11, 0xee, 0xd9, 0x03, 0xbe, 0xf2, 0x43, 0x1c, 0x4a, 0xc5, 0xa8, 0x85,
|
|
0xf7, 0x1c, 0x0b, 0xb5, 0xa4, 0xf0, 0x7b, 0xa1, 0x36, 0xea, 0x8a, 0x8f, 0x8f, 0xda, 0x75, 0xc8,
|
|
0x31, 0xeb, 0xed, 0x1d, 0xef, 0x39, 0xba, 0x08, 0x1a, 0xab, 0x0c, 0x11, 0xe3, 0x4c, 0xd2, 0x41,
|
|
0xcc, 0x0f, 0x8d, 0xbb, 0x90, 0x97, 0x1c, 0x3e, 0x39, 0xc2, 0x0b, 0x42, 0x9f, 0xa7, 0xc9, 0x31,
|
|
0x8d, 0xbe, 0x56, 0xe1, 0x1c, 0xd7, 0xf2, 0xdc, 0x80, 0xb8, 0x41, 0x87, 0xbc, 0x08, 0xf8, 0xcd,
|
|
0x68, 0x16, 0xd2, 0x01, 0x79, 0x11, 0x70, 0x62, 0xa9, 0xa7, 0x30, 0x5b, 0xa1, 0x9b, 0xa0, 0x0d,
|
|
0x83, 0xfd, 0x1e, 0x61, 0x40, 0xcd, 0xcc, 0xff, 0xef, 0x80, 0x53, 0xf1, 0x2d, 0xe5, 0x36, 0x15,
|
|
0xab, 0xa7, 0x30, 0x97, 0xa7, 0x8a, 0x7d, 0xcb, 0xdf, 0x1d, 0x16, 0x26, 0x98, 0x3f, 0x63, 0x14,
|
|
0xd7, 0xa9, 0x18, 0x55, 0x64, 0xf2, 0x68, 0x0e, 0x20, 0xf0, 0xb6, 0xb7, 0x7b, 0xc4, 0xda, 0xea,
|
|
0x91, 0x42, 0x7a, 0x4e, 0xb9, 0x92, 0xad, 0xa7, 0xb0, 0xb4, 0x87, 0xee, 0x01, 0x50, 0x51, 0xe2,
|
|
0xd3, 0x2a, 0x2d, 0x68, 0xcc, 0xb1, 0x8b, 0xe3, 0xef, 0xe7, 0xb2, 0xf4, 0x9e, 0x58, 0x13, 0x95,
|
|
0x20, 0xd7, 0xdd, 0x21, 0xdd, 0x5d, 0x66, 0x28, 0x23, 0x0c, 0xc5, 0x5b, 0xa8, 0x48, 0x9f, 0x84,
|
|
0x74, 0x77, 0x89, 0x5d, 0x98, 0x14, 0xa7, 0xe1, 0x46, 0x35, 0x0b, 0x19, 0xfe, 0x10, 0xc6, 0xaf,
|
|
0x4a, 0x12, 0xd2, 0x0d, 0x6b, 0x9b, 0x08, 0x48, 0x23, 0xf0, 0x94, 0x31, 0xe0, 0x51, 0xf9, 0x83,
|
|
0xe0, 0xdd, 0x81, 0x1c, 0x6f, 0x03, 0x7b, 0x3e, 0x11, 0x14, 0xfc, 0xdf, 0x43, 0xca, 0x2e, 0xe9,
|
|
0xd2, 0x7c, 0x1d, 0xae, 0x39, 0xc3, 0x80, 0x3a, 0x1e, 0x69, 0xa0, 0xcf, 0x21, 0xc3, 0x9e, 0x3b,
|
|
0x04, 0xff, 0x4c, 0x52, 0x37, 0xd4, 0x10, 0x42, 0x52, 0x2c, 0xaf, 0x14, 0xd1, 0x4a, 0x38, 0xa9,
|
|
0x8b, 0x30, 0xf4, 0xb8, 0xe1, 0xd4, 0x53, 0xb4, 0xe5, 0xa0, 0x2b, 0x82, 0x3b, 0xd5, 0x77, 0x71,
|
|
0x27, 0xcb, 0x1f, 0x8a, 0xf1, 0x2c, 0xa4, 0x5d, 0xab, 0x4f, 0x98, 0x23, 0x2c, 0xab, 0xe8, 0x8a,
|
|
0xee, 0x3a, 0x5d, 0xcf, 0x65, 0xaf, 0xcb, 0x76, 0xe9, 0x0a, 0xdd, 0x81, 0xfc, 0x80, 0xf8, 0x7d,
|
|
0x67, 0x38, 0xa4, 0x61, 0xb1, 0x87, 0xcd, 0xcf, 0x9f, 0x4f, 0x5e, 0xbe, 0x11, 0x0b, 0xd4, 0x53,
|
|
0x58, 0x96, 0x97, 0xc2, 0xf8, 0x43, 0x81, 0xff, 0xc8, 0x10, 0xd7, 0xac, 0xe1, 0xce, 0x96, 0x67,
|
|
0xf9, 0xb6, 0x08, 0xe8, 0x76, 0xf2, 0x5d, 0x46, 0xe7, 0x4e, 0xa4, 0xf4, 0x81, 0x1f, 0x67, 0x09,
|
|
0x26, 0x77, 0x18, 0xba, 0xe1, 0xeb, 0x9c, 0x1f, 0xd5, 0x5c, 0x43, 0xc5, 0x50, 0x56, 0x8a, 0xee,
|
|
0xe7, 0xb0, 0xdf, 0x57, 0x02, 0xaf, 0xef, 0x74, 0x45, 0x4c, 0x07, 0xa6, 0x02, 0xb4, 0x24, 0xca,
|
|
0x59, 0x3d, 0xa2, 0xfc, 0xb8, 0x7a, 0x54, 0xef, 0x77, 0x93, 0xed, 0x9f, 0x7b, 0x58, 0x1c, 0xe5,
|
|
0x61, 0xa4, 0x28, 0x2b, 0x50, 0xb3, 0x03, 0x6b, 0x9b, 0xd7, 0x6d, 0x7e, 0x4c, 0xc6, 0xc7, 0x66,
|
|
0xa9, 0x38, 0xaa, 0x41, 0xce, 0x0e, 0xf1, 0x16, 0x0f, 0x7f, 0xc4, 0xab, 0x44, 0x17, 0xc4, 0x8a,
|
|
0x12, 0x46, 0x35, 0x98, 0x92, 0x59, 0x13, 0x2d, 0xca, 0xec, 0x3a, 0x71, 0x38, 0x24, 0x19, 0xca,
|
|
0x98, 0x62, 0x7f, 0x53, 0x41, 0x63, 0xc7, 0xe8, 0x33, 0xc8, 0xf0, 0x87, 0x10, 0xf4, 0x3a, 0x7a,
|
|
0x20, 0x12, 0x32, 0xe8, 0xae, 0x1c, 0x4d, 0x9e, 0x29, 0x94, 0xc6, 0x47, 0x93, 0x88, 0x03, 0x5d,
|
|
0x13, 0x20, 0x4e, 0x8d, 0xca, 0x0f, 0x09, 0xc4, 0x08, 0xbe, 0x65, 0xc8, 0xda, 0x56, 0x60, 0x3d,
|
|
0x73, 0xc8, 0xf3, 0xc2, 0xf4, 0x3b, 0x32, 0x92, 0xdb, 0xe3, 0x42, 0xf5, 0x14, 0x8e, 0x14, 0xa8,
|
|
0x35, 0x96, 0x29, 0x33, 0x63, 0xac, 0xd1, 0x4c, 0x89, 0x72, 0x64, 0x1e, 0xb4, 0x3e, 0xb1, 0x1d,
|
|
0xab, 0x70, 0x6a, 0x54, 0x76, 0x08, 0x8d, 0x75, 0x2a, 0xc1, 0x58, 0x9d, 0x7e, 0x54, 0x73, 0x30,
|
|
0xd9, 0xe5, 0x07, 0xc6, 0x4b, 0x45, 0x74, 0x2e, 0x91, 0x32, 0x07, 0x33, 0xf7, 0xd2, 0x51, 0xe4,
|
|
0x22, 0xa8, 0xe5, 0x32, 0x64, 0x9e, 0x38, 0xa4, 0x67, 0x87, 0x75, 0x74, 0x2a, 0x92, 0x6c, 0xb3,
|
|
0x62, 0xc3, 0xe2, 0x18, 0x2d, 0x27, 0x79, 0x25, 0x7d, 0x04, 0xaf, 0x24, 0x58, 0xc5, 0xf8, 0x56,
|
|
0x4c, 0xe0, 0x92, 0x00, 0x42, 0x90, 0xf6, 0x89, 0xc5, 0x7d, 0xce, 0x62, 0xf6, 0x4d, 0xf7, 0x88,
|
|
0xed, 0xf0, 0x7a, 0xcb, 0x62, 0xf6, 0x8d, 0xce, 0x41, 0xc6, 0x27, 0x7d, 0xef, 0x19, 0xa7, 0xbf,
|
|
0x2c, 0x16, 0x2b, 0x2a, 0x6b, 0xfb, 0xd6, 0x36, 0x6f, 0x6e, 0x98, 0x7d, 0x53, 0x59, 0xdb, 0xf7,
|
|
0x06, 0x2d, 0x97, 0xa5, 0x7f, 0x16, 0x8b, 0x95, 0xf1, 0x9d, 0x22, 0x1c, 0x90, 0x48, 0xe5, 0x10,
|
|
0x64, 0x08, 0xd2, 0x6e, 0x58, 0xec, 0x39, 0xcc, 0xbe, 0x91, 0x01, 0x53, 0x5d, 0xaf, 0xb7, 0xd7,
|
|
0x77, 0xab, 0x5e, 0x10, 0x78, 0x7d, 0xce, 0xc0, 0x38, 0xb1, 0x87, 0x8a, 0x90, 0xf5, 0xbd, 0xe7,
|
|
0xd8, 0xd9, 0xde, 0x09, 0x38, 0x17, 0xe3, 0x68, 0x8d, 0x66, 0x41, 0x73, 0x5c, 0x97, 0xf8, 0xcc,
|
|
0x9f, 0x1c, 0xe6, 0x0b, 0xa3, 0x05, 0xb3, 0xa3, 0x28, 0x0e, 0xdd, 0x94, 0x49, 0x91, 0x97, 0xd8,
|
|
0xf9, 0x77, 0x92, 0xa2, 0x44, 0x87, 0x46, 0x55, 0x84, 0x27, 0xd1, 0x1e, 0x2a, 0xc7, 0x14, 0xc9,
|
|
0xaf, 0x1a, 0x5d, 0x6e, 0xa1, 0x90, 0xb1, 0x08, 0x10, 0x37, 0x36, 0x74, 0x29, 0xea, 0x7e, 0x5c,
|
|
0xf9, 0xe0, 0x28, 0x24, 0x4e, 0x8d, 0xbf, 0x25, 0x64, 0xc3, 0x8a, 0x42, 0x4b, 0x27, 0x6b, 0xd9,
|
|
0x61, 0x4f, 0x58, 0x3e, 0x69, 0x4f, 0x90, 0x3b, 0xc2, 0xd5, 0x63, 0xb4, 0xeb, 0xc8, 0xeb, 0x05,
|
|
0xd0, 0x98, 0x65, 0x94, 0x03, 0xcd, 0x5c, 0xdf, 0xe8, 0x3c, 0xd2, 0x53, 0x74, 0x52, 0xed, 0x54,
|
|
0xda, 0xab, 0xba, 0x82, 0xa6, 0x20, 0x5b, 0x6d, 0xb5, 0x56, 0xd7, 0x2b, 0x78, 0x55, 0x57, 0xd1,
|
|
0x24, 0x4c, 0xb4, 0xcd, 0x8e, 0x3e, 0x61, 0xfc, 0xa9, 0xc0, 0xd9, 0x91, 0xbc, 0x83, 0xbe, 0x7c,
|
|
0x8f, 0x56, 0xf8, 0x41, 0x82, 0x5e, 0x38, 0x7e, 0x1b, 0x8c, 0x1f, 0xba, 0x10, 0x06, 0x7f, 0x0a,
|
|
0xf2, 0xeb, 0x95, 0x46, 0xf3, 0x71, 0x7b, 0x05, 0x9b, 0x66, 0x53, 0x4f, 0x19, 0xe7, 0xe2, 0xbc,
|
|
0x94, 0x89, 0xce, 0x78, 0xa9, 0x25, 0x1f, 0x99, 0x12, 0x19, 0x2d, 0x97, 0x78, 0xd4, 0x15, 0xa4,
|
|
0xb6, 0x74, 0xb2, 0x41, 0x57, 0x1a, 0x06, 0xd8, 0xd8, 0x4a, 0xfd, 0x3c, 0xe6, 0xa8, 0x8b, 0x63,
|
|
0x0d, 0x54, 0x3a, 0x3c, 0xec, 0x26, 0x46, 0xdd, 0xda, 0xfb, 0x8e, 0xba, 0x89, 0x41, 0xf7, 0xc2,
|
|
0xa1, 0x41, 0x57, 0x1e, 0x73, 0x0b, 0x07, 0xc6, 0xdc, 0x68, 0xc8, 0x2d, 0xde, 0x01, 0x8d, 0x79,
|
|
0x8c, 0x16, 0xc3, 0x61, 0x9e, 0x57, 0x54, 0x69, 0xbc, 0x07, 0x62, 0x92, 0x2f, 0xbe, 0x52, 0x20,
|
|
0x4d, 0xd7, 0xf4, 0xb7, 0x89, 0x4f, 0x3b, 0xea, 0xa1, 0xdf, 0x26, 0x98, 0xf5, 0x5b, 0x7e, 0x88,
|
|
0x6e, 0x26, 0x78, 0xff, 0xff, 0xe3, 0x6d, 0x94, 0xa5, 0x46, 0x30, 0x0b, 0xda, 0xc0, 0xf2, 0xad,
|
|
0x90, 0xe2, 0xf8, 0xc2, 0xb8, 0x0f, 0x69, 0x16, 0xfc, 0x69, 0x98, 0x6e, 0x77, 0x70, 0x63, 0xd5,
|
|
0xec, 0xd4, 0x71, 0x6b, 0xf3, 0x7e, 0x5d, 0x4f, 0xd1, 0x2a, 0x59, 0x35, 0x1f, 0x55, 0x5b, 0x15,
|
|
0x5c, 0xd3, 0x15, 0x04, 0x90, 0x69, 0x74, 0x2a, 0x6b, 0x8d, 0x15, 0x5d, 0xa5, 0x95, 0x54, 0x6d,
|
|
0xad, 0xd5, 0xf4, 0x09, 0xfa, 0xb5, 0xd6, 0x68, 0xae, 0xea, 0x69, 0xe3, 0x56, 0x98, 0x74, 0x1a,
|
|
0x28, 0x03, 0x3d, 0x85, 0x32, 0xa0, 0xee, 0x5c, 0xd7, 0x15, 0xf6, 0x77, 0x5e, 0x57, 0xd9, 0xdf,
|
|
0x05, 0x7d, 0x82, 0xfd, 0x5d, 0xd4, 0xd3, 0xb4, 0x30, 0x9f, 0xee, 0x79, 0x01, 0xd1, 0x35, 0xa3,
|
|
0x0c, 0x10, 0x3f, 0x09, 0xbd, 0xd2, 0xf5, 0x5c, 0xa2, 0xa7, 0xa8, 0x49, 0x77, 0xaf, 0xbf, 0x45,
|
|
0x7c, 0x6e, 0x7e, 0x6b, 0xaf, 0xd7, 0x23, 0x81, 0xae, 0x1a, 0x97, 0xc5, 0x64, 0x27, 0xf7, 0x50,
|
|
0x9a, 0xad, 0x3d, 0xc7, 0xdd, 0x0d, 0xb3, 0x95, 0x7e, 0x1b, 0x57, 0x41, 0x63, 0xd8, 0xd1, 0xc3,
|
|
0x27, 0xbe, 0xd7, 0x67, 0x87, 0x1a, 0x66, 0xdf, 0xb4, 0x3b, 0x04, 0x1e, 0x83, 0x51, 0xc3, 0x6a,
|
|
0xe0, 0x7d, 0xfa, 0x8d, 0xf8, 0x71, 0xca, 0x9c, 0x98, 0x86, 0x5c, 0xad, 0xd2, 0xae, 0xf3, 0xe0,
|
|
0x19, 0x75, 0x6c, 0x54, 0xee, 0x9b, 0x9c, 0x3a, 0x6a, 0x95, 0x4e, 0xe5, 0x41, 0xc3, 0x7c, 0xc8,
|
|
0x81, 0xe8, 0x98, 0x5f, 0x75, 0x38, 0x10, 0xf7, 0x1a, 0x6b, 0xa6, 0x9e, 0x46, 0x79, 0x98, 0xdc,
|
|
0x68, 0xac, 0x74, 0x36, 0xb1, 0xa9, 0x6b, 0x34, 0xca, 0x07, 0x8d, 0x9a, 0xd9, 0xd2, 0x33, 0xd5,
|
|
0x0b, 0xbf, 0xbc, 0x29, 0x29, 0xaf, 0xdf, 0x94, 0x94, 0xbf, 0xde, 0x94, 0x94, 0xef, 0xdf, 0x96,
|
|
0x52, 0xaf, 0xdf, 0x96, 0x52, 0xbf, 0xbf, 0x2d, 0xa5, 0xbe, 0x56, 0x07, 0x5b, 0x5b, 0x19, 0xf6,
|
|
0x9f, 0xac, 0x85, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0x79, 0x56, 0x82, 0xe1, 0xef, 0x12, 0x00,
|
|
0x00,
|
|
}
|
|
|
|
func (m *BlockOpenRequest) 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 *BlockOpenRequest) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockOpenRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Id) > 0 {
|
|
i -= len(m.Id)
|
|
copy(dAtA[i:], m.Id)
|
|
i = encodeVarintBlock(dAtA, i, uint64(len(m.Id)))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *BlockOpenResponse) 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 *BlockOpenResponse) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockOpenResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.BlockHeader != nil {
|
|
{
|
|
size, err := m.BlockHeader.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintBlock(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if m.Error != nil {
|
|
{
|
|
size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintBlock(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *BlockOpenResponse_Error) 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 *BlockOpenResponse_Error) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockOpenResponse_Error) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Description) > 0 {
|
|
i -= len(m.Description)
|
|
copy(dAtA[i:], m.Description)
|
|
i = encodeVarintBlock(dAtA, i, uint64(len(m.Description)))
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if m.Code != 0 {
|
|
i = encodeVarintBlock(dAtA, i, uint64(m.Code))
|
|
i--
|
|
dAtA[i] = 0x8
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *BlockCreateRequest) 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 *BlockCreateRequest) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockCreateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Type != 0 {
|
|
i = encodeVarintBlock(dAtA, i, uint64(m.Type))
|
|
i--
|
|
dAtA[i] = 0x8
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *BlockCreateResponse) 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 *BlockCreateResponse) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockCreateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Error != nil {
|
|
{
|
|
size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintBlock(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *BlockCreateResponse_Error) 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 *BlockCreateResponse_Error) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockCreateResponse_Error) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Description) > 0 {
|
|
i -= len(m.Description)
|
|
copy(dAtA[i:], m.Description)
|
|
i = encodeVarintBlock(dAtA, i, uint64(len(m.Description)))
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if m.Code != 0 {
|
|
i = encodeVarintBlock(dAtA, i, uint64(m.Code))
|
|
i--
|
|
dAtA[i] = 0x8
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *BlockUpdateRequest) 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 *BlockUpdateRequest) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockUpdateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Changes != nil {
|
|
{
|
|
size, err := m.Changes.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintBlock(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *BlockUpdateResponse) 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 *BlockUpdateResponse) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockUpdateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Error != nil {
|
|
{
|
|
size, err := m.Error.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintBlock(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *BlockUpdateResponse_Error) 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 *BlockUpdateResponse_Error) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockUpdateResponse_Error) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Description) > 0 {
|
|
i -= len(m.Description)
|
|
copy(dAtA[i:], m.Description)
|
|
i = encodeVarintBlock(dAtA, i, uint64(len(m.Description)))
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if m.Code != 0 {
|
|
i = encodeVarintBlock(dAtA, i, uint64(m.Code))
|
|
i--
|
|
dAtA[i] = 0x8
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *BlockShow) 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 *BlockShow) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockShow) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Block != nil {
|
|
{
|
|
size, err := m.Block.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintBlock(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *BlockUpdate) 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 *BlockUpdate) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Changes != nil {
|
|
{
|
|
size, err := m.Changes.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintBlock(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *BlockCreate) 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 *BlockCreate) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockCreate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Block != nil {
|
|
{
|
|
size, err := m.Block.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintBlock(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *BlockContentTextChange) 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 *BlockContentTextChange) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockContentTextChange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Change != nil {
|
|
{
|
|
size := m.Change.Size()
|
|
i -= size
|
|
if _, err := m.Change.MarshalTo(dAtA[i:]); err != nil {
|
|
return 0, err
|
|
}
|
|
}
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *BlockContentTextChange_Text) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockContentTextChange_Text) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
i -= len(m.Text)
|
|
copy(dAtA[i:], m.Text)
|
|
i = encodeVarintBlock(dAtA, i, uint64(len(m.Text)))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
return len(dAtA) - i, nil
|
|
}
|
|
func (m *BlockContentTextChange_Style) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockContentTextChange_Style) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
i = encodeVarintBlock(dAtA, i, uint64(m.Style))
|
|
i--
|
|
dAtA[i] = 0x10
|
|
return len(dAtA) - i, nil
|
|
}
|
|
func (m *BlockContentTextChange_Marks) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockContentTextChange_Marks) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
if m.Marks != nil {
|
|
{
|
|
size, err := m.Marks.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintBlock(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
func (m *BlockContentTextChange_Toggleable) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockContentTextChange_Toggleable) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
i--
|
|
if m.Toggleable {
|
|
dAtA[i] = 1
|
|
} else {
|
|
dAtA[i] = 0
|
|
}
|
|
i--
|
|
dAtA[i] = 0x20
|
|
return len(dAtA) - i, nil
|
|
}
|
|
func (m *BlockContentTextChange_MarkerType) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockContentTextChange_MarkerType) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
i = encodeVarintBlock(dAtA, i, uint64(m.MarkerType))
|
|
i--
|
|
dAtA[i] = 0x28
|
|
return len(dAtA) - i, nil
|
|
}
|
|
func (m *BlockContentTextChange_Checkable) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockContentTextChange_Checkable) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
i--
|
|
if m.Checkable {
|
|
dAtA[i] = 1
|
|
} else {
|
|
dAtA[i] = 0
|
|
}
|
|
i--
|
|
dAtA[i] = 0x30
|
|
return len(dAtA) - i, nil
|
|
}
|
|
func (m *BlockContentTextChange_Checked) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockContentTextChange_Checked) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
i--
|
|
if m.Checked {
|
|
dAtA[i] = 1
|
|
} else {
|
|
dAtA[i] = 0
|
|
}
|
|
i--
|
|
dAtA[i] = 0x38
|
|
return len(dAtA) - i, nil
|
|
}
|
|
func (m *BlockContentPageChange) 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 *BlockContentPageChange) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockContentPageChange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Change != nil {
|
|
{
|
|
size := m.Change.Size()
|
|
i -= size
|
|
if _, err := m.Change.MarshalTo(dAtA[i:]); err != nil {
|
|
return 0, err
|
|
}
|
|
}
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *BlockContentPageChange_Style) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockContentPageChange_Style) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
i = encodeVarintBlock(dAtA, i, uint64(m.Style))
|
|
i--
|
|
dAtA[i] = 0x8
|
|
return len(dAtA) - i, nil
|
|
}
|
|
func (m *BlockContentPageChange_Structure) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockContentPageChange_Structure) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
if m.Structure != nil {
|
|
{
|
|
size, err := m.Structure.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintBlock(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
func (m *BlockContentPageChange_Blocks) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockContentPageChange_Blocks) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
if m.Blocks != nil {
|
|
{
|
|
size, err := m.Blocks.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintBlock(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
func (m *BlockHeaderChange) 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 *BlockHeaderChange) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockHeaderChange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Change != nil {
|
|
{
|
|
size := m.Change.Size()
|
|
i -= size
|
|
if _, err := m.Change.MarshalTo(dAtA[i:]); err != nil {
|
|
return 0, err
|
|
}
|
|
}
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *BlockHeaderChange_Id) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockHeaderChange_Id) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
i -= len(m.Id)
|
|
copy(dAtA[i:], m.Id)
|
|
i = encodeVarintBlock(dAtA, i, uint64(len(m.Id)))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
return len(dAtA) - i, nil
|
|
}
|
|
func (m *BlockHeaderChange_Type) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockHeaderChange_Type) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
i = encodeVarintBlock(dAtA, i, uint64(m.Type))
|
|
i--
|
|
dAtA[i] = 0x10
|
|
return len(dAtA) - i, nil
|
|
}
|
|
func (m *BlockHeaderChange_Name) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockHeaderChange_Name) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
i -= len(m.Name)
|
|
copy(dAtA[i:], m.Name)
|
|
i = encodeVarintBlock(dAtA, i, uint64(len(m.Name)))
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
return len(dAtA) - i, nil
|
|
}
|
|
func (m *BlockHeaderChange_Icon) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockHeaderChange_Icon) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
i -= len(m.Icon)
|
|
copy(dAtA[i:], m.Icon)
|
|
i = encodeVarintBlock(dAtA, i, uint64(len(m.Icon)))
|
|
i--
|
|
dAtA[i] = 0x22
|
|
return len(dAtA) - i, nil
|
|
}
|
|
func (m *BlockHeaderChange_Permissions) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockHeaderChange_Permissions) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
if m.Permissions != nil {
|
|
{
|
|
size, err := m.Permissions.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintBlock(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x2a
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
func (m *BlockContentDashboardChange) 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 *BlockContentDashboardChange) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockContentDashboardChange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Change != nil {
|
|
{
|
|
size := m.Change.Size()
|
|
i -= size
|
|
if _, err := m.Change.MarshalTo(dAtA[i:]); err != nil {
|
|
return 0, err
|
|
}
|
|
}
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *BlockContentDashboardChange_Style) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockContentDashboardChange_Style) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
i = encodeVarintBlock(dAtA, i, uint64(m.Style))
|
|
i--
|
|
dAtA[i] = 0x8
|
|
return len(dAtA) - i, nil
|
|
}
|
|
func (m *BlockContentDashboardChange_Structure) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockContentDashboardChange_Structure) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
if m.Structure != nil {
|
|
{
|
|
size, err := m.Structure.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintBlock(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
func (m *BlockContentDashboardChange_Headers) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockContentDashboardChange_Headers) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
if m.Headers != nil {
|
|
{
|
|
size, err := m.Headers.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintBlock(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
func (m *BlockAtomicChange) 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 *BlockAtomicChange) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockAtomicChange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Change != nil {
|
|
{
|
|
size := m.Change.Size()
|
|
i -= size
|
|
if _, err := m.Change.MarshalTo(dAtA[i:]); err != nil {
|
|
return 0, err
|
|
}
|
|
}
|
|
}
|
|
if len(m.Id) > 0 {
|
|
i -= len(m.Id)
|
|
copy(dAtA[i:], m.Id)
|
|
i = encodeVarintBlock(dAtA, i, uint64(len(m.Id)))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *BlockAtomicChange_Text) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockAtomicChange_Text) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
if m.Text != nil {
|
|
{
|
|
size, err := m.Text.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintBlock(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
func (m *BlockAtomicChange_BlockHeader) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockAtomicChange_BlockHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
if m.BlockHeader != nil {
|
|
{
|
|
size, err := m.BlockHeader.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintBlock(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
func (m *BlockAtomicChange_Page) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockAtomicChange_Page) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
if m.Page != nil {
|
|
{
|
|
size, err := m.Page.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintBlock(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x22
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
func (m *BlockAtomicChange_Dashboard) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockAtomicChange_Dashboard) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
if m.Dashboard != nil {
|
|
{
|
|
size, err := m.Dashboard.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintBlock(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x2a
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
func (m *BlockChanges) 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 *BlockChanges) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockChanges) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Changes) > 0 {
|
|
for iNdEx := len(m.Changes) - 1; iNdEx >= 0; iNdEx-- {
|
|
{
|
|
size, err := m.Changes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintBlock(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *Block) 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 *Block) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *Block) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Content != nil {
|
|
{
|
|
size := m.Content.Size()
|
|
i -= size
|
|
if _, err := m.Content.MarshalTo(dAtA[i:]); err != nil {
|
|
return 0, err
|
|
}
|
|
}
|
|
}
|
|
if m.Header != nil {
|
|
{
|
|
size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintBlock(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *Block_Dashboard) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *Block_Dashboard) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
if m.Dashboard != nil {
|
|
{
|
|
size, err := m.Dashboard.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintBlock(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x5a
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
func (m *Block_Page) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *Block_Page) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
if m.Page != nil {
|
|
{
|
|
size, err := m.Page.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintBlock(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x62
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
func (m *Block_Dataview) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *Block_Dataview) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
if m.Dataview != nil {
|
|
{
|
|
size, err := m.Dataview.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintBlock(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x6a
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
func (m *Block_Text) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *Block_Text) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
if m.Text != nil {
|
|
{
|
|
size, err := m.Text.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintBlock(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x72
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
func (m *Block_Media) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *Block_Media) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
if m.Media != nil {
|
|
{
|
|
size, err := m.Media.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintBlock(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x7a
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
func (m *BlockHeader) 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 *BlockHeader) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Permissions != nil {
|
|
{
|
|
size, err := m.Permissions.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintBlock(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x22
|
|
}
|
|
if m.Fields != nil {
|
|
{
|
|
size, err := m.Fields.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintBlock(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
if m.Type != 0 {
|
|
i = encodeVarintBlock(dAtA, i, uint64(m.Type))
|
|
i--
|
|
dAtA[i] = 0x10
|
|
}
|
|
if len(m.Id) > 0 {
|
|
i -= len(m.Id)
|
|
copy(dAtA[i:], m.Id)
|
|
i = encodeVarintBlock(dAtA, i, uint64(len(m.Id)))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *BlockPermissions) 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 *BlockPermissions) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockPermissions) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.DropOn {
|
|
i--
|
|
if m.DropOn {
|
|
dAtA[i] = 1
|
|
} else {
|
|
dAtA[i] = 0
|
|
}
|
|
i--
|
|
dAtA[i] = 0x28
|
|
}
|
|
if m.Drag {
|
|
i--
|
|
if m.Drag {
|
|
dAtA[i] = 1
|
|
} else {
|
|
dAtA[i] = 0
|
|
}
|
|
i--
|
|
dAtA[i] = 0x20
|
|
}
|
|
if m.Remove {
|
|
i--
|
|
if m.Remove {
|
|
dAtA[i] = 1
|
|
} else {
|
|
dAtA[i] = 0
|
|
}
|
|
i--
|
|
dAtA[i] = 0x18
|
|
}
|
|
if m.Edit {
|
|
i--
|
|
if m.Edit {
|
|
dAtA[i] = 1
|
|
} else {
|
|
dAtA[i] = 0
|
|
}
|
|
i--
|
|
dAtA[i] = 0x10
|
|
}
|
|
if m.Read {
|
|
i--
|
|
if m.Read {
|
|
dAtA[i] = 1
|
|
} else {
|
|
dAtA[i] = 0
|
|
}
|
|
i--
|
|
dAtA[i] = 0x8
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *BlockConnections) 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 *BlockConnections) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockConnections) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Inner) > 0 {
|
|
i -= len(m.Inner)
|
|
copy(dAtA[i:], m.Inner)
|
|
i = encodeVarintBlock(dAtA, i, uint64(len(m.Inner)))
|
|
i--
|
|
dAtA[i] = 0x2a
|
|
}
|
|
if len(m.RowRight) > 0 {
|
|
i -= len(m.RowRight)
|
|
copy(dAtA[i:], m.RowRight)
|
|
i = encodeVarintBlock(dAtA, i, uint64(len(m.RowRight)))
|
|
i--
|
|
dAtA[i] = 0x22
|
|
}
|
|
if len(m.ColumnBottom) > 0 {
|
|
i -= len(m.ColumnBottom)
|
|
copy(dAtA[i:], m.ColumnBottom)
|
|
i = encodeVarintBlock(dAtA, i, uint64(len(m.ColumnBottom)))
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
if len(m.Next) > 0 {
|
|
i -= len(m.Next)
|
|
copy(dAtA[i:], m.Next)
|
|
i = encodeVarintBlock(dAtA, i, uint64(len(m.Next)))
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if len(m.Id) > 0 {
|
|
i -= len(m.Id)
|
|
copy(dAtA[i:], m.Id)
|
|
i = encodeVarintBlock(dAtA, i, uint64(len(m.Id)))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *BlockConnectionsList) 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 *BlockConnectionsList) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockConnectionsList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Structure) > 0 {
|
|
for iNdEx := len(m.Structure) - 1; iNdEx >= 0; iNdEx-- {
|
|
{
|
|
size, err := m.Structure[iNdEx].MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintBlock(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *BlockHeadersList) 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 *BlockHeadersList) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockHeadersList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Headers) > 0 {
|
|
for iNdEx := len(m.Headers) - 1; iNdEx >= 0; iNdEx-- {
|
|
{
|
|
size, err := m.Headers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintBlock(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *BlocksList) 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 *BlocksList) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlocksList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
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 = encodeVarintBlock(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *BlockContentPage) 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 *BlockContentPage) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockContentPage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Blocks != nil {
|
|
{
|
|
size, err := m.Blocks.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintBlock(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
if m.Structure != nil {
|
|
{
|
|
size, err := m.Structure.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintBlock(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if m.Style != 0 {
|
|
i = encodeVarintBlock(dAtA, i, uint64(m.Style))
|
|
i--
|
|
dAtA[i] = 0x8
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *BlockContentDashboard) 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 *BlockContentDashboard) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockContentDashboard) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Headers != nil {
|
|
{
|
|
size, err := m.Headers.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintBlock(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
if m.Structure != nil {
|
|
{
|
|
size, err := m.Structure.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintBlock(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if m.Style != 0 {
|
|
i = encodeVarintBlock(dAtA, i, uint64(m.Style))
|
|
i--
|
|
dAtA[i] = 0x8
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *BlockContentDataview) 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 *BlockContentDataview) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockContentDataview) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *BlockContentText) 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 *BlockContentText) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockContentText) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Checked {
|
|
i--
|
|
if m.Checked {
|
|
dAtA[i] = 1
|
|
} else {
|
|
dAtA[i] = 0
|
|
}
|
|
i--
|
|
dAtA[i] = 0x38
|
|
}
|
|
if m.Checkable {
|
|
i--
|
|
if m.Checkable {
|
|
dAtA[i] = 1
|
|
} else {
|
|
dAtA[i] = 0
|
|
}
|
|
i--
|
|
dAtA[i] = 0x30
|
|
}
|
|
if m.MarkerType != 0 {
|
|
i = encodeVarintBlock(dAtA, i, uint64(m.MarkerType))
|
|
i--
|
|
dAtA[i] = 0x28
|
|
}
|
|
if m.Toggleable {
|
|
i--
|
|
if m.Toggleable {
|
|
dAtA[i] = 1
|
|
} else {
|
|
dAtA[i] = 0
|
|
}
|
|
i--
|
|
dAtA[i] = 0x20
|
|
}
|
|
if m.MarksList != nil {
|
|
{
|
|
size, err := m.MarksList.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintBlock(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
if m.Style != 0 {
|
|
i = encodeVarintBlock(dAtA, i, uint64(m.Style))
|
|
i--
|
|
dAtA[i] = 0x10
|
|
}
|
|
if len(m.Text) > 0 {
|
|
i -= len(m.Text)
|
|
copy(dAtA[i:], m.Text)
|
|
i = encodeVarintBlock(dAtA, i, uint64(len(m.Text)))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *BlockContentText_Marks) 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 *BlockContentText_Marks) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockContentText_Marks) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Marks) > 0 {
|
|
for iNdEx := len(m.Marks) - 1; iNdEx >= 0; iNdEx-- {
|
|
{
|
|
size, err := m.Marks[iNdEx].MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintBlock(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *BlockContentText_Mark) 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 *BlockContentText_Mark) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockContentText_Mark) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Param) > 0 {
|
|
i -= len(m.Param)
|
|
copy(dAtA[i:], m.Param)
|
|
i = encodeVarintBlock(dAtA, i, uint64(len(m.Param)))
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
if m.Type != 0 {
|
|
i = encodeVarintBlock(dAtA, i, uint64(m.Type))
|
|
i--
|
|
dAtA[i] = 0x10
|
|
}
|
|
if m.Range != nil {
|
|
{
|
|
size, err := m.Range.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintBlock(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *BlockContentMedia) 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 *BlockContentMedia) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *BlockContentMedia) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Link) > 0 {
|
|
i -= len(m.Link)
|
|
copy(dAtA[i:], m.Link)
|
|
i = encodeVarintBlock(dAtA, i, uint64(len(m.Link)))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *Range) 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 *Range) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *Range) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.To != 0 {
|
|
i = encodeVarintBlock(dAtA, i, uint64(m.To))
|
|
i--
|
|
dAtA[i] = 0x10
|
|
}
|
|
if m.From != 0 {
|
|
i = encodeVarintBlock(dAtA, i, uint64(m.From))
|
|
i--
|
|
dAtA[i] = 0x8
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func encodeVarintBlock(dAtA []byte, offset int, v uint64) int {
|
|
offset -= sovBlock(v)
|
|
base := offset
|
|
for v >= 1<<7 {
|
|
dAtA[offset] = uint8(v&0x7f | 0x80)
|
|
v >>= 7
|
|
offset++
|
|
}
|
|
dAtA[offset] = uint8(v)
|
|
return base
|
|
}
|
|
func (m *BlockOpenRequest) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Id)
|
|
if l > 0 {
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *BlockOpenResponse) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Error != nil {
|
|
l = m.Error.Size()
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
if m.BlockHeader != nil {
|
|
l = m.BlockHeader.Size()
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *BlockOpenResponse_Error) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Code != 0 {
|
|
n += 1 + sovBlock(uint64(m.Code))
|
|
}
|
|
l = len(m.Description)
|
|
if l > 0 {
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *BlockCreateRequest) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Type != 0 {
|
|
n += 1 + sovBlock(uint64(m.Type))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *BlockCreateResponse) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Error != nil {
|
|
l = m.Error.Size()
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *BlockCreateResponse_Error) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Code != 0 {
|
|
n += 1 + sovBlock(uint64(m.Code))
|
|
}
|
|
l = len(m.Description)
|
|
if l > 0 {
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *BlockUpdateRequest) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Changes != nil {
|
|
l = m.Changes.Size()
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *BlockUpdateResponse) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Error != nil {
|
|
l = m.Error.Size()
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *BlockUpdateResponse_Error) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Code != 0 {
|
|
n += 1 + sovBlock(uint64(m.Code))
|
|
}
|
|
l = len(m.Description)
|
|
if l > 0 {
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *BlockShow) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Block != nil {
|
|
l = m.Block.Size()
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *BlockUpdate) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Changes != nil {
|
|
l = m.Changes.Size()
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *BlockCreate) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Block != nil {
|
|
l = m.Block.Size()
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *BlockContentTextChange) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Change != nil {
|
|
n += m.Change.Size()
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *BlockContentTextChange_Text) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Text)
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
return n
|
|
}
|
|
func (m *BlockContentTextChange_Style) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
n += 1 + sovBlock(uint64(m.Style))
|
|
return n
|
|
}
|
|
func (m *BlockContentTextChange_Marks) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Marks != nil {
|
|
l = m.Marks.Size()
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
func (m *BlockContentTextChange_Toggleable) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
n += 2
|
|
return n
|
|
}
|
|
func (m *BlockContentTextChange_MarkerType) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
n += 1 + sovBlock(uint64(m.MarkerType))
|
|
return n
|
|
}
|
|
func (m *BlockContentTextChange_Checkable) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
n += 2
|
|
return n
|
|
}
|
|
func (m *BlockContentTextChange_Checked) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
n += 2
|
|
return n
|
|
}
|
|
func (m *BlockContentPageChange) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Change != nil {
|
|
n += m.Change.Size()
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *BlockContentPageChange_Style) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
n += 1 + sovBlock(uint64(m.Style))
|
|
return n
|
|
}
|
|
func (m *BlockContentPageChange_Structure) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Structure != nil {
|
|
l = m.Structure.Size()
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
func (m *BlockContentPageChange_Blocks) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Blocks != nil {
|
|
l = m.Blocks.Size()
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
func (m *BlockHeaderChange) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Change != nil {
|
|
n += m.Change.Size()
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *BlockHeaderChange_Id) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Id)
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
return n
|
|
}
|
|
func (m *BlockHeaderChange_Type) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
n += 1 + sovBlock(uint64(m.Type))
|
|
return n
|
|
}
|
|
func (m *BlockHeaderChange_Name) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Name)
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
return n
|
|
}
|
|
func (m *BlockHeaderChange_Icon) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Icon)
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
return n
|
|
}
|
|
func (m *BlockHeaderChange_Permissions) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Permissions != nil {
|
|
l = m.Permissions.Size()
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
func (m *BlockContentDashboardChange) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Change != nil {
|
|
n += m.Change.Size()
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *BlockContentDashboardChange_Style) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
n += 1 + sovBlock(uint64(m.Style))
|
|
return n
|
|
}
|
|
func (m *BlockContentDashboardChange_Structure) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Structure != nil {
|
|
l = m.Structure.Size()
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
func (m *BlockContentDashboardChange_Headers) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Headers != nil {
|
|
l = m.Headers.Size()
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
func (m *BlockAtomicChange) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Id)
|
|
if l > 0 {
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
if m.Change != nil {
|
|
n += m.Change.Size()
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *BlockAtomicChange_Text) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Text != nil {
|
|
l = m.Text.Size()
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
func (m *BlockAtomicChange_BlockHeader) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.BlockHeader != nil {
|
|
l = m.BlockHeader.Size()
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
func (m *BlockAtomicChange_Page) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Page != nil {
|
|
l = m.Page.Size()
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
func (m *BlockAtomicChange_Dashboard) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Dashboard != nil {
|
|
l = m.Dashboard.Size()
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
func (m *BlockChanges) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if len(m.Changes) > 0 {
|
|
for _, e := range m.Changes {
|
|
l = e.Size()
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *Block) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Header != nil {
|
|
l = m.Header.Size()
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
if m.Content != nil {
|
|
n += m.Content.Size()
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *Block_Dashboard) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Dashboard != nil {
|
|
l = m.Dashboard.Size()
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
func (m *Block_Page) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Page != nil {
|
|
l = m.Page.Size()
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
func (m *Block_Dataview) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Dataview != nil {
|
|
l = m.Dataview.Size()
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
func (m *Block_Text) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Text != nil {
|
|
l = m.Text.Size()
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
func (m *Block_Media) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Media != nil {
|
|
l = m.Media.Size()
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
func (m *BlockHeader) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Id)
|
|
if l > 0 {
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
if m.Type != 0 {
|
|
n += 1 + sovBlock(uint64(m.Type))
|
|
}
|
|
if m.Fields != nil {
|
|
l = m.Fields.Size()
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
if m.Permissions != nil {
|
|
l = m.Permissions.Size()
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *BlockPermissions) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Read {
|
|
n += 2
|
|
}
|
|
if m.Edit {
|
|
n += 2
|
|
}
|
|
if m.Remove {
|
|
n += 2
|
|
}
|
|
if m.Drag {
|
|
n += 2
|
|
}
|
|
if m.DropOn {
|
|
n += 2
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *BlockConnections) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Id)
|
|
if l > 0 {
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
l = len(m.Next)
|
|
if l > 0 {
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
l = len(m.ColumnBottom)
|
|
if l > 0 {
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
l = len(m.RowRight)
|
|
if l > 0 {
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
l = len(m.Inner)
|
|
if l > 0 {
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *BlockConnectionsList) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if len(m.Structure) > 0 {
|
|
for _, e := range m.Structure {
|
|
l = e.Size()
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *BlockHeadersList) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if len(m.Headers) > 0 {
|
|
for _, e := range m.Headers {
|
|
l = e.Size()
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *BlocksList) 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 + sovBlock(uint64(l))
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *BlockContentPage) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Style != 0 {
|
|
n += 1 + sovBlock(uint64(m.Style))
|
|
}
|
|
if m.Structure != nil {
|
|
l = m.Structure.Size()
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
if m.Blocks != nil {
|
|
l = m.Blocks.Size()
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *BlockContentDashboard) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Style != 0 {
|
|
n += 1 + sovBlock(uint64(m.Style))
|
|
}
|
|
if m.Structure != nil {
|
|
l = m.Structure.Size()
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
if m.Headers != nil {
|
|
l = m.Headers.Size()
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *BlockContentDataview) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
return n
|
|
}
|
|
|
|
func (m *BlockContentText) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Text)
|
|
if l > 0 {
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
if m.Style != 0 {
|
|
n += 1 + sovBlock(uint64(m.Style))
|
|
}
|
|
if m.MarksList != nil {
|
|
l = m.MarksList.Size()
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
if m.Toggleable {
|
|
n += 2
|
|
}
|
|
if m.MarkerType != 0 {
|
|
n += 1 + sovBlock(uint64(m.MarkerType))
|
|
}
|
|
if m.Checkable {
|
|
n += 2
|
|
}
|
|
if m.Checked {
|
|
n += 2
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *BlockContentText_Marks) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if len(m.Marks) > 0 {
|
|
for _, e := range m.Marks {
|
|
l = e.Size()
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *BlockContentText_Mark) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Range != nil {
|
|
l = m.Range.Size()
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
if m.Type != 0 {
|
|
n += 1 + sovBlock(uint64(m.Type))
|
|
}
|
|
l = len(m.Param)
|
|
if l > 0 {
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *BlockContentMedia) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Link)
|
|
if l > 0 {
|
|
n += 1 + l + sovBlock(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *Range) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.From != 0 {
|
|
n += 1 + sovBlock(uint64(m.From))
|
|
}
|
|
if m.To != 0 {
|
|
n += 1 + sovBlock(uint64(m.To))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func sovBlock(x uint64) (n int) {
|
|
return (math_bits.Len64(x|1) + 6) / 7
|
|
}
|
|
func sozBlock(x uint64) (n int) {
|
|
return sovBlock(uint64((x << 1) ^ uint64((int64(x) >> 63))))
|
|
}
|
|
func (m *BlockOpenRequest) 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 ErrIntOverflowBlock
|
|
}
|
|
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: BlockOpenRequest: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: BlockOpenRequest: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
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 ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Id = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipBlock(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *BlockOpenResponse) 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 ErrIntOverflowBlock
|
|
}
|
|
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: BlockOpenResponse: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: BlockOpenResponse: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Error == nil {
|
|
m.Error = &BlockOpenResponse_Error{}
|
|
}
|
|
if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field BlockHeader", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.BlockHeader == nil {
|
|
m.BlockHeader = &BlockHeader{}
|
|
}
|
|
if err := m.BlockHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipBlock(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *BlockOpenResponse_Error) 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 ErrIntOverflowBlock
|
|
}
|
|
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: Error: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
|
|
}
|
|
m.Code = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Code |= BlockOpenResponse_Error_Code(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
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 ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Description = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipBlock(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *BlockCreateRequest) 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 ErrIntOverflowBlock
|
|
}
|
|
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: BlockCreateRequest: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: BlockCreateRequest: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
|
|
}
|
|
m.Type = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Type |= BlockType(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipBlock(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *BlockCreateResponse) 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 ErrIntOverflowBlock
|
|
}
|
|
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: BlockCreateResponse: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: BlockCreateResponse: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Error == nil {
|
|
m.Error = &BlockCreateResponse_Error{}
|
|
}
|
|
if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipBlock(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *BlockCreateResponse_Error) 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 ErrIntOverflowBlock
|
|
}
|
|
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: Error: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
|
|
}
|
|
m.Code = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Code |= BlockCreateResponse_Error_Code(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
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 ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Description = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipBlock(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *BlockUpdateRequest) 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 ErrIntOverflowBlock
|
|
}
|
|
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: BlockUpdateRequest: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: BlockUpdateRequest: 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 ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Changes == nil {
|
|
m.Changes = &BlockChanges{}
|
|
}
|
|
if err := m.Changes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipBlock(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *BlockUpdateResponse) 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 ErrIntOverflowBlock
|
|
}
|
|
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: BlockUpdateResponse: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: BlockUpdateResponse: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Error == nil {
|
|
m.Error = &BlockUpdateResponse_Error{}
|
|
}
|
|
if err := m.Error.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipBlock(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *BlockUpdateResponse_Error) 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 ErrIntOverflowBlock
|
|
}
|
|
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: Error: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: Error: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
|
|
}
|
|
m.Code = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Code |= BlockUpdateResponse_Error_Code(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
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 ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Description = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipBlock(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *BlockShow) 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 ErrIntOverflowBlock
|
|
}
|
|
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: BlockShow: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: BlockShow: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Block", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Block == nil {
|
|
m.Block = &Block{}
|
|
}
|
|
if err := m.Block.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipBlock(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *BlockUpdate) 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 ErrIntOverflowBlock
|
|
}
|
|
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: BlockUpdate: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: BlockUpdate: 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 ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Changes == nil {
|
|
m.Changes = &BlockChanges{}
|
|
}
|
|
if err := m.Changes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipBlock(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *BlockCreate) 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 ErrIntOverflowBlock
|
|
}
|
|
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: BlockCreate: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: BlockCreate: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Block", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Block == nil {
|
|
m.Block = &Block{}
|
|
}
|
|
if err := m.Block.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipBlock(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *BlockContentTextChange) 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 ErrIntOverflowBlock
|
|
}
|
|
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: BlockContentTextChange: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: BlockContentTextChange: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Text", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
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 ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Change = &BlockContentTextChange_Text{string(dAtA[iNdEx:postIndex])}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Style", wireType)
|
|
}
|
|
var v BlockContentText_Style
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= BlockContentText_Style(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Change = &BlockContentTextChange_Style{v}
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Marks", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
v := &BlockContentText_Marks{}
|
|
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
m.Change = &BlockContentTextChange_Marks{v}
|
|
iNdEx = postIndex
|
|
case 4:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Toggleable", wireType)
|
|
}
|
|
var v int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
b := bool(v != 0)
|
|
m.Change = &BlockContentTextChange_Toggleable{b}
|
|
case 5:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field MarkerType", wireType)
|
|
}
|
|
var v BlockContentText_MarkerType
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= BlockContentText_MarkerType(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Change = &BlockContentTextChange_MarkerType{v}
|
|
case 6:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Checkable", wireType)
|
|
}
|
|
var v int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
b := bool(v != 0)
|
|
m.Change = &BlockContentTextChange_Checkable{b}
|
|
case 7:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Checked", wireType)
|
|
}
|
|
var v int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
b := bool(v != 0)
|
|
m.Change = &BlockContentTextChange_Checked{b}
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipBlock(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *BlockContentPageChange) 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 ErrIntOverflowBlock
|
|
}
|
|
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: BlockContentPageChange: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: BlockContentPageChange: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Style", wireType)
|
|
}
|
|
var v BlockContentPage_Style
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= BlockContentPage_Style(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Change = &BlockContentPageChange_Style{v}
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Structure", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
v := &BlockConnectionsList{}
|
|
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
m.Change = &BlockContentPageChange_Structure{v}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
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 ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
v := &BlocksList{}
|
|
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
m.Change = &BlockContentPageChange_Blocks{v}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipBlock(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *BlockHeaderChange) 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 ErrIntOverflowBlock
|
|
}
|
|
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: BlockHeaderChange: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: BlockHeaderChange: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
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 ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Change = &BlockHeaderChange_Id{string(dAtA[iNdEx:postIndex])}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
|
|
}
|
|
var v BlockType
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= BlockType(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Change = &BlockHeaderChange_Type{v}
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
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 ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Change = &BlockHeaderChange_Name{string(dAtA[iNdEx:postIndex])}
|
|
iNdEx = postIndex
|
|
case 4:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Icon", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
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 ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Change = &BlockHeaderChange_Icon{string(dAtA[iNdEx:postIndex])}
|
|
iNdEx = postIndex
|
|
case 5:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Permissions", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
v := &BlockPermissions{}
|
|
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
m.Change = &BlockHeaderChange_Permissions{v}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipBlock(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *BlockContentDashboardChange) 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 ErrIntOverflowBlock
|
|
}
|
|
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: BlockContentDashboardChange: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: BlockContentDashboardChange: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Style", wireType)
|
|
}
|
|
var v BlockContentDashboard_Style
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= BlockContentDashboard_Style(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Change = &BlockContentDashboardChange_Style{v}
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Structure", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
v := &BlockConnectionsList{}
|
|
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
m.Change = &BlockContentDashboardChange_Structure{v}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Headers", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
v := &BlockHeadersList{}
|
|
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
m.Change = &BlockContentDashboardChange_Headers{v}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipBlock(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *BlockAtomicChange) 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 ErrIntOverflowBlock
|
|
}
|
|
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: BlockAtomicChange: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: BlockAtomicChange: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
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 ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Id = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Text", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
v := &BlockContentTextChange{}
|
|
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
m.Change = &BlockAtomicChange_Text{v}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field BlockHeader", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
v := &BlockHeaderChange{}
|
|
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
m.Change = &BlockAtomicChange_BlockHeader{v}
|
|
iNdEx = postIndex
|
|
case 4:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Page", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
v := &BlockContentPageChange{}
|
|
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
m.Change = &BlockAtomicChange_Page{v}
|
|
iNdEx = postIndex
|
|
case 5:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Dashboard", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
v := &BlockContentDashboardChange{}
|
|
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
m.Change = &BlockAtomicChange_Dashboard{v}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipBlock(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *BlockChanges) 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 ErrIntOverflowBlock
|
|
}
|
|
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: BlockChanges: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: BlockChanges: 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 ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Changes = append(m.Changes, &BlockAtomicChange{})
|
|
if err := m.Changes[len(m.Changes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipBlock(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *Block) 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 ErrIntOverflowBlock
|
|
}
|
|
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 {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Header == nil {
|
|
m.Header = &BlockHeader{}
|
|
}
|
|
if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 11:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Dashboard", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
v := &BlockContentDashboard{}
|
|
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
m.Content = &Block_Dashboard{v}
|
|
iNdEx = postIndex
|
|
case 12:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Page", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
v := &BlockContentPage{}
|
|
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
m.Content = &Block_Page{v}
|
|
iNdEx = postIndex
|
|
case 13:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Dataview", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
v := &BlockContentDataview{}
|
|
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
m.Content = &Block_Dataview{v}
|
|
iNdEx = postIndex
|
|
case 14:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Text", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
v := &BlockContentText{}
|
|
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
m.Content = &Block_Text{v}
|
|
iNdEx = postIndex
|
|
case 15:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Media", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
v := &BlockContentMedia{}
|
|
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
m.Content = &Block_Media{v}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipBlock(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *BlockHeader) 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 ErrIntOverflowBlock
|
|
}
|
|
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: BlockHeader: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: BlockHeader: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
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 ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Id = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
|
|
}
|
|
m.Type = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Type |= BlockType(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Fields", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Fields == nil {
|
|
m.Fields = &Struct{}
|
|
}
|
|
if err := m.Fields.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 4:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Permissions", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Permissions == nil {
|
|
m.Permissions = &BlockPermissions{}
|
|
}
|
|
if err := m.Permissions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipBlock(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *BlockPermissions) 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 ErrIntOverflowBlock
|
|
}
|
|
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: BlockPermissions: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: BlockPermissions: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Read", wireType)
|
|
}
|
|
var v int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Read = bool(v != 0)
|
|
case 2:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Edit", wireType)
|
|
}
|
|
var v int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Edit = bool(v != 0)
|
|
case 3:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Remove", wireType)
|
|
}
|
|
var v int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Remove = bool(v != 0)
|
|
case 4:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Drag", wireType)
|
|
}
|
|
var v int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Drag = bool(v != 0)
|
|
case 5:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field DropOn", wireType)
|
|
}
|
|
var v int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.DropOn = bool(v != 0)
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipBlock(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *BlockConnections) 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 ErrIntOverflowBlock
|
|
}
|
|
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: BlockConnections: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: BlockConnections: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
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 ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Id = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Next", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
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 ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Next = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field ColumnBottom", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
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 ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.ColumnBottom = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 4:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field RowRight", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
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 ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.RowRight = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 5:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Inner", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
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 ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Inner = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipBlock(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *BlockConnectionsList) 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 ErrIntOverflowBlock
|
|
}
|
|
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: BlockConnectionsList: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: BlockConnectionsList: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Structure", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Structure = append(m.Structure, &BlockConnections{})
|
|
if err := m.Structure[len(m.Structure)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipBlock(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *BlockHeadersList) 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 ErrIntOverflowBlock
|
|
}
|
|
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: BlockHeadersList: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: BlockHeadersList: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Headers", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Headers = append(m.Headers, &BlockHeader{})
|
|
if err := m.Headers[len(m.Headers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipBlock(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *BlocksList) 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 ErrIntOverflowBlock
|
|
}
|
|
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: BlocksList: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: BlocksList: 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 ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Blocks = append(m.Blocks, &Block{})
|
|
if err := m.Blocks[len(m.Blocks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipBlock(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *BlockContentPage) 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 ErrIntOverflowBlock
|
|
}
|
|
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: BlockContentPage: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: BlockContentPage: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Style", wireType)
|
|
}
|
|
m.Style = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Style |= BlockContentPage_Style(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Structure", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Structure == nil {
|
|
m.Structure = &BlockConnectionsList{}
|
|
}
|
|
if err := m.Structure.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
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 ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Blocks == nil {
|
|
m.Blocks = &BlocksList{}
|
|
}
|
|
if err := m.Blocks.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipBlock(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *BlockContentDashboard) 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 ErrIntOverflowBlock
|
|
}
|
|
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: BlockContentDashboard: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: BlockContentDashboard: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Style", wireType)
|
|
}
|
|
m.Style = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Style |= BlockContentDashboard_Style(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Structure", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Structure == nil {
|
|
m.Structure = &BlockConnectionsList{}
|
|
}
|
|
if err := m.Structure.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Headers", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Headers == nil {
|
|
m.Headers = &BlockHeadersList{}
|
|
}
|
|
if err := m.Headers.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipBlock(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *BlockContentDataview) 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 ErrIntOverflowBlock
|
|
}
|
|
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: BlockContentDataview: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: BlockContentDataview: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipBlock(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *BlockContentText) 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 ErrIntOverflowBlock
|
|
}
|
|
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: BlockContentText: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: BlockContentText: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Text", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
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 ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Text = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Style", wireType)
|
|
}
|
|
m.Style = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Style |= BlockContentText_Style(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field MarksList", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.MarksList == nil {
|
|
m.MarksList = &BlockContentText_Marks{}
|
|
}
|
|
if err := m.MarksList.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 4:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Toggleable", wireType)
|
|
}
|
|
var v int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Toggleable = bool(v != 0)
|
|
case 5:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field MarkerType", wireType)
|
|
}
|
|
m.MarkerType = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.MarkerType |= BlockContentText_MarkerType(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 6:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Checkable", wireType)
|
|
}
|
|
var v int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Checkable = bool(v != 0)
|
|
case 7:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Checked", wireType)
|
|
}
|
|
var v int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.Checked = bool(v != 0)
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipBlock(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *BlockContentText_Marks) 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 ErrIntOverflowBlock
|
|
}
|
|
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: Marks: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: Marks: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Marks", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Marks = append(m.Marks, &BlockContentText_Mark{})
|
|
if err := m.Marks[len(m.Marks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipBlock(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *BlockContentText_Mark) 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 ErrIntOverflowBlock
|
|
}
|
|
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: Mark: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: Mark: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
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 ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Range == nil {
|
|
m.Range = &Range{}
|
|
}
|
|
if err := m.Range.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
|
|
}
|
|
m.Type = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Type |= BlockContentText_Mark_Type(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Param", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
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 ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Param = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipBlock(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *BlockContentMedia) 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 ErrIntOverflowBlock
|
|
}
|
|
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: BlockContentMedia: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: BlockContentMedia: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Link", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
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 ErrInvalidLengthBlock
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Link = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipBlock(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *Range) 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 ErrIntOverflowBlock
|
|
}
|
|
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: Range: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: Range: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field From", wireType)
|
|
}
|
|
m.From = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.From |= int32(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 2:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field To", wireType)
|
|
}
|
|
m.To = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowBlock
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.To |= int32(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipBlock(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if skippy < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) < 0 {
|
|
return ErrInvalidLengthBlock
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func skipBlock(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, ErrIntOverflowBlock
|
|
}
|
|
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, ErrIntOverflowBlock
|
|
}
|
|
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, ErrIntOverflowBlock
|
|
}
|
|
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, ErrInvalidLengthBlock
|
|
}
|
|
iNdEx += length
|
|
case 3:
|
|
depth++
|
|
case 4:
|
|
if depth == 0 {
|
|
return 0, ErrUnexpectedEndOfGroupBlock
|
|
}
|
|
depth--
|
|
case 5:
|
|
iNdEx += 4
|
|
default:
|
|
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
|
|
}
|
|
if iNdEx < 0 {
|
|
return 0, ErrInvalidLengthBlock
|
|
}
|
|
if depth == 0 {
|
|
return iNdEx, nil
|
|
}
|
|
}
|
|
return 0, io.ErrUnexpectedEOF
|
|
}
|
|
|
|
var (
|
|
ErrInvalidLengthBlock = fmt.Errorf("proto: negative length found during unmarshaling")
|
|
ErrIntOverflowBlock = fmt.Errorf("proto: integer overflow")
|
|
ErrUnexpectedEndOfGroupBlock = fmt.Errorf("proto: unexpected end of group")
|
|
)
|