SeaweedFS is a distributed storage system for object storage (S3), file systems, Iceberg table buckets, and Lance vector buckets, designed to handle billions of files with O(1) disk access and effortless horizontal scaling.
Go blob-storagecloud-drivedistributed-file-systemdistributed-storageerasure-codingfusehadoop-hdfshdfskuberneteslancelancedbobject-storageposixs3s3-storageseaweedfstiered-file-systemvector-search
generate vtproto marshalers for filer_pb and use them on the metadata log path (#10337)
Chris Luc015cc3939ca
diff --git a/go.mod b/go.modindex aae0bb28f7..b4e346814f 100644--- a/go.mod+++ b/go.mod@@ -442,7 +442,7 @@ require (github.com/pingcap/log v1.1.1-0.20221110025148-ca232912c9f3 // indirectgithub.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c // indirectgithub.com/pkg/xattr v0.4.12 // indirect- github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10 // indirect+ github.com/planetscale/vtprotobuf v0.6.1-0.20240319094008-0393e58bdf10github.com/power-devops/perfstat v0.0.0-20240221224432-82ca36839d55 // indirectgithub.com/putdotio/go-putio/putio v0.0.0-20200123120452-16d982cac2b8 // indirectgithub.com/relvacode/iso8601 v1.7.0 // indirectdiff --git a/weed/filer/filer_notify_read.go b/weed/filer/filer_notify_read.goindex 8e89805c8c..c2e8ceeb45 100644--- a/weed/filer/filer_notify_read.go+++ b/weed/filer/filer_notify_read.go@@ -11,13 +11,11 @@ import ("strings""time"+ "github.com/seaweedfs/seaweedfs/weed/glog""github.com/seaweedfs/seaweedfs/weed/pb/filer_pb"+ "github.com/seaweedfs/seaweedfs/weed/util""github.com/seaweedfs/seaweedfs/weed/util/log_buffer""github.com/seaweedfs/seaweedfs/weed/wdclient"- "google.golang.org/protobuf/proto"-- "github.com/seaweedfs/seaweedfs/weed/glog"- "github.com/seaweedfs/seaweedfs/weed/util")type LogFileEntry struct {@@ -518,7 +516,7 @@ func (iter *LogFileIterator) getNext() (logEntry *filer_pb.LogEntry, err error)return nil, fmt.Errorf("entry data %d bytes, expected %d bytes", n, size)}logEntry = &filer_pb.LogEntry{}- if err = proto.Unmarshal(entryData, logEntry); err != nil {+ if err = logEntry.UnmarshalVT(entryData); err != nil {return}if logEntry.TsNs <= iter.startTsNs {diff --git a/weed/filer/persisted_log_cache.go b/weed/filer/persisted_log_cache.goindex 2d48fc6b6e..6f33a8c444 100644--- a/weed/filer/persisted_log_cache.go+++ b/weed/filer/persisted_log_cache.go@@ -8,13 +8,11 @@ import ("sync""time"- "golang.org/x/sync/semaphore"- "golang.org/x/sync/singleflight"- "google.golang.org/protobuf/proto"-"github.com/seaweedfs/seaweedfs/weed/pb/filer_pb""github.com/seaweedfs/seaweedfs/weed/util""github.com/seaweedfs/seaweedfs/weed/wdclient"+ "golang.org/x/sync/semaphore"+ "golang.org/x/sync/singleflight")const (@@ -201,10 +199,10 @@ func loadLogFileEntries(masterClient *wdclient.MasterClient, chunk *filer_pb.Fil// decodeLogRecords parses size-prefixed LogEntry records. A buffer that stops// mid-record, or whose size prefix is garbage (also the symptom of starting// mid-record), reports errLogChunkIncomplete with the cleanly decoded prefix.-// Since proto.Unmarshal is permissive enough to accept misaligned bytes,+// Since UnmarshalVT is permissive enough to accept misaligned bytes,// records must also satisfy the writer's invariants: never empty, a positive// timestamp, and strictly increasing within one flushed buffer.-// proto.Unmarshal copies all bytes, so the entries do not alias data.+// UnmarshalVT copies all bytes, so the entries do not alias data.func decodeLogRecords(data []byte) (entries []*filer_pb.LogEntry, cacheable bool, err error) {var lastTsNs int64for pos := 0; pos < len(data); {@@ -220,7 +218,7 @@ func decodeLogRecords(data []byte) (entries []*filer_pb.LogEntry, cacheable boolreturn entries, false, errLogChunkIncomplete}logEntry := &filer_pb.LogEntry{}- if unmarshalErr := proto.Unmarshal(data[pos+4:pos+4+size], logEntry); unmarshalErr != nil {+ if unmarshalErr := logEntry.UnmarshalVT(data[pos+4 : pos+4+size]); unmarshalErr != nil {return entries, false, errLogChunkIncomplete}if logEntry.TsNs <= lastTsNs {diff --git a/weed/pb/Makefile b/weed/pb/Makefileindex f6edcef40d..b58f914dd9 100644--- a/weed/pb/Makefile+++ b/weed/pb/Makefile@@ -5,7 +5,7 @@ all: gengen:protoc master.proto --go_out=./master_pb --go-grpc_out=./master_pb --go_opt=paths=source_relative --go-grpc_opt=paths=source_relativeprotoc volume_server.proto --go_out=./volume_server_pb --go-grpc_out=./volume_server_pb --go_opt=paths=source_relative --go-grpc_opt=paths=source_relative- protoc filer.proto --go_out=./filer_pb --go-grpc_out=./filer_pb --go_opt=paths=source_relative --go-grpc_opt=paths=source_relative+ protoc filer.proto --go_out=./filer_pb --go-grpc_out=./filer_pb --go-vtproto_out=./filer_pb --go_opt=paths=source_relative --go-grpc_opt=paths=source_relative --go-vtproto_opt=paths=source_relative,features=marshal+unmarshal+sizeprotoc remote.proto --go_out=./remote_pb --go-grpc_out=./remote_pb --go_opt=paths=source_relative --go-grpc_opt=paths=source_relativeprotoc iam.proto --go_out=./iam_pb --go-grpc_out=./iam_pb --go_opt=paths=source_relative --go-grpc_opt=paths=source_relativeprotoc mount.proto --go_out=./mount_pb --go-grpc_out=./mount_pb --go_opt=paths=source_relative --go-grpc_opt=paths=source_relativediff --git a/weed/pb/filer_pb/filer_vtproto.pb.go b/weed/pb/filer_pb/filer_vtproto.pb.gonew file mode 100644index 0000000000..ed0cd806d1--- /dev/null+++ b/weed/pb/filer_pb/filer_vtproto.pb.go@@ -0,0 +1,24298 @@+// Code generated by protoc-gen-go-vtproto. DO NOT EDIT.+// protoc-gen-go-vtproto version: v0.6.1-0.20240319094008-0393e58bdf10+// source: filer.proto++package filer_pb++import (+ binary "encoding/binary"+ fmt "fmt"+ protohelpers "github.com/planetscale/vtprotobuf/protohelpers"+ protoimpl "google.golang.org/protobuf/runtime/protoimpl"+ io "io"+)++const (+ // Verify that this generated code is sufficiently up-to-date.+ _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)+ // Verify that runtime/protoimpl is sufficiently up-to-date.+ _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)+)++func (m *LookupDirectoryEntryRequest) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *LookupDirectoryEntryRequest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *LookupDirectoryEntryRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.Name) > 0 {+ i -= len(m.Name)+ copy(dAtA[i:], m.Name)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))+ i--+ dAtA[i] = 0x12+ }+ if len(m.Directory) > 0 {+ i -= len(m.Directory)+ copy(dAtA[i:], m.Directory)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Directory)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *LookupDirectoryEntryResponse) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *LookupDirectoryEntryResponse) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *LookupDirectoryEntryResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if m.Entry != nil {+ size, err := m.Entry.MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *ListEntriesRequest) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *ListEntriesRequest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *ListEntriesRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if m.SnapshotTsNs != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.SnapshotTsNs))+ i--+ dAtA[i] = 0x30+ }+ if m.Limit != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Limit))+ i--+ dAtA[i] = 0x28+ }+ if m.InclusiveStartFrom {+ i--+ if m.InclusiveStartFrom {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x20+ }+ if len(m.StartFromFileName) > 0 {+ i -= len(m.StartFromFileName)+ copy(dAtA[i:], m.StartFromFileName)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StartFromFileName)))+ i--+ dAtA[i] = 0x1a+ }+ if len(m.Prefix) > 0 {+ i -= len(m.Prefix)+ copy(dAtA[i:], m.Prefix)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Prefix)))+ i--+ dAtA[i] = 0x12+ }+ if len(m.Directory) > 0 {+ i -= len(m.Directory)+ copy(dAtA[i:], m.Directory)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Directory)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *ListEntriesResponse) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *ListEntriesResponse) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *ListEntriesResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if m.SnapshotTsNs != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.SnapshotTsNs))+ i--+ dAtA[i] = 0x10+ }+ if m.Entry != nil {+ size, err := m.Entry.MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *RemoteEntry) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *RemoteEntry) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *RemoteEntry) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if m.RemoteSize != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.RemoteSize))+ i--+ dAtA[i] = 0x28+ }+ if m.RemoteMtime != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.RemoteMtime))+ i--+ dAtA[i] = 0x20+ }+ if len(m.RemoteETag) > 0 {+ i -= len(m.RemoteETag)+ copy(dAtA[i:], m.RemoteETag)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.RemoteETag)))+ i--+ dAtA[i] = 0x1a+ }+ if m.LastLocalSyncTsNs != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.LastLocalSyncTsNs))+ i--+ dAtA[i] = 0x10+ }+ if len(m.StorageName) > 0 {+ i -= len(m.StorageName)+ copy(dAtA[i:], m.StorageName)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.StorageName)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *Entry) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *Entry) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *Entry) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if m.WormEnforcedAtTsNs != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.WormEnforcedAtTsNs))+ i--+ dAtA[i] = 0x60+ }+ if m.Quota != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Quota))+ i--+ dAtA[i] = 0x58+ }+ if m.RemoteEntry != nil {+ size, err := m.RemoteEntry.MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0x52+ }+ if len(m.Content) > 0 {+ i -= len(m.Content)+ copy(dAtA[i:], m.Content)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Content)))+ i--+ dAtA[i] = 0x4a+ }+ if m.HardLinkCounter != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.HardLinkCounter))+ i--+ dAtA[i] = 0x40+ }+ if len(m.HardLinkId) > 0 {+ i -= len(m.HardLinkId)+ copy(dAtA[i:], m.HardLinkId)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.HardLinkId)))+ i--+ dAtA[i] = 0x3a+ }+ if len(m.Extended) > 0 {+ for k := range m.Extended {+ v := m.Extended[k]+ baseI := i+ i -= len(v)+ copy(dAtA[i:], v)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(v)))+ i--+ dAtA[i] = 0x12+ i -= len(k)+ copy(dAtA[i:], k)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k)))+ i--+ dAtA[i] = 0xa+ i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i))+ i--+ dAtA[i] = 0x2a+ }+ }+ if m.Attributes != nil {+ size, err := m.Attributes.MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0x22+ }+ if len(m.Chunks) > 0 {+ for iNdEx := len(m.Chunks) - 1; iNdEx >= 0; iNdEx-- {+ size, err := m.Chunks[iNdEx].MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0x1a+ }+ }+ if m.IsDirectory {+ i--+ if m.IsDirectory {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x10+ }+ if len(m.Name) > 0 {+ i -= len(m.Name)+ copy(dAtA[i:], m.Name)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *FullEntry) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *FullEntry) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *FullEntry) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if m.Entry != nil {+ size, err := m.Entry.MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0x12+ }+ if len(m.Dir) > 0 {+ i -= len(m.Dir)+ copy(dAtA[i:], m.Dir)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Dir)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *EventNotification) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *EventNotification) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *EventNotification) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.Signatures) > 0 {+ var pksize2 int+ for _, num := range m.Signatures {+ pksize2 += protohelpers.SizeOfVarint(uint64(num))+ }+ i -= pksize2+ j1 := i+ for _, num1 := range m.Signatures {+ num := uint64(num1)+ for num >= 1<<7 {+ dAtA[j1] = uint8(uint64(num)&0x7f | 0x80)+ num >>= 7+ j1+++ }+ dAtA[j1] = uint8(num)+ j1+++ }+ i = protohelpers.EncodeVarint(dAtA, i, uint64(pksize2))+ i--+ dAtA[i] = 0x32+ }+ if m.IsFromOtherCluster {+ i--+ if m.IsFromOtherCluster {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x28+ }+ if len(m.NewParentPath) > 0 {+ i -= len(m.NewParentPath)+ copy(dAtA[i:], m.NewParentPath)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.NewParentPath)))+ i--+ dAtA[i] = 0x22+ }+ if m.DeleteChunks {+ i--+ if m.DeleteChunks {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x18+ }+ if m.NewEntry != nil {+ size, err := m.NewEntry.MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0x12+ }+ if m.OldEntry != nil {+ size, err := m.OldEntry.MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *FileChunk) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *FileChunk) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *FileChunk) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.SseMetadata) > 0 {+ i -= len(m.SseMetadata)+ copy(dAtA[i:], m.SseMetadata)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.SseMetadata)))+ i--+ dAtA[i] = 0x6a+ }+ if m.SseType != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.SseType))+ i--+ dAtA[i] = 0x60+ }+ if m.IsChunkManifest {+ i--+ if m.IsChunkManifest {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x58+ }+ if m.IsCompressed {+ i--+ if m.IsCompressed {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x50+ }+ if len(m.CipherKey) > 0 {+ i -= len(m.CipherKey)+ copy(dAtA[i:], m.CipherKey)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.CipherKey)))+ i--+ dAtA[i] = 0x4a+ }+ if m.SourceFid != nil {+ size, err := m.SourceFid.MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0x42+ }+ if m.Fid != nil {+ size, err := m.Fid.MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0x3a+ }+ if len(m.SourceFileId) > 0 {+ i -= len(m.SourceFileId)+ copy(dAtA[i:], m.SourceFileId)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.SourceFileId)))+ i--+ dAtA[i] = 0x32+ }+ if len(m.ETag) > 0 {+ i -= len(m.ETag)+ copy(dAtA[i:], m.ETag)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ETag)))+ i--+ dAtA[i] = 0x2a+ }+ if m.ModifiedTsNs != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ModifiedTsNs))+ i--+ dAtA[i] = 0x20+ }+ if m.Size != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Size))+ i--+ dAtA[i] = 0x18+ }+ if m.Offset != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Offset))+ i--+ dAtA[i] = 0x10+ }+ if len(m.FileId) > 0 {+ i -= len(m.FileId)+ copy(dAtA[i:], m.FileId)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.FileId)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *FileChunkManifest) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *FileChunkManifest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *FileChunkManifest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.Chunks) > 0 {+ for iNdEx := len(m.Chunks) - 1; iNdEx >= 0; iNdEx-- {+ size, err := m.Chunks[iNdEx].MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0xa+ }+ }+ return len(dAtA) - i, nil+}++func (m *FileId) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *FileId) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *FileId) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if m.Cookie != 0 {+ i -= 4+ binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.Cookie))+ i--+ dAtA[i] = 0x1d+ }+ if m.FileKey != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.FileKey))+ i--+ dAtA[i] = 0x10+ }+ if m.VolumeId != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.VolumeId))+ i--+ dAtA[i] = 0x8+ }+ return len(dAtA) - i, nil+}++func (m *FuseAttributes) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *FuseAttributes) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *FuseAttributes) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if m.AtimeNs != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.AtimeNs))+ i--+ dAtA[i] = 0x1+ i--+ dAtA[i] = 0xb8+ }+ if m.Atime != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Atime))+ i--+ dAtA[i] = 0x1+ i--+ dAtA[i] = 0xb0+ }+ if m.CrtimeNs != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.CrtimeNs))+ i--+ dAtA[i] = 0x1+ i--+ dAtA[i] = 0xa8+ }+ if m.CtimeNs != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.CtimeNs))+ i--+ dAtA[i] = 0x1+ i--+ dAtA[i] = 0xa0+ }+ if m.MtimeNs != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.MtimeNs))+ i--+ dAtA[i] = 0x1+ i--+ dAtA[i] = 0x98+ }+ if m.Ctime != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Ctime))+ i--+ dAtA[i] = 0x1+ i--+ dAtA[i] = 0x90+ }+ if m.Inode != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Inode))+ i--+ dAtA[i] = 0x1+ i--+ dAtA[i] = 0x88+ }+ if m.Rdev != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Rdev))+ i--+ dAtA[i] = 0x1+ i--+ dAtA[i] = 0x80+ }+ if len(m.Md5) > 0 {+ i -= len(m.Md5)+ copy(dAtA[i:], m.Md5)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Md5)))+ i--+ dAtA[i] = 0x72+ }+ if len(m.SymlinkTarget) > 0 {+ i -= len(m.SymlinkTarget)+ copy(dAtA[i:], m.SymlinkTarget)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.SymlinkTarget)))+ i--+ dAtA[i] = 0x6a+ }+ if len(m.GroupName) > 0 {+ for iNdEx := len(m.GroupName) - 1; iNdEx >= 0; iNdEx-- {+ i -= len(m.GroupName[iNdEx])+ copy(dAtA[i:], m.GroupName[iNdEx])+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.GroupName[iNdEx])))+ i--+ dAtA[i] = 0x62+ }+ }+ if len(m.UserName) > 0 {+ i -= len(m.UserName)+ copy(dAtA[i:], m.UserName)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.UserName)))+ i--+ dAtA[i] = 0x5a+ }+ if m.TtlSec != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TtlSec))+ i--+ dAtA[i] = 0x50+ }+ if len(m.Mime) > 0 {+ i -= len(m.Mime)+ copy(dAtA[i:], m.Mime)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Mime)))+ i--+ dAtA[i] = 0x3a+ }+ if m.Crtime != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Crtime))+ i--+ dAtA[i] = 0x30+ }+ if m.Gid != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Gid))+ i--+ dAtA[i] = 0x28+ }+ if m.Uid != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Uid))+ i--+ dAtA[i] = 0x20+ }+ if m.FileMode != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.FileMode))+ i--+ dAtA[i] = 0x18+ }+ if m.Mtime != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Mtime))+ i--+ dAtA[i] = 0x10+ }+ if m.FileSize != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.FileSize))+ i--+ dAtA[i] = 0x8+ }+ return len(dAtA) - i, nil+}++func (m *CreateEntryRequest) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *CreateEntryRequest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *CreateEntryRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if m.Condition != nil {+ size, err := m.Condition.MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0x3a+ }+ if m.SkipCheckParentDirectory {+ i--+ if m.SkipCheckParentDirectory {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x30+ }+ if len(m.Signatures) > 0 {+ var pksize2 int+ for _, num := range m.Signatures {+ pksize2 += protohelpers.SizeOfVarint(uint64(num))+ }+ i -= pksize2+ j1 := i+ for _, num1 := range m.Signatures {+ num := uint64(num1)+ for num >= 1<<7 {+ dAtA[j1] = uint8(uint64(num)&0x7f | 0x80)+ num >>= 7+ j1+++ }+ dAtA[j1] = uint8(num)+ j1+++ }+ i = protohelpers.EncodeVarint(dAtA, i, uint64(pksize2))+ i--+ dAtA[i] = 0x2a+ }+ if m.IsFromOtherCluster {+ i--+ if m.IsFromOtherCluster {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x20+ }+ if m.OExcl {+ i--+ if m.OExcl {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x18+ }+ if m.Entry != nil {+ size, err := m.Entry.MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0x12+ }+ if len(m.Directory) > 0 {+ i -= len(m.Directory)+ copy(dAtA[i:], m.Directory)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Directory)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *WriteCondition_Clause) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *WriteCondition_Clause) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *WriteCondition_Clause) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.GateValue) > 0 {+ i -= len(m.GateValue)+ copy(dAtA[i:], m.GateValue)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.GateValue)))+ i--+ dAtA[i] = 0x42+ }+ if len(m.GateKey) > 0 {+ i -= len(m.GateKey)+ copy(dAtA[i:], m.GateKey)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.GateKey)))+ i--+ dAtA[i] = 0x3a+ }+ if len(m.ExtValue) > 0 {+ i -= len(m.ExtValue)+ copy(dAtA[i:], m.ExtValue)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ExtValue)))+ i--+ dAtA[i] = 0x32+ }+ if len(m.ExtKey) > 0 {+ i -= len(m.ExtKey)+ copy(dAtA[i:], m.ExtKey)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ExtKey)))+ i--+ dAtA[i] = 0x2a+ }+ if m.AllowWeak {+ i--+ if m.AllowWeak {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x20+ }+ if m.UnixTime != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.UnixTime))+ i--+ dAtA[i] = 0x18+ }+ if len(m.Etags) > 0 {+ for iNdEx := len(m.Etags) - 1; iNdEx >= 0; iNdEx-- {+ i -= len(m.Etags[iNdEx])+ copy(dAtA[i:], m.Etags[iNdEx])+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Etags[iNdEx])))+ i--+ dAtA[i] = 0x12+ }+ }+ if m.Kind != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Kind))+ i--+ dAtA[i] = 0x8+ }+ return len(dAtA) - i, nil+}++func (m *WriteCondition) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *WriteCondition) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *WriteCondition) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.Clauses) > 0 {+ for iNdEx := len(m.Clauses) - 1; iNdEx >= 0; iNdEx-- {+ size, err := m.Clauses[iNdEx].MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0xa+ }+ }+ return len(dAtA) - i, nil+}++func (m *ObjectMutation) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *ObjectMutation) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *ObjectMutation) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if m.RemoveEmptyParent {+ i--+ if m.RemoveEmptyParent {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x68+ }+ if m.TouchMtime {+ i--+ if m.TouchMtime {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x60+ }+ if len(m.Content) > 0 {+ i -= len(m.Content)+ copy(dAtA[i:], m.Content)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Content)))+ i--+ dAtA[i] = 0x5a+ }+ if m.SetContent {+ i--+ if m.SetContent {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x50+ }+ if m.Recompute != nil {+ size, err := m.Recompute.MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0x4a+ }+ if m.IsRecursive {+ i--+ if m.IsRecursive {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x40+ }+ if m.IsDeleteData {+ i--+ if m.IsDeleteData {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x38+ }+ if len(m.DeleteExtended) > 0 {+ for iNdEx := len(m.DeleteExtended) - 1; iNdEx >= 0; iNdEx-- {+ i -= len(m.DeleteExtended[iNdEx])+ copy(dAtA[i:], m.DeleteExtended[iNdEx])+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DeleteExtended[iNdEx])))+ i--+ dAtA[i] = 0x32+ }+ }+ if len(m.SetExtended) > 0 {+ for k := range m.SetExtended {+ v := m.SetExtended[k]+ baseI := i+ i -= len(v)+ copy(dAtA[i:], v)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(v)))+ i--+ dAtA[i] = 0x12+ i -= len(k)+ copy(dAtA[i:], k)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k)))+ i--+ dAtA[i] = 0xa+ i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i))+ i--+ dAtA[i] = 0x2a+ }+ }+ if m.Entry != nil {+ size, err := m.Entry.MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0x22+ }+ if len(m.Name) > 0 {+ i -= len(m.Name)+ copy(dAtA[i:], m.Name)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))+ i--+ dAtA[i] = 0x1a+ }+ if len(m.Directory) > 0 {+ i -= len(m.Directory)+ copy(dAtA[i:], m.Directory)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Directory)))+ i--+ dAtA[i] = 0x12+ }+ if m.Type != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Type))+ i--+ dAtA[i] = 0x8+ }+ return len(dAtA) - i, nil+}++func (m *Recompute) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *Recompute) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *Recompute) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.ExcludeName) > 0 {+ i -= len(m.ExcludeName)+ copy(dAtA[i:], m.ExcludeName)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ExcludeName)))+ i--+ dAtA[i] = 0x4a+ }+ if len(m.DemoteValue) > 0 {+ i -= len(m.DemoteValue)+ copy(dAtA[i:], m.DemoteValue)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DemoteValue)))+ i--+ dAtA[i] = 0x42+ }+ if len(m.DemoteKey) > 0 {+ i -= len(m.DemoteKey)+ copy(dAtA[i:], m.DemoteKey)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DemoteKey)))+ i--+ dAtA[i] = 0x3a+ }+ if len(m.MtimeToKey) > 0 {+ i -= len(m.MtimeToKey)+ copy(dAtA[i:], m.MtimeToKey)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.MtimeToKey)))+ i--+ dAtA[i] = 0x32+ }+ if len(m.SizeToKey) > 0 {+ i -= len(m.SizeToKey)+ copy(dAtA[i:], m.SizeToKey)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.SizeToKey)))+ i--+ dAtA[i] = 0x2a+ }+ if len(m.NameToKey) > 0 {+ i -= len(m.NameToKey)+ copy(dAtA[i:], m.NameToKey)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.NameToKey)))+ i--+ dAtA[i] = 0x22+ }+ if len(m.CopyExtended) > 0 {+ for k := range m.CopyExtended {+ v := m.CopyExtended[k]+ baseI := i+ i -= len(v)+ copy(dAtA[i:], v)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(v)))+ i--+ dAtA[i] = 0x12+ i -= len(k)+ copy(dAtA[i:], k)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k)))+ i--+ dAtA[i] = 0xa+ i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i))+ i--+ dAtA[i] = 0x1a+ }+ }+ if m.Descending {+ i--+ if m.Descending {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x10+ }+ if len(m.ScanDir) > 0 {+ i -= len(m.ScanDir)+ copy(dAtA[i:], m.ScanDir)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ScanDir)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *ObjectTransactionRequest) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *ObjectTransactionRequest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *ObjectTransactionRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if m.IsMoved {+ i--+ if m.IsMoved {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x40+ }+ if len(m.RouteKey) > 0 {+ i -= len(m.RouteKey)+ copy(dAtA[i:], m.RouteKey)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.RouteKey)))+ i--+ dAtA[i] = 0x3a+ }+ if len(m.ConditionKey) > 0 {+ i -= len(m.ConditionKey)+ copy(dAtA[i:], m.ConditionKey)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ConditionKey)))+ i--+ dAtA[i] = 0x32+ }+ if len(m.Signatures) > 0 {+ var pksize2 int+ for _, num := range m.Signatures {+ pksize2 += protohelpers.SizeOfVarint(uint64(num))+ }+ i -= pksize2+ j1 := i+ for _, num1 := range m.Signatures {+ num := uint64(num1)+ for num >= 1<<7 {+ dAtA[j1] = uint8(uint64(num)&0x7f | 0x80)+ num >>= 7+ j1+++ }+ dAtA[j1] = uint8(num)+ j1+++ }+ i = protohelpers.EncodeVarint(dAtA, i, uint64(pksize2))+ i--+ dAtA[i] = 0x2a+ }+ if m.IsFromOtherCluster {+ i--+ if m.IsFromOtherCluster {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x20+ }+ if len(m.Mutations) > 0 {+ for iNdEx := len(m.Mutations) - 1; iNdEx >= 0; iNdEx-- {+ size, err := m.Mutations[iNdEx].MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0x1a+ }+ }+ if m.Condition != nil {+ size, err := m.Condition.MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0x12+ }+ if len(m.LockKey) > 0 {+ i -= len(m.LockKey)+ copy(dAtA[i:], m.LockKey)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.LockKey)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *ObjectTransactionResponse) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *ObjectTransactionResponse) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *ObjectTransactionResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if m.ErrorCode != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ErrorCode))+ i--+ dAtA[i] = 0x10+ }+ if len(m.Error) > 0 {+ i -= len(m.Error)+ copy(dAtA[i:], m.Error)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Error)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *PosixLockRange) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *PosixLockRange) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *PosixLockRange) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if m.IsFlock {+ i--+ if m.IsFlock {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x38+ }+ if m.Pid != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Pid))+ i--+ dAtA[i] = 0x30+ }+ if m.Owner != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Owner))+ i--+ dAtA[i] = 0x28+ }+ if m.Sid != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Sid))+ i--+ dAtA[i] = 0x20+ }+ if m.Type != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Type))+ i--+ dAtA[i] = 0x18+ }+ if m.End != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.End))+ i--+ dAtA[i] = 0x10+ }+ if m.Start != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Start))+ i--+ dAtA[i] = 0x8+ }+ return len(dAtA) - i, nil+}++func (m *PosixLockRequest) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *PosixLockRequest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *PosixLockRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if m.CoolingProbe {+ i--+ if m.CoolingProbe {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x30+ }+ if len(m.Locks) > 0 {+ for iNdEx := len(m.Locks) - 1; iNdEx >= 0; iNdEx-- {+ size, err := m.Locks[iNdEx].MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0x2a+ }+ }+ if m.Lock != nil {+ size, err := m.Lock.MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0x22+ }+ if m.Op != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Op))+ i--+ dAtA[i] = 0x18+ }+ if m.IsMoved {+ i--+ if m.IsMoved {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x10+ }+ if len(m.Key) > 0 {+ i -= len(m.Key)+ copy(dAtA[i:], m.Key)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Key)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *PosixLockResponse) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *PosixLockResponse) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *PosixLockResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if m.Conflict != nil {+ size, err := m.Conflict.MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0x1a+ }+ if m.HasConflict {+ i--+ if m.HasConflict {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x10+ }+ if m.Granted {+ i--+ if m.Granted {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x8+ }+ return len(dAtA) - i, nil+}++func (m *ObjectTransactionBatchRequest) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *ObjectTransactionBatchRequest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *ObjectTransactionBatchRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.Transactions) > 0 {+ for iNdEx := len(m.Transactions) - 1; iNdEx >= 0; iNdEx-- {+ size, err := m.Transactions[iNdEx].MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0xa+ }+ }+ return len(dAtA) - i, nil+}++func (m *ObjectTransactionBatchResponse) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *ObjectTransactionBatchResponse) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *ObjectTransactionBatchResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.Responses) > 0 {+ for iNdEx := len(m.Responses) - 1; iNdEx >= 0; iNdEx-- {+ size, err := m.Responses[iNdEx].MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0xa+ }+ }+ return len(dAtA) - i, nil+}++func (m *CreateEntryResponse) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *CreateEntryResponse) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *CreateEntryResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if m.ErrorCode != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ErrorCode))+ i--+ dAtA[i] = 0x18+ }+ if m.MetadataEvent != nil {+ size, err := m.MetadataEvent.MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0x12+ }+ if len(m.Error) > 0 {+ i -= len(m.Error)+ copy(dAtA[i:], m.Error)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Error)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *UpdateEntryRequest) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *UpdateEntryRequest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *UpdateEntryRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.ExpectedExtended) > 0 {+ for k := range m.ExpectedExtended {+ v := m.ExpectedExtended[k]+ baseI := i+ i -= len(v)+ copy(dAtA[i:], v)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(v)))+ i--+ dAtA[i] = 0x12+ i -= len(k)+ copy(dAtA[i:], k)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k)))+ i--+ dAtA[i] = 0xa+ i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i))+ i--+ dAtA[i] = 0x2a+ }+ }+ if len(m.Signatures) > 0 {+ var pksize2 int+ for _, num := range m.Signatures {+ pksize2 += protohelpers.SizeOfVarint(uint64(num))+ }+ i -= pksize2+ j1 := i+ for _, num1 := range m.Signatures {+ num := uint64(num1)+ for num >= 1<<7 {+ dAtA[j1] = uint8(uint64(num)&0x7f | 0x80)+ num >>= 7+ j1+++ }+ dAtA[j1] = uint8(num)+ j1+++ }+ i = protohelpers.EncodeVarint(dAtA, i, uint64(pksize2))+ i--+ dAtA[i] = 0x22+ }+ if m.IsFromOtherCluster {+ i--+ if m.IsFromOtherCluster {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x18+ }+ if m.Entry != nil {+ size, err := m.Entry.MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0x12+ }+ if len(m.Directory) > 0 {+ i -= len(m.Directory)+ copy(dAtA[i:], m.Directory)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Directory)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *UpdateEntryResponse) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *UpdateEntryResponse) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *UpdateEntryResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if m.MetadataEvent != nil {+ size, err := m.MetadataEvent.MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *TouchAccessTimeRequest) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *TouchAccessTimeRequest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *TouchAccessTimeRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if m.ClientAtimeNs != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ClientAtimeNs))+ i--+ dAtA[i] = 0x18+ }+ if len(m.Name) > 0 {+ i -= len(m.Name)+ copy(dAtA[i:], m.Name)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))+ i--+ dAtA[i] = 0x12+ }+ if len(m.Directory) > 0 {+ i -= len(m.Directory)+ copy(dAtA[i:], m.Directory)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Directory)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *TouchAccessTimeResponse) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *TouchAccessTimeResponse) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *TouchAccessTimeResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if m.Updated {+ i--+ if m.Updated {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x10+ }+ if m.PersistedAtimeNs != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.PersistedAtimeNs))+ i--+ dAtA[i] = 0x8+ }+ return len(dAtA) - i, nil+}++func (m *AppendToEntryRequest) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *AppendToEntryRequest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *AppendToEntryRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.Chunks) > 0 {+ for iNdEx := len(m.Chunks) - 1; iNdEx >= 0; iNdEx-- {+ size, err := m.Chunks[iNdEx].MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0x1a+ }+ }+ if len(m.EntryName) > 0 {+ i -= len(m.EntryName)+ copy(dAtA[i:], m.EntryName)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.EntryName)))+ i--+ dAtA[i] = 0x12+ }+ if len(m.Directory) > 0 {+ i -= len(m.Directory)+ copy(dAtA[i:], m.Directory)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Directory)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *AppendToEntryResponse) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *AppendToEntryResponse) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *AppendToEntryResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ return len(dAtA) - i, nil+}++func (m *DeleteEntryRequest) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *DeleteEntryRequest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *DeleteEntryRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if m.IfNotModifiedAfter != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.IfNotModifiedAfter))+ i--+ dAtA[i] = 0x48+ }+ if len(m.Signatures) > 0 {+ var pksize2 int+ for _, num := range m.Signatures {+ pksize2 += protohelpers.SizeOfVarint(uint64(num))+ }+ i -= pksize2+ j1 := i+ for _, num1 := range m.Signatures {+ num := uint64(num1)+ for num >= 1<<7 {+ dAtA[j1] = uint8(uint64(num)&0x7f | 0x80)+ num >>= 7+ j1+++ }+ dAtA[j1] = uint8(num)+ j1+++ }+ i = protohelpers.EncodeVarint(dAtA, i, uint64(pksize2))+ i--+ dAtA[i] = 0x42+ }+ if m.IsFromOtherCluster {+ i--+ if m.IsFromOtherCluster {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x38+ }+ if m.IgnoreRecursiveError {+ i--+ if m.IgnoreRecursiveError {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x30+ }+ if m.IsRecursive {+ i--+ if m.IsRecursive {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x28+ }+ if m.IsDeleteData {+ i--+ if m.IsDeleteData {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x20+ }+ if len(m.Name) > 0 {+ i -= len(m.Name)+ copy(dAtA[i:], m.Name)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))+ i--+ dAtA[i] = 0x12+ }+ if len(m.Directory) > 0 {+ i -= len(m.Directory)+ copy(dAtA[i:], m.Directory)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Directory)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *DeleteEntryResponse) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *DeleteEntryResponse) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *DeleteEntryResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if m.MetadataEvent != nil {+ size, err := m.MetadataEvent.MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0x12+ }+ if len(m.Error) > 0 {+ i -= len(m.Error)+ copy(dAtA[i:], m.Error)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Error)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *AtomicRenameEntryRequest) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *AtomicRenameEntryRequest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *AtomicRenameEntryRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.Signatures) > 0 {+ var pksize2 int+ for _, num := range m.Signatures {+ pksize2 += protohelpers.SizeOfVarint(uint64(num))+ }+ i -= pksize2+ j1 := i+ for _, num1 := range m.Signatures {+ num := uint64(num1)+ for num >= 1<<7 {+ dAtA[j1] = uint8(uint64(num)&0x7f | 0x80)+ num >>= 7+ j1+++ }+ dAtA[j1] = uint8(num)+ j1+++ }+ i = protohelpers.EncodeVarint(dAtA, i, uint64(pksize2))+ i--+ dAtA[i] = 0x2a+ }+ if len(m.NewName) > 0 {+ i -= len(m.NewName)+ copy(dAtA[i:], m.NewName)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.NewName)))+ i--+ dAtA[i] = 0x22+ }+ if len(m.NewDirectory) > 0 {+ i -= len(m.NewDirectory)+ copy(dAtA[i:], m.NewDirectory)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.NewDirectory)))+ i--+ dAtA[i] = 0x1a+ }+ if len(m.OldName) > 0 {+ i -= len(m.OldName)+ copy(dAtA[i:], m.OldName)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.OldName)))+ i--+ dAtA[i] = 0x12+ }+ if len(m.OldDirectory) > 0 {+ i -= len(m.OldDirectory)+ copy(dAtA[i:], m.OldDirectory)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.OldDirectory)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *AtomicRenameEntryResponse) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *AtomicRenameEntryResponse) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *AtomicRenameEntryResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ return len(dAtA) - i, nil+}++func (m *StreamRenameEntryRequest) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *StreamRenameEntryRequest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *StreamRenameEntryRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.Signatures) > 0 {+ var pksize2 int+ for _, num := range m.Signatures {+ pksize2 += protohelpers.SizeOfVarint(uint64(num))+ }+ i -= pksize2+ j1 := i+ for _, num1 := range m.Signatures {+ num := uint64(num1)+ for num >= 1<<7 {+ dAtA[j1] = uint8(uint64(num)&0x7f | 0x80)+ num >>= 7+ j1+++ }+ dAtA[j1] = uint8(num)+ j1+++ }+ i = protohelpers.EncodeVarint(dAtA, i, uint64(pksize2))+ i--+ dAtA[i] = 0x2a+ }+ if len(m.NewName) > 0 {+ i -= len(m.NewName)+ copy(dAtA[i:], m.NewName)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.NewName)))+ i--+ dAtA[i] = 0x22+ }+ if len(m.NewDirectory) > 0 {+ i -= len(m.NewDirectory)+ copy(dAtA[i:], m.NewDirectory)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.NewDirectory)))+ i--+ dAtA[i] = 0x1a+ }+ if len(m.OldName) > 0 {+ i -= len(m.OldName)+ copy(dAtA[i:], m.OldName)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.OldName)))+ i--+ dAtA[i] = 0x12+ }+ if len(m.OldDirectory) > 0 {+ i -= len(m.OldDirectory)+ copy(dAtA[i:], m.OldDirectory)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.OldDirectory)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *StreamRenameEntryResponse) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *StreamRenameEntryResponse) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *StreamRenameEntryResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if m.TsNs != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TsNs))+ i--+ dAtA[i] = 0x18+ }+ if m.EventNotification != nil {+ size, err := m.EventNotification.MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0x12+ }+ if len(m.Directory) > 0 {+ i -= len(m.Directory)+ copy(dAtA[i:], m.Directory)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Directory)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *AssignVolumeRequest) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *AssignVolumeRequest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *AssignVolumeRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if m.ExpectedDataSize != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ExpectedDataSize))+ i--+ dAtA[i] = 0x50+ }+ if len(m.DataNode) > 0 {+ i -= len(m.DataNode)+ copy(dAtA[i:], m.DataNode)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DataNode)))+ i--+ dAtA[i] = 0x4a+ }+ if len(m.DiskType) > 0 {+ i -= len(m.DiskType)+ copy(dAtA[i:], m.DiskType)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DiskType)))+ i--+ dAtA[i] = 0x42+ }+ if len(m.Rack) > 0 {+ i -= len(m.Rack)+ copy(dAtA[i:], m.Rack)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Rack)))+ i--+ dAtA[i] = 0x3a+ }+ if len(m.Path) > 0 {+ i -= len(m.Path)+ copy(dAtA[i:], m.Path)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Path)))+ i--+ dAtA[i] = 0x32+ }+ if len(m.DataCenter) > 0 {+ i -= len(m.DataCenter)+ copy(dAtA[i:], m.DataCenter)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DataCenter)))+ i--+ dAtA[i] = 0x2a+ }+ if m.TtlSec != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TtlSec))+ i--+ dAtA[i] = 0x20+ }+ if len(m.Replication) > 0 {+ i -= len(m.Replication)+ copy(dAtA[i:], m.Replication)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Replication)))+ i--+ dAtA[i] = 0x1a+ }+ if len(m.Collection) > 0 {+ i -= len(m.Collection)+ copy(dAtA[i:], m.Collection)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Collection)))+ i--+ dAtA[i] = 0x12+ }+ if m.Count != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Count))+ i--+ dAtA[i] = 0x8+ }+ return len(dAtA) - i, nil+}++func (m *AssignVolumeResponse) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *AssignVolumeResponse) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *AssignVolumeResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.Replicas) > 0 {+ for iNdEx := len(m.Replicas) - 1; iNdEx >= 0; iNdEx-- {+ size, err := m.Replicas[iNdEx].MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0x52+ }+ }+ if m.Location != nil {+ size, err := m.Location.MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0x4a+ }+ if len(m.Error) > 0 {+ i -= len(m.Error)+ copy(dAtA[i:], m.Error)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Error)))+ i--+ dAtA[i] = 0x42+ }+ if len(m.Replication) > 0 {+ i -= len(m.Replication)+ copy(dAtA[i:], m.Replication)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Replication)))+ i--+ dAtA[i] = 0x3a+ }+ if len(m.Collection) > 0 {+ i -= len(m.Collection)+ copy(dAtA[i:], m.Collection)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Collection)))+ i--+ dAtA[i] = 0x32+ }+ if len(m.Auth) > 0 {+ i -= len(m.Auth)+ copy(dAtA[i:], m.Auth)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Auth)))+ i--+ dAtA[i] = 0x2a+ }+ if m.Count != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Count))+ i--+ dAtA[i] = 0x20+ }+ if len(m.FileId) > 0 {+ i -= len(m.FileId)+ copy(dAtA[i:], m.FileId)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.FileId)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *LookupVolumeRequest) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *LookupVolumeRequest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *LookupVolumeRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.VolumeIds) > 0 {+ for iNdEx := len(m.VolumeIds) - 1; iNdEx >= 0; iNdEx-- {+ i -= len(m.VolumeIds[iNdEx])+ copy(dAtA[i:], m.VolumeIds[iNdEx])+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.VolumeIds[iNdEx])))+ i--+ dAtA[i] = 0xa+ }+ }+ return len(dAtA) - i, nil+}++func (m *Locations) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *Locations) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *Locations) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.Locations) > 0 {+ for iNdEx := len(m.Locations) - 1; iNdEx >= 0; iNdEx-- {+ size, err := m.Locations[iNdEx].MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0xa+ }+ }+ return len(dAtA) - i, nil+}++func (m *Location) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *Location) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *Location) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.DataCenter) > 0 {+ i -= len(m.DataCenter)+ copy(dAtA[i:], m.DataCenter)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DataCenter)))+ i--+ dAtA[i] = 0x22+ }+ if m.GrpcPort != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.GrpcPort))+ i--+ dAtA[i] = 0x18+ }+ if len(m.PublicUrl) > 0 {+ i -= len(m.PublicUrl)+ copy(dAtA[i:], m.PublicUrl)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.PublicUrl)))+ i--+ dAtA[i] = 0x12+ }+ if len(m.Url) > 0 {+ i -= len(m.Url)+ copy(dAtA[i:], m.Url)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Url)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *LookupVolumeResponse) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *LookupVolumeResponse) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *LookupVolumeResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.LocationsMap) > 0 {+ for k := range m.LocationsMap {+ v := m.LocationsMap[k]+ baseI := i+ size, err := v.MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0x12+ i -= len(k)+ copy(dAtA[i:], k)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(k)))+ i--+ dAtA[i] = 0xa+ i = protohelpers.EncodeVarint(dAtA, i, uint64(baseI-i))+ i--+ dAtA[i] = 0xa+ }+ }+ return len(dAtA) - i, nil+}++func (m *Collection) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *Collection) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *Collection) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.Name) > 0 {+ i -= len(m.Name)+ copy(dAtA[i:], m.Name)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *CollectionListRequest) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *CollectionListRequest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *CollectionListRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if m.IncludeEcVolumes {+ i--+ if m.IncludeEcVolumes {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x10+ }+ if m.IncludeNormalVolumes {+ i--+ if m.IncludeNormalVolumes {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x8+ }+ return len(dAtA) - i, nil+}++func (m *CollectionListResponse) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *CollectionListResponse) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *CollectionListResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.Collections) > 0 {+ for iNdEx := len(m.Collections) - 1; iNdEx >= 0; iNdEx-- {+ size, err := m.Collections[iNdEx].MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0xa+ }+ }+ return len(dAtA) - i, nil+}++func (m *DeleteCollectionRequest) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *DeleteCollectionRequest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *DeleteCollectionRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.Collection) > 0 {+ i -= len(m.Collection)+ copy(dAtA[i:], m.Collection)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Collection)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *DeleteCollectionResponse) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *DeleteCollectionResponse) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *DeleteCollectionResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ return len(dAtA) - i, nil+}++func (m *StatisticsRequest) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *StatisticsRequest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *StatisticsRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.DiskType) > 0 {+ i -= len(m.DiskType)+ copy(dAtA[i:], m.DiskType)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DiskType)))+ i--+ dAtA[i] = 0x22+ }+ if len(m.Ttl) > 0 {+ i -= len(m.Ttl)+ copy(dAtA[i:], m.Ttl)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Ttl)))+ i--+ dAtA[i] = 0x1a+ }+ if len(m.Collection) > 0 {+ i -= len(m.Collection)+ copy(dAtA[i:], m.Collection)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Collection)))+ i--+ dAtA[i] = 0x12+ }+ if len(m.Replication) > 0 {+ i -= len(m.Replication)+ copy(dAtA[i:], m.Replication)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Replication)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *StatisticsResponse) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *StatisticsResponse) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *StatisticsResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if m.FileCount != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.FileCount))+ i--+ dAtA[i] = 0x30+ }+ if m.UsedSize != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.UsedSize))+ i--+ dAtA[i] = 0x28+ }+ if m.TotalSize != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TotalSize))+ i--+ dAtA[i] = 0x20+ }+ return len(dAtA) - i, nil+}++func (m *PingRequest) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *PingRequest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *PingRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.TargetType) > 0 {+ i -= len(m.TargetType)+ copy(dAtA[i:], m.TargetType)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.TargetType)))+ i--+ dAtA[i] = 0x12+ }+ if len(m.Target) > 0 {+ i -= len(m.Target)+ copy(dAtA[i:], m.Target)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Target)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *PingResponse) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *PingResponse) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *PingResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if m.StopTimeNs != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.StopTimeNs))+ i--+ dAtA[i] = 0x18+ }+ if m.RemoteTimeNs != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.RemoteTimeNs))+ i--+ dAtA[i] = 0x10+ }+ if m.StartTimeNs != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.StartTimeNs))+ i--+ dAtA[i] = 0x8+ }+ return len(dAtA) - i, nil+}++func (m *GetFilerConfigurationRequest) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *GetFilerConfigurationRequest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *GetFilerConfigurationRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ return len(dAtA) - i, nil+}++func (m *GetFilerConfigurationResponse) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *GetFilerConfigurationResponse) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *GetFilerConfigurationResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if m.MinorVersion != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.MinorVersion))+ i--+ dAtA[i] = 0x78+ }+ if m.MajorVersion != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.MajorVersion))+ i--+ dAtA[i] = 0x70+ }+ if len(m.FilerGroup) > 0 {+ i -= len(m.FilerGroup)+ copy(dAtA[i:], m.FilerGroup)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.FilerGroup)))+ i--+ dAtA[i] = 0x6a+ }+ if len(m.ClusterId) > 0 {+ i -= len(m.ClusterId)+ copy(dAtA[i:], m.ClusterId)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ClusterId)))+ i--+ dAtA[i] = 0x62+ }+ if len(m.Version) > 0 {+ i -= len(m.Version)+ copy(dAtA[i:], m.Version)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Version)))+ i--+ dAtA[i] = 0x5a+ }+ if m.MetricsIntervalSec != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.MetricsIntervalSec))+ i--+ dAtA[i] = 0x50+ }+ if len(m.MetricsAddress) > 0 {+ i -= len(m.MetricsAddress)+ copy(dAtA[i:], m.MetricsAddress)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.MetricsAddress)))+ i--+ dAtA[i] = 0x4a+ }+ if m.Signature != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Signature))+ i--+ dAtA[i] = 0x40+ }+ if m.Cipher {+ i--+ if m.Cipher {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x38+ }+ if len(m.DirBuckets) > 0 {+ i -= len(m.DirBuckets)+ copy(dAtA[i:], m.DirBuckets)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DirBuckets)))+ i--+ dAtA[i] = 0x2a+ }+ if m.MaxMb != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.MaxMb))+ i--+ dAtA[i] = 0x20+ }+ if len(m.Collection) > 0 {+ i -= len(m.Collection)+ copy(dAtA[i:], m.Collection)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Collection)))+ i--+ dAtA[i] = 0x1a+ }+ if len(m.Replication) > 0 {+ i -= len(m.Replication)+ copy(dAtA[i:], m.Replication)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Replication)))+ i--+ dAtA[i] = 0x12+ }+ if len(m.Masters) > 0 {+ for iNdEx := len(m.Masters) - 1; iNdEx >= 0; iNdEx-- {+ i -= len(m.Masters[iNdEx])+ copy(dAtA[i:], m.Masters[iNdEx])+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Masters[iNdEx])))+ i--+ dAtA[i] = 0xa+ }+ }+ return len(dAtA) - i, nil+}++func (m *SubscribeMetadataRequest) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *SubscribeMetadataRequest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *SubscribeMetadataRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if m.ClientSupportsIdleHeartbeat {+ i--+ if m.ClientSupportsIdleHeartbeat {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x68+ }+ if m.ClientSupportsMetadataChunks {+ i--+ if m.ClientSupportsMetadataChunks {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x60+ }+ if m.ClientSupportsBatching {+ i--+ if m.ClientSupportsBatching {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x58+ }+ if len(m.Directories) > 0 {+ for iNdEx := len(m.Directories) - 1; iNdEx >= 0; iNdEx-- {+ i -= len(m.Directories[iNdEx])+ copy(dAtA[i:], m.Directories[iNdEx])+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Directories[iNdEx])))+ i--+ dAtA[i] = 0x52+ }+ }+ if m.ClientEpoch != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ClientEpoch))+ i--+ dAtA[i] = 0x48+ }+ if m.UntilNs != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.UntilNs))+ i--+ dAtA[i] = 0x40+ }+ if m.ClientId != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ClientId))+ i--+ dAtA[i] = 0x38+ }+ if len(m.PathPrefixes) > 0 {+ for iNdEx := len(m.PathPrefixes) - 1; iNdEx >= 0; iNdEx-- {+ i -= len(m.PathPrefixes[iNdEx])+ copy(dAtA[i:], m.PathPrefixes[iNdEx])+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.PathPrefixes[iNdEx])))+ i--+ dAtA[i] = 0x32+ }+ }+ if m.Signature != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Signature))+ i--+ dAtA[i] = 0x20+ }+ if m.SinceNs != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.SinceNs))+ i--+ dAtA[i] = 0x18+ }+ if len(m.PathPrefix) > 0 {+ i -= len(m.PathPrefix)+ copy(dAtA[i:], m.PathPrefix)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.PathPrefix)))+ i--+ dAtA[i] = 0x12+ }+ if len(m.ClientName) > 0 {+ i -= len(m.ClientName)+ copy(dAtA[i:], m.ClientName)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ClientName)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *SubscribeMetadataResponse) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *SubscribeMetadataResponse) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *SubscribeMetadataResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.LogFileRefs) > 0 {+ for iNdEx := len(m.LogFileRefs) - 1; iNdEx >= 0; iNdEx-- {+ size, err := m.LogFileRefs[iNdEx].MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0x2a+ }+ }+ if len(m.Events) > 0 {+ for iNdEx := len(m.Events) - 1; iNdEx >= 0; iNdEx-- {+ size, err := m.Events[iNdEx].MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0x22+ }+ }+ if m.TsNs != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TsNs))+ i--+ dAtA[i] = 0x18+ }+ if m.EventNotification != nil {+ size, err := m.EventNotification.MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0x12+ }+ if len(m.Directory) > 0 {+ i -= len(m.Directory)+ copy(dAtA[i:], m.Directory)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Directory)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *ListMetadataSubscribersRequest) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *ListMetadataSubscribersRequest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *ListMetadataSubscribersRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.ClientTypes) > 0 {+ for iNdEx := len(m.ClientTypes) - 1; iNdEx >= 0; iNdEx-- {+ i -= len(m.ClientTypes[iNdEx])+ copy(dAtA[i:], m.ClientTypes[iNdEx])+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ClientTypes[iNdEx])))+ i--+ dAtA[i] = 0xa+ }+ }+ return len(dAtA) - i, nil+}++func (m *ListMetadataSubscribersResponse) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *ListMetadataSubscribersResponse) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *ListMetadataSubscribersResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.Subscribers) > 0 {+ for iNdEx := len(m.Subscribers) - 1; iNdEx >= 0; iNdEx-- {+ size, err := m.Subscribers[iNdEx].MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0xa+ }+ }+ return len(dAtA) - i, nil+}++func (m *MetadataSubscriber) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *MetadataSubscriber) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *MetadataSubscriber) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.FilerAddress) > 0 {+ i -= len(m.FilerAddress)+ copy(dAtA[i:], m.FilerAddress)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.FilerAddress)))+ i--+ dAtA[i] = 0x42+ }+ if m.ConnectedAtNs != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ConnectedAtNs))+ i--+ dAtA[i] = 0x38+ }+ if m.ClientEpoch != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ClientEpoch))+ i--+ dAtA[i] = 0x30+ }+ if m.ClientId != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ClientId))+ i--+ dAtA[i] = 0x28+ }+ if len(m.PathPrefix) > 0 {+ i -= len(m.PathPrefix)+ copy(dAtA[i:], m.PathPrefix)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.PathPrefix)))+ i--+ dAtA[i] = 0x22+ }+ if len(m.Address) > 0 {+ i -= len(m.Address)+ copy(dAtA[i:], m.Address)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Address)))+ i--+ dAtA[i] = 0x1a+ }+ if len(m.ClientType) > 0 {+ i -= len(m.ClientType)+ copy(dAtA[i:], m.ClientType)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ClientType)))+ i--+ dAtA[i] = 0x12+ }+ if len(m.ClientName) > 0 {+ i -= len(m.ClientName)+ copy(dAtA[i:], m.ClientName)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ClientName)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *LogFileChunkRef) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *LogFileChunkRef) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *LogFileChunkRef) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.FilerId) > 0 {+ i -= len(m.FilerId)+ copy(dAtA[i:], m.FilerId)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.FilerId)))+ i--+ dAtA[i] = 0x1a+ }+ if m.FileTsNs != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.FileTsNs))+ i--+ dAtA[i] = 0x10+ }+ if len(m.Chunks) > 0 {+ for iNdEx := len(m.Chunks) - 1; iNdEx >= 0; iNdEx-- {+ size, err := m.Chunks[iNdEx].MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0xa+ }+ }+ return len(dAtA) - i, nil+}++func (m *TraverseBfsMetadataRequest) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *TraverseBfsMetadataRequest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *TraverseBfsMetadataRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.ExcludedPrefixes) > 0 {+ for iNdEx := len(m.ExcludedPrefixes) - 1; iNdEx >= 0; iNdEx-- {+ i -= len(m.ExcludedPrefixes[iNdEx])+ copy(dAtA[i:], m.ExcludedPrefixes[iNdEx])+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.ExcludedPrefixes[iNdEx])))+ i--+ dAtA[i] = 0x12+ }+ }+ if len(m.Directory) > 0 {+ i -= len(m.Directory)+ copy(dAtA[i:], m.Directory)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Directory)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *TraverseBfsMetadataResponse) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *TraverseBfsMetadataResponse) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *TraverseBfsMetadataResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if m.Entry != nil {+ size, err := m.Entry.MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0x12+ }+ if len(m.Directory) > 0 {+ i -= len(m.Directory)+ copy(dAtA[i:], m.Directory)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Directory)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *LogEntry) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *LogEntry) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *LogEntry) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if m.Offset != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Offset))+ i--+ dAtA[i] = 0x28+ }+ if len(m.Key) > 0 {+ i -= len(m.Key)+ copy(dAtA[i:], m.Key)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Key)))+ i--+ dAtA[i] = 0x22+ }+ if len(m.Data) > 0 {+ i -= len(m.Data)+ copy(dAtA[i:], m.Data)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Data)))+ i--+ dAtA[i] = 0x1a+ }+ if m.PartitionKeyHash != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.PartitionKeyHash))+ i--+ dAtA[i] = 0x10+ }+ if m.TsNs != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TsNs))+ i--+ dAtA[i] = 0x8+ }+ return len(dAtA) - i, nil+}++func (m *KeepConnectedRequest) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *KeepConnectedRequest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *KeepConnectedRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.Resources) > 0 {+ for iNdEx := len(m.Resources) - 1; iNdEx >= 0; iNdEx-- {+ i -= len(m.Resources[iNdEx])+ copy(dAtA[i:], m.Resources[iNdEx])+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Resources[iNdEx])))+ i--+ dAtA[i] = 0x1a+ }+ }+ if m.GrpcPort != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.GrpcPort))+ i--+ dAtA[i] = 0x10+ }+ if len(m.Name) > 0 {+ i -= len(m.Name)+ copy(dAtA[i:], m.Name)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *KeepConnectedResponse) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *KeepConnectedResponse) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *KeepConnectedResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ return len(dAtA) - i, nil+}++func (m *LocateBrokerRequest) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *LocateBrokerRequest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *LocateBrokerRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.Resource) > 0 {+ i -= len(m.Resource)+ copy(dAtA[i:], m.Resource)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Resource)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *LocateBrokerResponse_Resource) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *LocateBrokerResponse_Resource) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *LocateBrokerResponse_Resource) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if m.ResourceCount != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ResourceCount))+ i--+ dAtA[i] = 0x10+ }+ if len(m.GrpcAddresses) > 0 {+ i -= len(m.GrpcAddresses)+ copy(dAtA[i:], m.GrpcAddresses)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.GrpcAddresses)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *LocateBrokerResponse) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *LocateBrokerResponse) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *LocateBrokerResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.Resources) > 0 {+ for iNdEx := len(m.Resources) - 1; iNdEx >= 0; iNdEx-- {+ size, err := m.Resources[iNdEx].MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0x12+ }+ }+ if m.Found {+ i--+ if m.Found {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x8+ }+ return len(dAtA) - i, nil+}++func (m *KvGetRequest) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *KvGetRequest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *KvGetRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.Key) > 0 {+ i -= len(m.Key)+ copy(dAtA[i:], m.Key)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Key)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *KvGetResponse) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *KvGetResponse) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *KvGetResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.Error) > 0 {+ i -= len(m.Error)+ copy(dAtA[i:], m.Error)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Error)))+ i--+ dAtA[i] = 0x12+ }+ if len(m.Value) > 0 {+ i -= len(m.Value)+ copy(dAtA[i:], m.Value)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Value)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *KvPutRequest) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *KvPutRequest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *KvPutRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.Value) > 0 {+ i -= len(m.Value)+ copy(dAtA[i:], m.Value)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Value)))+ i--+ dAtA[i] = 0x12+ }+ if len(m.Key) > 0 {+ i -= len(m.Key)+ copy(dAtA[i:], m.Key)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Key)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *KvPutResponse) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *KvPutResponse) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *KvPutResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.Error) > 0 {+ i -= len(m.Error)+ copy(dAtA[i:], m.Error)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Error)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *FilerConf_PathConf) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *FilerConf_PathConf) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *FilerConf_PathConf) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if m.WormRetentionTimeSeconds != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.WormRetentionTimeSeconds))+ i--+ dAtA[i] = 0x1+ i--+ dAtA[i] = 0x80+ }+ if m.WormGracePeriodSeconds != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.WormGracePeriodSeconds))+ i--+ dAtA[i] = 0x78+ }+ if m.Worm {+ i--+ if m.Worm {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x70+ }+ if m.DisableChunkDeletion {+ i--+ if m.DisableChunkDeletion {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x68+ }+ if m.MaxFileNameLength != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.MaxFileNameLength))+ i--+ dAtA[i] = 0x60+ }+ if len(m.DataNode) > 0 {+ i -= len(m.DataNode)+ copy(dAtA[i:], m.DataNode)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DataNode)))+ i--+ dAtA[i] = 0x5a+ }+ if len(m.Rack) > 0 {+ i -= len(m.Rack)+ copy(dAtA[i:], m.Rack)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Rack)))+ i--+ dAtA[i] = 0x52+ }+ if len(m.DataCenter) > 0 {+ i -= len(m.DataCenter)+ copy(dAtA[i:], m.DataCenter)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DataCenter)))+ i--+ dAtA[i] = 0x4a+ }+ if m.ReadOnly {+ i--+ if m.ReadOnly {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x40+ }+ if m.VolumeGrowthCount != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.VolumeGrowthCount))+ i--+ dAtA[i] = 0x38+ }+ if m.Fsync {+ i--+ if m.Fsync {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x30+ }+ if len(m.DiskType) > 0 {+ i -= len(m.DiskType)+ copy(dAtA[i:], m.DiskType)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DiskType)))+ i--+ dAtA[i] = 0x2a+ }+ if len(m.Ttl) > 0 {+ i -= len(m.Ttl)+ copy(dAtA[i:], m.Ttl)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Ttl)))+ i--+ dAtA[i] = 0x22+ }+ if len(m.Replication) > 0 {+ i -= len(m.Replication)+ copy(dAtA[i:], m.Replication)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Replication)))+ i--+ dAtA[i] = 0x1a+ }+ if len(m.Collection) > 0 {+ i -= len(m.Collection)+ copy(dAtA[i:], m.Collection)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Collection)))+ i--+ dAtA[i] = 0x12+ }+ if len(m.LocationPrefix) > 0 {+ i -= len(m.LocationPrefix)+ copy(dAtA[i:], m.LocationPrefix)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.LocationPrefix)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *FilerConf) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *FilerConf) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *FilerConf) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.Locations) > 0 {+ for iNdEx := len(m.Locations) - 1; iNdEx >= 0; iNdEx-- {+ size, err := m.Locations[iNdEx].MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0x12+ }+ }+ if m.Version != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Version))+ i--+ dAtA[i] = 0x8+ }+ return len(dAtA) - i, nil+}++func (m *CacheRemoteObjectToLocalClusterRequest) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *CacheRemoteObjectToLocalClusterRequest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *CacheRemoteObjectToLocalClusterRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if m.DownloadConcurrency != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.DownloadConcurrency))+ i--+ dAtA[i] = 0x20+ }+ if m.ChunkConcurrency != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ChunkConcurrency))+ i--+ dAtA[i] = 0x18+ }+ if len(m.Name) > 0 {+ i -= len(m.Name)+ copy(dAtA[i:], m.Name)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))+ i--+ dAtA[i] = 0x12+ }+ if len(m.Directory) > 0 {+ i -= len(m.Directory)+ copy(dAtA[i:], m.Directory)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Directory)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *CacheRemoteObjectToLocalClusterResponse) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *CacheRemoteObjectToLocalClusterResponse) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *CacheRemoteObjectToLocalClusterResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if m.MetadataEvent != nil {+ size, err := m.MetadataEvent.MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0x12+ }+ if m.Entry != nil {+ size, err := m.Entry.MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *LockRequest) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *LockRequest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *LockRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.Owner) > 0 {+ i -= len(m.Owner)+ copy(dAtA[i:], m.Owner)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Owner)))+ i--+ dAtA[i] = 0x2a+ }+ if m.IsMoved {+ i--+ if m.IsMoved {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x20+ }+ if len(m.RenewToken) > 0 {+ i -= len(m.RenewToken)+ copy(dAtA[i:], m.RenewToken)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.RenewToken)))+ i--+ dAtA[i] = 0x1a+ }+ if m.SecondsToLock != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.SecondsToLock))+ i--+ dAtA[i] = 0x10+ }+ if len(m.Name) > 0 {+ i -= len(m.Name)+ copy(dAtA[i:], m.Name)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *LockResponse) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *LockResponse) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *LockResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if m.Generation != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Generation))+ i--+ dAtA[i] = 0x28+ }+ if len(m.Error) > 0 {+ i -= len(m.Error)+ copy(dAtA[i:], m.Error)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Error)))+ i--+ dAtA[i] = 0x22+ }+ if len(m.LockHostMovedTo) > 0 {+ i -= len(m.LockHostMovedTo)+ copy(dAtA[i:], m.LockHostMovedTo)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.LockHostMovedTo)))+ i--+ dAtA[i] = 0x1a+ }+ if len(m.LockOwner) > 0 {+ i -= len(m.LockOwner)+ copy(dAtA[i:], m.LockOwner)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.LockOwner)))+ i--+ dAtA[i] = 0x12+ }+ if len(m.RenewToken) > 0 {+ i -= len(m.RenewToken)+ copy(dAtA[i:], m.RenewToken)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.RenewToken)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *UnlockRequest) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *UnlockRequest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *UnlockRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if m.IsMoved {+ i--+ if m.IsMoved {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x18+ }+ if len(m.RenewToken) > 0 {+ i -= len(m.RenewToken)+ copy(dAtA[i:], m.RenewToken)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.RenewToken)))+ i--+ dAtA[i] = 0x12+ }+ if len(m.Name) > 0 {+ i -= len(m.Name)+ copy(dAtA[i:], m.Name)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *UnlockResponse) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *UnlockResponse) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *UnlockResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.MovedTo) > 0 {+ i -= len(m.MovedTo)+ copy(dAtA[i:], m.MovedTo)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.MovedTo)))+ i--+ dAtA[i] = 0x12+ }+ if len(m.Error) > 0 {+ i -= len(m.Error)+ copy(dAtA[i:], m.Error)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Error)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *FindLockOwnerRequest) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *FindLockOwnerRequest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *FindLockOwnerRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if m.IsMoved {+ i--+ if m.IsMoved {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x10+ }+ if len(m.Name) > 0 {+ i -= len(m.Name)+ copy(dAtA[i:], m.Name)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *FindLockOwnerResponse) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *FindLockOwnerResponse) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *FindLockOwnerResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.Owner) > 0 {+ i -= len(m.Owner)+ copy(dAtA[i:], m.Owner)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Owner)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *Lock) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *Lock) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *Lock) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if m.Seq != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Seq))+ i--+ dAtA[i] = 0x38+ }+ if m.IsBackup {+ i--+ if m.IsBackup {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x30+ }+ if m.Generation != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Generation))+ i--+ dAtA[i] = 0x28+ }+ if len(m.Owner) > 0 {+ i -= len(m.Owner)+ copy(dAtA[i:], m.Owner)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Owner)))+ i--+ dAtA[i] = 0x22+ }+ if m.ExpiredAtNs != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ExpiredAtNs))+ i--+ dAtA[i] = 0x18+ }+ if len(m.RenewToken) > 0 {+ i -= len(m.RenewToken)+ copy(dAtA[i:], m.RenewToken)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.RenewToken)))+ i--+ dAtA[i] = 0x12+ }+ if len(m.Name) > 0 {+ i -= len(m.Name)+ copy(dAtA[i:], m.Name)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *TransferLocksRequest) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *TransferLocksRequest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *TransferLocksRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.Locks) > 0 {+ for iNdEx := len(m.Locks) - 1; iNdEx >= 0; iNdEx-- {+ size, err := m.Locks[iNdEx].MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0xa+ }+ }+ return len(dAtA) - i, nil+}++func (m *TransferLocksResponse) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *TransferLocksResponse) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *TransferLocksResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ return len(dAtA) - i, nil+}++func (m *ReplicateLockRequest) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *ReplicateLockRequest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *ReplicateLockRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if m.Seq != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Seq))+ i--+ dAtA[i] = 0x38+ }+ if m.IsUnlock {+ i--+ if m.IsUnlock {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x30+ }+ if m.Generation != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Generation))+ i--+ dAtA[i] = 0x28+ }+ if len(m.Owner) > 0 {+ i -= len(m.Owner)+ copy(dAtA[i:], m.Owner)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Owner)))+ i--+ dAtA[i] = 0x22+ }+ if m.ExpiredAtNs != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ExpiredAtNs))+ i--+ dAtA[i] = 0x18+ }+ if len(m.RenewToken) > 0 {+ i -= len(m.RenewToken)+ copy(dAtA[i:], m.RenewToken)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.RenewToken)))+ i--+ dAtA[i] = 0x12+ }+ if len(m.Name) > 0 {+ i -= len(m.Name)+ copy(dAtA[i:], m.Name)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *ReplicateLockResponse) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *ReplicateLockResponse) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *ReplicateLockResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ return len(dAtA) - i, nil+}++func (m *StreamMutateEntryRequest) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *StreamMutateEntryRequest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *StreamMutateEntryRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if vtmsg, ok := m.Request.(interface {+ MarshalToSizedBufferVT([]byte) (int, error)+ }); ok {+ size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ }+ if m.RequestId != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.RequestId))+ i--+ dAtA[i] = 0x8+ }+ return len(dAtA) - i, nil+}++func (m *StreamMutateEntryRequest_CreateRequest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *StreamMutateEntryRequest_CreateRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ i := len(dAtA)+ if m.CreateRequest != nil {+ size, err := m.CreateRequest.MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0x12+ } else {+ i = protohelpers.EncodeVarint(dAtA, i, 0)+ i--+ dAtA[i] = 0x12+ }+ return len(dAtA) - i, nil+}+func (m *StreamMutateEntryRequest_UpdateRequest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *StreamMutateEntryRequest_UpdateRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ i := len(dAtA)+ if m.UpdateRequest != nil {+ size, err := m.UpdateRequest.MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0x1a+ } else {+ i = protohelpers.EncodeVarint(dAtA, i, 0)+ i--+ dAtA[i] = 0x1a+ }+ return len(dAtA) - i, nil+}+func (m *StreamMutateEntryRequest_DeleteRequest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *StreamMutateEntryRequest_DeleteRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ i := len(dAtA)+ if m.DeleteRequest != nil {+ size, err := m.DeleteRequest.MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0x22+ } else {+ i = protohelpers.EncodeVarint(dAtA, i, 0)+ i--+ dAtA[i] = 0x22+ }+ return len(dAtA) - i, nil+}+func (m *StreamMutateEntryRequest_RenameRequest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *StreamMutateEntryRequest_RenameRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ i := len(dAtA)+ if m.RenameRequest != nil {+ size, err := m.RenameRequest.MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0x2a+ } else {+ i = protohelpers.EncodeVarint(dAtA, i, 0)+ i--+ dAtA[i] = 0x2a+ }+ return len(dAtA) - i, nil+}+func (m *StreamMutateEntryResponse) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *StreamMutateEntryResponse) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *StreamMutateEntryResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if vtmsg, ok := m.Response.(interface {+ MarshalToSizedBufferVT([]byte) (int, error)+ }); ok {+ size, err := vtmsg.MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ }+ if m.Errno != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Errno))+ i--+ dAtA[i] = 0x40+ }+ if len(m.Error) > 0 {+ i -= len(m.Error)+ copy(dAtA[i:], m.Error)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Error)))+ i--+ dAtA[i] = 0x3a+ }+ if m.IsLast {+ i--+ if m.IsLast {+ dAtA[i] = 1+ } else {+ dAtA[i] = 0+ }+ i--+ dAtA[i] = 0x10+ }+ if m.RequestId != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.RequestId))+ i--+ dAtA[i] = 0x8+ }+ return len(dAtA) - i, nil+}++func (m *StreamMutateEntryResponse_CreateResponse) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *StreamMutateEntryResponse_CreateResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ i := len(dAtA)+ if m.CreateResponse != nil {+ size, err := m.CreateResponse.MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0x1a+ } else {+ i = protohelpers.EncodeVarint(dAtA, i, 0)+ i--+ dAtA[i] = 0x1a+ }+ return len(dAtA) - i, nil+}+func (m *StreamMutateEntryResponse_UpdateResponse) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *StreamMutateEntryResponse_UpdateResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ i := len(dAtA)+ if m.UpdateResponse != nil {+ size, err := m.UpdateResponse.MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0x22+ } else {+ i = protohelpers.EncodeVarint(dAtA, i, 0)+ i--+ dAtA[i] = 0x22+ }+ return len(dAtA) - i, nil+}+func (m *StreamMutateEntryResponse_DeleteResponse) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *StreamMutateEntryResponse_DeleteResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ i := len(dAtA)+ if m.DeleteResponse != nil {+ size, err := m.DeleteResponse.MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0x2a+ } else {+ i = protohelpers.EncodeVarint(dAtA, i, 0)+ i--+ dAtA[i] = 0x2a+ }+ return len(dAtA) - i, nil+}+func (m *StreamMutateEntryResponse_RenameResponse) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *StreamMutateEntryResponse_RenameResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ i := len(dAtA)+ if m.RenameResponse != nil {+ size, err := m.RenameResponse.MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0x32+ } else {+ i = protohelpers.EncodeVarint(dAtA, i, 0)+ i--+ dAtA[i] = 0x32+ }+ return len(dAtA) - i, nil+}+func (m *MountRegisterRequest) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *MountRegisterRequest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *MountRegisterRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.DataCenter) > 0 {+ i -= len(m.DataCenter)+ copy(dAtA[i:], m.DataCenter)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DataCenter)))+ i--+ dAtA[i] = 0x22+ }+ if m.TtlSeconds != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.TtlSeconds))+ i--+ dAtA[i] = 0x18+ }+ if len(m.Rack) > 0 {+ i -= len(m.Rack)+ copy(dAtA[i:], m.Rack)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Rack)))+ i--+ dAtA[i] = 0x12+ }+ if len(m.PeerAddr) > 0 {+ i -= len(m.PeerAddr)+ copy(dAtA[i:], m.PeerAddr)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.PeerAddr)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *MountRegisterResponse) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *MountRegisterResponse) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *MountRegisterResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ return len(dAtA) - i, nil+}++func (m *MountListRequest) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *MountListRequest) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *MountListRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ return len(dAtA) - i, nil+}++func (m *MountListResponse) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *MountListResponse) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *MountListResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.Mounts) > 0 {+ for iNdEx := len(m.Mounts) - 1; iNdEx >= 0; iNdEx-- {+ size, err := m.Mounts[iNdEx].MarshalToSizedBufferVT(dAtA[:i])+ if err != nil {+ return 0, err+ }+ i -= size+ i = protohelpers.EncodeVarint(dAtA, i, uint64(size))+ i--+ dAtA[i] = 0xa+ }+ }+ return len(dAtA) - i, nil+}++func (m *MountInfo) MarshalVT() (dAtA []byte, err error) {+ if m == nil {+ return nil, nil+ }+ size := m.SizeVT()+ dAtA = make([]byte, size)+ n, err := m.MarshalToSizedBufferVT(dAtA[:size])+ if err != nil {+ return nil, err+ }+ return dAtA[:n], nil+}++func (m *MountInfo) MarshalToVT(dAtA []byte) (int, error) {+ size := m.SizeVT()+ return m.MarshalToSizedBufferVT(dAtA[:size])+}++func (m *MountInfo) MarshalToSizedBufferVT(dAtA []byte) (int, error) {+ if m == nil {+ return 0, nil+ }+ i := len(dAtA)+ _ = i+ var l int+ _ = l+ if m.unknownFields != nil {+ i -= len(m.unknownFields)+ copy(dAtA[i:], m.unknownFields)+ }+ if len(m.DataCenter) > 0 {+ i -= len(m.DataCenter)+ copy(dAtA[i:], m.DataCenter)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.DataCenter)))+ i--+ dAtA[i] = 0x22+ }+ if m.LastSeenNs != 0 {+ i = protohelpers.EncodeVarint(dAtA, i, uint64(m.LastSeenNs))+ i--+ dAtA[i] = 0x18+ }+ if len(m.Rack) > 0 {+ i -= len(m.Rack)+ copy(dAtA[i:], m.Rack)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Rack)))+ i--+ dAtA[i] = 0x12+ }+ if len(m.PeerAddr) > 0 {+ i -= len(m.PeerAddr)+ copy(dAtA[i:], m.PeerAddr)+ i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.PeerAddr)))+ i--+ dAtA[i] = 0xa+ }+ return len(dAtA) - i, nil+}++func (m *LookupDirectoryEntryRequest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.Directory)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.Name)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ n += len(m.unknownFields)+ return n+}++func (m *LookupDirectoryEntryResponse) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if m.Entry != nil {+ l = m.Entry.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ n += len(m.unknownFields)+ return n+}++func (m *ListEntriesRequest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.Directory)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.Prefix)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.StartFromFileName)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.InclusiveStartFrom {+ n += 2+ }+ if m.Limit != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.Limit))+ }+ if m.SnapshotTsNs != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.SnapshotTsNs))+ }+ n += len(m.unknownFields)+ return n+}++func (m *ListEntriesResponse) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if m.Entry != nil {+ l = m.Entry.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.SnapshotTsNs != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.SnapshotTsNs))+ }+ n += len(m.unknownFields)+ return n+}++func (m *RemoteEntry) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.StorageName)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.LastLocalSyncTsNs != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.LastLocalSyncTsNs))+ }+ l = len(m.RemoteETag)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.RemoteMtime != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.RemoteMtime))+ }+ if m.RemoteSize != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.RemoteSize))+ }+ n += len(m.unknownFields)+ return n+}++func (m *Entry) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.Name)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.IsDirectory {+ n += 2+ }+ if len(m.Chunks) > 0 {+ for _, e := range m.Chunks {+ l = e.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ }+ if m.Attributes != nil {+ l = m.Attributes.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if len(m.Extended) > 0 {+ for k, v := range m.Extended {+ _ = k+ _ = v+ l = 1 + len(v) + protohelpers.SizeOfVarint(uint64(len(v)))+ mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + l+ n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize))+ }+ }+ l = len(m.HardLinkId)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.HardLinkCounter != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.HardLinkCounter))+ }+ l = len(m.Content)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.RemoteEntry != nil {+ l = m.RemoteEntry.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.Quota != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.Quota))+ }+ if m.WormEnforcedAtTsNs != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.WormEnforcedAtTsNs))+ }+ n += len(m.unknownFields)+ return n+}++func (m *FullEntry) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.Dir)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.Entry != nil {+ l = m.Entry.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ n += len(m.unknownFields)+ return n+}++func (m *EventNotification) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if m.OldEntry != nil {+ l = m.OldEntry.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.NewEntry != nil {+ l = m.NewEntry.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.DeleteChunks {+ n += 2+ }+ l = len(m.NewParentPath)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.IsFromOtherCluster {+ n += 2+ }+ if len(m.Signatures) > 0 {+ l = 0+ for _, e := range m.Signatures {+ l += protohelpers.SizeOfVarint(uint64(e))+ }+ n += 1 + protohelpers.SizeOfVarint(uint64(l)) + l+ }+ n += len(m.unknownFields)+ return n+}++func (m *FileChunk) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.FileId)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.Offset != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.Offset))+ }+ if m.Size != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.Size))+ }+ if m.ModifiedTsNs != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.ModifiedTsNs))+ }+ l = len(m.ETag)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.SourceFileId)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.Fid != nil {+ l = m.Fid.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.SourceFid != nil {+ l = m.SourceFid.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.CipherKey)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.IsCompressed {+ n += 2+ }+ if m.IsChunkManifest {+ n += 2+ }+ if m.SseType != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.SseType))+ }+ l = len(m.SseMetadata)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ n += len(m.unknownFields)+ return n+}++func (m *FileChunkManifest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if len(m.Chunks) > 0 {+ for _, e := range m.Chunks {+ l = e.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ }+ n += len(m.unknownFields)+ return n+}++func (m *FileId) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if m.VolumeId != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.VolumeId))+ }+ if m.FileKey != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.FileKey))+ }+ if m.Cookie != 0 {+ n += 5+ }+ n += len(m.unknownFields)+ return n+}++func (m *FuseAttributes) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if m.FileSize != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.FileSize))+ }+ if m.Mtime != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.Mtime))+ }+ if m.FileMode != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.FileMode))+ }+ if m.Uid != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.Uid))+ }+ if m.Gid != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.Gid))+ }+ if m.Crtime != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.Crtime))+ }+ l = len(m.Mime)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.TtlSec != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.TtlSec))+ }+ l = len(m.UserName)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if len(m.GroupName) > 0 {+ for _, s := range m.GroupName {+ l = len(s)+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ }+ l = len(m.SymlinkTarget)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.Md5)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.Rdev != 0 {+ n += 2 + protohelpers.SizeOfVarint(uint64(m.Rdev))+ }+ if m.Inode != 0 {+ n += 2 + protohelpers.SizeOfVarint(uint64(m.Inode))+ }+ if m.Ctime != 0 {+ n += 2 + protohelpers.SizeOfVarint(uint64(m.Ctime))+ }+ if m.MtimeNs != 0 {+ n += 2 + protohelpers.SizeOfVarint(uint64(m.MtimeNs))+ }+ if m.CtimeNs != 0 {+ n += 2 + protohelpers.SizeOfVarint(uint64(m.CtimeNs))+ }+ if m.CrtimeNs != 0 {+ n += 2 + protohelpers.SizeOfVarint(uint64(m.CrtimeNs))+ }+ if m.Atime != 0 {+ n += 2 + protohelpers.SizeOfVarint(uint64(m.Atime))+ }+ if m.AtimeNs != 0 {+ n += 2 + protohelpers.SizeOfVarint(uint64(m.AtimeNs))+ }+ n += len(m.unknownFields)+ return n+}++func (m *CreateEntryRequest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.Directory)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.Entry != nil {+ l = m.Entry.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.OExcl {+ n += 2+ }+ if m.IsFromOtherCluster {+ n += 2+ }+ if len(m.Signatures) > 0 {+ l = 0+ for _, e := range m.Signatures {+ l += protohelpers.SizeOfVarint(uint64(e))+ }+ n += 1 + protohelpers.SizeOfVarint(uint64(l)) + l+ }+ if m.SkipCheckParentDirectory {+ n += 2+ }+ if m.Condition != nil {+ l = m.Condition.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ n += len(m.unknownFields)+ return n+}++func (m *WriteCondition_Clause) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if m.Kind != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.Kind))+ }+ if len(m.Etags) > 0 {+ for _, s := range m.Etags {+ l = len(s)+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ }+ if m.UnixTime != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.UnixTime))+ }+ if m.AllowWeak {+ n += 2+ }+ l = len(m.ExtKey)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.ExtValue)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.GateKey)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.GateValue)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ n += len(m.unknownFields)+ return n+}++func (m *WriteCondition) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if len(m.Clauses) > 0 {+ for _, e := range m.Clauses {+ l = e.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ }+ n += len(m.unknownFields)+ return n+}++func (m *ObjectMutation) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if m.Type != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.Type))+ }+ l = len(m.Directory)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.Name)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.Entry != nil {+ l = m.Entry.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if len(m.SetExtended) > 0 {+ for k, v := range m.SetExtended {+ _ = k+ _ = v+ l = 1 + len(v) + protohelpers.SizeOfVarint(uint64(len(v)))+ mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + l+ n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize))+ }+ }+ if len(m.DeleteExtended) > 0 {+ for _, s := range m.DeleteExtended {+ l = len(s)+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ }+ if m.IsDeleteData {+ n += 2+ }+ if m.IsRecursive {+ n += 2+ }+ if m.Recompute != nil {+ l = m.Recompute.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.SetContent {+ n += 2+ }+ l = len(m.Content)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.TouchMtime {+ n += 2+ }+ if m.RemoveEmptyParent {+ n += 2+ }+ n += len(m.unknownFields)+ return n+}++func (m *Recompute) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.ScanDir)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.Descending {+ n += 2+ }+ if len(m.CopyExtended) > 0 {+ for k, v := range m.CopyExtended {+ _ = k+ _ = v+ mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + 1 + len(v) + protohelpers.SizeOfVarint(uint64(len(v)))+ n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize))+ }+ }+ l = len(m.NameToKey)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.SizeToKey)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.MtimeToKey)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.DemoteKey)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.DemoteValue)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.ExcludeName)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ n += len(m.unknownFields)+ return n+}++func (m *ObjectTransactionRequest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.LockKey)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.Condition != nil {+ l = m.Condition.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if len(m.Mutations) > 0 {+ for _, e := range m.Mutations {+ l = e.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ }+ if m.IsFromOtherCluster {+ n += 2+ }+ if len(m.Signatures) > 0 {+ l = 0+ for _, e := range m.Signatures {+ l += protohelpers.SizeOfVarint(uint64(e))+ }+ n += 1 + protohelpers.SizeOfVarint(uint64(l)) + l+ }+ l = len(m.ConditionKey)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.RouteKey)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.IsMoved {+ n += 2+ }+ n += len(m.unknownFields)+ return n+}++func (m *ObjectTransactionResponse) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.Error)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.ErrorCode != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.ErrorCode))+ }+ n += len(m.unknownFields)+ return n+}++func (m *PosixLockRange) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if m.Start != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.Start))+ }+ if m.End != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.End))+ }+ if m.Type != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.Type))+ }+ if m.Sid != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.Sid))+ }+ if m.Owner != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.Owner))+ }+ if m.Pid != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.Pid))+ }+ if m.IsFlock {+ n += 2+ }+ n += len(m.unknownFields)+ return n+}++func (m *PosixLockRequest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.Key)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.IsMoved {+ n += 2+ }+ if m.Op != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.Op))+ }+ if m.Lock != nil {+ l = m.Lock.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if len(m.Locks) > 0 {+ for _, e := range m.Locks {+ l = e.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ }+ if m.CoolingProbe {+ n += 2+ }+ n += len(m.unknownFields)+ return n+}++func (m *PosixLockResponse) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if m.Granted {+ n += 2+ }+ if m.HasConflict {+ n += 2+ }+ if m.Conflict != nil {+ l = m.Conflict.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ n += len(m.unknownFields)+ return n+}++func (m *ObjectTransactionBatchRequest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if len(m.Transactions) > 0 {+ for _, e := range m.Transactions {+ l = e.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ }+ n += len(m.unknownFields)+ return n+}++func (m *ObjectTransactionBatchResponse) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if len(m.Responses) > 0 {+ for _, e := range m.Responses {+ l = e.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ }+ n += len(m.unknownFields)+ return n+}++func (m *CreateEntryResponse) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.Error)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.MetadataEvent != nil {+ l = m.MetadataEvent.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.ErrorCode != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.ErrorCode))+ }+ n += len(m.unknownFields)+ return n+}++func (m *UpdateEntryRequest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.Directory)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.Entry != nil {+ l = m.Entry.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.IsFromOtherCluster {+ n += 2+ }+ if len(m.Signatures) > 0 {+ l = 0+ for _, e := range m.Signatures {+ l += protohelpers.SizeOfVarint(uint64(e))+ }+ n += 1 + protohelpers.SizeOfVarint(uint64(l)) + l+ }+ if len(m.ExpectedExtended) > 0 {+ for k, v := range m.ExpectedExtended {+ _ = k+ _ = v+ l = 1 + len(v) + protohelpers.SizeOfVarint(uint64(len(v)))+ mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + l+ n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize))+ }+ }+ n += len(m.unknownFields)+ return n+}++func (m *UpdateEntryResponse) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if m.MetadataEvent != nil {+ l = m.MetadataEvent.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ n += len(m.unknownFields)+ return n+}++func (m *TouchAccessTimeRequest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.Directory)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.Name)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.ClientAtimeNs != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.ClientAtimeNs))+ }+ n += len(m.unknownFields)+ return n+}++func (m *TouchAccessTimeResponse) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if m.PersistedAtimeNs != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.PersistedAtimeNs))+ }+ if m.Updated {+ n += 2+ }+ n += len(m.unknownFields)+ return n+}++func (m *AppendToEntryRequest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.Directory)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.EntryName)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if len(m.Chunks) > 0 {+ for _, e := range m.Chunks {+ l = e.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ }+ n += len(m.unknownFields)+ return n+}++func (m *AppendToEntryResponse) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ n += len(m.unknownFields)+ return n+}++func (m *DeleteEntryRequest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.Directory)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.Name)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.IsDeleteData {+ n += 2+ }+ if m.IsRecursive {+ n += 2+ }+ if m.IgnoreRecursiveError {+ n += 2+ }+ if m.IsFromOtherCluster {+ n += 2+ }+ if len(m.Signatures) > 0 {+ l = 0+ for _, e := range m.Signatures {+ l += protohelpers.SizeOfVarint(uint64(e))+ }+ n += 1 + protohelpers.SizeOfVarint(uint64(l)) + l+ }+ if m.IfNotModifiedAfter != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.IfNotModifiedAfter))+ }+ n += len(m.unknownFields)+ return n+}++func (m *DeleteEntryResponse) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.Error)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.MetadataEvent != nil {+ l = m.MetadataEvent.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ n += len(m.unknownFields)+ return n+}++func (m *AtomicRenameEntryRequest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.OldDirectory)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.OldName)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.NewDirectory)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.NewName)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if len(m.Signatures) > 0 {+ l = 0+ for _, e := range m.Signatures {+ l += protohelpers.SizeOfVarint(uint64(e))+ }+ n += 1 + protohelpers.SizeOfVarint(uint64(l)) + l+ }+ n += len(m.unknownFields)+ return n+}++func (m *AtomicRenameEntryResponse) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ n += len(m.unknownFields)+ return n+}++func (m *StreamRenameEntryRequest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.OldDirectory)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.OldName)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.NewDirectory)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.NewName)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if len(m.Signatures) > 0 {+ l = 0+ for _, e := range m.Signatures {+ l += protohelpers.SizeOfVarint(uint64(e))+ }+ n += 1 + protohelpers.SizeOfVarint(uint64(l)) + l+ }+ n += len(m.unknownFields)+ return n+}++func (m *StreamRenameEntryResponse) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.Directory)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.EventNotification != nil {+ l = m.EventNotification.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.TsNs != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.TsNs))+ }+ n += len(m.unknownFields)+ return n+}++func (m *AssignVolumeRequest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if m.Count != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.Count))+ }+ l = len(m.Collection)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.Replication)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.TtlSec != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.TtlSec))+ }+ l = len(m.DataCenter)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.Path)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.Rack)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.DiskType)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.DataNode)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.ExpectedDataSize != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.ExpectedDataSize))+ }+ n += len(m.unknownFields)+ return n+}++func (m *AssignVolumeResponse) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.FileId)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.Count != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.Count))+ }+ l = len(m.Auth)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.Collection)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.Replication)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.Error)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.Location != nil {+ l = m.Location.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if len(m.Replicas) > 0 {+ for _, e := range m.Replicas {+ l = e.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ }+ n += len(m.unknownFields)+ return n+}++func (m *LookupVolumeRequest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if len(m.VolumeIds) > 0 {+ for _, s := range m.VolumeIds {+ l = len(s)+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ }+ n += len(m.unknownFields)+ return n+}++func (m *Locations) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if len(m.Locations) > 0 {+ for _, e := range m.Locations {+ l = e.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ }+ n += len(m.unknownFields)+ return n+}++func (m *Location) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.Url)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.PublicUrl)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.GrpcPort != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.GrpcPort))+ }+ l = len(m.DataCenter)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ n += len(m.unknownFields)+ return n+}++func (m *LookupVolumeResponse) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if len(m.LocationsMap) > 0 {+ for k, v := range m.LocationsMap {+ _ = k+ _ = v+ l = 0+ if v != nil {+ l = v.SizeVT()+ }+ l += 1 + protohelpers.SizeOfVarint(uint64(l))+ mapEntrySize := 1 + len(k) + protohelpers.SizeOfVarint(uint64(len(k))) + l+ n += mapEntrySize + 1 + protohelpers.SizeOfVarint(uint64(mapEntrySize))+ }+ }+ n += len(m.unknownFields)+ return n+}++func (m *Collection) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.Name)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ n += len(m.unknownFields)+ return n+}++func (m *CollectionListRequest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if m.IncludeNormalVolumes {+ n += 2+ }+ if m.IncludeEcVolumes {+ n += 2+ }+ n += len(m.unknownFields)+ return n+}++func (m *CollectionListResponse) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if len(m.Collections) > 0 {+ for _, e := range m.Collections {+ l = e.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ }+ n += len(m.unknownFields)+ return n+}++func (m *DeleteCollectionRequest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.Collection)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ n += len(m.unknownFields)+ return n+}++func (m *DeleteCollectionResponse) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ n += len(m.unknownFields)+ return n+}++func (m *StatisticsRequest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.Replication)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.Collection)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.Ttl)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.DiskType)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ n += len(m.unknownFields)+ return n+}++func (m *StatisticsResponse) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if m.TotalSize != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.TotalSize))+ }+ if m.UsedSize != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.UsedSize))+ }+ if m.FileCount != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.FileCount))+ }+ n += len(m.unknownFields)+ return n+}++func (m *PingRequest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.Target)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.TargetType)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ n += len(m.unknownFields)+ return n+}++func (m *PingResponse) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if m.StartTimeNs != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.StartTimeNs))+ }+ if m.RemoteTimeNs != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.RemoteTimeNs))+ }+ if m.StopTimeNs != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.StopTimeNs))+ }+ n += len(m.unknownFields)+ return n+}++func (m *GetFilerConfigurationRequest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ n += len(m.unknownFields)+ return n+}++func (m *GetFilerConfigurationResponse) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if len(m.Masters) > 0 {+ for _, s := range m.Masters {+ l = len(s)+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ }+ l = len(m.Replication)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.Collection)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.MaxMb != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.MaxMb))+ }+ l = len(m.DirBuckets)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.Cipher {+ n += 2+ }+ if m.Signature != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.Signature))+ }+ l = len(m.MetricsAddress)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.MetricsIntervalSec != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.MetricsIntervalSec))+ }+ l = len(m.Version)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.ClusterId)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.FilerGroup)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.MajorVersion != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.MajorVersion))+ }+ if m.MinorVersion != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.MinorVersion))+ }+ n += len(m.unknownFields)+ return n+}++func (m *SubscribeMetadataRequest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.ClientName)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.PathPrefix)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.SinceNs != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.SinceNs))+ }+ if m.Signature != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.Signature))+ }+ if len(m.PathPrefixes) > 0 {+ for _, s := range m.PathPrefixes {+ l = len(s)+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ }+ if m.ClientId != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.ClientId))+ }+ if m.UntilNs != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.UntilNs))+ }+ if m.ClientEpoch != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.ClientEpoch))+ }+ if len(m.Directories) > 0 {+ for _, s := range m.Directories {+ l = len(s)+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ }+ if m.ClientSupportsBatching {+ n += 2+ }+ if m.ClientSupportsMetadataChunks {+ n += 2+ }+ if m.ClientSupportsIdleHeartbeat {+ n += 2+ }+ n += len(m.unknownFields)+ return n+}++func (m *SubscribeMetadataResponse) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.Directory)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.EventNotification != nil {+ l = m.EventNotification.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.TsNs != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.TsNs))+ }+ if len(m.Events) > 0 {+ for _, e := range m.Events {+ l = e.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ }+ if len(m.LogFileRefs) > 0 {+ for _, e := range m.LogFileRefs {+ l = e.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ }+ n += len(m.unknownFields)+ return n+}++func (m *ListMetadataSubscribersRequest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if len(m.ClientTypes) > 0 {+ for _, s := range m.ClientTypes {+ l = len(s)+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ }+ n += len(m.unknownFields)+ return n+}++func (m *ListMetadataSubscribersResponse) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if len(m.Subscribers) > 0 {+ for _, e := range m.Subscribers {+ l = e.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ }+ n += len(m.unknownFields)+ return n+}++func (m *MetadataSubscriber) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.ClientName)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.ClientType)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.Address)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.PathPrefix)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.ClientId != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.ClientId))+ }+ if m.ClientEpoch != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.ClientEpoch))+ }+ if m.ConnectedAtNs != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.ConnectedAtNs))+ }+ l = len(m.FilerAddress)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ n += len(m.unknownFields)+ return n+}++func (m *LogFileChunkRef) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if len(m.Chunks) > 0 {+ for _, e := range m.Chunks {+ l = e.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ }+ if m.FileTsNs != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.FileTsNs))+ }+ l = len(m.FilerId)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ n += len(m.unknownFields)+ return n+}++func (m *TraverseBfsMetadataRequest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.Directory)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if len(m.ExcludedPrefixes) > 0 {+ for _, s := range m.ExcludedPrefixes {+ l = len(s)+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ }+ n += len(m.unknownFields)+ return n+}++func (m *TraverseBfsMetadataResponse) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.Directory)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.Entry != nil {+ l = m.Entry.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ n += len(m.unknownFields)+ return n+}++func (m *LogEntry) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if m.TsNs != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.TsNs))+ }+ if m.PartitionKeyHash != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.PartitionKeyHash))+ }+ l = len(m.Data)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.Key)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.Offset != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.Offset))+ }+ n += len(m.unknownFields)+ return n+}++func (m *KeepConnectedRequest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.Name)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.GrpcPort != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.GrpcPort))+ }+ if len(m.Resources) > 0 {+ for _, s := range m.Resources {+ l = len(s)+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ }+ n += len(m.unknownFields)+ return n+}++func (m *KeepConnectedResponse) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ n += len(m.unknownFields)+ return n+}++func (m *LocateBrokerRequest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.Resource)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ n += len(m.unknownFields)+ return n+}++func (m *LocateBrokerResponse_Resource) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.GrpcAddresses)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.ResourceCount != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.ResourceCount))+ }+ n += len(m.unknownFields)+ return n+}++func (m *LocateBrokerResponse) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if m.Found {+ n += 2+ }+ if len(m.Resources) > 0 {+ for _, e := range m.Resources {+ l = e.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ }+ n += len(m.unknownFields)+ return n+}++func (m *KvGetRequest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.Key)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ n += len(m.unknownFields)+ return n+}++func (m *KvGetResponse) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.Value)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.Error)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ n += len(m.unknownFields)+ return n+}++func (m *KvPutRequest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.Key)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.Value)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ n += len(m.unknownFields)+ return n+}++func (m *KvPutResponse) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.Error)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ n += len(m.unknownFields)+ return n+}++func (m *FilerConf_PathConf) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.LocationPrefix)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.Collection)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.Replication)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.Ttl)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.DiskType)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.Fsync {+ n += 2+ }+ if m.VolumeGrowthCount != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.VolumeGrowthCount))+ }+ if m.ReadOnly {+ n += 2+ }+ l = len(m.DataCenter)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.Rack)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.DataNode)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.MaxFileNameLength != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.MaxFileNameLength))+ }+ if m.DisableChunkDeletion {+ n += 2+ }+ if m.Worm {+ n += 2+ }+ if m.WormGracePeriodSeconds != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.WormGracePeriodSeconds))+ }+ if m.WormRetentionTimeSeconds != 0 {+ n += 2 + protohelpers.SizeOfVarint(uint64(m.WormRetentionTimeSeconds))+ }+ n += len(m.unknownFields)+ return n+}++func (m *FilerConf) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if m.Version != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.Version))+ }+ if len(m.Locations) > 0 {+ for _, e := range m.Locations {+ l = e.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ }+ n += len(m.unknownFields)+ return n+}++func (m *CacheRemoteObjectToLocalClusterRequest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.Directory)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.Name)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.ChunkConcurrency != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.ChunkConcurrency))+ }+ if m.DownloadConcurrency != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.DownloadConcurrency))+ }+ n += len(m.unknownFields)+ return n+}++func (m *CacheRemoteObjectToLocalClusterResponse) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if m.Entry != nil {+ l = m.Entry.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.MetadataEvent != nil {+ l = m.MetadataEvent.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ n += len(m.unknownFields)+ return n+}++func (m *LockRequest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.Name)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.SecondsToLock != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.SecondsToLock))+ }+ l = len(m.RenewToken)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.IsMoved {+ n += 2+ }+ l = len(m.Owner)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ n += len(m.unknownFields)+ return n+}++func (m *LockResponse) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.RenewToken)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.LockOwner)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.LockHostMovedTo)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.Error)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.Generation != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.Generation))+ }+ n += len(m.unknownFields)+ return n+}++func (m *UnlockRequest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.Name)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.RenewToken)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.IsMoved {+ n += 2+ }+ n += len(m.unknownFields)+ return n+}++func (m *UnlockResponse) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.Error)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.MovedTo)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ n += len(m.unknownFields)+ return n+}++func (m *FindLockOwnerRequest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.Name)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.IsMoved {+ n += 2+ }+ n += len(m.unknownFields)+ return n+}++func (m *FindLockOwnerResponse) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.Owner)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ n += len(m.unknownFields)+ return n+}++func (m *Lock) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.Name)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.RenewToken)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.ExpiredAtNs != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.ExpiredAtNs))+ }+ l = len(m.Owner)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.Generation != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.Generation))+ }+ if m.IsBackup {+ n += 2+ }+ if m.Seq != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.Seq))+ }+ n += len(m.unknownFields)+ return n+}++func (m *TransferLocksRequest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if len(m.Locks) > 0 {+ for _, e := range m.Locks {+ l = e.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ }+ n += len(m.unknownFields)+ return n+}++func (m *TransferLocksResponse) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ n += len(m.unknownFields)+ return n+}++func (m *ReplicateLockRequest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.Name)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.RenewToken)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.ExpiredAtNs != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.ExpiredAtNs))+ }+ l = len(m.Owner)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.Generation != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.Generation))+ }+ if m.IsUnlock {+ n += 2+ }+ if m.Seq != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.Seq))+ }+ n += len(m.unknownFields)+ return n+}++func (m *ReplicateLockResponse) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ n += len(m.unknownFields)+ return n+}++func (m *StreamMutateEntryRequest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if m.RequestId != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.RequestId))+ }+ if vtmsg, ok := m.Request.(interface{ SizeVT() int }); ok {+ n += vtmsg.SizeVT()+ }+ n += len(m.unknownFields)+ return n+}++func (m *StreamMutateEntryRequest_CreateRequest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if m.CreateRequest != nil {+ l = m.CreateRequest.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ } else {+ n += 3+ }+ return n+}+func (m *StreamMutateEntryRequest_UpdateRequest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if m.UpdateRequest != nil {+ l = m.UpdateRequest.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ } else {+ n += 3+ }+ return n+}+func (m *StreamMutateEntryRequest_DeleteRequest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if m.DeleteRequest != nil {+ l = m.DeleteRequest.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ } else {+ n += 3+ }+ return n+}+func (m *StreamMutateEntryRequest_RenameRequest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if m.RenameRequest != nil {+ l = m.RenameRequest.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ } else {+ n += 3+ }+ return n+}+func (m *StreamMutateEntryResponse) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if m.RequestId != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.RequestId))+ }+ if m.IsLast {+ n += 2+ }+ if vtmsg, ok := m.Response.(interface{ SizeVT() int }); ok {+ n += vtmsg.SizeVT()+ }+ l = len(m.Error)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.Errno != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.Errno))+ }+ n += len(m.unknownFields)+ return n+}++func (m *StreamMutateEntryResponse_CreateResponse) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if m.CreateResponse != nil {+ l = m.CreateResponse.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ } else {+ n += 3+ }+ return n+}+func (m *StreamMutateEntryResponse_UpdateResponse) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if m.UpdateResponse != nil {+ l = m.UpdateResponse.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ } else {+ n += 3+ }+ return n+}+func (m *StreamMutateEntryResponse_DeleteResponse) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if m.DeleteResponse != nil {+ l = m.DeleteResponse.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ } else {+ n += 3+ }+ return n+}+func (m *StreamMutateEntryResponse_RenameResponse) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if m.RenameResponse != nil {+ l = m.RenameResponse.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ } else {+ n += 3+ }+ return n+}+func (m *MountRegisterRequest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.PeerAddr)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.Rack)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.TtlSeconds != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.TtlSeconds))+ }+ l = len(m.DataCenter)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ n += len(m.unknownFields)+ return n+}++func (m *MountRegisterResponse) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ n += len(m.unknownFields)+ return n+}++func (m *MountListRequest) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ n += len(m.unknownFields)+ return n+}++func (m *MountListResponse) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ if len(m.Mounts) > 0 {+ for _, e := range m.Mounts {+ l = e.SizeVT()+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ }+ n += len(m.unknownFields)+ return n+}++func (m *MountInfo) SizeVT() (n int) {+ if m == nil {+ return 0+ }+ var l int+ _ = l+ l = len(m.PeerAddr)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ l = len(m.Rack)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ if m.LastSeenNs != 0 {+ n += 1 + protohelpers.SizeOfVarint(uint64(m.LastSeenNs))+ }+ l = len(m.DataCenter)+ if l > 0 {+ n += 1 + l + protohelpers.SizeOfVarint(uint64(l))+ }+ n += len(m.unknownFields)+ return n+}++func (m *LookupDirectoryEntryRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: LookupDirectoryEntryRequest: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: LookupDirectoryEntryRequest: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Directory", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Directory = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ 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 protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Name = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *LookupDirectoryEntryResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: LookupDirectoryEntryResponse: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: LookupDirectoryEntryResponse: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Entry", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ if m.Entry == nil {+ m.Entry = &Entry{}+ }+ if err := m.Entry.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *ListEntriesRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: ListEntriesRequest: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: ListEntriesRequest: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Directory", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Directory = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Prefix", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Prefix = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 3:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field StartFromFileName", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.StartFromFileName = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 4:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field InclusiveStartFrom", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.InclusiveStartFrom = bool(v != 0)+ case 5:+ 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 protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.Limit |= uint32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 6:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field SnapshotTsNs", wireType)+ }+ m.SnapshotTsNs = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.SnapshotTsNs |= int64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *ListEntriesResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: ListEntriesResponse: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: ListEntriesResponse: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Entry", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ if m.Entry == nil {+ m.Entry = &Entry{}+ }+ if err := m.Entry.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ case 2:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field SnapshotTsNs", wireType)+ }+ m.SnapshotTsNs = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.SnapshotTsNs |= int64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *RemoteEntry) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: RemoteEntry: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: RemoteEntry: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field StorageName", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.StorageName = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field LastLocalSyncTsNs", wireType)+ }+ m.LastLocalSyncTsNs = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.LastLocalSyncTsNs |= int64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 3:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field RemoteETag", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.RemoteETag = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 4:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field RemoteMtime", wireType)+ }+ m.RemoteMtime = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.RemoteMtime |= int64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 5:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field RemoteSize", wireType)+ }+ m.RemoteSize = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.RemoteSize |= int64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *Entry) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: Entry: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: Entry: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ 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 protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Name = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field IsDirectory", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.IsDirectory = bool(v != 0)+ case 3:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Chunks", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Chunks = append(m.Chunks, &FileChunk{})+ if err := m.Chunks[len(m.Chunks)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ case 4:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Attributes", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ if m.Attributes == nil {+ m.Attributes = &FuseAttributes{}+ }+ if err := m.Attributes.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ case 5:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Extended", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ if m.Extended == nil {+ m.Extended = make(map[string][]byte)+ }+ var mapkey string+ var mapvalue []byte+ for iNdEx < postIndex {+ entryPreIndex := iNdEx+ var wire uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ wire |= uint64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ fieldNum := int32(wire >> 3)+ if fieldNum == 1 {+ var stringLenmapkey uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ stringLenmapkey |= uint64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ intStringLenmapkey := int(stringLenmapkey)+ if intStringLenmapkey < 0 {+ return protohelpers.ErrInvalidLength+ }+ postStringIndexmapkey := iNdEx + intStringLenmapkey+ if postStringIndexmapkey < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postStringIndexmapkey > l {+ return io.ErrUnexpectedEOF+ }+ mapkey = string(dAtA[iNdEx:postStringIndexmapkey])+ iNdEx = postStringIndexmapkey+ } else if fieldNum == 2 {+ var mapbyteLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ mapbyteLen |= uint64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ intMapbyteLen := int(mapbyteLen)+ if intMapbyteLen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postbytesIndex := iNdEx + intMapbyteLen+ if postbytesIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postbytesIndex > l {+ return io.ErrUnexpectedEOF+ }+ mapvalue = make([]byte, mapbyteLen)+ copy(mapvalue, dAtA[iNdEx:postbytesIndex])+ iNdEx = postbytesIndex+ } else {+ iNdEx = entryPreIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > postIndex {+ return io.ErrUnexpectedEOF+ }+ iNdEx += skippy+ }+ }+ m.Extended[mapkey] = mapvalue+ iNdEx = postIndex+ case 7:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field HardLinkId", wireType)+ }+ var byteLen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ byteLen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if byteLen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + byteLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.HardLinkId = append(m.HardLinkId[:0], dAtA[iNdEx:postIndex]...)+ if m.HardLinkId == nil {+ m.HardLinkId = []byte{}+ }+ iNdEx = postIndex+ case 8:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field HardLinkCounter", wireType)+ }+ m.HardLinkCounter = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.HardLinkCounter |= int32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 9:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Content", wireType)+ }+ var byteLen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ byteLen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if byteLen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + byteLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Content = append(m.Content[:0], dAtA[iNdEx:postIndex]...)+ if m.Content == nil {+ m.Content = []byte{}+ }+ iNdEx = postIndex+ case 10:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field RemoteEntry", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ if m.RemoteEntry == nil {+ m.RemoteEntry = &RemoteEntry{}+ }+ if err := m.RemoteEntry.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ case 11:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field Quota", wireType)+ }+ m.Quota = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.Quota |= int64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 12:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field WormEnforcedAtTsNs", wireType)+ }+ m.WormEnforcedAtTsNs = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.WormEnforcedAtTsNs |= int64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *FullEntry) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: FullEntry: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: FullEntry: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Dir", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Dir = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Entry", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ if m.Entry == nil {+ m.Entry = &Entry{}+ }+ if err := m.Entry.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *EventNotification) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: EventNotification: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: EventNotification: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field OldEntry", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ if m.OldEntry == nil {+ m.OldEntry = &Entry{}+ }+ if err := m.OldEntry.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ case 2:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field NewEntry", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ if m.NewEntry == nil {+ m.NewEntry = &Entry{}+ }+ if err := m.NewEntry.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ case 3:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field DeleteChunks", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.DeleteChunks = bool(v != 0)+ case 4:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field NewParentPath", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.NewParentPath = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 5:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field IsFromOtherCluster", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.IsFromOtherCluster = bool(v != 0)+ case 6:+ if wireType == 0 {+ var v int32+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.Signatures = append(m.Signatures, v)+ } else if wireType == 2 {+ var packedLen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ packedLen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if packedLen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + packedLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ var elementCount int+ var count int+ for _, integer := range dAtA[iNdEx:postIndex] {+ if integer < 128 {+ count+++ }+ }+ elementCount = count+ if elementCount != 0 && len(m.Signatures) == 0 {+ m.Signatures = make([]int32, 0, elementCount)+ }+ for iNdEx < postIndex {+ var v int32+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.Signatures = append(m.Signatures, v)+ }+ } else {+ return fmt.Errorf("proto: wrong wireType = %d for field Signatures", wireType)+ }+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *FileChunk) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: FileChunk: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: FileChunk: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field FileId", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.FileId = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType)+ }+ m.Offset = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.Offset |= int64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 3:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field Size", wireType)+ }+ m.Size = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.Size |= uint64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 4:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field ModifiedTsNs", wireType)+ }+ m.ModifiedTsNs = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.ModifiedTsNs |= int64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 5:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field ETag", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.ETag = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 6:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field SourceFileId", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.SourceFileId = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 7:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Fid", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ if m.Fid == nil {+ m.Fid = &FileId{}+ }+ if err := m.Fid.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ case 8:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field SourceFid", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ if m.SourceFid == nil {+ m.SourceFid = &FileId{}+ }+ if err := m.SourceFid.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ case 9:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field CipherKey", wireType)+ }+ var byteLen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ byteLen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if byteLen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + byteLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.CipherKey = append(m.CipherKey[:0], dAtA[iNdEx:postIndex]...)+ if m.CipherKey == nil {+ m.CipherKey = []byte{}+ }+ iNdEx = postIndex+ case 10:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field IsCompressed", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.IsCompressed = bool(v != 0)+ case 11:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field IsChunkManifest", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.IsChunkManifest = bool(v != 0)+ case 12:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field SseType", wireType)+ }+ m.SseType = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.SseType |= SSEType(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 13:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field SseMetadata", wireType)+ }+ var byteLen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ byteLen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if byteLen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + byteLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.SseMetadata = append(m.SseMetadata[:0], dAtA[iNdEx:postIndex]...)+ if m.SseMetadata == nil {+ m.SseMetadata = []byte{}+ }+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *FileChunkManifest) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: FileChunkManifest: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: FileChunkManifest: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Chunks", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Chunks = append(m.Chunks, &FileChunk{})+ if err := m.Chunks[len(m.Chunks)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *FileId) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: FileId: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: FileId: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field VolumeId", wireType)+ }+ m.VolumeId = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.VolumeId |= uint32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 2:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field FileKey", wireType)+ }+ m.FileKey = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.FileKey |= uint64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 3:+ if wireType != 5 {+ return fmt.Errorf("proto: wrong wireType = %d for field Cookie", wireType)+ }+ m.Cookie = 0+ if (iNdEx + 4) > l {+ return io.ErrUnexpectedEOF+ }+ m.Cookie = uint32(binary.LittleEndian.Uint32(dAtA[iNdEx:]))+ iNdEx += 4+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *FuseAttributes) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: FuseAttributes: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: FuseAttributes: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field FileSize", wireType)+ }+ m.FileSize = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.FileSize |= uint64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 2:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field Mtime", wireType)+ }+ m.Mtime = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.Mtime |= int64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 3:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field FileMode", wireType)+ }+ m.FileMode = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.FileMode |= uint32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 4:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field Uid", wireType)+ }+ m.Uid = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.Uid |= uint32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 5:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field Gid", wireType)+ }+ m.Gid = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.Gid |= uint32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 6:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field Crtime", wireType)+ }+ m.Crtime = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.Crtime |= int64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 7:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Mime", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Mime = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 10:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field TtlSec", wireType)+ }+ m.TtlSec = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.TtlSec |= int32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 11:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field UserName", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.UserName = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 12:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field GroupName", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.GroupName = append(m.GroupName, string(dAtA[iNdEx:postIndex]))+ iNdEx = postIndex+ case 13:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field SymlinkTarget", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.SymlinkTarget = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 14:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Md5", wireType)+ }+ var byteLen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ byteLen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if byteLen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + byteLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Md5 = append(m.Md5[:0], dAtA[iNdEx:postIndex]...)+ if m.Md5 == nil {+ m.Md5 = []byte{}+ }+ iNdEx = postIndex+ case 16:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field Rdev", wireType)+ }+ m.Rdev = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.Rdev |= uint32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 17:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field Inode", wireType)+ }+ m.Inode = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.Inode |= uint64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 18:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field Ctime", wireType)+ }+ m.Ctime = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.Ctime |= int64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 19:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field MtimeNs", wireType)+ }+ m.MtimeNs = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.MtimeNs |= int32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 20:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field CtimeNs", wireType)+ }+ m.CtimeNs = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.CtimeNs |= int32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 21:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field CrtimeNs", wireType)+ }+ m.CrtimeNs = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.CrtimeNs |= int32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 22:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field Atime", wireType)+ }+ m.Atime = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.Atime |= int64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 23:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field AtimeNs", wireType)+ }+ m.AtimeNs = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.AtimeNs |= int32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *CreateEntryRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: CreateEntryRequest: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: CreateEntryRequest: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Directory", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Directory = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Entry", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ if m.Entry == nil {+ m.Entry = &Entry{}+ }+ if err := m.Entry.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ case 3:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field OExcl", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.OExcl = bool(v != 0)+ case 4:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field IsFromOtherCluster", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.IsFromOtherCluster = bool(v != 0)+ case 5:+ if wireType == 0 {+ var v int32+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.Signatures = append(m.Signatures, v)+ } else if wireType == 2 {+ var packedLen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ packedLen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if packedLen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + packedLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ var elementCount int+ var count int+ for _, integer := range dAtA[iNdEx:postIndex] {+ if integer < 128 {+ count+++ }+ }+ elementCount = count+ if elementCount != 0 && len(m.Signatures) == 0 {+ m.Signatures = make([]int32, 0, elementCount)+ }+ for iNdEx < postIndex {+ var v int32+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.Signatures = append(m.Signatures, v)+ }+ } else {+ return fmt.Errorf("proto: wrong wireType = %d for field Signatures", wireType)+ }+ case 6:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field SkipCheckParentDirectory", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.SkipCheckParentDirectory = bool(v != 0)+ case 7:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Condition", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ if m.Condition == nil {+ m.Condition = &WriteCondition{}+ }+ if err := m.Condition.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *WriteCondition_Clause) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: WriteCondition_Clause: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: WriteCondition_Clause: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)+ }+ m.Kind = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.Kind |= WriteCondition_Kind(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 2:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Etags", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Etags = append(m.Etags, string(dAtA[iNdEx:postIndex]))+ iNdEx = postIndex+ case 3:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field UnixTime", wireType)+ }+ m.UnixTime = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.UnixTime |= int64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 4:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field AllowWeak", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.AllowWeak = bool(v != 0)+ case 5:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field ExtKey", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.ExtKey = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 6:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field ExtValue", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.ExtValue = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 7:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field GateKey", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.GateKey = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 8:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field GateValue", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.GateValue = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *WriteCondition) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: WriteCondition: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: WriteCondition: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Clauses", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Clauses = append(m.Clauses, &WriteCondition_Clause{})+ if err := m.Clauses[len(m.Clauses)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *ObjectMutation) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: ObjectMutation: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: ObjectMutation: 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 protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.Type |= ObjectMutation_Type(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 2:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Directory", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Directory = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ 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 protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Name = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 4:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Entry", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ if m.Entry == nil {+ m.Entry = &Entry{}+ }+ if err := m.Entry.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ case 5:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field SetExtended", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ if m.SetExtended == nil {+ m.SetExtended = make(map[string][]byte)+ }+ var mapkey string+ var mapvalue []byte+ for iNdEx < postIndex {+ entryPreIndex := iNdEx+ var wire uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ wire |= uint64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ fieldNum := int32(wire >> 3)+ if fieldNum == 1 {+ var stringLenmapkey uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ stringLenmapkey |= uint64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ intStringLenmapkey := int(stringLenmapkey)+ if intStringLenmapkey < 0 {+ return protohelpers.ErrInvalidLength+ }+ postStringIndexmapkey := iNdEx + intStringLenmapkey+ if postStringIndexmapkey < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postStringIndexmapkey > l {+ return io.ErrUnexpectedEOF+ }+ mapkey = string(dAtA[iNdEx:postStringIndexmapkey])+ iNdEx = postStringIndexmapkey+ } else if fieldNum == 2 {+ var mapbyteLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ mapbyteLen |= uint64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ intMapbyteLen := int(mapbyteLen)+ if intMapbyteLen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postbytesIndex := iNdEx + intMapbyteLen+ if postbytesIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postbytesIndex > l {+ return io.ErrUnexpectedEOF+ }+ mapvalue = make([]byte, mapbyteLen)+ copy(mapvalue, dAtA[iNdEx:postbytesIndex])+ iNdEx = postbytesIndex+ } else {+ iNdEx = entryPreIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > postIndex {+ return io.ErrUnexpectedEOF+ }+ iNdEx += skippy+ }+ }+ m.SetExtended[mapkey] = mapvalue+ iNdEx = postIndex+ case 6:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field DeleteExtended", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.DeleteExtended = append(m.DeleteExtended, string(dAtA[iNdEx:postIndex]))+ iNdEx = postIndex+ case 7:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field IsDeleteData", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.IsDeleteData = bool(v != 0)+ case 8:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field IsRecursive", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.IsRecursive = bool(v != 0)+ case 9:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Recompute", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ if m.Recompute == nil {+ m.Recompute = &Recompute{}+ }+ if err := m.Recompute.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ case 10:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field SetContent", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.SetContent = bool(v != 0)+ case 11:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Content", wireType)+ }+ var byteLen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ byteLen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if byteLen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + byteLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Content = append(m.Content[:0], dAtA[iNdEx:postIndex]...)+ if m.Content == nil {+ m.Content = []byte{}+ }+ iNdEx = postIndex+ case 12:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field TouchMtime", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.TouchMtime = bool(v != 0)+ case 13:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field RemoveEmptyParent", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.RemoveEmptyParent = bool(v != 0)+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *Recompute) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: Recompute: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: Recompute: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field ScanDir", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.ScanDir = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field Descending", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.Descending = bool(v != 0)+ case 3:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field CopyExtended", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ if m.CopyExtended == nil {+ m.CopyExtended = make(map[string]string)+ }+ var mapkey string+ var mapvalue string+ for iNdEx < postIndex {+ entryPreIndex := iNdEx+ var wire uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ wire |= uint64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ fieldNum := int32(wire >> 3)+ if fieldNum == 1 {+ var stringLenmapkey uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ stringLenmapkey |= uint64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ intStringLenmapkey := int(stringLenmapkey)+ if intStringLenmapkey < 0 {+ return protohelpers.ErrInvalidLength+ }+ postStringIndexmapkey := iNdEx + intStringLenmapkey+ if postStringIndexmapkey < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postStringIndexmapkey > l {+ return io.ErrUnexpectedEOF+ }+ mapkey = string(dAtA[iNdEx:postStringIndexmapkey])+ iNdEx = postStringIndexmapkey+ } else if fieldNum == 2 {+ var stringLenmapvalue uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ stringLenmapvalue |= uint64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ intStringLenmapvalue := int(stringLenmapvalue)+ if intStringLenmapvalue < 0 {+ return protohelpers.ErrInvalidLength+ }+ postStringIndexmapvalue := iNdEx + intStringLenmapvalue+ if postStringIndexmapvalue < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postStringIndexmapvalue > l {+ return io.ErrUnexpectedEOF+ }+ mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])+ iNdEx = postStringIndexmapvalue+ } else {+ iNdEx = entryPreIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > postIndex {+ return io.ErrUnexpectedEOF+ }+ iNdEx += skippy+ }+ }+ m.CopyExtended[mapkey] = mapvalue+ iNdEx = postIndex+ case 4:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field NameToKey", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.NameToKey = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 5:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field SizeToKey", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.SizeToKey = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 6:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field MtimeToKey", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.MtimeToKey = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 7:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field DemoteKey", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.DemoteKey = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 8:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field DemoteValue", wireType)+ }+ var byteLen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ byteLen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if byteLen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + byteLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.DemoteValue = append(m.DemoteValue[:0], dAtA[iNdEx:postIndex]...)+ if m.DemoteValue == nil {+ m.DemoteValue = []byte{}+ }+ iNdEx = postIndex+ case 9:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field ExcludeName", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.ExcludeName = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *ObjectTransactionRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: ObjectTransactionRequest: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: ObjectTransactionRequest: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field LockKey", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.LockKey = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Condition", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ if m.Condition == nil {+ m.Condition = &WriteCondition{}+ }+ if err := m.Condition.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ case 3:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Mutations", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Mutations = append(m.Mutations, &ObjectMutation{})+ if err := m.Mutations[len(m.Mutations)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ case 4:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field IsFromOtherCluster", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.IsFromOtherCluster = bool(v != 0)+ case 5:+ if wireType == 0 {+ var v int32+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.Signatures = append(m.Signatures, v)+ } else if wireType == 2 {+ var packedLen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ packedLen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if packedLen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + packedLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ var elementCount int+ var count int+ for _, integer := range dAtA[iNdEx:postIndex] {+ if integer < 128 {+ count+++ }+ }+ elementCount = count+ if elementCount != 0 && len(m.Signatures) == 0 {+ m.Signatures = make([]int32, 0, elementCount)+ }+ for iNdEx < postIndex {+ var v int32+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.Signatures = append(m.Signatures, v)+ }+ } else {+ return fmt.Errorf("proto: wrong wireType = %d for field Signatures", wireType)+ }+ case 6:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field ConditionKey", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.ConditionKey = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 7:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field RouteKey", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.RouteKey = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 8:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field IsMoved", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.IsMoved = bool(v != 0)+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *ObjectTransactionResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: ObjectTransactionResponse: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: ObjectTransactionResponse: 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 stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Error = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field ErrorCode", wireType)+ }+ m.ErrorCode = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.ErrorCode |= FilerError(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *PosixLockRange) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: PosixLockRange: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: PosixLockRange: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field Start", wireType)+ }+ m.Start = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.Start |= uint64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 2:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field End", wireType)+ }+ m.End = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.End |= uint64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 3:+ 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 protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.Type |= uint32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 4:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field Sid", wireType)+ }+ m.Sid = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.Sid |= uint64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 5:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType)+ }+ m.Owner = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.Owner |= uint64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 6:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field Pid", wireType)+ }+ m.Pid = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.Pid |= uint32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 7:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field IsFlock", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.IsFlock = bool(v != 0)+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *PosixLockRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: PosixLockRequest: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: PosixLockRequest: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Key = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field IsMoved", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.IsMoved = bool(v != 0)+ case 3:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field Op", wireType)+ }+ m.Op = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.Op |= PosixLockOp(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 4:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Lock", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ if m.Lock == nil {+ m.Lock = &PosixLockRange{}+ }+ if err := m.Lock.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ case 5:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Locks", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Locks = append(m.Locks, &PosixLockRange{})+ if err := m.Locks[len(m.Locks)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ case 6:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field CoolingProbe", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.CoolingProbe = bool(v != 0)+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *PosixLockResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: PosixLockResponse: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: PosixLockResponse: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field Granted", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.Granted = bool(v != 0)+ case 2:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field HasConflict", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.HasConflict = bool(v != 0)+ case 3:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Conflict", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ if m.Conflict == nil {+ m.Conflict = &PosixLockRange{}+ }+ if err := m.Conflict.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *ObjectTransactionBatchRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: ObjectTransactionBatchRequest: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: ObjectTransactionBatchRequest: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Transactions", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Transactions = append(m.Transactions, &ObjectTransactionRequest{})+ if err := m.Transactions[len(m.Transactions)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *ObjectTransactionBatchResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: ObjectTransactionBatchResponse: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: ObjectTransactionBatchResponse: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Responses", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Responses = append(m.Responses, &ObjectTransactionResponse{})+ if err := m.Responses[len(m.Responses)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *CreateEntryResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: CreateEntryResponse: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: CreateEntryResponse: 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 stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Error = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field MetadataEvent", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ if m.MetadataEvent == nil {+ m.MetadataEvent = &SubscribeMetadataResponse{}+ }+ if err := m.MetadataEvent.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ case 3:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field ErrorCode", wireType)+ }+ m.ErrorCode = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.ErrorCode |= FilerError(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *UpdateEntryRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: UpdateEntryRequest: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: UpdateEntryRequest: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Directory", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Directory = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Entry", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ if m.Entry == nil {+ m.Entry = &Entry{}+ }+ if err := m.Entry.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ case 3:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field IsFromOtherCluster", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.IsFromOtherCluster = bool(v != 0)+ case 4:+ if wireType == 0 {+ var v int32+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.Signatures = append(m.Signatures, v)+ } else if wireType == 2 {+ var packedLen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ packedLen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if packedLen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + packedLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ var elementCount int+ var count int+ for _, integer := range dAtA[iNdEx:postIndex] {+ if integer < 128 {+ count+++ }+ }+ elementCount = count+ if elementCount != 0 && len(m.Signatures) == 0 {+ m.Signatures = make([]int32, 0, elementCount)+ }+ for iNdEx < postIndex {+ var v int32+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.Signatures = append(m.Signatures, v)+ }+ } else {+ return fmt.Errorf("proto: wrong wireType = %d for field Signatures", wireType)+ }+ case 5:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field ExpectedExtended", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ if m.ExpectedExtended == nil {+ m.ExpectedExtended = make(map[string][]byte)+ }+ var mapkey string+ var mapvalue []byte+ for iNdEx < postIndex {+ entryPreIndex := iNdEx+ var wire uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ wire |= uint64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ fieldNum := int32(wire >> 3)+ if fieldNum == 1 {+ var stringLenmapkey uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ stringLenmapkey |= uint64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ intStringLenmapkey := int(stringLenmapkey)+ if intStringLenmapkey < 0 {+ return protohelpers.ErrInvalidLength+ }+ postStringIndexmapkey := iNdEx + intStringLenmapkey+ if postStringIndexmapkey < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postStringIndexmapkey > l {+ return io.ErrUnexpectedEOF+ }+ mapkey = string(dAtA[iNdEx:postStringIndexmapkey])+ iNdEx = postStringIndexmapkey+ } else if fieldNum == 2 {+ var mapbyteLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ mapbyteLen |= uint64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ intMapbyteLen := int(mapbyteLen)+ if intMapbyteLen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postbytesIndex := iNdEx + intMapbyteLen+ if postbytesIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postbytesIndex > l {+ return io.ErrUnexpectedEOF+ }+ mapvalue = make([]byte, mapbyteLen)+ copy(mapvalue, dAtA[iNdEx:postbytesIndex])+ iNdEx = postbytesIndex+ } else {+ iNdEx = entryPreIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > postIndex {+ return io.ErrUnexpectedEOF+ }+ iNdEx += skippy+ }+ }+ m.ExpectedExtended[mapkey] = mapvalue+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *UpdateEntryResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: UpdateEntryResponse: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: UpdateEntryResponse: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field MetadataEvent", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ if m.MetadataEvent == nil {+ m.MetadataEvent = &SubscribeMetadataResponse{}+ }+ if err := m.MetadataEvent.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *TouchAccessTimeRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: TouchAccessTimeRequest: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: TouchAccessTimeRequest: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Directory", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Directory = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ 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 protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Name = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 3:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field ClientAtimeNs", wireType)+ }+ m.ClientAtimeNs = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.ClientAtimeNs |= int64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *TouchAccessTimeResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: TouchAccessTimeResponse: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: TouchAccessTimeResponse: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field PersistedAtimeNs", wireType)+ }+ m.PersistedAtimeNs = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.PersistedAtimeNs |= int64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 2:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field Updated", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.Updated = bool(v != 0)+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *AppendToEntryRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: AppendToEntryRequest: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: AppendToEntryRequest: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Directory", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Directory = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field EntryName", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.EntryName = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 3:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Chunks", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Chunks = append(m.Chunks, &FileChunk{})+ if err := m.Chunks[len(m.Chunks)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *AppendToEntryResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: AppendToEntryResponse: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: AppendToEntryResponse: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *DeleteEntryRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: DeleteEntryRequest: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: DeleteEntryRequest: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Directory", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Directory = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ 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 protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Name = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 4:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field IsDeleteData", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.IsDeleteData = bool(v != 0)+ case 5:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field IsRecursive", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.IsRecursive = bool(v != 0)+ case 6:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field IgnoreRecursiveError", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.IgnoreRecursiveError = bool(v != 0)+ case 7:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field IsFromOtherCluster", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.IsFromOtherCluster = bool(v != 0)+ case 8:+ if wireType == 0 {+ var v int32+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.Signatures = append(m.Signatures, v)+ } else if wireType == 2 {+ var packedLen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ packedLen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if packedLen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + packedLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ var elementCount int+ var count int+ for _, integer := range dAtA[iNdEx:postIndex] {+ if integer < 128 {+ count+++ }+ }+ elementCount = count+ if elementCount != 0 && len(m.Signatures) == 0 {+ m.Signatures = make([]int32, 0, elementCount)+ }+ for iNdEx < postIndex {+ var v int32+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.Signatures = append(m.Signatures, v)+ }+ } else {+ return fmt.Errorf("proto: wrong wireType = %d for field Signatures", wireType)+ }+ case 9:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field IfNotModifiedAfter", wireType)+ }+ m.IfNotModifiedAfter = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.IfNotModifiedAfter |= int64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *DeleteEntryResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: DeleteEntryResponse: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: DeleteEntryResponse: 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 stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Error = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field MetadataEvent", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ if m.MetadataEvent == nil {+ m.MetadataEvent = &SubscribeMetadataResponse{}+ }+ if err := m.MetadataEvent.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *AtomicRenameEntryRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: AtomicRenameEntryRequest: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: AtomicRenameEntryRequest: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field OldDirectory", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.OldDirectory = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field OldName", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.OldName = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 3:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field NewDirectory", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.NewDirectory = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 4:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field NewName", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.NewName = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 5:+ if wireType == 0 {+ var v int32+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.Signatures = append(m.Signatures, v)+ } else if wireType == 2 {+ var packedLen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ packedLen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if packedLen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + packedLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ var elementCount int+ var count int+ for _, integer := range dAtA[iNdEx:postIndex] {+ if integer < 128 {+ count+++ }+ }+ elementCount = count+ if elementCount != 0 && len(m.Signatures) == 0 {+ m.Signatures = make([]int32, 0, elementCount)+ }+ for iNdEx < postIndex {+ var v int32+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.Signatures = append(m.Signatures, v)+ }+ } else {+ return fmt.Errorf("proto: wrong wireType = %d for field Signatures", wireType)+ }+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *AtomicRenameEntryResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: AtomicRenameEntryResponse: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: AtomicRenameEntryResponse: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *StreamRenameEntryRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: StreamRenameEntryRequest: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: StreamRenameEntryRequest: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field OldDirectory", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.OldDirectory = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field OldName", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.OldName = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 3:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field NewDirectory", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.NewDirectory = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 4:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field NewName", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.NewName = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 5:+ if wireType == 0 {+ var v int32+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.Signatures = append(m.Signatures, v)+ } else if wireType == 2 {+ var packedLen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ packedLen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if packedLen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + packedLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ var elementCount int+ var count int+ for _, integer := range dAtA[iNdEx:postIndex] {+ if integer < 128 {+ count+++ }+ }+ elementCount = count+ if elementCount != 0 && len(m.Signatures) == 0 {+ m.Signatures = make([]int32, 0, elementCount)+ }+ for iNdEx < postIndex {+ var v int32+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.Signatures = append(m.Signatures, v)+ }+ } else {+ return fmt.Errorf("proto: wrong wireType = %d for field Signatures", wireType)+ }+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *StreamRenameEntryResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: StreamRenameEntryResponse: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: StreamRenameEntryResponse: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Directory", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Directory = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field EventNotification", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ if m.EventNotification == nil {+ m.EventNotification = &EventNotification{}+ }+ if err := m.EventNotification.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ case 3:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field TsNs", wireType)+ }+ m.TsNs = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.TsNs |= int64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *AssignVolumeRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: AssignVolumeRequest: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: AssignVolumeRequest: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ 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 protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.Count |= int32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 2:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Collection", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Collection = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 3:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Replication", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Replication = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 4:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field TtlSec", wireType)+ }+ m.TtlSec = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.TtlSec |= int32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 5:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field DataCenter", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.DataCenter = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 6:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Path = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 7:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Rack", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Rack = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 8:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field DiskType", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.DiskType = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 9:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field DataNode", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.DataNode = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 10:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field ExpectedDataSize", wireType)+ }+ m.ExpectedDataSize = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.ExpectedDataSize |= uint64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *AssignVolumeResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: AssignVolumeResponse: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: AssignVolumeResponse: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field FileId", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.FileId = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 4:+ 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 protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.Count |= int32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 5:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Auth", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Auth = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 6:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Collection", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Collection = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 7:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Replication", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Replication = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 8:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Error = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 9:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Location", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ if m.Location == nil {+ m.Location = &Location{}+ }+ if err := m.Location.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ case 10:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Replicas", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Replicas = append(m.Replicas, &Location{})+ if err := m.Replicas[len(m.Replicas)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *LookupVolumeRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: LookupVolumeRequest: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: LookupVolumeRequest: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field VolumeIds", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.VolumeIds = append(m.VolumeIds, string(dAtA[iNdEx:postIndex]))+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *Locations) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: Locations: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: Locations: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Locations", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Locations = append(m.Locations, &Location{})+ if err := m.Locations[len(m.Locations)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *Location) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: Location: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: Location: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Url", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Url = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field PublicUrl", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.PublicUrl = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 3:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field GrpcPort", wireType)+ }+ m.GrpcPort = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.GrpcPort |= uint32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 4:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field DataCenter", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.DataCenter = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *LookupVolumeResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: LookupVolumeResponse: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: LookupVolumeResponse: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field LocationsMap", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ if m.LocationsMap == nil {+ m.LocationsMap = make(map[string]*Locations)+ }+ var mapkey string+ var mapvalue *Locations+ for iNdEx < postIndex {+ entryPreIndex := iNdEx+ var wire uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ wire |= uint64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ fieldNum := int32(wire >> 3)+ if fieldNum == 1 {+ var stringLenmapkey uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ stringLenmapkey |= uint64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ intStringLenmapkey := int(stringLenmapkey)+ if intStringLenmapkey < 0 {+ return protohelpers.ErrInvalidLength+ }+ postStringIndexmapkey := iNdEx + intStringLenmapkey+ if postStringIndexmapkey < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postStringIndexmapkey > l {+ return io.ErrUnexpectedEOF+ }+ mapkey = string(dAtA[iNdEx:postStringIndexmapkey])+ iNdEx = postStringIndexmapkey+ } else if fieldNum == 2 {+ var mapmsglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ mapmsglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if mapmsglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postmsgIndex := iNdEx + mapmsglen+ if postmsgIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postmsgIndex > l {+ return io.ErrUnexpectedEOF+ }+ mapvalue = &Locations{}+ if err := mapvalue.UnmarshalVT(dAtA[iNdEx:postmsgIndex]); err != nil {+ return err+ }+ iNdEx = postmsgIndex+ } else {+ iNdEx = entryPreIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > postIndex {+ return io.ErrUnexpectedEOF+ }+ iNdEx += skippy+ }+ }+ m.LocationsMap[mapkey] = mapvalue+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *Collection) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: Collection: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: Collection: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ 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 protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Name = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *CollectionListRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: CollectionListRequest: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: CollectionListRequest: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field IncludeNormalVolumes", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.IncludeNormalVolumes = bool(v != 0)+ case 2:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field IncludeEcVolumes", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.IncludeEcVolumes = bool(v != 0)+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *CollectionListResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: CollectionListResponse: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: CollectionListResponse: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Collections", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Collections = append(m.Collections, &Collection{})+ if err := m.Collections[len(m.Collections)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *DeleteCollectionRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: DeleteCollectionRequest: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: DeleteCollectionRequest: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Collection", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Collection = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *DeleteCollectionResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: DeleteCollectionResponse: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: DeleteCollectionResponse: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *StatisticsRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: StatisticsRequest: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: StatisticsRequest: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Replication", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Replication = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Collection", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Collection = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 3:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Ttl", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Ttl = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 4:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field DiskType", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.DiskType = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *StatisticsResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: StatisticsResponse: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: StatisticsResponse: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 4:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field TotalSize", wireType)+ }+ m.TotalSize = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.TotalSize |= uint64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 5:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field UsedSize", wireType)+ }+ m.UsedSize = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.UsedSize |= uint64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 6:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field FileCount", wireType)+ }+ m.FileCount = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.FileCount |= uint64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *PingRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: PingRequest: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: PingRequest: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Target = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field TargetType", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.TargetType = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *PingResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: PingResponse: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: PingResponse: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field StartTimeNs", wireType)+ }+ m.StartTimeNs = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.StartTimeNs |= int64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 2:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field RemoteTimeNs", wireType)+ }+ m.RemoteTimeNs = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.RemoteTimeNs |= int64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 3:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field StopTimeNs", wireType)+ }+ m.StopTimeNs = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.StopTimeNs |= int64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *GetFilerConfigurationRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: GetFilerConfigurationRequest: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: GetFilerConfigurationRequest: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *GetFilerConfigurationResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: GetFilerConfigurationResponse: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: GetFilerConfigurationResponse: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Masters", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Masters = append(m.Masters, string(dAtA[iNdEx:postIndex]))+ iNdEx = postIndex+ case 2:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Replication", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Replication = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 3:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Collection", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Collection = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 4:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field MaxMb", wireType)+ }+ m.MaxMb = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.MaxMb |= uint32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 5:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field DirBuckets", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.DirBuckets = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 7:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field Cipher", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.Cipher = bool(v != 0)+ case 8:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)+ }+ m.Signature = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.Signature |= int32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 9:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field MetricsAddress", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.MetricsAddress = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 10:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field MetricsIntervalSec", wireType)+ }+ m.MetricsIntervalSec = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.MetricsIntervalSec |= int32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 11:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Version = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 12:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.ClusterId = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 13:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field FilerGroup", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.FilerGroup = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 14:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field MajorVersion", wireType)+ }+ m.MajorVersion = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.MajorVersion |= int32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 15:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field MinorVersion", wireType)+ }+ m.MinorVersion = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.MinorVersion |= int32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *SubscribeMetadataRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: SubscribeMetadataRequest: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: SubscribeMetadataRequest: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field ClientName", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.ClientName = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field PathPrefix", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.PathPrefix = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 3:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field SinceNs", wireType)+ }+ m.SinceNs = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.SinceNs |= int64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 4:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)+ }+ m.Signature = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.Signature |= int32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 6:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field PathPrefixes", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.PathPrefixes = append(m.PathPrefixes, string(dAtA[iNdEx:postIndex]))+ iNdEx = postIndex+ case 7:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field ClientId", wireType)+ }+ m.ClientId = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.ClientId |= int32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 8:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field UntilNs", wireType)+ }+ m.UntilNs = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.UntilNs |= int64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 9:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field ClientEpoch", wireType)+ }+ m.ClientEpoch = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.ClientEpoch |= int32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 10:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Directories", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Directories = append(m.Directories, string(dAtA[iNdEx:postIndex]))+ iNdEx = postIndex+ case 11:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field ClientSupportsBatching", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.ClientSupportsBatching = bool(v != 0)+ case 12:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field ClientSupportsMetadataChunks", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.ClientSupportsMetadataChunks = bool(v != 0)+ case 13:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field ClientSupportsIdleHeartbeat", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.ClientSupportsIdleHeartbeat = bool(v != 0)+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *SubscribeMetadataResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: SubscribeMetadataResponse: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: SubscribeMetadataResponse: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Directory", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Directory = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field EventNotification", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ if m.EventNotification == nil {+ m.EventNotification = &EventNotification{}+ }+ if err := m.EventNotification.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ case 3:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field TsNs", wireType)+ }+ m.TsNs = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.TsNs |= int64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 4:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Events", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Events = append(m.Events, &SubscribeMetadataResponse{})+ if err := m.Events[len(m.Events)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ case 5:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field LogFileRefs", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.LogFileRefs = append(m.LogFileRefs, &LogFileChunkRef{})+ if err := m.LogFileRefs[len(m.LogFileRefs)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *ListMetadataSubscribersRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: ListMetadataSubscribersRequest: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: ListMetadataSubscribersRequest: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field ClientTypes", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.ClientTypes = append(m.ClientTypes, string(dAtA[iNdEx:postIndex]))+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *ListMetadataSubscribersResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: ListMetadataSubscribersResponse: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: ListMetadataSubscribersResponse: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Subscribers", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Subscribers = append(m.Subscribers, &MetadataSubscriber{})+ if err := m.Subscribers[len(m.Subscribers)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *MetadataSubscriber) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: MetadataSubscriber: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: MetadataSubscriber: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field ClientName", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.ClientName = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field ClientType", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.ClientType = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 3:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Address = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 4:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field PathPrefix", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.PathPrefix = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 5:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field ClientId", wireType)+ }+ m.ClientId = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.ClientId |= int32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 6:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field ClientEpoch", wireType)+ }+ m.ClientEpoch = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.ClientEpoch |= int32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 7:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field ConnectedAtNs", wireType)+ }+ m.ConnectedAtNs = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.ConnectedAtNs |= int64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 8:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field FilerAddress", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.FilerAddress = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *LogFileChunkRef) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: LogFileChunkRef: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: LogFileChunkRef: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Chunks", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Chunks = append(m.Chunks, &FileChunk{})+ if err := m.Chunks[len(m.Chunks)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ case 2:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field FileTsNs", wireType)+ }+ m.FileTsNs = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.FileTsNs |= int64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 3:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field FilerId", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.FilerId = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *TraverseBfsMetadataRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: TraverseBfsMetadataRequest: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: TraverseBfsMetadataRequest: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Directory", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Directory = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field ExcludedPrefixes", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.ExcludedPrefixes = append(m.ExcludedPrefixes, string(dAtA[iNdEx:postIndex]))+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *TraverseBfsMetadataResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: TraverseBfsMetadataResponse: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: TraverseBfsMetadataResponse: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Directory", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Directory = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Entry", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ if m.Entry == nil {+ m.Entry = &Entry{}+ }+ if err := m.Entry.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *LogEntry) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: LogEntry: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: LogEntry: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field TsNs", wireType)+ }+ m.TsNs = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.TsNs |= int64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 2:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field PartitionKeyHash", wireType)+ }+ m.PartitionKeyHash = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.PartitionKeyHash |= int32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ 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 protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ byteLen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if byteLen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + byteLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ 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 != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)+ }+ var byteLen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ byteLen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if byteLen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + byteLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)+ if m.Key == nil {+ m.Key = []byte{}+ }+ iNdEx = postIndex+ case 5:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType)+ }+ m.Offset = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.Offset |= int64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *KeepConnectedRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: KeepConnectedRequest: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: KeepConnectedRequest: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ 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 protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Name = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field GrpcPort", wireType)+ }+ m.GrpcPort = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.GrpcPort |= uint32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 3:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Resources", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Resources = append(m.Resources, string(dAtA[iNdEx:postIndex]))+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *KeepConnectedResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: KeepConnectedResponse: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: KeepConnectedResponse: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *LocateBrokerRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: LocateBrokerRequest: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: LocateBrokerRequest: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Resource", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Resource = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *LocateBrokerResponse_Resource) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: LocateBrokerResponse_Resource: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: LocateBrokerResponse_Resource: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field GrpcAddresses", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.GrpcAddresses = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field ResourceCount", wireType)+ }+ m.ResourceCount = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.ResourceCount |= int32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *LocateBrokerResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: LocateBrokerResponse: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: LocateBrokerResponse: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field Found", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.Found = bool(v != 0)+ case 2:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Resources", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Resources = append(m.Resources, &LocateBrokerResponse_Resource{})+ if err := m.Resources[len(m.Resources)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *KvGetRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: KvGetRequest: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: KvGetRequest: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)+ }+ var byteLen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ byteLen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if byteLen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + byteLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)+ if m.Key == nil {+ m.Key = []byte{}+ }+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *KvGetResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: KvGetResponse: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: KvGetResponse: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)+ }+ var byteLen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ byteLen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if byteLen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + byteLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...)+ if m.Value == nil {+ m.Value = []byte{}+ }+ iNdEx = postIndex+ case 2:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Error = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *KvPutRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: KvPutRequest: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: KvPutRequest: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)+ }+ var byteLen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ byteLen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if byteLen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + byteLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)+ if m.Key == nil {+ m.Key = []byte{}+ }+ iNdEx = postIndex+ case 2:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)+ }+ var byteLen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ byteLen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if byteLen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + byteLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...)+ if m.Value == nil {+ m.Value = []byte{}+ }+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *KvPutResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: KvPutResponse: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: KvPutResponse: 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 stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Error = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *FilerConf_PathConf) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: FilerConf_PathConf: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: FilerConf_PathConf: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field LocationPrefix", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.LocationPrefix = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Collection", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Collection = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 3:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Replication", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Replication = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 4:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Ttl", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Ttl = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 5:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field DiskType", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.DiskType = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 6:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field Fsync", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.Fsync = bool(v != 0)+ case 7:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field VolumeGrowthCount", wireType)+ }+ m.VolumeGrowthCount = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.VolumeGrowthCount |= uint32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 8:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field ReadOnly", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.ReadOnly = bool(v != 0)+ case 9:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field DataCenter", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.DataCenter = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 10:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Rack", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Rack = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 11:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field DataNode", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.DataNode = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 12:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field MaxFileNameLength", wireType)+ }+ m.MaxFileNameLength = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.MaxFileNameLength |= uint32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 13:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field DisableChunkDeletion", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.DisableChunkDeletion = bool(v != 0)+ case 14:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field Worm", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.Worm = bool(v != 0)+ case 15:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field WormGracePeriodSeconds", wireType)+ }+ m.WormGracePeriodSeconds = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.WormGracePeriodSeconds |= uint64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 16:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field WormRetentionTimeSeconds", wireType)+ }+ m.WormRetentionTimeSeconds = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.WormRetentionTimeSeconds |= uint64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *FilerConf) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: FilerConf: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: FilerConf: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)+ }+ m.Version = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.Version |= int32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 2:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Locations", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Locations = append(m.Locations, &FilerConf_PathConf{})+ if err := m.Locations[len(m.Locations)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *CacheRemoteObjectToLocalClusterRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: CacheRemoteObjectToLocalClusterRequest: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: CacheRemoteObjectToLocalClusterRequest: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Directory", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Directory = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ 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 protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Name = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 3:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field ChunkConcurrency", wireType)+ }+ m.ChunkConcurrency = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.ChunkConcurrency |= int32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 4:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field DownloadConcurrency", wireType)+ }+ m.DownloadConcurrency = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.DownloadConcurrency |= int32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *CacheRemoteObjectToLocalClusterResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: CacheRemoteObjectToLocalClusterResponse: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: CacheRemoteObjectToLocalClusterResponse: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Entry", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ if m.Entry == nil {+ m.Entry = &Entry{}+ }+ if err := m.Entry.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ case 2:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field MetadataEvent", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ if m.MetadataEvent == nil {+ m.MetadataEvent = &SubscribeMetadataResponse{}+ }+ if err := m.MetadataEvent.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *LockRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: LockRequest: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: LockRequest: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ 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 protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Name = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field SecondsToLock", wireType)+ }+ m.SecondsToLock = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.SecondsToLock |= int64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 3:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field RenewToken", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.RenewToken = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 4:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field IsMoved", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.IsMoved = bool(v != 0)+ case 5:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Owner = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *LockResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: LockResponse: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: LockResponse: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field RenewToken", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.RenewToken = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field LockOwner", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.LockOwner = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 3:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field LockHostMovedTo", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.LockHostMovedTo = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 4:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Error = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 5:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field Generation", wireType)+ }+ m.Generation = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.Generation |= int64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *UnlockRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: UnlockRequest: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: UnlockRequest: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ 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 protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Name = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field RenewToken", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.RenewToken = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 3:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field IsMoved", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.IsMoved = bool(v != 0)+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *UnlockResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: UnlockResponse: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: UnlockResponse: 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 stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Error = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field MovedTo", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.MovedTo = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *FindLockOwnerRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: FindLockOwnerRequest: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: FindLockOwnerRequest: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ 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 protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Name = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field IsMoved", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.IsMoved = bool(v != 0)+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *FindLockOwnerResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: FindLockOwnerResponse: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: FindLockOwnerResponse: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Owner = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *Lock) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: Lock: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: Lock: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ 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 protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Name = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field RenewToken", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.RenewToken = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 3:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field ExpiredAtNs", wireType)+ }+ m.ExpiredAtNs = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.ExpiredAtNs |= int64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 4:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Owner = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 5:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field Generation", wireType)+ }+ m.Generation = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.Generation |= int64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 6:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field IsBackup", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.IsBackup = bool(v != 0)+ case 7:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field Seq", wireType)+ }+ m.Seq = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.Seq |= int64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *TransferLocksRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: TransferLocksRequest: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: TransferLocksRequest: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Locks", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Locks = append(m.Locks, &Lock{})+ if err := m.Locks[len(m.Locks)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *TransferLocksResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: TransferLocksResponse: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: TransferLocksResponse: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *ReplicateLockRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: ReplicateLockRequest: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: ReplicateLockRequest: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ 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 protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Name = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field RenewToken", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.RenewToken = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 3:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field ExpiredAtNs", wireType)+ }+ m.ExpiredAtNs = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.ExpiredAtNs |= int64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 4:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Owner = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 5:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field Generation", wireType)+ }+ m.Generation = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.Generation |= int64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 6:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field IsUnlock", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.IsUnlock = bool(v != 0)+ case 7:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field Seq", wireType)+ }+ m.Seq = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.Seq |= int64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *ReplicateLockResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: ReplicateLockResponse: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: ReplicateLockResponse: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *StreamMutateEntryRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: StreamMutateEntryRequest: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: StreamMutateEntryRequest: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field RequestId", wireType)+ }+ m.RequestId = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.RequestId |= uint64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 2:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field CreateRequest", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ if oneof, ok := m.Request.(*StreamMutateEntryRequest_CreateRequest); ok {+ if err := oneof.CreateRequest.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ } else {+ v := &CreateEntryRequest{}+ if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ m.Request = &StreamMutateEntryRequest_CreateRequest{CreateRequest: v}+ }+ iNdEx = postIndex+ case 3:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field UpdateRequest", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ if oneof, ok := m.Request.(*StreamMutateEntryRequest_UpdateRequest); ok {+ if err := oneof.UpdateRequest.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ } else {+ v := &UpdateEntryRequest{}+ if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ m.Request = &StreamMutateEntryRequest_UpdateRequest{UpdateRequest: v}+ }+ iNdEx = postIndex+ case 4:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field DeleteRequest", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ if oneof, ok := m.Request.(*StreamMutateEntryRequest_DeleteRequest); ok {+ if err := oneof.DeleteRequest.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ } else {+ v := &DeleteEntryRequest{}+ if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ m.Request = &StreamMutateEntryRequest_DeleteRequest{DeleteRequest: v}+ }+ iNdEx = postIndex+ case 5:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field RenameRequest", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ if oneof, ok := m.Request.(*StreamMutateEntryRequest_RenameRequest); ok {+ if err := oneof.RenameRequest.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ } else {+ v := &StreamRenameEntryRequest{}+ if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ m.Request = &StreamMutateEntryRequest_RenameRequest{RenameRequest: v}+ }+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *StreamMutateEntryResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: StreamMutateEntryResponse: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: StreamMutateEntryResponse: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field RequestId", wireType)+ }+ m.RequestId = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.RequestId |= uint64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 2:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field IsLast", wireType)+ }+ var v int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ v |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ m.IsLast = bool(v != 0)+ case 3:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field CreateResponse", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ if oneof, ok := m.Response.(*StreamMutateEntryResponse_CreateResponse); ok {+ if err := oneof.CreateResponse.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ } else {+ v := &CreateEntryResponse{}+ if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ m.Response = &StreamMutateEntryResponse_CreateResponse{CreateResponse: v}+ }+ iNdEx = postIndex+ case 4:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field UpdateResponse", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ if oneof, ok := m.Response.(*StreamMutateEntryResponse_UpdateResponse); ok {+ if err := oneof.UpdateResponse.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ } else {+ v := &UpdateEntryResponse{}+ if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ m.Response = &StreamMutateEntryResponse_UpdateResponse{UpdateResponse: v}+ }+ iNdEx = postIndex+ case 5:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field DeleteResponse", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ if oneof, ok := m.Response.(*StreamMutateEntryResponse_DeleteResponse); ok {+ if err := oneof.DeleteResponse.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ } else {+ v := &DeleteEntryResponse{}+ if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ m.Response = &StreamMutateEntryResponse_DeleteResponse{DeleteResponse: v}+ }+ iNdEx = postIndex+ case 6:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field RenameResponse", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ if oneof, ok := m.Response.(*StreamMutateEntryResponse_RenameResponse); ok {+ if err := oneof.RenameResponse.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ } else {+ v := &StreamRenameEntryResponse{}+ if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ m.Response = &StreamMutateEntryResponse_RenameResponse{RenameResponse: v}+ }+ iNdEx = postIndex+ case 7:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Error = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 8:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field Errno", wireType)+ }+ m.Errno = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.Errno |= int32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *MountRegisterRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: MountRegisterRequest: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: MountRegisterRequest: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field PeerAddr", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.PeerAddr = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Rack", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Rack = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 3:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field TtlSeconds", wireType)+ }+ m.TtlSeconds = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.TtlSeconds |= int32(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 4:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field DataCenter", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.DataCenter = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *MountRegisterResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: MountRegisterResponse: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: MountRegisterResponse: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *MountListRequest) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: MountListRequest: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: MountListRequest: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *MountListResponse) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: MountListResponse: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: MountListResponse: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Mounts", wireType)+ }+ var msglen int+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ msglen |= int(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ if msglen < 0 {+ return protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + msglen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Mounts = append(m.Mounts, &MountInfo{})+ if err := m.Mounts[len(m.Mounts)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {+ return err+ }+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}+func (m *MountInfo) UnmarshalVT(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 protohelpers.ErrIntOverflow+ }+ 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: MountInfo: wiretype end group for non-group")+ }+ if fieldNum <= 0 {+ return fmt.Errorf("proto: MountInfo: illegal tag %d (wire type %d)", fieldNum, wire)+ }+ switch fieldNum {+ case 1:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field PeerAddr", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.PeerAddr = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 2:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field Rack", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.Rack = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ case 3:+ if wireType != 0 {+ return fmt.Errorf("proto: wrong wireType = %d for field LastSeenNs", wireType)+ }+ m.LastSeenNs = 0+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ if iNdEx >= l {+ return io.ErrUnexpectedEOF+ }+ b := dAtA[iNdEx]+ iNdEx+++ m.LastSeenNs |= int64(b&0x7F) << shift+ if b < 0x80 {+ break+ }+ }+ case 4:+ if wireType != 2 {+ return fmt.Errorf("proto: wrong wireType = %d for field DataCenter", wireType)+ }+ var stringLen uint64+ for shift := uint(0); ; shift += 7 {+ if shift >= 64 {+ return protohelpers.ErrIntOverflow+ }+ 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 protohelpers.ErrInvalidLength+ }+ postIndex := iNdEx + intStringLen+ if postIndex < 0 {+ return protohelpers.ErrInvalidLength+ }+ if postIndex > l {+ return io.ErrUnexpectedEOF+ }+ m.DataCenter = string(dAtA[iNdEx:postIndex])+ iNdEx = postIndex+ default:+ iNdEx = preIndex+ skippy, err := protohelpers.Skip(dAtA[iNdEx:])+ if err != nil {+ return err+ }+ if (skippy < 0) || (iNdEx+skippy) < 0 {+ return protohelpers.ErrInvalidLength+ }+ if (iNdEx + skippy) > l {+ return io.ErrUnexpectedEOF+ }+ m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)+ iNdEx += skippy+ }+ }++ if iNdEx > l {+ return io.ErrUnexpectedEOF+ }+ return nil+}diff --git a/weed/pb/filer_pb/filer_vtproto_test.go b/weed/pb/filer_pb/filer_vtproto_test.gonew file mode 100644index 0000000000..4a422813fb--- /dev/null+++ b/weed/pb/filer_pb/filer_vtproto_test.go@@ -0,0 +1,265 @@+package filer_pb++import (+ "fmt"+ "testing"++ "google.golang.org/protobuf/proto"+)++// sampleResponse builds a metadata event exercising the fields touched on the+// hot subscribe path: nested entries, a repeated chunk list, a map, and byte+// fields.+func sampleResponse() *SubscribeMetadataResponse {+ entry := func(name string) *Entry {+ return &Entry{+ Name: name,+ IsDirectory: false,+ Chunks: []*FileChunk{+ {+ FileId: "3,01637037d6",+ Offset: 0,+ Size: 1234,+ ModifiedTsNs: 111,+ ETag: "abc",+ Fid: &FileId{VolumeId: 3, FileKey: 0x1637037, Cookie: 0xd6},+ CipherKey: []byte{1, 2, 3, 4},+ },+ },+ Attributes: &FuseAttributes{+ FileSize: 1234, Mtime: 222, FileMode: 0644, Uid: 1000, Gid: 1000,+ GroupName: []string{"staff", "wheel"}, Md5: []byte{9, 8, 7},+ },+ Extended: map[string][]byte{+ "foo": []byte("bar"),+ "baz": []byte("qux"),+ "k3": []byte("v3"),+ },+ Content: []byte("hello"),+ }+ }+ return &SubscribeMetadataResponse{+ Directory: "/buckets/test/dir",+ EventNotification: &EventNotification{+ OldEntry: entry("old.txt"),+ NewEntry: entry("new.txt"),+ DeleteChunks: true,+ NewParentPath: "/buckets/test/dir2",+ IsFromOtherCluster: true,+ Signatures: []int32{101, 202, 303},+ },+ TsNs: 1234567890,+ }+}++// eventWithChunks models a real create/update event: a file split into n chunks,+// each a nested FileChunk+FileId message. n scales the number of nested messages+// the decoder must allocate, which is where vtproto's edge over reflection grows.+func eventWithChunks(n int) *SubscribeMetadataResponse {+ chunks := make([]*FileChunk, n)+ for i := 0; i < n; i++ {+ chunks[i] = &FileChunk{+ FileId: fmt.Sprintf("%d,%08x%04x", i%64, i*7919, i%251),+ Offset: int64(i) * 8 << 20,+ Size: 8 << 20,+ ModifiedTsNs: 1700000000000000000 + int64(i),+ ETag: fmt.Sprintf("etag-%d", i),+ Fid: &FileId{VolumeId: uint32(i%64 + 1), FileKey: uint64(i * 7919), Cookie: uint32(i % 251)},+ }+ }+ return &SubscribeMetadataResponse{+ Directory: "/buckets/data/2026/07/15",+ EventNotification: &EventNotification{+ NewEntry: &Entry{+ Name: "object.bin",+ Chunks: chunks,+ Attributes: &FuseAttributes{FileSize: uint64(n) * 8 << 20, Mtime: 1700000000, FileMode: 0644, Uid: 1000, Gid: 1000},+ },+ Signatures: []int32{12345},+ },+ TsNs: 1700000000000000000,+ }+}++// TestVTWireCompatibility guards that the vtproto-generated MarshalVT/UnmarshalVT+// stay wire-compatible with the reflection-based proto path in both directions,+// so adopting VT on the metadata hot paths cannot silently corrupt events.+func TestVTWireCompatibility(t *testing.T) {+ orig := sampleResponse()++ // vt marshal -> proto unmarshal+ vtBytes, err := orig.MarshalVT()+ if err != nil {+ t.Fatalf("MarshalVT: %v", err)+ }+ var fromVT SubscribeMetadataResponse+ if err := proto.Unmarshal(vtBytes, &fromVT); err != nil {+ t.Fatalf("proto.Unmarshal(vtBytes): %v", err)+ }+ if !proto.Equal(orig, &fromVT) {+ t.Fatalf("proto.Unmarshal(MarshalVT) diverged from original")+ }++ // proto marshal -> vt unmarshal+ protoBytes, err := proto.Marshal(orig)+ if err != nil {+ t.Fatalf("proto.Marshal: %v", err)+ }+ var fromProto SubscribeMetadataResponse+ if err := fromProto.UnmarshalVT(protoBytes); err != nil {+ t.Fatalf("UnmarshalVT(protoBytes): %v", err)+ }+ if !proto.Equal(orig, &fromProto) {+ t.Fatalf("UnmarshalVT(proto.Marshal) diverged from original")+ }++ // MarshalToSizedBufferVT into a pre-sized slice matches MarshalVT, the write+ // path used by the log buffer.+ sized := make([]byte, orig.SizeVT())+ if _, err := orig.MarshalToSizedBufferVT(sized); err != nil {+ t.Fatalf("MarshalToSizedBufferVT: %v", err)+ }+ var fromSized SubscribeMetadataResponse+ if err := fromSized.UnmarshalVT(sized); err != nil {+ t.Fatalf("UnmarshalVT(sized): %v", err)+ }+ if !proto.Equal(orig, &fromSized) {+ t.Fatalf("MarshalToSizedBufferVT diverged from original")+ }++ // LogEntry carrying a marshaled event, mirroring the log buffer write path.+ le := &LogEntry{TsNs: 7, PartitionKeyHash: 9, Data: vtBytes, Key: []byte("k"), Offset: 42}+ leBytes, err := le.MarshalVT()+ if err != nil {+ t.Fatalf("LogEntry.MarshalVT: %v", err)+ }+ var leDecoded LogEntry+ if err := proto.Unmarshal(leBytes, &leDecoded); err != nil {+ t.Fatalf("proto.Unmarshal(LogEntry): %v", err)+ }+ if !proto.Equal(le, &leDecoded) {+ t.Fatalf("LogEntry vt/proto roundtrip diverged")+ }+}++// TestUTF8Validation documents the deliberate UTF-8 difference between the two+// decoders. UnmarshalVT skips proto3's UTF-8 validation for string fields, so+// the metadata delivery paths keep decoding SubscribeMetadataResponse with+// proto.Unmarshal; only LogEntry (bytes-only) decodes use UnmarshalVT.+func TestUTF8Validation(t *testing.T) {+ // SubscribeMetadataResponse{Directory: "\xff"}: field 1 (string), wire type 2,+ // length 1, byte 0xff.+ malformed := []byte{0x0a, 0x01, 0xff}++ var viaProto SubscribeMetadataResponse+ if err := proto.Unmarshal(malformed, &viaProto); err == nil {+ t.Fatal("proto.Unmarshal accepted invalid UTF-8 in a string field; expected rejection")+ }++ var viaVT SubscribeMetadataResponse+ if err := viaVT.UnmarshalVT(malformed); err != nil {+ t.Fatalf("UnmarshalVT rejected invalid UTF-8: %v", err)+ }+ if viaVT.Directory != "\xff" {+ t.Fatalf("UnmarshalVT Directory = %q, want \\xff", viaVT.Directory)+ }++ // LogEntry carries only bytes fields, so the decoders agree on arbitrary bytes;+ // that is why the log entry decode paths can use UnmarshalVT.+ // LogEntry{Data: "\xff"}: field 3 (bytes), wire type 2, length 1, byte 0xff.+ leBytes := []byte{0x1a, 0x01, 0xff}+ var leProto LogEntry+ if err := proto.Unmarshal(leBytes, &leProto); err != nil {+ t.Fatalf("proto.Unmarshal LogEntry: %v", err)+ }+ var leVT LogEntry+ if err := leVT.UnmarshalVT(leBytes); err != nil {+ t.Fatalf("UnmarshalVT LogEntry: %v", err)+ }+ if !proto.Equal(&leProto, &leVT) {+ t.Fatal("LogEntry proto/VT decode of a bytes field diverged")+ }+}++var chunkCounts = []int{1, 8, 32, 128}++// BenchmarkUnmarshal is the decode hot path: each subscriber decodes every+// delivered event, so this cost is paid once per (event, subscriber).+func BenchmarkUnmarshal(b *testing.B) {+ for _, n := range chunkCounts {+ data, _ := proto.Marshal(eventWithChunks(n))+ b.Run(fmt.Sprintf("proto/chunks=%d", n), func(b *testing.B) {+ b.ReportAllocs()+ for i := 0; i < b.N; i++ {+ var m SubscribeMetadataResponse+ if err := proto.Unmarshal(data, &m); err != nil {+ b.Fatal(err)+ }+ }+ })+ b.Run(fmt.Sprintf("vt/chunks=%d", n), func(b *testing.B) {+ b.ReportAllocs()+ for i := 0; i < b.N; i++ {+ var m SubscribeMetadataResponse+ if err := m.UnmarshalVT(data); err != nil {+ b.Fatal(err)+ }+ }+ })+ }+}++// BenchmarkMarshal is the encode path: each metadata write marshals one LogEntry+// payload.+func BenchmarkMarshal(b *testing.B) {+ for _, n := range chunkCounts {+ ev := eventWithChunks(n)+ b.Run(fmt.Sprintf("proto/chunks=%d", n), func(b *testing.B) {+ b.ReportAllocs()+ for i := 0; i < b.N; i++ {+ if _, err := proto.Marshal(ev); err != nil {+ b.Fatal(err)+ }+ }+ })+ b.Run(fmt.Sprintf("vt/chunks=%d", n), func(b *testing.B) {+ b.ReportAllocs()+ for i := 0; i < b.N; i++ {+ if _, err := ev.MarshalVT(); err != nil {+ b.Fatal(err)+ }+ }+ })+ }+}++// BenchmarkMarshalIntoBuffer mirrors the log buffer write path: marshal into a+// reused destination buffer. proto.Marshal must allocate a fresh slice and copy;+// SizeVT + MarshalToSizedBufferVT writes straight into the destination.+func BenchmarkMarshalIntoBuffer(b *testing.B) {+ for _, n := range chunkCounts {+ ev := eventWithChunks(n)+ dst := make([]byte, 0, ev.SizeVT()*2)+ b.Run(fmt.Sprintf("proto+copy/chunks=%d", n), func(b *testing.B) {+ b.ReportAllocs()+ for i := 0; i < b.N; i++ {+ data, err := proto.Marshal(ev)+ if err != nil {+ b.Fatal(err)+ }+ dst = dst[:len(data)]+ copy(dst, data)+ }+ })+ b.Run(fmt.Sprintf("vt-sized/chunks=%d", n), func(b *testing.B) {+ b.ReportAllocs()+ for i := 0; i < b.N; i++ {+ size := ev.SizeVT()+ dst = dst[:size]+ if _, err := ev.MarshalToSizedBufferVT(dst); err != nil {+ b.Fatal(err)+ }+ }+ })+ }+}diff --git a/weed/pb/filer_pb_direct_read.go b/weed/pb/filer_pb_direct_read.goindex 40d473b98a..0011d82d79 100644--- a/weed/pb/filer_pb_direct_read.go+++ b/weed/pb/filer_pb_direct_read.go@@ -236,6 +236,8 @@ func readFilerFilesToChannel(func processOneLogEntry(logEntry *filer_pb.LogEntry, filter PathFilter, processEventFn ProcessMetadataFunc) (int64, error) {event := &filer_pb.SubscribeMetadataResponse{}+ // proto.Unmarshal (not UnmarshalVT) validates UTF-8 in string fields, so+ // malformed metadata is skipped here instead of reaching path filtering.if err := proto.Unmarshal(logEntry.Data, event); err != nil {glog.Errorf("unmarshal log entry: %v", err)return 0, nil // skip corrupt entries@@ -329,7 +331,7 @@ func streamLogFileEntries(newReader LogFileReaderFn, chunks []*filer_pb.FileChun}logEntry := &filer_pb.LogEntry{}- if err := proto.Unmarshal(entryData, logEntry); err != nil {+ if err := logEntry.UnmarshalVT(entryData); err != nil {return err}diff --git a/weed/pb/filer_pb_direct_read_test.go b/weed/pb/filer_pb_direct_read_test.goindex 20bdc89534..04c73fd49e 100644--- a/weed/pb/filer_pb_direct_read_test.go+++ b/weed/pb/filer_pb_direct_read_test.go@@ -449,3 +449,29 @@ func TestReadLogFileRefsSingleFilerNotFoundSkips(t *testing.T) {t.Fatalf("expected %d events after skipping one file, got %d", want, count)}}++// TestProcessOneLogEntrySkipsInvalidUTF8 guards that an event whose string field+// is not valid UTF-8 is rejected by proto.Unmarshal and never reaches path+// filtering or the consumer. UnmarshalVT would accept it, so the decode here+// must stay on proto.Unmarshal.+func TestProcessOneLogEntrySkipsInvalidUTF8(t *testing.T) {+ // SubscribeMetadataResponse{Directory: "\xff"}: field 1 (string), wire type 2,+ // length 1, byte 0xff — a syntactically valid message with an invalid-UTF-8+ // string, which proto3 forbids.+ logEntry := &filer_pb.LogEntry{Data: []byte{0x0a, 0x01, 0xff}}++ called := false+ tsNs, err := processOneLogEntry(logEntry, PathFilter{PathPrefix: "/"}, func(resp *filer_pb.SubscribeMetadataResponse) error {+ called = true+ return nil+ })+ if err != nil {+ t.Fatalf("processOneLogEntry err = %v, want nil (corrupt entries are skipped)", err)+ }+ if called {+ t.Fatal("consumer was invoked for a malformed (invalid UTF-8) event; validation was bypassed")+ }+ if tsNs != 0 {+ t.Fatalf("tsNs = %d, want 0 for a skipped entry", tsNs)+ }+}diff --git a/weed/server/filer_grpc_server_sub_meta.go b/weed/server/filer_grpc_server_sub_meta.goindex adf0cb6449..6a373a36a8 100644--- a/weed/server/filer_grpc_server_sub_meta.go+++ b/weed/server/filer_grpc_server_sub_meta.go@@ -515,6 +515,9 @@ func eachLogEntryFn(req *filer_pb.SubscribeMetadataRequest, sender metadataStrea}}event := &filer_pb.SubscribeMetadataResponse{}+ // proto.Unmarshal (not UnmarshalVT) validates UTF-8 in string fields, so+ // malformed metadata is rejected here instead of reaching path filtering+ // and subscribers.if err := proto.Unmarshal(logEntry.Data, event); err != nil {glog.Errorf("unexpected unmarshal filer_pb.SubscribeMetadataResponse: %v", err)return false, fmt.Errorf("unexpected unmarshal filer_pb.SubscribeMetadataResponse: %w", err)diff --git a/weed/util/log_buffer/log_buffer.go b/weed/util/log_buffer/log_buffer.goindex 98cd5a8716..d6fd2b50e8 100644--- a/weed/util/log_buffer/log_buffer.go+++ b/weed/util/log_buffer/log_buffer.go@@ -9,8 +9,6 @@ import ("sync/atomic""time"- "google.golang.org/protobuf/proto"-"github.com/seaweedfs/seaweedfs/weed/glog""github.com/seaweedfs/seaweedfs/weed/pb/filer_pb""github.com/seaweedfs/seaweedfs/weed/pb/mq_pb"@@ -302,13 +300,9 @@ func (logBuffer *LogBuffer) AddLogEntryToBuffer(logEntry *filer_pb.LogEntry) errlogBuffer.LastTsNs.Store(processingTsNs)}- logEntryData, err := proto.Marshal(logEntry)- if err != nil {- marshalErr = fmt.Errorf("failed to marshal LogEntry: %w", err)- glog.Errorf("%v", marshalErr)- return marshalErr- }- size := len(logEntryData)+ // Size is computed without allocating; the entry is marshaled straight into+ // the buffer below via MarshalToSizedBufferVT.+ size := logEntry.SizeVT()if logBuffer.pos == 0 {logBuffer.startTime = ts@@ -352,10 +346,17 @@ func (logBuffer *LogBuffer) AddLogEntryToBuffer(logEntry *filer_pb.LogEntry) err}logBuffer.stopTime = ts+ // Marshal directly into the buffer, avoiding an intermediate slice and copy.+ // On the (practically impossible) error the entry is dropped before idx/pos+ // are advanced, leaving the buffer consistent.+ if _, err := logEntry.MarshalToSizedBufferVT(logBuffer.buf[logBuffer.pos+4 : logBuffer.pos+4+size]); err != nil {+ marshalErr = fmt.Errorf("failed to marshal LogEntry: %w", err)+ glog.Errorf("%v", marshalErr)+ return marshalErr+ }logBuffer.idx = append(logBuffer.idx, logBuffer.pos)util.Uint32toBytes(logBuffer.sizeBuf, uint32(size))copy(logBuffer.buf[logBuffer.pos:logBuffer.pos+4], logBuffer.sizeBuf)- copy(logBuffer.buf[logBuffer.pos+4:logBuffer.pos+4+size], logEntryData)logBuffer.pos += size + 4logBuffer.offset++@@ -416,15 +417,9 @@ func (logBuffer *LogBuffer) AddDataToBuffer(partitionKey, data []byte, processin// Note: This also enables AddToBuffer to work correctly with Kafka-style offset-based readslogEntry.Offset = logBuffer.offset- // Marshal with correct timestamp and offset- logEntryData, err := proto.Marshal(logEntry)- if err != nil {- marshalErr = fmt.Errorf("failed to marshal LogEntry: %w", err)- glog.Errorf("%v", marshalErr)- return marshalErr- }-- size := len(logEntryData)+ // Size is computed without allocating; the entry is marshaled straight into+ // the buffer below via MarshalToSizedBufferVT.+ size := logEntry.SizeVT()if logBuffer.pos == 0 {logBuffer.startTime = ts@@ -466,10 +461,17 @@ func (logBuffer *LogBuffer) AddDataToBuffer(partitionKey, data []byte, processin}logBuffer.stopTime = ts+ // Marshal directly into the buffer, avoiding an intermediate slice and copy.+ // On the (practically impossible) error the entry is dropped before idx/pos+ // are advanced, leaving the buffer consistent.+ if _, err := logEntry.MarshalToSizedBufferVT(logBuffer.buf[logBuffer.pos+4 : logBuffer.pos+4+size]); err != nil {+ marshalErr = fmt.Errorf("failed to marshal LogEntry: %w", err)+ glog.Errorf("%v", marshalErr)+ return marshalErr+ }logBuffer.idx = append(logBuffer.idx, logBuffer.pos)util.Uint32toBytes(logBuffer.sizeBuf, uint32(size))copy(logBuffer.buf[logBuffer.pos:logBuffer.pos+4], logBuffer.sizeBuf)- copy(logBuffer.buf[logBuffer.pos+4:logBuffer.pos+4+size], logEntryData)logBuffer.pos += size + 4logBuffer.offset++diff --git a/weed/util/log_buffer/log_read_stateless.go b/weed/util/log_buffer/log_read_stateless.goindex 279a842dd0..7cabc1701f 100644--- a/weed/util/log_buffer/log_read_stateless.go+++ b/weed/util/log_buffer/log_read_stateless.go@@ -422,7 +422,7 @@ func parseMessagesFromBuffer(buf []byte, startOffset int64, maxMessages int, max// Parse messageentryData := buf[pos+4 : pos+4+int(size)]logEntry := &filer_pb.LogEntry{}- if err = proto.Unmarshal(entryData, logEntry); err != nil {+ if err = logEntry.UnmarshalVT(entryData); err != nil {glog.Warningf("[parseMessages] Failed to unmarshal message: %v", err)pos += 4 + int(size)continue