nodesync.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: nodesync/nodesyncproto/protos/nodesync.proto

package nodesyncproto

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 ErrCodes int32

const (
	ErrCodes_Unexpected          ErrCodes = 0
	ErrCodes_ExpectedCoordinator ErrCodes = 1
	ErrCodes_ErrorOffset         ErrCodes = 1000
)

var ErrCodes_name = map[int32]string{
	0:    "Unexpected",
	1:    "ExpectedCoordinator",
	1000: "ErrorOffset",
}

var ErrCodes_value = map[string]int32{
	"Unexpected":          0,
	"ExpectedCoordinator": 1,
	"ErrorOffset":         1000,
}

func (x ErrCodes) String() string {
	return proto.EnumName(ErrCodes_name, int32(x))
}

func (ErrCodes) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_e54c508e329d960e, []int{0}
}

// PartitionSyncRange presenting a request for one range
type PartitionSyncRange struct {
	From     uint64 `protobuf:"varint,1,opt,name=from,proto3" json:"from,omitempty"`
	To       uint64 `protobuf:"varint,2,opt,name=to,proto3" json:"to,omitempty"`
	Limit    uint32 `protobuf:"varint,3,opt,name=limit,proto3" json:"limit,omitempty"`
	Elements bool   `protobuf:"varint,4,opt,name=elements,proto3" json:"elements,omitempty"`
}

func (m *PartitionSyncRange) Reset()         { *m = PartitionSyncRange{} }
func (m *PartitionSyncRange) String() string { return proto.CompactTextString(m) }
func (*PartitionSyncRange) ProtoMessage()    {}
func (*PartitionSyncRange) Descriptor() ([]byte, []int) {
	return fileDescriptor_e54c508e329d960e, []int{0}
}
func (m *PartitionSyncRange) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PartitionSyncRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PartitionSyncRange.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 *PartitionSyncRange) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PartitionSyncRange.Merge(m, src)
}
func (m *PartitionSyncRange) XXX_Size() int {
	return m.Size()
}
func (m *PartitionSyncRange) XXX_DiscardUnknown() {
	xxx_messageInfo_PartitionSyncRange.DiscardUnknown(m)
}

var xxx_messageInfo_PartitionSyncRange proto.InternalMessageInfo

func (m *PartitionSyncRange) GetFrom() uint64 {
	if m != nil {
		return m.From
	}
	return 0
}

func (m *PartitionSyncRange) GetTo() uint64 {
	if m != nil {
		return m.To
	}
	return 0
}

func (m *PartitionSyncRange) GetLimit() uint32 {
	if m != nil {
		return m.Limit
	}
	return 0
}

func (m *PartitionSyncRange) GetElements() bool {
	if m != nil {
		return m.Elements
	}
	return false
}

// PartitionSyncResult presenting a response for one range
type PartitionSyncResult struct {
	Hash     []byte                        `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
	Elements []*PartitionSyncResultElement `protobuf:"bytes,2,rep,name=elements,proto3" json:"elements,omitempty"`
	Count    uint32                        `protobuf:"varint,3,opt,name=count,proto3" json:"count,omitempty"`
}

func (m *PartitionSyncResult) Reset()         { *m = PartitionSyncResult{} }
func (m *PartitionSyncResult) String() string { return proto.CompactTextString(m) }
func (*PartitionSyncResult) ProtoMessage()    {}
func (*PartitionSyncResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_e54c508e329d960e, []int{1}
}
func (m *PartitionSyncResult) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PartitionSyncResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PartitionSyncResult.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 *PartitionSyncResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PartitionSyncResult.Merge(m, src)
}
func (m *PartitionSyncResult) XXX_Size() int {
	return m.Size()
}
func (m *PartitionSyncResult) XXX_DiscardUnknown() {
	xxx_messageInfo_PartitionSyncResult.DiscardUnknown(m)
}

var xxx_messageInfo_PartitionSyncResult proto.InternalMessageInfo

func (m *PartitionSyncResult) GetHash() []byte {
	if m != nil {
		return m.Hash
	}
	return nil
}

func (m *PartitionSyncResult) GetElements() []*PartitionSyncResultElement {
	if m != nil {
		return m.Elements
	}
	return nil
}

func (m *PartitionSyncResult) GetCount() uint32 {
	if m != nil {
		return m.Count
	}
	return 0
}

// PartitionSyncResultElement presenting state of one object
type PartitionSyncResultElement struct {
	Id   string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Head string `protobuf:"bytes,2,opt,name=head,proto3" json:"head,omitempty"`
}

func (m *PartitionSyncResultElement) Reset()         { *m = PartitionSyncResultElement{} }
func (m *PartitionSyncResultElement) String() string { return proto.CompactTextString(m) }
func (*PartitionSyncResultElement) ProtoMessage()    {}
func (*PartitionSyncResultElement) Descriptor() ([]byte, []int) {
	return fileDescriptor_e54c508e329d960e, []int{2}
}
func (m *PartitionSyncResultElement) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PartitionSyncResultElement) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PartitionSyncResultElement.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 *PartitionSyncResultElement) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PartitionSyncResultElement.Merge(m, src)
}
func (m *PartitionSyncResultElement) XXX_Size() int {
	return m.Size()
}
func (m *PartitionSyncResultElement) XXX_DiscardUnknown() {
	xxx_messageInfo_PartitionSyncResultElement.DiscardUnknown(m)
}

var xxx_messageInfo_PartitionSyncResultElement proto.InternalMessageInfo

func (m *PartitionSyncResultElement) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *PartitionSyncResultElement) GetHead() string {
	if m != nil {
		return m.Head
	}
	return ""
}

// HeadSyncRequest is a request for HeadSync
type PartitionSyncRequest struct {
	PartitionId uint64                `protobuf:"varint,1,opt,name=partitionId,proto3" json:"partitionId,omitempty"`
	Ranges      []*PartitionSyncRange `protobuf:"bytes,2,rep,name=ranges,proto3" json:"ranges,omitempty"`
}

func (m *PartitionSyncRequest) Reset()         { *m = PartitionSyncRequest{} }
func (m *PartitionSyncRequest) String() string { return proto.CompactTextString(m) }
func (*PartitionSyncRequest) ProtoMessage()    {}
func (*PartitionSyncRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_e54c508e329d960e, []int{3}
}
func (m *PartitionSyncRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PartitionSyncRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PartitionSyncRequest.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 *PartitionSyncRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PartitionSyncRequest.Merge(m, src)
}
func (m *PartitionSyncRequest) XXX_Size() int {
	return m.Size()
}
func (m *PartitionSyncRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_PartitionSyncRequest.DiscardUnknown(m)
}

var xxx_messageInfo_PartitionSyncRequest proto.InternalMessageInfo

func (m *PartitionSyncRequest) GetPartitionId() uint64 {
	if m != nil {
		return m.PartitionId
	}
	return 0
}

func (m *PartitionSyncRequest) GetRanges() []*PartitionSyncRange {
	if m != nil {
		return m.Ranges
	}
	return nil
}

// PartitionSyncResponse is a response for HeadSync
type PartitionSyncResponse struct {
	Results []*PartitionSyncResult `protobuf:"bytes,1,rep,name=results,proto3" json:"results,omitempty"`
}

func (m *PartitionSyncResponse) Reset()         { *m = PartitionSyncResponse{} }
func (m *PartitionSyncResponse) String() string { return proto.CompactTextString(m) }
func (*PartitionSyncResponse) ProtoMessage()    {}
func (*PartitionSyncResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_e54c508e329d960e, []int{4}
}
func (m *PartitionSyncResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PartitionSyncResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PartitionSyncResponse.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 *PartitionSyncResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PartitionSyncResponse.Merge(m, src)
}
func (m *PartitionSyncResponse) XXX_Size() int {
	return m.Size()
}
func (m *PartitionSyncResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_PartitionSyncResponse.DiscardUnknown(m)
}

var xxx_messageInfo_PartitionSyncResponse proto.InternalMessageInfo

func (m *PartitionSyncResponse) GetResults() []*PartitionSyncResult {
	if m != nil {
		return m.Results
	}
	return nil
}

type ColdSyncRequest struct {
	SpaceId string `protobuf:"bytes,1,opt,name=spaceId,proto3" json:"spaceId,omitempty"`
}

func (m *ColdSyncRequest) Reset()         { *m = ColdSyncRequest{} }
func (m *ColdSyncRequest) String() string { return proto.CompactTextString(m) }
func (*ColdSyncRequest) ProtoMessage()    {}
func (*ColdSyncRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_e54c508e329d960e, []int{5}
}
func (m *ColdSyncRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ColdSyncRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ColdSyncRequest.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 *ColdSyncRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ColdSyncRequest.Merge(m, src)
}
func (m *ColdSyncRequest) XXX_Size() int {
	return m.Size()
}
func (m *ColdSyncRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ColdSyncRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ColdSyncRequest proto.InternalMessageInfo

func (m *ColdSyncRequest) GetSpaceId() string {
	if m != nil {
		return m.SpaceId
	}
	return ""
}

type ColdSyncResponse struct {
	Filename string `protobuf:"bytes,2,opt,name=filename,proto3" json:"filename,omitempty"`
	Data     []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
	Crc32    uint32 `protobuf:"varint,4,opt,name=crc32,proto3" json:"crc32,omitempty"`
}

func (m *ColdSyncResponse) Reset()         { *m = ColdSyncResponse{} }
func (m *ColdSyncResponse) String() string { return proto.CompactTextString(m) }
func (*ColdSyncResponse) ProtoMessage()    {}
func (*ColdSyncResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_e54c508e329d960e, []int{6}
}
func (m *ColdSyncResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ColdSyncResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ColdSyncResponse.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 *ColdSyncResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ColdSyncResponse.Merge(m, src)
}
func (m *ColdSyncResponse) XXX_Size() int {
	return m.Size()
}
func (m *ColdSyncResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ColdSyncResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ColdSyncResponse proto.InternalMessageInfo

func (m *ColdSyncResponse) GetFilename() string {
	if m != nil {
		return m.Filename
	}
	return ""
}

func (m *ColdSyncResponse) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *ColdSyncResponse) GetCrc32() uint32 {
	if m != nil {
		return m.Crc32
	}
	return 0
}

func init() {
	proto.RegisterEnum("anyNodeSync.ErrCodes", ErrCodes_name, ErrCodes_value)
	proto.RegisterType((*PartitionSyncRange)(nil), "anyNodeSync.PartitionSyncRange")
	proto.RegisterType((*PartitionSyncResult)(nil), "anyNodeSync.PartitionSyncResult")
	proto.RegisterType((*PartitionSyncResultElement)(nil), "anyNodeSync.PartitionSyncResultElement")
	proto.RegisterType((*PartitionSyncRequest)(nil), "anyNodeSync.PartitionSyncRequest")
	proto.RegisterType((*PartitionSyncResponse)(nil), "anyNodeSync.PartitionSyncResponse")
	proto.RegisterType((*ColdSyncRequest)(nil), "anyNodeSync.ColdSyncRequest")
	proto.RegisterType((*ColdSyncResponse)(nil), "anyNodeSync.ColdSyncResponse")
}

func init() {
	proto.RegisterFile("nodesync/nodesyncproto/protos/nodesync.proto", fileDescriptor_e54c508e329d960e)
}

var fileDescriptor_e54c508e329d960e = []byte{
	// 503 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x53, 0xc1, 0x6e, 0xd3, 0x4c,
	0x10, 0xce, 0xa6, 0xf9, 0x1b, 0x77, 0xd2, 0xf6, 0xb7, 0xb6, 0x05, 0x2c, 0x0b, 0x8c, 0xf1, 0x85,
	0x08, 0x50, 0x5a, 0xa5, 0x07, 0x24, 0x4e, 0x88, 0xc8, 0x87, 0x5c, 0x00, 0x6d, 0x05, 0x42, 0xdc,
	0x16, 0xef, 0x86, 0x1a, 0x39, 0xbb, 0xee, 0xee, 0x46, 0x22, 0x77, 0x1e, 0x80, 0x17, 0xe1, 0x3d,
	0x38, 0xf6, 0xc8, 0x11, 0x25, 0x17, 0x1e, 0x03, 0xed, 0xc6, 0x4e, 0x93, 0xa8, 0x0d, 0x17, 0x7b,
	0xbe, 0xf1, 0xec, 0xcc, 0xf7, 0x7d, 0x3b, 0x86, 0x67, 0x42, 0x32, 0xae, 0xa7, 0x22, 0x3b, 0xa9,
	0x83, 0x52, 0x49, 0x23, 0x4f, 0xdc, 0x53, 0x2f, 0x93, 0x3d, 0x87, 0x71, 0x87, 0x8a, 0xe9, 0x6b,
	0xc9, 0xf8, 0xf9, 0x54, 0x64, 0xc9, 0x17, 0xc0, 0x6f, 0xa9, 0x32, 0xb9, 0xc9, 0xa5, 0xb0, 0x09,
	0x42, 0xc5, 0x67, 0x8e, 0x31, 0xb4, 0x46, 0x4a, 0x8e, 0x03, 0x14, 0xa3, 0x6e, 0x8b, 0xb8, 0x18,
	0x1f, 0x42, 0xd3, 0xc8, 0xa0, 0xe9, 0x32, 0x4d, 0x23, 0xf1, 0x31, 0xfc, 0x57, 0xe4, 0xe3, 0xdc,
	0x04, 0x3b, 0x31, 0xea, 0x1e, 0x90, 0x05, 0xc0, 0x21, 0x78, 0xbc, 0xe0, 0x63, 0x2e, 0x8c, 0x0e,
	0x5a, 0x31, 0xea, 0x7a, 0x64, 0x89, 0x93, 0x6f, 0x08, 0x8e, 0xd6, 0x87, 0x71, 0x3d, 0x29, 0x8c,
	0x9d, 0x76, 0x41, 0xf5, 0x85, 0x9b, 0xb6, 0x4f, 0x5c, 0x8c, 0x07, 0x2b, 0x7d, 0x9a, 0xf1, 0x4e,
	0xb7, 0xd3, 0x7f, 0xdc, 0x5b, 0xe1, 0xdd, 0xbb, 0xa1, 0x4f, 0xba, 0xa8, 0xbf, 0x1e, 0x68, 0x29,
	0x66, 0x72, 0x22, 0x96, 0x14, 0x1d, 0x48, 0x5e, 0x42, 0x78, 0xfb, 0x69, 0x2b, 0x33, 0x67, 0x8e,
	0xca, 0x1e, 0x69, 0xe6, 0xcc, 0x91, 0xe3, 0x94, 0x39, 0xe1, 0x7b, 0xc4, 0xc5, 0xc9, 0x25, 0x1c,
	0x6f, 0x74, 0xb8, 0x9c, 0x70, 0x6d, 0x70, 0x0c, 0x9d, 0xb2, 0xce, 0x0f, 0x59, 0xe5, 0xde, 0x6a,
	0x0a, 0x3f, 0x87, 0x5d, 0x65, 0x1d, 0xae, 0x45, 0x3d, 0xdc, 0x22, 0xca, 0xd6, 0x91, 0xaa, 0x3c,
	0x39, 0x87, 0x3b, 0x9b, 0xa4, 0x4b, 0x29, 0x34, 0xc7, 0x2f, 0xa0, 0xad, 0x9c, 0x00, 0x1d, 0x20,
	0xd7, 0x32, 0xfe, 0x97, 0x4f, 0xa4, 0x3e, 0x90, 0x3c, 0x85, 0xff, 0x07, 0xb2, 0x60, 0xab, 0x12,
	0x02, 0x68, 0xeb, 0x92, 0x66, 0x7c, 0x58, 0x7b, 0x50, 0xc3, 0xe4, 0x03, 0xf8, 0xd7, 0xc5, 0xd5,
	0xf0, 0x10, 0xbc, 0x51, 0x5e, 0x70, 0x41, 0xc7, 0xbc, 0x32, 0x68, 0x89, 0xad, 0x71, 0x8c, 0x1a,
	0xea, 0xbc, 0xdf, 0x27, 0x2e, 0x76, 0x17, 0xa2, 0xb2, 0xb3, 0xbe, 0x5b, 0x0d, 0x7b, 0x21, 0x16,
	0x3c, 0x49, 0xc1, 0x4b, 0x95, 0x1a, 0xd8, 0x2d, 0xc5, 0x87, 0x00, 0xef, 0x04, 0xff, 0x5a, 0xf2,
	0xcc, 0x70, 0xe6, 0x37, 0xf0, 0x3d, 0x38, 0x4a, 0x2b, 0x34, 0x90, 0x52, 0xb1, 0x5c, 0x50, 0x23,
	0x95, 0x8f, 0xb0, 0x0f, 0x9d, 0x54, 0x29, 0xa9, 0xde, 0x8c, 0x46, 0x9a, 0x1b, 0xff, 0x4f, 0xbb,
	0xff, 0x03, 0x81, 0x57, 0xeb, 0xc6, 0xef, 0xe1, 0x60, 0x4d, 0x3a, 0x7e, 0xb4, 0xcd, 0x16, 0xa7,
	0x3d, 0x4c, 0xb6, 0x3a, 0xb7, 0x50, 0x3c, 0x04, 0xaf, 0x76, 0x01, 0xdf, 0x5f, 0xab, 0xdf, 0x70,
	0x32, 0x7c, 0x70, 0xcb, 0xd7, 0x45, 0xa3, 0x53, 0xf4, 0xea, 0xf4, 0xe7, 0x2c, 0x42, 0x57, 0xb3,
	0x08, 0xfd, 0x9e, 0x45, 0xe8, 0xfb, 0x3c, 0x6a, 0x5c, 0xcd, 0xa3, 0xc6, 0xaf, 0x79, 0xd4, 0xf8,
	0x78, 0xf7, 0xe6, 0xff, 0xf9, 0xd3, 0xae, 0x7b, 0x9d, 0xfd, 0x0d, 0x00, 0x00, 0xff, 0xff, 0x8e,
	0xc4, 0xd1, 0xd9, 0xf0, 0x03, 0x00, 0x00,
}

func (m *PartitionSyncRange) 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 *PartitionSyncRange) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PartitionSyncRange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Elements {
		i--
		if m.Elements {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if m.Limit != 0 {
		i = encodeVarintNodesync(dAtA, i, uint64(m.Limit))
		i--
		dAtA[i] = 0x18
	}
	if m.To != 0 {
		i = encodeVarintNodesync(dAtA, i, uint64(m.To))
		i--
		dAtA[i] = 0x10
	}
	if m.From != 0 {
		i = encodeVarintNodesync(dAtA, i, uint64(m.From))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *PartitionSyncResult) 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 *PartitionSyncResult) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PartitionSyncResult) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Count != 0 {
		i = encodeVarintNodesync(dAtA, i, uint64(m.Count))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Elements) > 0 {
		for iNdEx := len(m.Elements) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Elements[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintNodesync(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Hash) > 0 {
		i -= len(m.Hash)
		copy(dAtA[i:], m.Hash)
		i = encodeVarintNodesync(dAtA, i, uint64(len(m.Hash)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *PartitionSyncResultElement) 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 *PartitionSyncResultElement) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PartitionSyncResultElement) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Head) > 0 {
		i -= len(m.Head)
		copy(dAtA[i:], m.Head)
		i = encodeVarintNodesync(dAtA, i, uint64(len(m.Head)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintNodesync(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *PartitionSyncRequest) 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 *PartitionSyncRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PartitionSyncRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Ranges) > 0 {
		for iNdEx := len(m.Ranges) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Ranges[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintNodesync(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if m.PartitionId != 0 {
		i = encodeVarintNodesync(dAtA, i, uint64(m.PartitionId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *PartitionSyncResponse) 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 *PartitionSyncResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PartitionSyncResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Results) > 0 {
		for iNdEx := len(m.Results) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Results[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintNodesync(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *ColdSyncRequest) 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 *ColdSyncRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ColdSyncRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.SpaceId) > 0 {
		i -= len(m.SpaceId)
		copy(dAtA[i:], m.SpaceId)
		i = encodeVarintNodesync(dAtA, i, uint64(len(m.SpaceId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ColdSyncResponse) 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 *ColdSyncResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ColdSyncResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Crc32 != 0 {
		i = encodeVarintNodesync(dAtA, i, uint64(m.Crc32))
		i--
		dAtA[i] = 0x20
	}
	if len(m.Data) > 0 {
		i -= len(m.Data)
		copy(dAtA[i:], m.Data)
		i = encodeVarintNodesync(dAtA, i, uint64(len(m.Data)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Filename) > 0 {
		i -= len(m.Filename)
		copy(dAtA[i:], m.Filename)
		i = encodeVarintNodesync(dAtA, i, uint64(len(m.Filename)))
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}

func encodeVarintNodesync(dAtA []byte, offset int, v uint64) int {
	offset -= sovNodesync(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *PartitionSyncRange) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.From != 0 {
		n += 1 + sovNodesync(uint64(m.From))
	}
	if m.To != 0 {
		n += 1 + sovNodesync(uint64(m.To))
	}
	if m.Limit != 0 {
		n += 1 + sovNodesync(uint64(m.Limit))
	}
	if m.Elements {
		n += 2
	}
	return n
}

func (m *PartitionSyncResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Hash)
	if l > 0 {
		n += 1 + l + sovNodesync(uint64(l))
	}
	if len(m.Elements) > 0 {
		for _, e := range m.Elements {
			l = e.Size()
			n += 1 + l + sovNodesync(uint64(l))
		}
	}
	if m.Count != 0 {
		n += 1 + sovNodesync(uint64(m.Count))
	}
	return n
}

func (m *PartitionSyncResultElement) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovNodesync(uint64(l))
	}
	l = len(m.Head)
	if l > 0 {
		n += 1 + l + sovNodesync(uint64(l))
	}
	return n
}

func (m *PartitionSyncRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PartitionId != 0 {
		n += 1 + sovNodesync(uint64(m.PartitionId))
	}
	if len(m.Ranges) > 0 {
		for _, e := range m.Ranges {
			l = e.Size()
			n += 1 + l + sovNodesync(uint64(l))
		}
	}
	return n
}

func (m *PartitionSyncResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Results) > 0 {
		for _, e := range m.Results {
			l = e.Size()
			n += 1 + l + sovNodesync(uint64(l))
		}
	}
	return n
}

func (m *ColdSyncRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SpaceId)
	if l > 0 {
		n += 1 + l + sovNodesync(uint64(l))
	}
	return n
}

func (m *ColdSyncResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Filename)
	if l > 0 {
		n += 1 + l + sovNodesync(uint64(l))
	}
	l = len(m.Data)
	if l > 0 {
		n += 1 + l + sovNodesync(uint64(l))
	}
	if m.Crc32 != 0 {
		n += 1 + sovNodesync(uint64(m.Crc32))
	}
	return n
}

func sovNodesync(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozNodesync(x uint64) (n int) {
	return sovNodesync(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *PartitionSyncRange) 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 ErrIntOverflowNodesync
			}
			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: PartitionSyncRange: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PartitionSyncRange: 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 ErrIntOverflowNodesync
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.From |= uint64(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 ErrIntOverflowNodesync
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.To |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
			}
			m.Limit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNodesync
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Limit |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Elements", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNodesync
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Elements = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipNodesync(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNodesync
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PartitionSyncResult) 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 ErrIntOverflowNodesync
			}
			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: PartitionSyncResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PartitionSyncResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNodesync
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthNodesync
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthNodesync
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Hash = append(m.Hash[:0], dAtA[iNdEx:postIndex]...)
			if m.Hash == nil {
				m.Hash = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Elements", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNodesync
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNodesync
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNodesync
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Elements = append(m.Elements, &PartitionSyncResultElement{})
			if err := m.Elements[len(m.Elements)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
			}
			m.Count = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNodesync
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Count |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipNodesync(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNodesync
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PartitionSyncResultElement) 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 ErrIntOverflowNodesync
			}
			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: PartitionSyncResultElement: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PartitionSyncResultElement: 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 ErrIntOverflowNodesync
				}
				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 ErrInvalidLengthNodesync
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNodesync
			}
			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 Head", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNodesync
				}
				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 ErrInvalidLengthNodesync
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNodesync
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Head = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNodesync(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNodesync
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PartitionSyncRequest) 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 ErrIntOverflowNodesync
			}
			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: PartitionSyncRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PartitionSyncRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PartitionId", wireType)
			}
			m.PartitionId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNodesync
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PartitionId |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNodesync
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNodesync
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNodesync
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ranges = append(m.Ranges, &PartitionSyncRange{})
			if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNodesync(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNodesync
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PartitionSyncResponse) 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 ErrIntOverflowNodesync
			}
			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: PartitionSyncResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PartitionSyncResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Results", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNodesync
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthNodesync
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthNodesync
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Results = append(m.Results, &PartitionSyncResult{})
			if err := m.Results[len(m.Results)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNodesync(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNodesync
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ColdSyncRequest) 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 ErrIntOverflowNodesync
			}
			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: ColdSyncRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ColdSyncRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SpaceId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNodesync
				}
				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 ErrInvalidLengthNodesync
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNodesync
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SpaceId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipNodesync(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNodesync
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ColdSyncResponse) 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 ErrIntOverflowNodesync
			}
			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: ColdSyncResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ColdSyncResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Filename", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNodesync
				}
				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 ErrInvalidLengthNodesync
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthNodesync
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Filename = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNodesync
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthNodesync
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthNodesync
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
			if m.Data == nil {
				m.Data = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Crc32", wireType)
			}
			m.Crc32 = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowNodesync
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Crc32 |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipNodesync(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthNodesync
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipNodesync(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, ErrIntOverflowNodesync
			}
			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, ErrIntOverflowNodesync
				}
				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, ErrIntOverflowNodesync
				}
				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, ErrInvalidLengthNodesync
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupNodesync
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthNodesync
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthNodesync        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowNodesync          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupNodesync = fmt.Errorf("proto: unexpected end of group")
)