From e8a34d39f1a589230592efa96049fb70a241ff52 Mon Sep 17 00:00:00 2001 From: Leonard Lyubich Date: Tue, 9 Jul 2024 23:39:46 +0400 Subject: [PATCH] api: Support stable marshaling for NeoFS messages Specific encoding of NeoFS messages is required to implement protocol checksums and signatures. Continues 51fa18fcce6bd7803f1936f1b934b9e92949a9b7. Signed-off-by: Leonard Lyubich --- api/accounting/encoding.go | 82 +++ api/accounting/encoding_test.go | 54 ++ api/acl/encoding.go | 233 ++++++++ api/acl/encoding_test.go | 3 + api/audit/encoding.go | 74 +++ api/audit/encoding_test.go | 3 + api/container/encoding.go | 437 +++++++++++++++ api/container/encoding_test.go | 3 + api/internal/test/assert.go | 60 ++ api/internal/test/encoding.go | 61 ++ api/internal/test/rand.go | 28 + api/link/encoding.go | 60 ++ api/link/encoding_test.go | 3 + api/lock/encoding.go | 32 ++ api/lock/encoding_test.go | 3 + api/netmap/encoding.go | 454 +++++++++++++++ api/netmap/encoding_test.go | 3 + api/object/encoding.go | 898 ++++++++++++++++++++++++++++++ api/object/encoding_test.go | 3 + api/refs/encoding.go | 239 ++++++++ api/refs/encoding_test.go | 117 ++++ api/reputation/encoding.go | 193 +++++++ api/reputation/encoding_test.go | 3 + api/session/encoding.go | 456 +++++++++++++++ api/session/encoding_test.go | 3 + api/status/encoding.go | 66 +++ api/status/encoding_test.go | 3 + api/storagegroup/encoding.go | 40 ++ api/storagegroup/encoding_test.go | 3 + api/subnet/encoding.go | 30 + api/subnet/encoding_test.go | 3 + api/tombstone/encoding.go | 37 ++ api/tombstone/encoding_test.go | 3 + 33 files changed, 3690 insertions(+) create mode 100644 api/accounting/encoding.go create mode 100644 api/accounting/encoding_test.go create mode 100644 api/acl/encoding.go create mode 100644 api/acl/encoding_test.go create mode 100644 api/audit/encoding.go create mode 100644 api/audit/encoding_test.go create mode 100644 api/container/encoding.go create mode 100644 api/container/encoding_test.go create mode 100644 api/internal/test/assert.go create mode 100644 api/internal/test/encoding.go create mode 100644 api/internal/test/rand.go create mode 100644 api/link/encoding.go create mode 100644 api/link/encoding_test.go create mode 100644 api/lock/encoding.go create mode 100644 api/lock/encoding_test.go create mode 100644 api/netmap/encoding.go create mode 100644 api/netmap/encoding_test.go create mode 100644 api/object/encoding.go create mode 100644 api/object/encoding_test.go create mode 100644 api/refs/encoding.go create mode 100644 api/refs/encoding_test.go create mode 100644 api/reputation/encoding.go create mode 100644 api/reputation/encoding_test.go create mode 100644 api/session/encoding.go create mode 100644 api/session/encoding_test.go create mode 100644 api/status/encoding.go create mode 100644 api/status/encoding_test.go create mode 100644 api/storagegroup/encoding.go create mode 100644 api/storagegroup/encoding_test.go create mode 100644 api/subnet/encoding.go create mode 100644 api/subnet/encoding_test.go create mode 100644 api/tombstone/encoding.go create mode 100644 api/tombstone/encoding_test.go diff --git a/api/accounting/encoding.go b/api/accounting/encoding.go new file mode 100644 index 00000000..e12cd396 --- /dev/null +++ b/api/accounting/encoding.go @@ -0,0 +1,82 @@ +package accounting + +import ( + "github.com/nspcc-dev/neofs-sdk-go/internal/proto" +) + +const ( + _ = iota + fieldDecimalValue + fieldDecimalPrecision +) + +// MarshaledSize returns size of the Decimal in Protocol Buffers V3 format in +// bytes. MarshaledSize is NPE-safe. +func (x *Decimal) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeVarint(fieldDecimalValue, x.Value) + + proto.SizeVarint(fieldDecimalPrecision, x.Precision) + } + return sz +} + +// MarshalStable writes the Decimal in Protocol Buffers V3 format with ascending +// order of fields by number into b. MarshalStable uses exactly +// [Decimal.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *Decimal) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToVarint(b, fieldDecimalValue, x.Value) + proto.MarshalToVarint(b[off:], fieldDecimalPrecision, x.Precision) + } +} + +const ( + _ = iota + fieldBalanceReqOwner +) + +// MarshaledSize returns size of the BalanceRequest_Body in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *BalanceRequest_Body) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldBalanceReqOwner, x.OwnerId) + } + return sz +} + +// MarshalStable writes the BalanceRequest_Body in Protocol Buffers V3 format +// with ascending order of fields by number into b. MarshalStable uses exactly +// [BalanceRequest_Body.MarshaledSize] first bytes of b. MarshalStable is +// NPE-safe. +func (x *BalanceRequest_Body) MarshalStable(b []byte) { + if x != nil { + proto.MarshalToEmbedded(b, fieldBalanceReqOwner, x.OwnerId) + } +} + +const ( + _ = iota + fieldBalanceRespBalance +) + +// MarshaledSize returns size of the BalanceResponse_Body in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *BalanceResponse_Body) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldBalanceRespBalance, x.Balance) + } + return sz +} + +// MarshalStable writes the BalanceResponse_Body in Protocol Buffers V3 format +// with ascending order of fields by number into b. MarshalStable uses exactly +// [BalanceResponse_Body.MarshaledSize] first bytes of b. MarshalStable is +// NPE-safe. +func (x *BalanceResponse_Body) MarshalStable(b []byte) { + if x != nil { + proto.MarshalToEmbedded(b, fieldBalanceRespBalance, x.Balance) + } +} diff --git a/api/accounting/encoding_test.go b/api/accounting/encoding_test.go new file mode 100644 index 00000000..e361fe64 --- /dev/null +++ b/api/accounting/encoding_test.go @@ -0,0 +1,54 @@ +package accounting_test + +import ( + "testing" + + "github.com/nspcc-dev/neofs-sdk-go/api/accounting" + apitest "github.com/nspcc-dev/neofs-sdk-go/api/internal/test" + "github.com/nspcc-dev/neofs-sdk-go/api/refs" + "github.com/stretchr/testify/require" +) + +func assertEqualDecimals(t testing.TB, v1, v2 *accounting.Decimal, msg string) { + require.Equal(t, v1.GetValue(), v2.GetValue(), msg) + require.Equal(t, v1.GetPrecision(), v2.GetPrecision(), msg) +} + +func TestDecimal_MarshalStable(t *testing.T) { + apitest.TestMarshalStable(t, assertEqualDecimals, []*accounting.Decimal{ + nil, + new(accounting.Decimal), + { + Value: apitest.RandomInteger[int64](), + Precision: apitest.RandomInteger[uint32](), + }, + }) +} + +func assertEqualBalanceRequestBodies(t testing.TB, v1, v2 *accounting.BalanceRequest_Body, msg string) { + apitest.AssertEqualOwnerIDs(t, v1.OwnerId, v2.OwnerId, msg) +} + +func TestBalanceRequest_Body_MarshalStable(t *testing.T) { + apitest.TestMarshalStable(t, assertEqualBalanceRequestBodies, []*accounting.BalanceRequest_Body{ + nil, + new(accounting.BalanceRequest_Body), + {OwnerId: new(refs.OwnerID)}, + }) +} + +func assertEqualBalanceResponseBodies(t testing.TB, v1, v2 *accounting.BalanceResponse_Body, msg string) { + assertEqualDecimals(t, v1.Balance, v2.Balance, msg) +} + +func TestBalanceResponse_Body_MarshalStable(t *testing.T) { + apitest.TestMarshalStable(t, assertEqualBalanceResponseBodies, []*accounting.BalanceResponse_Body{ + nil, + new(accounting.BalanceResponse_Body), + {Balance: new(accounting.Decimal)}, + {Balance: &accounting.Decimal{ + Value: apitest.RandomInteger[int64](), + Precision: apitest.RandomInteger[uint32](), + }}, + }) +} diff --git a/api/acl/encoding.go b/api/acl/encoding.go new file mode 100644 index 00000000..4750f30a --- /dev/null +++ b/api/acl/encoding.go @@ -0,0 +1,233 @@ +package acl + +import ( + "github.com/nspcc-dev/neofs-sdk-go/internal/proto" +) + +const ( + _ = iota + fieldEACLVersion + fieldEACLContainer + fieldEACLRecords +) + +// MarshaledSize returns size of the EACLTable in Protocol Buffers V3 format in +// bytes. MarshaledSize is NPE-safe. +func (x *EACLTable) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldEACLVersion, x.Version) + + proto.SizeEmbedded(fieldEACLContainer, x.ContainerId) + for i := range x.Records { + sz += proto.SizeEmbedded(fieldEACLRecords, x.Records[i]) + } + } + return sz +} + +// MarshalStable writes the EACLTable in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [EACLTable.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *EACLTable) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToEmbedded(b, fieldEACLVersion, x.Version) + off += proto.MarshalToEmbedded(b[off:], fieldEACLContainer, x.ContainerId) + for i := range x.Records { + off += proto.MarshalToEmbedded(b[off:], fieldEACLRecords, x.Records[i]) + } + } +} + +const ( + _ = iota + fieldEACLOp + fieldEACLAction + fieldEACLFilters + fieldEACLTargets +) + +// MarshaledSize returns size of the EACLRecord in Protocol Buffers V3 format in +// bytes. MarshaledSize is NPE-safe. +func (x *EACLRecord) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeVarint(fieldEACLOp, int32(x.Operation)) + + proto.SizeVarint(fieldEACLAction, int32(x.Action)) + for i := range x.Filters { + sz += proto.SizeEmbedded(fieldEACLFilters, x.Filters[i]) + } + for i := range x.Targets { + sz += proto.SizeEmbedded(fieldEACLTargets, x.Targets[i]) + } + } + return sz +} + +// MarshalStable writes the EACLRecord in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [EACLRecord.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *EACLRecord) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToVarint(b, fieldEACLOp, int32(x.Operation)) + off += proto.MarshalToVarint(b[off:], fieldEACLAction, int32(x.Action)) + for i := range x.Filters { + off += proto.MarshalToEmbedded(b[off:], fieldEACLFilters, x.Filters[i]) + } + for i := range x.Targets { + off += proto.MarshalToEmbedded(b[off:], fieldEACLTargets, x.Targets[i]) + } + } +} + +const ( + _ = iota + fieldEACLHeader + fieldEACLMatcher + fieldEACLKey + fieldEACLValue +) + +// MarshaledSize returns size of the EACLRecord_Filter in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *EACLRecord_Filter) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeVarint(fieldEACLHeader, int32(x.HeaderType)) + + proto.SizeVarint(fieldEACLMatcher, int32(x.MatchType)) + + proto.SizeBytes(fieldEACLKey, x.Key) + + proto.SizeBytes(fieldEACLValue, x.Value) + } + return sz +} + +// MarshalStable writes the EACLRecord_Filter in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [EACLRecord_Filter.MarshaledSize] first bytes of b. MarshalStable is +// NPE-safe. +func (x *EACLRecord_Filter) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToVarint(b, fieldEACLHeader, int32(x.HeaderType)) + off += proto.MarshalToVarint(b[off:], fieldEACLMatcher, int32(x.MatchType)) + off += proto.MarshalToBytes(b[off:], fieldEACLKey, x.Key) + proto.MarshalToBytes(b[off:], fieldEACLValue, x.Value) + } +} + +const ( + _ = iota + fieldEACLRole + fieldEACLTargetKeys +) + +// MarshaledSize returns size of the EACLRecord_Target in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *EACLRecord_Target) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeVarint(fieldEACLRole, int32(x.Role)) + + proto.SizeRepeatedBytes(fieldEACLTargetKeys, x.Keys) + } + return sz +} + +// MarshalStable writes the EACLRecord_Target in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [EACLRecord_Target.MarshaledSize] first bytes of b. MarshalStable is +// NPE-safe. +func (x *EACLRecord_Target) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToVarint(b, fieldEACLRole, int32(x.Role)) + proto.MarshalToRepeatedBytes(b[off:], fieldEACLTargetKeys, x.Keys) + } +} + +const ( + _ = iota + fieldBearerExp + fieldBearerNbf + fieldBearerIat +) + +// MarshaledSize returns size of the BearerToken_Body_TokenLifetime in Protocol +// Buffers V3 format in bytes. MarshaledSize is NPE-safe. +func (x *BearerToken_Body_TokenLifetime) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeVarint(fieldBearerExp, x.Exp) + + proto.SizeVarint(fieldBearerNbf, x.Nbf) + + proto.SizeVarint(fieldBearerIat, x.Iat) + } + return sz +} + +// MarshalStable writes the BearerToken_Body_TokenLifetime in Protocol Buffers +// V3 format with ascending order of fields by number into b. MarshalStable uses +// exactly [BearerToken_Body_TokenLifetime.MarshaledSize] first bytes of b. +// MarshalStable is NPE-safe. +func (x *BearerToken_Body_TokenLifetime) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToVarint(b, fieldBearerExp, x.Exp) + off += proto.MarshalToVarint(b[off:], fieldBearerNbf, x.Nbf) + proto.MarshalToVarint(b[off:], fieldBearerIat, x.Iat) + } +} + +const ( + _ = iota + fieldBearerEACL + fieldBearerOwner + fieldBearerLifetime + fieldBearerIssuer +) + +// MarshaledSize returns size of the BearerToken_Body in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *BearerToken_Body) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldBearerEACL, x.EaclTable) + + proto.SizeEmbedded(fieldBearerOwner, x.OwnerId) + + proto.SizeEmbedded(fieldBearerLifetime, x.Lifetime) + + proto.SizeEmbedded(fieldBearerIssuer, x.Issuer) + } + return sz +} + +// MarshalStable writes the BearerToken_Body in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [BearerToken_Body.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *BearerToken_Body) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToEmbedded(b, fieldBearerEACL, x.EaclTable) + off += proto.MarshalToEmbedded(b[off:], fieldBearerOwner, x.OwnerId) + off += proto.MarshalToEmbedded(b[off:], fieldBearerLifetime, x.Lifetime) + proto.MarshalToEmbedded(b[off:], fieldBearerIssuer, x.Issuer) + } +} + +const ( + _ = iota + fieldBearerBody + fieldBearerSignature +) + +// MarshaledSize returns size of the BearerToken in Protocol Buffers V3 format +// in bytes. MarshaledSize is NPE-safe. +func (x *BearerToken) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldBearerBody, x.Body) + + proto.SizeEmbedded(fieldBearerSignature, x.Signature) + } + return sz +} + +// MarshalStable writes the BearerToken in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [BearerToken.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *BearerToken) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToEmbedded(b, fieldBearerBody, x.Body) + proto.MarshalToEmbedded(b[off:], fieldBearerSignature, x.Signature) + } +} diff --git a/api/acl/encoding_test.go b/api/acl/encoding_test.go new file mode 100644 index 00000000..8a28a543 --- /dev/null +++ b/api/acl/encoding_test.go @@ -0,0 +1,3 @@ +package acl_test + +// TODO diff --git a/api/audit/encoding.go b/api/audit/encoding.go new file mode 100644 index 00000000..4cefa41f --- /dev/null +++ b/api/audit/encoding.go @@ -0,0 +1,74 @@ +package audit + +import "github.com/nspcc-dev/neofs-sdk-go/internal/proto" + +const ( + _ = iota + fieldResultVersion + fieldResultEpoch + fieldResultContainer + fieldResultPubKey + fieldResultCompleted + fieldResultRequests + fieldResultRetries + fieldResultPassedSG + fieldResultFailedSG + fieldResultHits + fieldResultMisses + fieldResultFailures + fieldResultPassedNodes + fieldResultFailedNodes +) + +// MarshaledSize returns size of the DataAuditResult in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *DataAuditResult) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldResultVersion, x.Version) + sz += proto.SizeFixed64(fieldResultEpoch, x.AuditEpoch) + sz += proto.SizeEmbedded(fieldResultContainer, x.ContainerId) + sz += proto.SizeBytes(fieldResultPubKey, x.PublicKey) + sz += proto.SizeBool(fieldResultCompleted, x.Complete) + sz += proto.SizeVarint(fieldResultRequests, x.Requests) + sz += proto.SizeVarint(fieldResultRetries, x.Retries) + sz += proto.SizeVarint(fieldResultHits, x.Hit) + sz += proto.SizeVarint(fieldResultMisses, x.Miss) + sz += proto.SizeVarint(fieldResultFailures, x.Fail) + sz += proto.SizeRepeatedBytes(fieldResultPassedNodes, x.PassNodes) + sz += proto.SizeRepeatedBytes(fieldResultFailedNodes, x.FailNodes) + for i := range x.PassSg { + sz += proto.SizeEmbedded(fieldResultPassedSG, x.PassSg[i]) + } + for i := range x.FailSg { + sz += proto.SizeEmbedded(fieldResultFailedSG, x.FailSg[i]) + } + } + return sz +} + +// MarshalStable writes the DataAuditResult in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [DataAuditResult.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *DataAuditResult) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToEmbedded(b, fieldResultVersion, x.Version) + off += proto.MarshalToFixed64(b[off:], fieldResultEpoch, x.AuditEpoch) + off += proto.MarshalToEmbedded(b[off:], fieldResultContainer, x.ContainerId) + off += proto.MarshalToBytes(b[off:], fieldResultPubKey, x.PublicKey) + off += proto.MarshalToBool(b[off:], fieldResultCompleted, x.Complete) + off += proto.MarshalToVarint(b[off:], fieldResultRequests, x.Requests) + off += proto.MarshalToVarint(b[off:], fieldResultRetries, x.Retries) + for i := range x.PassSg { + off += proto.MarshalToEmbedded(b[off:], fieldResultPassedSG, x.PassSg[i]) + } + for i := range x.FailSg { + off += proto.MarshalToEmbedded(b[off:], fieldResultFailedSG, x.FailSg[i]) + } + off += proto.MarshalToVarint(b[off:], fieldResultHits, x.Hit) + off += proto.MarshalToVarint(b[off:], fieldResultMisses, x.Miss) + off += proto.MarshalToVarint(b[off:], fieldResultFailures, x.Fail) + off += proto.MarshalToRepeatedBytes(b[off:], fieldResultPassedNodes, x.PassNodes) + proto.MarshalToRepeatedBytes(b[off:], fieldResultFailedNodes, x.FailNodes) + } +} diff --git a/api/audit/encoding_test.go b/api/audit/encoding_test.go new file mode 100644 index 00000000..f6ff1967 --- /dev/null +++ b/api/audit/encoding_test.go @@ -0,0 +1,3 @@ +package audit_test + +// TODO diff --git a/api/container/encoding.go b/api/container/encoding.go new file mode 100644 index 00000000..a9abd01b --- /dev/null +++ b/api/container/encoding.go @@ -0,0 +1,437 @@ +package container + +import "github.com/nspcc-dev/neofs-sdk-go/internal/proto" + +const ( + _ = iota + fieldContainerAttrKey + fieldContainerAttrVal +) + +// MarshaledSize returns size of the Container_Attribute in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *Container_Attribute) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeBytes(fieldContainerAttrKey, x.Key) + + proto.SizeBytes(fieldContainerAttrVal, x.Value) + } + return sz +} + +// MarshalStable writes the Container_Attribute in Protocol Buffers V3 format +// with ascending order of fields by number into b. MarshalStable uses exactly +// [Container_Attribute.MarshaledSize] first bytes of b. MarshalStable is +// NPE-safe. +func (x *Container_Attribute) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToBytes(b, fieldContainerAttrKey, x.Key) + proto.MarshalToBytes(b[off:], fieldContainerAttrVal, x.Value) + } +} + +const ( + _ = iota + fieldContainerVersion + fieldContainerOwner + fieldContainerNonce + fieldContainerBasicACL + fieldContainerAttributes + fieldContainerPolicy +) + +// MarshaledSize returns size of the Container in Protocol Buffers V3 format in +// bytes. MarshaledSize is NPE-safe. +func (x *Container) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldContainerVersion, x.Version) + + proto.SizeEmbedded(fieldContainerOwner, x.OwnerId) + + proto.SizeBytes(fieldContainerNonce, x.Nonce) + + proto.SizeVarint(fieldContainerBasicACL, x.BasicAcl) + + proto.SizeEmbedded(fieldContainerPolicy, x.PlacementPolicy) + for i := range x.Attributes { + sz += proto.SizeEmbedded(fieldContainerAttributes, x.Attributes[i]) + } + } + return sz +} + +// MarshalStable writes the Container in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [Container.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *Container) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToEmbedded(b, fieldContainerVersion, x.Version) + off += proto.MarshalToEmbedded(b[off:], fieldContainerOwner, x.OwnerId) + off += proto.MarshalToBytes(b[off:], fieldContainerNonce, x.Nonce) + off += proto.MarshalToVarint(b[off:], fieldContainerBasicACL, x.BasicAcl) + for i := range x.Attributes { + off += proto.MarshalToEmbedded(b[off:], fieldContainerAttributes, x.Attributes[i]) + } + proto.MarshalToEmbedded(b[off:], fieldContainerPolicy, x.PlacementPolicy) + } +} + +const ( + _ = iota + fieldPutReqContainer + fieldPutReqSignature +) + +// MarshaledSize returns size of the PutRequest_Body in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *PutRequest_Body) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldPutReqContainer, x.Container) + + proto.SizeEmbedded(fieldPutReqSignature, x.Signature) + } + return sz +} + +// MarshalStable writes the PutRequest_Body in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [PutRequest_Body.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *PutRequest_Body) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToEmbedded(b, fieldPutReqContainer, x.Container) + proto.MarshalToEmbedded(b[off:], fieldPutReqSignature, x.Signature) + } +} + +const ( + _ = iota + fieldPutRespID +) + +// MarshaledSize returns size of the PutResponse_Body in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *PutResponse_Body) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldPutRespID, x.ContainerId) + } + return sz +} + +// MarshalStable writes the PutResponse_Body in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [PutResponse_Body.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *PutResponse_Body) MarshalStable(b []byte) { + if x != nil { + proto.MarshalToEmbedded(b, fieldPutRespID, x.ContainerId) + } +} + +const ( + _ = iota + fieldDeleteReqContainer + fieldDeleteReqSignature +) + +// MarshaledSize returns size of the DeleteRequest_Body in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *DeleteRequest_Body) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldDeleteReqContainer, x.ContainerId) + + proto.SizeEmbedded(fieldDeleteReqSignature, x.Signature) + } + return sz +} + +// MarshalStable writes the DeleteRequest_Body in Protocol Buffers V3 format +// with ascending order of fields by number into b. MarshalStable uses exactly +// [DeleteRequest_Body.MarshaledSize] first bytes of b. MarshalStable is +// NPE-safe. +func (x *DeleteRequest_Body) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToEmbedded(b, fieldDeleteReqContainer, x.ContainerId) + proto.MarshalToEmbedded(b[off:], fieldDeleteReqSignature, x.Signature) + } +} + +// MarshaledSize returns size of the DeleteResponse_Body in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *DeleteResponse_Body) MarshaledSize() int { return 0 } + +// MarshalStable writes the DeleteResponse_Body in Protocol Buffers V3 format +// with ascending order of fields by number into b. MarshalStable uses exactly +// [DeleteResponse_Body.MarshaledSize] first bytes of b. MarshalStable is +// NPE-safe. +func (x *DeleteResponse_Body) MarshalStable([]byte) {} + +const ( + _ = iota + fieldGetReqContainer +) + +// MarshaledSize returns size of the GetRequest_Body in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *GetRequest_Body) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldGetReqContainer, x.ContainerId) + } + return sz +} + +// MarshalStable writes the GetRequest_Body in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [GetRequest_Body.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *GetRequest_Body) MarshalStable(b []byte) { + if x != nil { + proto.MarshalToEmbedded(b, fieldGetReqContainer, x.ContainerId) + } +} + +const ( + _ = iota + fieldGetRespContainer + fieldGetRespSignature + fieldGetRespSession +) + +// MarshaledSize returns size of the GetResponse_Body in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *GetResponse_Body) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldGetRespContainer, x.Container) + + proto.SizeEmbedded(fieldGetRespSignature, x.Signature) + + proto.SizeEmbedded(fieldGetRespSession, x.SessionToken) + } + return sz +} + +// MarshalStable writes the GetResponse_Body in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [GetResponse_Body.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *GetResponse_Body) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToEmbedded(b, fieldGetRespContainer, x.Container) + off += proto.MarshalToEmbedded(b[off:], fieldGetRespSignature, x.Signature) + proto.MarshalToEmbedded(b[off:], fieldGetRespSession, x.SessionToken) + } +} + +const ( + _ = iota + fieldListReqOwner +) + +// MarshaledSize returns size of the ListRequest_Body in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *ListRequest_Body) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldListReqOwner, x.OwnerId) + } + return sz +} + +// MarshalStable writes the ListRequest_Body in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [ListRequest_Body.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *ListRequest_Body) MarshalStable(b []byte) { + if x != nil { + proto.MarshalToEmbedded(b, fieldListReqOwner, x.OwnerId) + } +} + +const ( + _ = iota + fieldListRespIDs +) + +// MarshaledSize returns size of the ListResponse_Body in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *ListResponse_Body) MarshaledSize() int { + var sz int + if x != nil { + for i := range x.ContainerIds { + sz += proto.SizeEmbedded(fieldListRespIDs, x.ContainerIds[i]) + } + } + return sz +} + +// MarshalStable writes the ListResponse_Body in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [ListResponse_Body.MarshaledSize] first bytes of b. MarshalStable is +// NPE-safe. +func (x *ListResponse_Body) MarshalStable(b []byte) { + if x != nil { + var off int + for i := range x.ContainerIds { + off += proto.MarshalToEmbedded(b[off:], fieldListRespIDs, x.ContainerIds[i]) + } + } +} + +const ( + _ = iota + fieldSetEACLReqTable + fieldSetEACLReqSignature +) + +// MarshaledSize returns size of the SetExtendedACLRequest_Body in Protocol +// Buffers V3 format in bytes. MarshaledSize is NPE-safe. +func (x *SetExtendedACLRequest_Body) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldSetEACLReqTable, x.Eacl) + + proto.SizeEmbedded(fieldSetEACLReqSignature, x.Signature) + } + return sz +} + +// MarshalStable writes the SetExtendedACLRequest_Body in Protocol Buffers V3 +// format with ascending order of fields by number into b. MarshalStable uses +// exactly [SetExtendedACLRequest_Body.MarshaledSize] first bytes of b. +// MarshalStable is NPE-safe. +func (x *SetExtendedACLRequest_Body) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToEmbedded(b, fieldSetEACLReqTable, x.Eacl) + proto.MarshalToEmbedded(b[off:], fieldSetEACLReqSignature, x.Signature) + } +} + +// MarshaledSize returns size of the SetExtendedACLResponse_Body in Protocol +// Buffers V3 format in bytes. MarshaledSize is NPE-safe. +func (x *SetExtendedACLResponse_Body) MarshaledSize() int { return 0 } + +// MarshalStable writes the SetExtendedACLResponse_Body in Protocol Buffers V3 +// format with ascending order of fields by number into b. MarshalStable uses +// exactly [SetExtendedACLResponse_Body.MarshaledSize] first bytes of b. +// MarshalStable is NPE-safe. +func (x *SetExtendedACLResponse_Body) MarshalStable([]byte) {} + +const ( + _ = iota + fieldGetEACLReqContainer +) + +// MarshaledSize returns size of the GetExtendedACLRequest_Body in Protocol +// Buffers V3 format in bytes. MarshaledSize is NPE-safe. +func (x *GetExtendedACLRequest_Body) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldGetEACLReqContainer, x.ContainerId) + } + return sz +} + +// MarshalStable writes the GetExtendedACLRequest_Body in Protocol Buffers V3 +// format with ascending order of fields by number into b. MarshalStable uses +// exactly [GetExtendedACLRequest_Body.MarshaledSize] first bytes of b. +// MarshalStable is NPE-safe. +func (x *GetExtendedACLRequest_Body) MarshalStable(b []byte) { + if x != nil { + proto.MarshalToEmbedded(b, fieldGetEACLReqContainer, x.ContainerId) + } +} + +const ( + _ = iota + fieldGetEACLRespTable + fieldGetEACLRespSignature + fieldGetEACLRespSession +) + +// MarshaledSize returns size of the GetExtendedACLResponse_Body in Protocol +// Buffers V3 format in bytes. MarshaledSize is NPE-safe. +func (x *GetExtendedACLResponse_Body) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldGetEACLRespTable, x.Eacl) + + proto.SizeEmbedded(fieldGetEACLRespSignature, x.Signature) + + proto.SizeEmbedded(fieldGetEACLRespSession, x.SessionToken) + } + return sz +} + +// MarshalStable writes the GetExtendedACLResponse_Body in Protocol Buffers V3 +// format with ascending order of fields by number into b. MarshalStable uses +// exactly [GetExtendedACLResponse_Body.MarshaledSize] first bytes of b. +// MarshalStable is NPE-safe. +func (x *GetExtendedACLResponse_Body) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToEmbedded(b, fieldGetEACLRespTable, x.Eacl) + off += proto.MarshalToEmbedded(b[off:], fieldGetEACLRespSignature, x.Signature) + proto.MarshalToEmbedded(b[off:], fieldGetEACLRespSession, x.SessionToken) + } +} + +const ( + _ = iota + fieldUsedSpaceEpoch + fieldUsedSpaceContainer + fieldUsedSpaceValue +) + +// MarshaledSize returns size of the AnnounceUsedSpaceRequest_Body_Announcement +// in Protocol Buffers V3 format in bytes. MarshaledSize is NPE-safe. +func (x *AnnounceUsedSpaceRequest_Body_Announcement) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeVarint(fieldUsedSpaceEpoch, x.Epoch) + + proto.SizeEmbedded(fieldUsedSpaceContainer, x.ContainerId) + + proto.SizeVarint(fieldUsedSpaceValue, x.UsedSpace) + } + return sz +} + +// MarshalStable writes the AnnounceUsedSpaceRequest_Body_Announcement in +// Protocol Buffers V3 format with ascending order of fields by number into b. +// MarshalStable uses exactly +// [AnnounceUsedSpaceRequest_Body_Announcement.MarshaledSize] first bytes of b. +// MarshalStable is NPE-safe. +func (x *AnnounceUsedSpaceRequest_Body_Announcement) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToVarint(b, fieldUsedSpaceEpoch, x.Epoch) + off += proto.MarshalToEmbedded(b[off:], fieldUsedSpaceContainer, x.ContainerId) + proto.MarshalToVarint(b[off:], fieldUsedSpaceValue, x.UsedSpace) + } +} + +const ( + _ = iota + fieldAnnounceReqList +) + +// MarshaledSize returns size of the AnnounceUsedSpaceRequest_Body in Protocol +// Buffers V3 format in bytes. MarshaledSize is NPE-safe. +func (x *AnnounceUsedSpaceRequest_Body) MarshaledSize() int { + var sz int + if x != nil { + for i := range x.Announcements { + sz += proto.SizeEmbedded(fieldAnnounceReqList, x.Announcements[i]) + } + } + return sz +} + +// MarshalStable writes the AnnounceUsedSpaceRequest_Body in Protocol Buffers V3 +// format with ascending order of fields by number into b. MarshalStable uses +// exactly [AnnounceUsedSpaceRequest_Body.MarshaledSize] first bytes of b. +// MarshalStable is NPE-safe. +func (x *AnnounceUsedSpaceRequest_Body) MarshalStable(b []byte) { + if x != nil { + var off int + for i := range x.Announcements { + off += proto.MarshalToEmbedded(b[off:], fieldAnnounceReqList, x.Announcements[i]) + } + } +} + +// MarshaledSize returns size of the AnnounceUsedSpaceResponse_Body in Protocol +// Buffers V3 format in bytes. MarshaledSize is NPE-safe. +func (x *AnnounceUsedSpaceResponse_Body) MarshaledSize() int { return 0 } + +// MarshalStable writes the AnnounceUsedSpaceResponse_Body in Protocol Buffers +// V3 format with ascending order of fields by number into b. MarshalStable uses +// exactly [AnnounceUsedSpaceResponse_Body.MarshaledSize] first bytes of b. +// MarshalStable is NPE-safe. +func (x *AnnounceUsedSpaceResponse_Body) MarshalStable([]byte) {} diff --git a/api/container/encoding_test.go b/api/container/encoding_test.go new file mode 100644 index 00000000..e20c2a6c --- /dev/null +++ b/api/container/encoding_test.go @@ -0,0 +1,3 @@ +package container_test + +// TODO diff --git a/api/internal/test/assert.go b/api/internal/test/assert.go new file mode 100644 index 00000000..ab2d80c0 --- /dev/null +++ b/api/internal/test/assert.go @@ -0,0 +1,60 @@ +package apitest + +import ( + "bytes" + "testing" + + "github.com/nspcc-dev/neofs-sdk-go/api/refs" + "github.com/stretchr/testify/require" +) + +// AssertEqualVersions asserts that two refs.Version are essentially the same. +func AssertEqualVersions(t testing.TB, v1, v2 *refs.Version, msg string) { + require.Equal(t, v1.Major, v2.Major, msg) + require.Equal(t, v1.Minor, v2.Minor, msg) +} + +// AssertEqualOwnerIDs asserts that two refs.OwnerID are essentially the same. +func AssertEqualOwnerIDs(t testing.TB, v1, v2 *refs.OwnerID, msg string) { + require.True(t, bytes.Equal(v1.GetValue(), v2.GetValue()), msg) +} + +// AssertEqualContainerIDs asserts that two refs.ContainerID are essentially the +// same. +func AssertEqualContainerIDs(t testing.TB, v1, v2 *refs.ContainerID, msg string) { + require.True(t, bytes.Equal(v1.GetValue(), v2.GetValue()), msg) +} + +// AssertEqualObjectIDs asserts that two refs.ObjectID are essentially the same. +func AssertEqualObjectIDs(t testing.TB, v1, v2 *refs.ObjectID, msg string) { + require.True(t, bytes.Equal(v1.GetValue(), v2.GetValue()), msg) +} + +// AssertEqualObjectAddresses asserts that two refs.Address are essentially the +// same. +func AssertEqualObjectAddresses(t testing.TB, v1, v2 *refs.Address, msg string) { + AssertEqualContainerIDs(t, v1.GetContainerId(), v2.GetContainerId(), msg) + AssertEqualObjectIDs(t, v1.GetObjectId(), v2.GetObjectId(), msg) +} + +// AssertEqualSignatures asserts that two refs.Signature are essentially the +// same. +func AssertEqualSignatures(t testing.TB, v1, v2 *refs.Signature, msg string) { + require.Equal(t, v1.GetScheme(), v2.GetScheme(), msg) + require.True(t, bytes.Equal(v1.GetKey(), v2.GetKey()), msg) + require.True(t, bytes.Equal(v1.GetSign(), v2.GetSign()), msg) +} + +// AssertEqualSignaturesRFC6979 asserts that two refs.SignatureRFC6979 are +// essentially the same. +func AssertEqualSignaturesRFC6979(t testing.TB, v1, v2 *refs.SignatureRFC6979, msg string) { + require.True(t, bytes.Equal(v1.GetKey(), v2.GetKey()), msg) + require.True(t, bytes.Equal(v1.GetSign(), v2.GetSign()), msg) +} + +// AssertEqualChecksums asserts that two refs.Checksum are essentially the +// same. +func AssertEqualChecksums(t testing.TB, v1, v2 *refs.Checksum, msg string) { + require.Equal(t, v1.GetType(), v2.GetType(), msg) + require.True(t, bytes.Equal(v1.GetSum(), v2.GetSum()), msg) +} diff --git a/api/internal/test/encoding.go b/api/internal/test/encoding.go new file mode 100644 index 00000000..d50164d4 --- /dev/null +++ b/api/internal/test/encoding.go @@ -0,0 +1,61 @@ +package apitest + +import ( + "strconv" + "testing" + + "github.com/nspcc-dev/neofs-sdk-go/internal/proto" + "github.com/stretchr/testify/require" + "google.golang.org/protobuf/encoding/protowire" + stdproto "google.golang.org/protobuf/proto" +) + +// TestMarshalStable tests that all given proto.Message instances encode into +// Protocol Buffers V3 correctly. TestMarshalStable also checks that +// [proto.Message.MarshalStable] panics if buffer length is less than +// [proto.Message.MarshaledSize]. The equality assert func should check that all +// protocol fields in both instances are equal. It is called only when v is +// non-nil. Note that simple v1 == v2 check will most likely fail due to gRPC +// service fields. +func TestMarshalStable[T any, PTR interface { + *T + proto.Message + stdproto.Message +}](t testing.TB, assertEqual func(t testing.TB, v1, v2 PTR, msg string), vs []PTR) { + require.NotEmpty(t, vs) + for i := range vs { + sz := vs[i].MarshaledSize() + if vs[i] == nil { + require.Zero(t, sz, i) + require.NotPanics(t, func() { vs[i].MarshalStable(nil) }, i) + continue + } + if sz > 0 { + require.Panics(t, func() { vs[i].MarshalStable(make([]byte, sz-1)) }, i) + } + + b := make([]byte, sz) + vs[i].MarshalStable(b) + + // assert ascending field order + var off int + prevNum := protowire.Number(-1) + for len(b[off:]) > 0 { + num, _, ln := protowire.ConsumeField(b[off:]) + require.NoError(t, protowire.ParseError(ln), i) + require.True(t, num >= 0, i) + if prevNum >= 0 { + require.GreaterOrEqual(t, num, prevNum, i) // may equal for repeated fields + } else { + prevNum = num + } + off += ln + } + + var v2 PTR = new(T) + err := stdproto.Unmarshal(b, v2) + require.NoError(t, err, i) + require.Empty(t, v2.ProtoReflect().GetUnknown(), i) + assertEqual(t, vs[i], v2, strconv.Itoa(i)) + } +} diff --git a/api/internal/test/rand.go b/api/internal/test/rand.go new file mode 100644 index 00000000..da25c908 --- /dev/null +++ b/api/internal/test/rand.go @@ -0,0 +1,28 @@ +package apitest + +import ( + "math/rand" + + "github.com/nspcc-dev/neofs-sdk-go/internal/proto" +) + +// RandomBytes random non-empty byte array up to 1024. +func RandomBytes[T proto.Bytes]() T { + var ln uint32 + for ln == 0 { + ln = RandomInteger[uint32]() % 1025 + } + b := make([]byte, ln) + //nolint:staticcheck + rand.Read(b) + return T(b) +} + +// RandomInteger returns random positive integer. +func RandomInteger[T proto.Varint]() T { + for { + if i := T(rand.Uint64()); i > 0 { + return i + } + } +} diff --git a/api/link/encoding.go b/api/link/encoding.go new file mode 100644 index 00000000..fe0d571e --- /dev/null +++ b/api/link/encoding.go @@ -0,0 +1,60 @@ +package link + +import "github.com/nspcc-dev/neofs-sdk-go/internal/proto" + +const ( + _ = iota + fieldLinkMeasuredObjectID + fieldLinkMeasuredObjectSize +) + +// MarshaledSize returns size of the Link_MeasuredObject in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *Link_MeasuredObject) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldLinkMeasuredObjectID, x.Id) + + proto.SizeVarint(fieldLinkMeasuredObjectSize, x.Size) + } + return sz +} + +// MarshalStable writes the Link_MeasuredObject in Protocol Buffers V3 format +// with ascending order of fields by number into b. MarshalStable uses exactly +// [Link_MeasuredObject.MarshaledSize] first bytes of b. MarshalStable is +// NPE-safe. +func (x *Link_MeasuredObject) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToEmbedded(b, fieldLinkMeasuredObjectID, x.Id) + proto.MarshalToVarint(b[off:], fieldLinkMeasuredObjectSize, x.Size) + } +} + +const ( + _ = iota + fieldLinkChildren +) + +// MarshaledSize returns size of the Link in Protocol Buffers V3 format in +// bytes. MarshaledSize is NPE-safe. +func (x *Link) MarshaledSize() int { + var sz int + if x != nil { + for i := range x.Children { + sz += proto.SizeEmbedded(fieldLinkChildren, x.Children[i]) + } + } + return sz +} + +// MarshalStable writes the Link in Protocol Buffers V3 format with ascending +// order of fields by number into b. MarshalStable uses exactly +// [Link.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *Link) MarshalStable(b []byte) { + if x != nil { + var off int + for i := range x.Children { + off += proto.MarshalToEmbedded(b[off:], fieldLinkChildren, x.Children[i]) + } + } +} diff --git a/api/link/encoding_test.go b/api/link/encoding_test.go new file mode 100644 index 00000000..05e4bb47 --- /dev/null +++ b/api/link/encoding_test.go @@ -0,0 +1,3 @@ +package link_test + +// TODO diff --git a/api/lock/encoding.go b/api/lock/encoding.go new file mode 100644 index 00000000..567920b4 --- /dev/null +++ b/api/lock/encoding.go @@ -0,0 +1,32 @@ +package lock + +import "github.com/nspcc-dev/neofs-sdk-go/internal/proto" + +const ( + _ = iota + fieldLockMembers +) + +// MarshaledSize returns size of the Lock in Protocol Buffers V3 format in +// bytes. MarshaledSize is NPE-safe. +func (x *Lock) MarshaledSize() int { + var sz int + if x != nil { + for i := range x.Members { + sz += proto.SizeEmbedded(fieldLockMembers, x.Members[i]) + } + } + return sz +} + +// MarshalStable writes the Lock in Protocol Buffers V3 format with ascending +// order of fields by number into b. MarshalStable uses exactly +// [Lock.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *Lock) MarshalStable(b []byte) { + if x != nil { + var off int + for i := range x.Members { + off += proto.MarshalToEmbedded(b[off:], fieldLockMembers, x.Members[i]) + } + } +} diff --git a/api/lock/encoding_test.go b/api/lock/encoding_test.go new file mode 100644 index 00000000..c00e8a6d --- /dev/null +++ b/api/lock/encoding_test.go @@ -0,0 +1,3 @@ +package lock_test + +// TODO diff --git a/api/netmap/encoding.go b/api/netmap/encoding.go new file mode 100644 index 00000000..a75ae08c --- /dev/null +++ b/api/netmap/encoding.go @@ -0,0 +1,454 @@ +package netmap + +import ( + "github.com/nspcc-dev/neofs-sdk-go/internal/proto" +) + +const ( + _ = iota + fieldReplicaCount + fieldReplicaSelector +) + +// MarshaledSize returns size of the Replica in Protocol Buffers V3 format in +// bytes. MarshaledSize is NPE-safe. +func (x *Replica) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeVarint(fieldReplicaCount, x.Count) + + proto.SizeBytes(fieldReplicaSelector, x.Selector) + } + return sz +} + +// MarshalStable writes the Replica in Protocol Buffers V3 format with ascending +// order of fields by number into b. MarshalStable uses exactly +// [Replica.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *Replica) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToVarint(b, fieldReplicaCount, x.Count) + proto.MarshalToBytes(b[off:], fieldReplicaSelector, x.Selector) + } +} + +const ( + _ = iota + fieldSelectorName + fieldSelectorCount + fieldSelectorClause + fieldSelectorAttribute + fieldSelectorFilter +) + +// MarshaledSize returns size of the Selector in Protocol Buffers V3 format in +// bytes. MarshaledSize is NPE-safe. +func (x *Selector) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeBytes(fieldSelectorName, x.Name) + + proto.SizeVarint(fieldSelectorCount, x.Count) + + proto.SizeVarint(fieldSelectorClause, int32(x.Clause)) + + proto.SizeBytes(fieldSelectorAttribute, x.Attribute) + + proto.SizeBytes(fieldSelectorFilter, x.Filter) + } + return sz +} + +// MarshalStable writes the Selector in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [Selector.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *Selector) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToBytes(b, fieldSelectorName, x.Name) + off += proto.MarshalToVarint(b[off:], fieldSelectorCount, x.Count) + off += proto.MarshalToVarint(b[off:], fieldSelectorClause, int32(x.Clause)) + off += proto.MarshalToBytes(b[off:], fieldSelectorAttribute, x.Attribute) + proto.MarshalToBytes(b[off:], fieldSelectorFilter, x.Filter) + } +} + +const ( + _ = iota + fieldFilterName + fieldFilterKey + fieldFilterOp + fieldFilterVal + fieldFilterSubs +) + +// MarshaledSize returns size of the Filter in Protocol Buffers V3 format in +// bytes. MarshaledSize is NPE-safe. +func (x *Filter) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeBytes(fieldFilterName, x.Name) + + proto.SizeBytes(fieldFilterKey, x.Key) + + proto.SizeVarint(fieldFilterOp, int32(x.Op)) + + proto.SizeBytes(fieldFilterVal, x.Value) + for i := range x.Filters { + sz += proto.SizeEmbedded(fieldFilterSubs, x.Filters[i]) + } + } + return sz +} + +// MarshalStable writes the Filter in Protocol Buffers V3 format with ascending +// order of fields by number into b. MarshalStable uses exactly +// [Filter.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *Filter) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToBytes(b, fieldFilterName, x.Name) + off += proto.MarshalToBytes(b[off:], fieldFilterKey, x.Key) + off += proto.MarshalToVarint(b[off:], fieldFilterOp, int32(x.Op)) + off += proto.MarshalToBytes(b[off:], fieldFilterVal, x.Value) + for i := range x.Filters { + off += proto.MarshalToEmbedded(b[off:], fieldFilterSubs, x.Filters[i]) + } + } +} + +const ( + _ = iota + fieldPolicyReplicas + fieldPolicyBackupFactor + fieldPolicySelectors + fieldPolicyFilters + fieldPolicySubnet +) + +// MarshaledSize returns size of the PlacementPolicy in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *PlacementPolicy) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeVarint(fieldPolicyBackupFactor, x.ContainerBackupFactor) + + proto.SizeEmbedded(fieldPolicySubnet, x.SubnetId) + for i := range x.Replicas { + sz += proto.SizeEmbedded(fieldPolicyReplicas, x.Replicas[i]) + } + for i := range x.Selectors { + sz += proto.SizeEmbedded(fieldPolicySelectors, x.Selectors[i]) + } + for i := range x.Filters { + sz += proto.SizeEmbedded(fieldPolicyFilters, x.Filters[i]) + } + } + return sz +} + +// MarshalStable writes the PlacementPolicy in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [PlacementPolicy.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *PlacementPolicy) MarshalStable(b []byte) { + if x != nil { + var off int + for i := range x.Replicas { + off += proto.MarshalToEmbedded(b[off:], fieldPolicyReplicas, x.Replicas[i]) + } + off += proto.MarshalToVarint(b[off:], fieldPolicyBackupFactor, x.ContainerBackupFactor) + for i := range x.Selectors { + off += proto.MarshalToEmbedded(b[off:], fieldPolicySelectors, x.Selectors[i]) + } + for i := range x.Filters { + off += proto.MarshalToEmbedded(b[off:], fieldPolicyFilters, x.Filters[i]) + } + proto.MarshalToEmbedded(b[off:], fieldPolicySubnet, x.SubnetId) + } +} + +const ( + _ = iota + fieldNetPrmKey + fieldNetPrmVal +) + +// MarshaledSize returns size of the NetworkConfig_Parameter in Protocol Buffers +// V3 format in bytes. MarshaledSize is NPE-safe. +func (x *NetworkConfig_Parameter) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeBytes(fieldNetPrmKey, x.Key) + + proto.SizeBytes(fieldNetPrmVal, x.Value) + } + return sz +} + +// MarshalStable writes the NetworkConfig_Parameter in Protocol Buffers V3 +// format with ascending order of fields by number into b. MarshalStable uses +// exactly [NetworkConfig_Parameter.MarshaledSize] first bytes of b. +// MarshalStable is NPE-safe. +func (x *NetworkConfig_Parameter) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToBytes(b, fieldNetPrmKey, x.Key) + proto.MarshalToBytes(b[off:], fieldNetPrmVal, x.Value) + } +} + +const ( + _ = iota + fieldNetConfigPrms +) + +// MarshaledSize returns size of the NetworkConfig in Protocol Buffers V3 format +// in bytes. MarshaledSize is NPE-safe. +func (x *NetworkConfig) MarshaledSize() int { + var sz int + if x != nil { + for i := range x.Parameters { + sz += proto.SizeEmbedded(fieldNetConfigPrms, x.Parameters[i]) + } + } + return sz +} + +// MarshalStable writes the NetworkConfig in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [NetworkConfig.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *NetworkConfig) MarshalStable(b []byte) { + if x != nil { + var off int + for i := range x.Parameters { + off += proto.MarshalToEmbedded(b[off:], fieldNetConfigPrms, x.Parameters[i]) + } + } +} + +const ( + _ = iota + fieldNetInfoCurEpoch + fieldNetInfoMagic + fieldNetInfoMSPerBlock + fieldNetInfoConfig +) + +// MarshaledSize returns size of the NetworkInfo in Protocol Buffers V3 format +// in bytes. MarshaledSize is NPE-safe. +func (x *NetworkInfo) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeVarint(fieldNetInfoCurEpoch, x.CurrentEpoch) + + proto.SizeVarint(fieldNetInfoMagic, x.MagicNumber) + + proto.SizeVarint(fieldNetInfoMSPerBlock, x.MsPerBlock) + + proto.SizeEmbedded(fieldNetInfoConfig, x.NetworkConfig) + } + return sz +} + +// MarshalStable writes the NetworkInfo in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [NetworkInfo.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *NetworkInfo) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToVarint(b, fieldNetInfoCurEpoch, x.CurrentEpoch) + off += proto.MarshalToVarint(b[off:], fieldNetInfoMagic, x.MagicNumber) + off += proto.MarshalToVarint(b[off:], fieldNetInfoMSPerBlock, x.MsPerBlock) + proto.MarshalToEmbedded(b[off:], fieldNetInfoConfig, x.NetworkConfig) + } +} + +const ( + _ = iota + fieldNumNodeAttrKey + fieldNumNodeAttrVal + fieldNumNodeAttrParents +) + +// MarshaledSize returns size of the NodeInfo_Attribute in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *NodeInfo_Attribute) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeBytes(fieldNumNodeAttrKey, x.Key) + + proto.SizeBytes(fieldNumNodeAttrVal, x.Value) + + proto.SizeRepeatedBytes(fieldNumNodeAttrParents, x.Parents) + } + return sz +} + +// MarshalStable writes the NodeInfo_Attribute in Protocol Buffers V3 format +// with ascending order of fields by number into b. MarshalStable uses exactly +// [NodeInfo_Attribute.MarshaledSize] first bytes of b. MarshalStable is +// NPE-safe. +func (x *NodeInfo_Attribute) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToBytes(b, fieldNumNodeAttrKey, x.Key) + off += proto.MarshalToBytes(b[off:], fieldNumNodeAttrVal, x.Value) + proto.MarshalToRepeatedBytes(b[off:], fieldNumNodeAttrParents, x.Parents) + } +} + +const ( + _ = iota + fieldNodeInfoPubKey + fieldNodeInfoAddresses + fieldNodeInfoAttributes + fieldNodeInfoState +) + +// MarshaledSize returns size of the NodeInfo in Protocol Buffers V3 format in +// bytes. MarshaledSize is NPE-safe. +func (x *NodeInfo) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeBytes(fieldNodeInfoPubKey, x.PublicKey) + + proto.SizeRepeatedBytes(fieldNodeInfoAddresses, x.Addresses) + + proto.SizeVarint(fieldNodeInfoState, int32(x.State)) + for i := range x.Attributes { + sz += proto.SizeEmbedded(fieldNodeInfoAttributes, x.Attributes[i]) + } + } + return sz +} + +// MarshalStable writes the NodeInfo in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [NodeInfo.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *NodeInfo) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToBytes(b, fieldNodeInfoPubKey, x.PublicKey) + off += proto.MarshalToRepeatedBytes(b[off:], fieldNodeInfoAddresses, x.Addresses) + for i := range x.Attributes { + off += proto.MarshalToEmbedded(b[off:], fieldNodeInfoAttributes, x.Attributes[i]) + } + proto.MarshalToVarint(b[off:], fieldNodeInfoState, int32(x.State)) + } +} + +const ( + _ = iota + fieldNetmapEpoch + fieldNetmapNodes +) + +// MarshaledSize returns size of the Netmap in Protocol Buffers V3 format in +// bytes. MarshaledSize is NPE-safe. +func (x *Netmap) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeVarint(fieldNetmapEpoch, x.Epoch) + for i := range x.Nodes { + sz += proto.SizeEmbedded(fieldNetmapNodes, x.Nodes[i]) + } + } + return sz +} + +// MarshalStable writes the Netmap in Protocol Buffers V3 format with ascending +// order of fields by number into b. MarshalStable uses exactly +// [Netmap.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *Netmap) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToVarint(b, fieldNetmapEpoch, x.Epoch) + for i := range x.Nodes { + off += proto.MarshalToEmbedded(b[off:], fieldNetmapNodes, x.Nodes[i]) + } + } +} + +// MarshaledSize returns size of the LocalNodeInfoRequest_Body in Protocol +// Buffers V3 format in bytes. MarshaledSize is NPE-safe. +func (x *LocalNodeInfoRequest_Body) MarshaledSize() int { return 0 } + +// MarshalStable writes the LocalNodeInfoRequest_Body in Protocol Buffers V3 +// format with ascending order of fields by number into b. MarshalStable uses +// exactly [LocalNodeInfoRequest_Body.MarshaledSize] first bytes of b. +// MarshalStable is NPE-safe. +func (x *LocalNodeInfoRequest_Body) MarshalStable([]byte) {} + +const ( + _ = iota + fieldNodeInfoRespVersion + fieldNodeInfoRespInfo +) + +// MarshaledSize returns size of the LocalNodeInfoResponse_Body in Protocol +// Buffers V3 format in bytes. MarshaledSize is NPE-safe. +func (x *LocalNodeInfoResponse_Body) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldNodeInfoRespVersion, x.Version) + + proto.SizeEmbedded(fieldNodeInfoRespInfo, x.NodeInfo) + } + return sz +} + +// MarshalStable writes the LocalNodeInfoResponse_Body in Protocol Buffers V3 +// format with ascending order of fields by number into b. MarshalStable uses +// exactly [LocalNodeInfoResponse_Body.MarshaledSize] first bytes of b. +// MarshalStable is NPE-safe. +func (x *LocalNodeInfoResponse_Body) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToEmbedded(b, fieldNodeInfoRespVersion, x.Version) + proto.MarshalToEmbedded(b[off:], fieldNodeInfoRespInfo, x.NodeInfo) + } +} + +// MarshaledSize returns size of the NetworkInfoRequest_Body in Protocol Buffers +// V3 format in bytes. MarshaledSize is NPE-safe. +func (x *NetworkInfoRequest_Body) MarshaledSize() int { return 0 } + +// MarshalStable writes the NetworkInfoRequest_Body in Protocol Buffers V3 +// format with ascending order of fields by number into b. MarshalStable uses +// exactly [NetworkInfoRequest_Body.MarshaledSize] first bytes of b. +// MarshalStable is NPE-safe. +func (x *NetworkInfoRequest_Body) MarshalStable([]byte) {} + +const ( + _ = iota + fieldNetInfoRespInfo +) + +// MarshaledSize returns size of the NetworkInfoResponse_Body in Protocol +// Buffers V3 format in bytes. MarshaledSize is NPE-safe. +func (x *NetworkInfoResponse_Body) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldNetInfoRespInfo, x.NetworkInfo) + } + return sz +} + +// MarshalStable writes the NetworkInfoResponse_Body in Protocol Buffers V3 +// format with ascending order of fields by number into b. MarshalStable uses +// exactly [NetworkInfoResponse_Body.MarshaledSize] first bytes of b. +// MarshalStable is NPE-safe. +func (x *NetworkInfoResponse_Body) MarshalStable(b []byte) { + if x != nil { + proto.MarshalToEmbedded(b, fieldNetInfoRespInfo, x.NetworkInfo) + } +} + +// MarshaledSize returns size of the NetmapSnapshotRequest_Body in Protocol +// Buffers V3 format in bytes. MarshaledSize is NPE-safe. +func (x *NetmapSnapshotRequest_Body) MarshaledSize() int { return 0 } + +// MarshalStable writes the NetmapSnapshotRequest_Body in Protocol Buffers V3 +// format with ascending order of fields by number into b. MarshalStable uses +// exactly [NetmapSnapshotRequest_Body.MarshaledSize] first bytes of b. +// MarshalStable is NPE-safe. +func (x *NetmapSnapshotRequest_Body) MarshalStable([]byte) {} + +const ( + _ = iota + fieldNetmapRespNetmap +) + +// MarshaledSize returns size of the NetmapSnapshotResponse_Body in Protocol +// Buffers V3 format in bytes. MarshaledSize is NPE-safe. +func (x *NetmapSnapshotResponse_Body) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldNetmapRespNetmap, x.Netmap) + } + return sz +} + +// MarshalStable writes the NetmapSnapshotResponse_Body in Protocol Buffers V3 +// format with ascending order of fields by number into b. MarshalStable uses +// exactly [NetmapSnapshotResponse_Body.MarshaledSize] first bytes of b. +// MarshalStable is NPE-safe. +func (x *NetmapSnapshotResponse_Body) MarshalStable(b []byte) { + if x != nil { + proto.MarshalToEmbedded(b, fieldNetmapRespNetmap, x.Netmap) + } +} diff --git a/api/netmap/encoding_test.go b/api/netmap/encoding_test.go new file mode 100644 index 00000000..62e30dbb --- /dev/null +++ b/api/netmap/encoding_test.go @@ -0,0 +1,3 @@ +package netmap_test + +// TODO diff --git a/api/object/encoding.go b/api/object/encoding.go new file mode 100644 index 00000000..f124749f --- /dev/null +++ b/api/object/encoding.go @@ -0,0 +1,898 @@ +package object + +import ( + "fmt" + + "github.com/nspcc-dev/neofs-sdk-go/internal/proto" +) + +const ( + _ = iota + fieldSplitParent + fieldSplitPrevious + fieldSplitParentSignature + fieldSplitParentHeader + fieldSplitChildren + fieldSplitID + fieldSplitFirst +) + +// MarshaledSize returns size of the Header_Split in Protocol Buffers V3 format +// in bytes. MarshaledSize is NPE-safe. +func (x *Header_Split) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldSplitParent, x.Parent) + + proto.SizeEmbedded(fieldSplitPrevious, x.Previous) + + proto.SizeEmbedded(fieldSplitParentSignature, x.ParentSignature) + + proto.SizeEmbedded(fieldSplitParentHeader, x.ParentHeader) + + proto.SizeBytes(fieldSplitID, x.SplitId) + + proto.SizeEmbedded(fieldSplitFirst, x.First) + for i := range x.Children { + sz += proto.SizeEmbedded(fieldSplitChildren, x.Children[i]) + } + } + return sz +} + +// MarshalStable writes the Header_Split in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [Header_Split.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *Header_Split) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToEmbedded(b, fieldSplitParent, x.Parent) + off += proto.MarshalToEmbedded(b[off:], fieldSplitPrevious, x.Previous) + off += proto.MarshalToEmbedded(b[off:], fieldSplitParentSignature, x.ParentSignature) + off += proto.MarshalToEmbedded(b[off:], fieldSplitParentHeader, x.ParentHeader) + off += proto.MarshalToBytes(b[off:], fieldSplitID, x.SplitId) + for i := range x.Children { + off += proto.MarshalToEmbedded(b[off:], fieldSplitChildren, x.Children[i]) + } + proto.MarshalToEmbedded(b[off:], fieldSplitFirst, x.First) + } +} + +const ( + _ = iota + fieldAttributeKey + fieldAttributeValue +) + +// MarshaledSize returns size of the Header_Attribute in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *Header_Attribute) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeBytes(fieldAttributeKey, x.Key) + + proto.SizeBytes(fieldAttributeValue, x.Value) + } + return sz +} + +// MarshalStable writes the Header_Attribute in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [Header_Attribute.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *Header_Attribute) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToBytes(b, fieldAttributeKey, x.Key) + proto.MarshalToBytes(b[off:], fieldAttributeValue, x.Value) + } +} + +const ( + _ = iota + fieldShortHeaderVersion + fieldShortHeaderCreationEpoch + fieldShortHeaderOwner + fieldShortHeaderType + fieldShortHeaderLen + fieldShortHeaderChecksum + fieldShortHeaderHomomorphic +) + +// MarshaledSize returns size of the ShortHeader in Protocol Buffers V3 format +// in bytes. MarshaledSize is NPE-safe. +func (x *ShortHeader) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldShortHeaderVersion, x.Version) + + proto.SizeVarint(fieldShortHeaderCreationEpoch, x.CreationEpoch) + + proto.SizeEmbedded(fieldShortHeaderOwner, x.OwnerId) + + proto.SizeVarint(fieldShortHeaderType, int32(x.ObjectType)) + + proto.SizeVarint(fieldShortHeaderLen, x.PayloadLength) + + proto.SizeEmbedded(fieldShortHeaderChecksum, x.PayloadHash) + + proto.SizeEmbedded(fieldShortHeaderHomomorphic, x.HomomorphicHash) + } + return sz +} + +// MarshalStable writes the ShortHeader in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [ShortHeader.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *ShortHeader) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToEmbedded(b, fieldShortHeaderVersion, x.Version) + off += proto.MarshalToVarint(b[off:], fieldShortHeaderCreationEpoch, x.CreationEpoch) + off += proto.MarshalToEmbedded(b[off:], fieldShortHeaderOwner, x.OwnerId) + off += proto.MarshalToVarint(b[off:], fieldShortHeaderType, int32(x.ObjectType)) + off += proto.MarshalToVarint(b[off:], fieldShortHeaderLen, x.PayloadLength) + off += proto.MarshalToEmbedded(b[off:], fieldShortHeaderChecksum, x.PayloadHash) + off += proto.MarshalToEmbedded(b[off:], fieldShortHeaderHomomorphic, x.HomomorphicHash) + } +} + +const ( + _ = iota + fieldHeaderVersion + fieldHeaderContainer + fieldHeaderOwner + fieldHeaderCreationEpoch + fieldHeaderLen + fieldHeaderChecksum + fieldHeaderType + fieldHeaderHomomorphic + fieldHeaderSession + fieldHeaderAttributes + fieldHeaderSplit +) + +// MarshaledSize returns size of the Header in Protocol Buffers V3 format in +// bytes. MarshaledSize is NPE-safe. +func (x *Header) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldHeaderVersion, x.Version) + + proto.SizeEmbedded(fieldHeaderContainer, x.ContainerId) + + proto.SizeEmbedded(fieldHeaderOwner, x.OwnerId) + + proto.SizeVarint(fieldHeaderCreationEpoch, x.CreationEpoch) + + proto.SizeVarint(fieldHeaderLen, x.PayloadLength) + + proto.SizeEmbedded(fieldHeaderChecksum, x.PayloadHash) + + proto.SizeVarint(fieldHeaderType, int32(x.ObjectType)) + + proto.SizeEmbedded(fieldHeaderHomomorphic, x.HomomorphicHash) + + proto.SizeEmbedded(fieldHeaderSession, x.SessionToken) + + proto.SizeEmbedded(fieldHeaderSplit, x.Split) + for i := range x.Attributes { + sz += proto.SizeEmbedded(fieldHeaderAttributes, x.Attributes[i]) + } + } + return sz +} + +// MarshalStable writes the Header in Protocol Buffers V3 format with ascending +// order of fields by number into b. MarshalStable uses exactly +// [Header.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *Header) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToEmbedded(b, fieldHeaderVersion, x.Version) + off += proto.MarshalToEmbedded(b[off:], fieldHeaderContainer, x.ContainerId) + off += proto.MarshalToEmbedded(b[off:], fieldHeaderOwner, x.OwnerId) + off += proto.MarshalToVarint(b[off:], fieldHeaderCreationEpoch, x.CreationEpoch) + off += proto.MarshalToVarint(b[off:], fieldHeaderLen, x.PayloadLength) + off += proto.MarshalToEmbedded(b[off:], fieldHeaderChecksum, x.PayloadHash) + off += proto.MarshalToVarint(b[off:], fieldHeaderType, int32(x.ObjectType)) + off += proto.MarshalToEmbedded(b[off:], fieldHeaderHomomorphic, x.HomomorphicHash) + off += proto.MarshalToEmbedded(b[off:], fieldHeaderSession, x.SessionToken) + for i := range x.Attributes { + off += proto.MarshalToEmbedded(b[off:], fieldHeaderAttributes, x.Attributes[i]) + } + proto.MarshalToEmbedded(b[off:], fieldHeaderSplit, x.Split) + } +} + +const ( + _ = iota + fieldObjectID + fieldObjectSignature + fieldObjectHeader + fieldObjectPayload +) + +// MarshaledSize returns size of the Object in Protocol Buffers V3 format in +// bytes. MarshaledSize is NPE-safe. +func (x *Object) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldObjectID, x.ObjectId) + + proto.SizeEmbedded(fieldObjectSignature, x.Signature) + + proto.SizeEmbedded(fieldObjectHeader, x.Header) + + proto.SizeBytes(fieldObjectPayload, x.Payload) + } + return sz +} + +// MarshalStable writes the Object in Protocol Buffers V3 format with ascending +// order of fields by number into b. MarshalStable uses exactly +// [Object.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *Object) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToEmbedded(b, fieldObjectID, x.ObjectId) + off += proto.MarshalToEmbedded(b[off:], fieldObjectSignature, x.Signature) + off += proto.MarshalToEmbedded(b[off:], fieldObjectHeader, x.Header) + proto.MarshalToBytes(b[off:], fieldObjectPayload, x.Payload) + } +} + +const ( + _ = iota + fieldSplitInfoID + fieldSplitInfoLast + fieldSplitInfoLink + fieldSplitInfoFirst +) + +// MarshaledSize returns size of the SplitInfo in Protocol Buffers V3 format in +// bytes. MarshaledSize is NPE-safe. +func (x *SplitInfo) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeBytes(fieldSplitInfoID, x.SplitId) + + proto.SizeEmbedded(fieldSplitInfoLast, x.LastPart) + + proto.SizeEmbedded(fieldSplitInfoLink, x.Link) + + proto.SizeEmbedded(fieldSplitInfoFirst, x.FirstPart) + } + return sz +} + +// MarshalStable writes the SplitInfo in Protocol Buffers V3 format with ascending +// order of fields by number into b. MarshalStable uses exactly +// [SplitInfo.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *SplitInfo) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToBytes(b, fieldSplitInfoID, x.SplitId) + off += proto.MarshalToEmbedded(b[off:], fieldSplitInfoLast, x.LastPart) + off += proto.MarshalToEmbedded(b[off:], fieldSplitInfoLink, x.Link) + proto.MarshalToEmbedded(b[off:], fieldSplitInfoFirst, x.FirstPart) + } +} + +const ( + _ = iota + fieldGetReqAddress + fieldGetReqRaw +) + +// MarshaledSize returns size of the GetRequest_Body in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *GetRequest_Body) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldGetReqAddress, x.Address) + + proto.SizeBool(fieldGetReqRaw, x.Raw) + } + return sz +} + +// MarshalStable writes the GetRequest_Body in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [GetRequest_Body.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *GetRequest_Body) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToEmbedded(b, fieldGetReqAddress, x.Address) + proto.MarshalToBool(b[off:], fieldGetReqRaw, x.Raw) + } +} + +const ( + _ = iota + fieldGetRespInitID + fieldGetRespInitSignature + fieldGetRespInitHeader +) + +// MarshaledSize returns size of the GetResponse_Body_Init in Protocol Buffers +// V3 format in bytes. MarshaledSize is NPE-safe. +func (x *GetResponse_Body_Init) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldGetRespInitID, x.ObjectId) + + proto.SizeEmbedded(fieldGetRespInitSignature, x.Signature) + + proto.SizeEmbedded(fieldGetRespInitHeader, x.Header) + } + return sz +} + +// MarshalStable writes the GetResponse_Body_Init in Protocol Buffers V3 format +// with ascending order of fields by number into b. MarshalStable uses exactly +// [GetResponse_Body_Init.MarshaledSize] first bytes of b. MarshalStable is +// NPE-safe. +func (x *GetResponse_Body_Init) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToEmbedded(b, fieldGetRespInitID, x.ObjectId) + off += proto.MarshalToEmbedded(b[off:], fieldGetRespInitSignature, x.Signature) + proto.MarshalToEmbedded(b[off:], fieldGetRespInitHeader, x.Header) + } +} + +const ( + _ = iota + fieldGetRespInit + fieldGetRespChunk + fieldGetRespSplitInfo +) + +// MarshaledSize returns size of the GetResponse_Body in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *GetResponse_Body) MarshaledSize() int { + var sz int + if x != nil { + switch p := x.ObjectPart.(type) { + default: + panic(fmt.Sprintf("unexpected object part %T", x.ObjectPart)) + case nil: + case *GetResponse_Body_Init_: + if p != nil { + sz = proto.SizeEmbedded(fieldGetRespInit, p.Init) + } + case *GetResponse_Body_Chunk: + if p != nil { + sz = proto.SizeBytes(fieldGetRespChunk, p.Chunk) + } + case *GetResponse_Body_SplitInfo: + if p != nil { + sz = proto.SizeEmbedded(fieldGetRespSplitInfo, p.SplitInfo) + } + } + } + return sz +} + +// MarshalStable writes the GetResponse_Body in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [GetResponse_Body.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *GetResponse_Body) MarshalStable(b []byte) { + if x != nil { + switch p := x.ObjectPart.(type) { + default: + panic(fmt.Sprintf("unexpected object part %T", x.ObjectPart)) + case nil: + case *GetResponse_Body_Init_: + if p != nil { + proto.MarshalToEmbedded(b, fieldGetRespInit, p.Init) + } + case *GetResponse_Body_Chunk: + if p != nil { + proto.MarshalToBytes(b, fieldGetRespChunk, p.Chunk) + } + case *GetResponse_Body_SplitInfo: + if p != nil { + proto.MarshalToEmbedded(b, fieldGetRespSplitInfo, p.SplitInfo) + } + } + } +} + +const ( + _ = iota + fieldHeadReqAddress + fieldHeadReqMain + fieldHeadReqRaw +) + +// MarshaledSize returns size of the HeadRequest_Body in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *HeadRequest_Body) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldHeadReqAddress, x.Address) + + proto.SizeBool(fieldHeadReqMain, x.MainOnly) + + proto.SizeBool(fieldHeadReqRaw, x.Raw) + } + return sz +} + +// MarshalStable writes the HeadRequest_Body in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [HeadRequest_Body.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *HeadRequest_Body) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToEmbedded(b, fieldHeadReqAddress, x.Address) + off += proto.MarshalToBool(b[off:], fieldHeadReqMain, x.MainOnly) + proto.MarshalToBool(b[off:], fieldHeadReqRaw, x.Raw) + } +} + +const ( + _ = iota + fieldHeaderSignatureHdr + fieldHeaderSignatureSig +) + +// MarshaledSize returns size of the HeaderWithSignature in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *HeaderWithSignature) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldHeaderSignatureHdr, x.Header) + + proto.SizeEmbedded(fieldHeaderSignatureSig, x.Signature) + } + return sz +} + +// MarshalStable writes the HeaderWithSignature in Protocol Buffers V3 format +// with ascending order of fields by number into b. MarshalStable uses exactly +// [HeaderWithSignature.MarshaledSize] first bytes of b. MarshalStable is +// NPE-safe. +func (x *HeaderWithSignature) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToEmbedded(b, fieldHeaderSignatureHdr, x.Header) + proto.MarshalToEmbedded(b[off:], fieldHeaderSignatureSig, x.Signature) + } +} + +const ( + _ = iota + fieldHeadRespHeader + fieldHeadRespShort + fieldHeadRespSplitInfo +) + +// MarshaledSize returns size of the HeadResponse_Body in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *HeadResponse_Body) MarshaledSize() int { + var sz int + if x != nil { + switch h := x.Head.(type) { + default: + panic(fmt.Sprintf("unexpected head part %T", x.Head)) + case nil: + case *HeadResponse_Body_Header: + if h != nil { + sz = proto.SizeEmbedded(fieldHeadRespHeader, h.Header) + } + case *HeadResponse_Body_ShortHeader: + if h != nil { + sz = proto.SizeEmbedded(fieldHeadRespShort, h.ShortHeader) + } + case *HeadResponse_Body_SplitInfo: + if h != nil { + sz = proto.SizeEmbedded(fieldHeadRespSplitInfo, h.SplitInfo) + } + } + } + return sz +} + +// MarshalStable writes the HeadResponse_Body in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [HeadResponse_Body.MarshaledSize] first bytes of b. MarshalStable is +// NPE-safe. +func (x *HeadResponse_Body) MarshalStable(b []byte) { + if x != nil { + switch h := x.Head.(type) { + default: + panic(fmt.Sprintf("unexpected head part %T", x.Head)) + case nil: + case *HeadResponse_Body_Header: + if h != nil { + proto.MarshalToEmbedded(b, fieldHeadRespHeader, h.Header) + } + case *HeadResponse_Body_ShortHeader: + if h != nil { + proto.MarshalToEmbedded(b, fieldHeadRespShort, h.ShortHeader) + } + case *HeadResponse_Body_SplitInfo: + if h != nil { + proto.MarshalToEmbedded(b, fieldHeadRespSplitInfo, h.SplitInfo) + } + } + } +} + +const ( + _ = iota + fieldRangeOff + fieldRangeLen +) + +// MarshaledSize returns size of the Range in Protocol Buffers V3 format in +// bytes. MarshaledSize is NPE-safe. +func (x *Range) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeVarint(fieldRangeOff, x.Offset) + + proto.SizeVarint(fieldRangeLen, x.Length) + } + return sz +} + +// MarshalStable writes the Range in Protocol Buffers V3 format with ascending +// order of fields by number into b. MarshalStable uses exactly +// [Range.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *Range) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToVarint(b, fieldRangeOff, x.Offset) + proto.MarshalToVarint(b[off:], fieldRangeLen, x.Length) + } +} + +const ( + _ = iota + fieldRangeReqAddress + fieldRangeReqRange + fieldRangeReqRaw +) + +// MarshaledSize returns size of the GetRangeRequest_Body in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *GetRangeRequest_Body) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldRangeReqAddress, x.Address) + + proto.SizeEmbedded(fieldRangeReqRange, x.Range) + + proto.SizeBool(fieldRangeReqRaw, x.Raw) + } + return sz +} + +// MarshalStable writes the GetRangeRequest_Body in Protocol Buffers V3 format +// with ascending order of fields by number into b. MarshalStable uses exactly +// [GetRangeRequest_Body.MarshaledSize] first bytes of b. MarshalStable is +// NPE-safe. +func (x *GetRangeRequest_Body) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToEmbedded(b, fieldRangeReqAddress, x.Address) + off += proto.MarshalToEmbedded(b[off:], fieldRangeReqRange, x.Range) + proto.MarshalToBool(b[off:], fieldRangeReqRaw, x.Raw) + } +} + +const ( + _ = iota + fieldRangeRespChunk + fieldRangeRespSplitInfo +) + +// MarshaledSize returns size of the GetRangeResponse_Body in Protocol Buffers +// V3 format in bytes. MarshaledSize is NPE-safe. +func (x *GetRangeResponse_Body) MarshaledSize() int { + var sz int + if x != nil { + switch p := x.RangePart.(type) { + default: + panic(fmt.Sprintf("unexpected range part %T", x.RangePart)) + case nil: + case *GetRangeResponse_Body_Chunk: + if p != nil { + sz = proto.SizeBytes(fieldRangeRespChunk, p.Chunk) + } + case *GetRangeResponse_Body_SplitInfo: + if p != nil { + sz = proto.SizeEmbedded(fieldRangeRespSplitInfo, p.SplitInfo) + } + } + } + return sz +} + +// MarshalStable writes the GetRangeResponse_Body in Protocol Buffers V3 format +// with ascending order of fields by number into b. MarshalStable uses exactly +// [GetRangeResponse_Body.MarshaledSize] first bytes of b. MarshalStable is +// NPE-safe. +func (x *GetRangeResponse_Body) MarshalStable(b []byte) { + if x != nil { + switch p := x.RangePart.(type) { + default: + panic(fmt.Sprintf("unexpected range part %T", x.RangePart)) + case nil: + case *GetRangeResponse_Body_Chunk: + if p != nil { + proto.MarshalToBytes(b, fieldRangeRespChunk, p.Chunk) + } + case *GetRangeResponse_Body_SplitInfo: + if p != nil { + proto.MarshalToEmbedded(b, fieldRangeRespSplitInfo, p.SplitInfo) + } + } + } +} + +const ( + _ = iota + fieldRangeHashReqAddress + fieldRangeHashReqRanges + fieldRangeHashReqSalt + fieldRangeHashReqType +) + +// MarshaledSize returns size of the GetRangeHashRequest_Body in Protocol +// Buffers V3 format in bytes. MarshaledSize is NPE-safe. +func (x *GetRangeHashRequest_Body) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldRangeHashReqAddress, x.Address) + + proto.SizeBytes(fieldRangeHashReqSalt, x.Salt) + + proto.SizeVarint(fieldRangeHashReqType, int32(x.Type)) + for i := range x.Ranges { + sz += proto.SizeEmbedded(fieldRangeHashReqRanges, x.Ranges[i]) + } + } + return sz +} + +// MarshalStable writes the GetRangeHashRequest_Body in Protocol Buffers V3 +// format with ascending order of fields by number into b. MarshalStable uses +// exactly [GetRangeHashRequest_Body.MarshaledSize] first bytes of b. +// MarshalStable is NPE-safe. +func (x *GetRangeHashRequest_Body) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToEmbedded(b, fieldRangeHashReqAddress, x.Address) + for i := range x.Ranges { + off += proto.MarshalToEmbedded(b[off:], fieldRangeHashReqRanges, x.Ranges[i]) + } + off += proto.MarshalToBytes(b[off:], fieldRangeHashReqSalt, x.Salt) + proto.MarshalToVarint(b[off:], fieldRangeHashReqType, int32(x.Type)) + } +} + +const ( + _ = iota + fieldRangeHashRespType + fieldRangeHashRespHashes +) + +// MarshaledSize returns size of the GetRangeHashResponse_Body in Protocol +// Buffers V3 format in bytes. MarshaledSize is NPE-safe. +func (x *GetRangeHashResponse_Body) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeVarint(fieldRangeHashRespType, int32(x.Type)) + + proto.SizeRepeatedBytes(fieldRangeHashRespHashes, x.HashList) + } + return sz +} + +// MarshalStable writes the GetRangeHashResponse_Body in Protocol Buffers V3 +// format with ascending order of fields by number into b. MarshalStable uses +// exactly [GetRangeHashResponse_Body.MarshaledSize] first bytes of b. +// MarshalStable is NPE-safe. +func (x *GetRangeHashResponse_Body) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToVarint(b, fieldRangeHashRespType, int32(x.Type)) + proto.MarshalToRepeatedBytes(b[off:], fieldRangeHashRespHashes, x.HashList) + } +} + +const ( + _ = iota + fieldPutReqInitID + fieldPutReqInitSignature + fieldPutReqInitHeader + fieldPutReqInitCopies +) + +// MarshaledSize returns size of the PutRequest_Body_Init in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *PutRequest_Body_Init) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldPutReqInitID, x.ObjectId) + + proto.SizeEmbedded(fieldPutReqInitSignature, x.Signature) + + proto.SizeEmbedded(fieldPutReqInitHeader, x.Header) + + proto.SizeVarint(fieldPutReqInitCopies, x.CopiesNumber) + } + return sz +} + +// MarshalStable writes the PutRequest_Body_Init in Protocol Buffers V3 format +// with ascending order of fields by number into b. MarshalStable uses exactly +// [PutRequest_Body_Init.MarshaledSize] first bytes of b. MarshalStable is +// NPE-safe. +func (x *PutRequest_Body_Init) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToEmbedded(b, fieldPutReqInitID, x.ObjectId) + off += proto.MarshalToEmbedded(b[off:], fieldPutReqInitSignature, x.Signature) + off += proto.MarshalToEmbedded(b[off:], fieldPutReqInitHeader, x.Header) + proto.MarshalToVarint(b[off:], fieldPutReqInitCopies, x.CopiesNumber) + } +} + +const ( + _ = iota + fieldPutReqInit + fieldPutReqChunk +) + +// MarshaledSize returns size of the PutRequest_Body in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *PutRequest_Body) MarshaledSize() int { + var sz int + if x != nil { + switch p := x.ObjectPart.(type) { + default: + panic(fmt.Sprintf("unexpected object part %T", x.ObjectPart)) + case nil: + case *PutRequest_Body_Init_: + sz = proto.SizeEmbedded(fieldPutReqInit, p.Init) + case *PutRequest_Body_Chunk: + sz = proto.SizeBytes(fieldPutReqChunk, p.Chunk) + } + } + return sz +} + +// MarshalStable writes the PutRequest_Body in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [PutRequest_Body.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *PutRequest_Body) MarshalStable(b []byte) { + if x != nil { + switch p := x.ObjectPart.(type) { + default: + panic(fmt.Sprintf("unexpected object part %T", x.ObjectPart)) + case nil: + case *PutRequest_Body_Init_: + proto.MarshalToEmbedded(b, fieldPutReqInit, p.Init) + case *PutRequest_Body_Chunk: + proto.MarshalToBytes(b, fieldPutReqChunk, p.Chunk) + } + } +} + +const ( + _ = iota + fieldPutRespID +) + +// MarshaledSize returns size of the PutResponse_Body in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *PutResponse_Body) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldPutRespID, x.ObjectId) + } + return sz +} + +// MarshalStable writes the PutResponse_Body in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [PutResponse_Body.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *PutResponse_Body) MarshalStable(b []byte) { + if x != nil { + proto.MarshalToEmbedded(b, fieldPutRespID, x.ObjectId) + } +} + +const ( + _ = iota + fieldDeleteReqAddress +) + +// MarshaledSize returns size of the DeleteRequest_Body in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *DeleteRequest_Body) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldDeleteReqAddress, x.Address) + } + return sz +} + +// MarshalStable writes the DeleteRequest_Body in Protocol Buffers V3 format +// with ascending order of fields by number into b. MarshalStable uses exactly +// [DeleteRequest_Body.MarshaledSize] first bytes of b. MarshalStable is +// NPE-safe. +func (x *DeleteRequest_Body) MarshalStable(b []byte) { + if x != nil { + proto.MarshalToEmbedded(b, fieldDeleteReqAddress, x.Address) + } +} + +const ( + _ = iota + fieldDeleteRespTombstone +) + +// MarshaledSize returns size of the DeleteResponse_Body in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *DeleteResponse_Body) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldDeleteRespTombstone, x.Tombstone) + } + return sz +} + +// MarshalStable writes the DeleteResponse_Body in Protocol Buffers V3 format +// with ascending order of fields by number into b. MarshalStable uses exactly +// [DeleteResponse_Body.MarshaledSize] first bytes of b. MarshalStable is +// NPE-safe. +func (x *DeleteResponse_Body) MarshalStable(b []byte) { + if x != nil { + proto.MarshalToEmbedded(b, fieldDeleteRespTombstone, x.Tombstone) + } +} + +const ( + _ = iota + fieldSearchFilterMatcher + fieldSearchFilterKey + fieldSearchFilterValue +) + +// MarshaledSize returns size of the SearchRequest_Body_Filter in Protocol +// Buffers V3 format in bytes. MarshaledSize is NPE-safe. +func (x *SearchRequest_Body_Filter) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeVarint(fieldSearchFilterMatcher, int32(x.MatchType)) + sz += proto.SizeBytes(fieldSearchFilterKey, x.Key) + sz += proto.SizeBytes(fieldSearchFilterValue, x.Value) + } + return sz +} + +// MarshalStable writes the SearchRequest_Body_Filter in Protocol Buffers V3 +// format with ascending order of fields by number into b. MarshalStable uses +// exactly [SearchRequest_Body_Filter.MarshaledSize] first bytes of b. +// MarshalStable is NPE-safe. +func (x *SearchRequest_Body_Filter) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToVarint(b, fieldSearchFilterMatcher, int32(x.MatchType)) + off += proto.MarshalToBytes(b[off:], fieldSearchFilterKey, x.Key) + proto.MarshalToBytes(b[off:], fieldSearchFilterValue, x.Value) + } +} + +const ( + _ = iota + fieldSearchReqContainer + fieldSearchReqVersion + fieldSearchReqFilters +) + +// MarshaledSize returns size of the SearchRequest_Body in Protocol +// Buffers V3 format in bytes. MarshaledSize is NPE-safe. +func (x *SearchRequest_Body) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldSearchReqContainer, x.ContainerId) + sz += proto.SizeVarint(fieldSearchReqVersion, x.Version) + for i := range x.Filters { + sz += proto.SizeEmbedded(fieldSearchReqFilters, x.Filters[i]) + } + } + return sz +} + +// MarshalStable writes the SearchRequest_Body in Protocol Buffers V3 format +// with ascending order of fields by number into b. MarshalStable uses exactly +// [SearchRequest_Body.MarshaledSize] first bytes of b. MarshalStable is +// NPE-safe. +func (x *SearchRequest_Body) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToEmbedded(b, fieldSearchReqContainer, x.ContainerId) + off += proto.MarshalToVarint(b[off:], fieldSearchReqVersion, x.Version) + for i := range x.Filters { + off += proto.MarshalToEmbedded(b[off:], fieldSearchReqFilters, x.Filters[i]) + } + } +} + +const ( + _ = iota + fieldSearchRespIDList +) + +// MarshaledSize returns size of the SearchResponse_Body in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *SearchResponse_Body) MarshaledSize() int { + var sz int + if x != nil { + for i := range x.IdList { + sz += proto.SizeEmbedded(fieldSearchRespIDList, x.IdList[i]) + } + } + return sz +} + +// MarshalStable writes the SearchResponse_Body in Protocol Buffers V3 format +// with ascending order of fields by number into b. MarshalStable uses exactly +// [SearchResponse_Body.MarshaledSize] first bytes of b. MarshalStable is +// NPE-safe. +func (x *SearchResponse_Body) MarshalStable(b []byte) { + if x != nil { + var off int + for i := range x.IdList { + off += proto.MarshalToEmbedded(b[off:], fieldSearchRespIDList, x.IdList[i]) + } + } +} diff --git a/api/object/encoding_test.go b/api/object/encoding_test.go new file mode 100644 index 00000000..4886d321 --- /dev/null +++ b/api/object/encoding_test.go @@ -0,0 +1,3 @@ +package object_test + +// TODO diff --git a/api/refs/encoding.go b/api/refs/encoding.go new file mode 100644 index 00000000..6adb774a --- /dev/null +++ b/api/refs/encoding.go @@ -0,0 +1,239 @@ +package refs + +import ( + "github.com/nspcc-dev/neofs-sdk-go/internal/proto" +) + +const ( + _ = iota + fieldOwnerIDValue +) + +// MarshaledSize returns size of the OwnerID in Protocol Buffers V3 format in +// bytes. MarshaledSize is NPE-safe. +func (x *OwnerID) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeBytes(fieldOwnerIDValue, x.Value) + } + return sz +} + +// MarshalStable writes the OwnerID in Protocol Buffers V3 format with ascending +// order of fields by number into b. MarshalStable uses exactly +// [OwnerID.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *OwnerID) MarshalStable(b []byte) { + if x != nil { + proto.MarshalToBytes(b, fieldOwnerIDValue, x.Value) + } +} + +const ( + _ = iota + fieldContainerIDValue +) + +// MarshaledSize returns size of the ContainerID in Protocol Buffers V3 format +// in bytes. MarshaledSize is NPE-safe. +func (x *ContainerID) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeBytes(fieldContainerIDValue, x.Value) + } + return sz +} + +// MarshalStable writes the ContainerID in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [ContainerID.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *ContainerID) MarshalStable(b []byte) { + if x != nil { + proto.MarshalToBytes(b, fieldContainerIDValue, x.Value) + } +} + +const ( + _ = iota + fieldObjectIDValue +) + +// MarshaledSize returns size of the ObjectID in Protocol Buffers V3 format in +// bytes. MarshaledSize is NPE-safe. +func (x *ObjectID) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeBytes(fieldObjectIDValue, x.Value) + } + return sz +} + +// MarshalStable writes the ObjectID in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [ObjectID.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *ObjectID) MarshalStable(b []byte) { + if x != nil { + proto.MarshalToBytes(b, fieldObjectIDValue, x.Value) + } +} + +const ( + _ = iota + fieldAddressContainer + fieldAddressObject +) + +// MarshaledSize returns size of the Address in Protocol Buffers V3 format in +// bytes. MarshaledSize is NPE-safe. +func (x *Address) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldAddressContainer, x.ContainerId) + + proto.SizeEmbedded(fieldAddressObject, x.ObjectId) + } + return sz +} + +// MarshalStable writes the Address in Protocol Buffers V3 format with ascending +// order of fields by number into b. MarshalStable uses exactly +// [Address.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *Address) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToEmbedded(b, fieldAddressContainer, x.ContainerId) + proto.MarshalToEmbedded(b[off:], fieldAddressObject, x.ObjectId) + } +} + +const ( + _ = iota + fieldVersionMajor + fieldVersionMinor +) + +// MarshaledSize returns size of the Version in Protocol Buffers V3 format in +// bytes. MarshaledSize is NPE-safe. +func (x *Version) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeVarint(fieldVersionMajor, x.Major) + + proto.SizeVarint(fieldVersionMinor, x.Minor) + } + return sz +} + +// MarshalStable writes the Version in Protocol Buffers V3 format with ascending +// order of fields by number into b. MarshalStable uses exactly +// [Version.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *Version) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToVarint(b, fieldVersionMajor, x.Major) + proto.MarshalToVarint(b[off:], fieldVersionMinor, x.Minor) + } +} + +const ( + _ = iota + fieldSignatureKey + fieldSignatureVal + fieldSignatureScheme +) + +// MarshaledSize returns size of the Signature in Protocol Buffers V3 format in +// bytes. MarshaledSize is NPE-safe. +func (x *Signature) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeBytes(fieldSignatureKey, x.Key) + + proto.SizeBytes(fieldSignatureVal, x.Sign) + + proto.SizeVarint(fieldSignatureScheme, int32(x.Scheme)) + } + return sz +} + +// MarshalStable writes the Signature in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [Signature.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *Signature) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToBytes(b, fieldSignatureKey, x.Key) + off += proto.MarshalToBytes(b[off:], fieldSignatureVal, x.Sign) + proto.MarshalToVarint(b[off:], fieldSignatureScheme, int32(x.Scheme)) + } +} + +const ( + _ = iota + fieldSigRFC6979Key + fieldSigRFC6979Val +) + +// MarshaledSize returns size of the SignatureRFC6979 in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *SignatureRFC6979) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeBytes(fieldSigRFC6979Key, x.Key) + + proto.SizeBytes(fieldSigRFC6979Val, x.Sign) + } + return sz +} + +// MarshalStable writes the SignatureRFC6979 in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [SignatureRFC6979.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *SignatureRFC6979) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToBytes(b, fieldSigRFC6979Key, x.Key) + proto.MarshalToBytes(b[off:], fieldSigRFC6979Val, x.Sign) + } +} + +const ( + _ = iota + fieldChecksumType + fieldChecksumValue +) + +// MarshaledSize returns size of the Checksum in Protocol Buffers V3 format in +// bytes. MarshaledSize is NPE-safe. +func (x *Checksum) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeVarint(fieldChecksumType, int32(x.Type)) + + proto.SizeBytes(fieldChecksumValue, x.Sum) + } + return sz +} + +// MarshalStable writes the Checksum in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [Checksum.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *Checksum) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToVarint(b, fieldChecksumType, int32(x.Type)) + proto.MarshalToBytes(b[off:], fieldChecksumValue, x.Sum) + } +} + +const ( + _ = iota + fieldSubnetVal +) + +// MarshaledSize returns size of the SubnetID in Protocol Buffers V3 format in +// bytes. MarshaledSize is NPE-safe. +func (x *SubnetID) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeFixed32(fieldSubnetVal, x.Value) + } + return sz +} + +// MarshalStable writes the SubnetID in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [SubnetID.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *SubnetID) MarshalStable(b []byte) { + if x != nil { + proto.MarshalToFixed32(b, fieldSubnetVal, x.Value) + } +} diff --git a/api/refs/encoding_test.go b/api/refs/encoding_test.go new file mode 100644 index 00000000..4633ec5e --- /dev/null +++ b/api/refs/encoding_test.go @@ -0,0 +1,117 @@ +package refs_test + +import ( + "testing" + + apitest "github.com/nspcc-dev/neofs-sdk-go/api/internal/test" + "github.com/nspcc-dev/neofs-sdk-go/api/refs" + "github.com/stretchr/testify/require" +) + +func TestOwnerID_MarshalStable(t *testing.T) { + apitest.TestMarshalStable(t, apitest.AssertEqualOwnerIDs, []*refs.OwnerID{ + nil, + new(refs.OwnerID), + {Value: []byte{}}, + {Value: apitest.RandomBytes[[]byte]()}, + }) +} + +func TestContainerID_MarshalStable(t *testing.T) { + apitest.TestMarshalStable(t, apitest.AssertEqualContainerIDs, []*refs.ContainerID{ + nil, + new(refs.ContainerID), + {Value: []byte{}}, + {Value: apitest.RandomBytes[[]byte]()}, + }) +} + +func TestObjectID_MarshalStable(t *testing.T) { + apitest.TestMarshalStable(t, apitest.AssertEqualObjectIDs, []*refs.ObjectID{ + nil, + new(refs.ObjectID), + {Value: []byte{}}, + {Value: apitest.RandomBytes[[]byte]()}, + }) +} + +func TestAddress_MarshalStable(t *testing.T) { + apitest.TestMarshalStable(t, apitest.AssertEqualObjectAddresses, []*refs.Address{ + nil, + new(refs.Address), + { + ContainerId: new(refs.ContainerID), + ObjectId: new(refs.ObjectID), + }, + { + ContainerId: &refs.ContainerID{Value: []byte{}}, + ObjectId: &refs.ObjectID{Value: []byte{}}, + }, + { + ContainerId: &refs.ContainerID{Value: apitest.RandomBytes[[]byte]()}, + ObjectId: &refs.ObjectID{Value: apitest.RandomBytes[[]byte]()}, + }, + }) +} + +func TestVersion_MarshalStable(t *testing.T) { + apitest.TestMarshalStable(t, apitest.AssertEqualVersions, []*refs.Version{ + nil, + new(refs.Version), + {Major: apitest.RandomInteger[uint32]()}, + {Minor: apitest.RandomInteger[uint32]()}, + { + Major: apitest.RandomInteger[uint32](), + Minor: apitest.RandomInteger[uint32](), + }, + }) +} + +func TestSignature_MarshalStable(t *testing.T) { + apitest.TestMarshalStable(t, apitest.AssertEqualSignatures, []*refs.Signature{ + nil, + new(refs.Signature), + {Key: []byte{}, Sign: []byte{}}, + { + Key: apitest.RandomBytes[[]byte](), + Sign: apitest.RandomBytes[[]byte](), + Scheme: apitest.RandomInteger[refs.SignatureScheme](), + }, + }) +} + +func TestSignatureRFC6979_MarshalStable(t *testing.T) { + apitest.TestMarshalStable(t, apitest.AssertEqualSignaturesRFC6979, []*refs.SignatureRFC6979{ + nil, + new(refs.SignatureRFC6979), + {Key: []byte{}, Sign: []byte{}}, + { + Key: apitest.RandomBytes[[]byte](), + Sign: apitest.RandomBytes[[]byte](), + }, + }) +} + +func TestChecksum_MarshalStable(t *testing.T) { + apitest.TestMarshalStable(t, apitest.AssertEqualChecksums, []*refs.Checksum{ + nil, + new(refs.Checksum), + {Sum: []byte{}}, + { + Type: apitest.RandomInteger[refs.ChecksumType](), + Sum: apitest.RandomBytes[[]byte](), + }, + }) +} + +func assertEqualSubnetIDs(t testing.TB, v1, v2 *refs.SubnetID, msg string) { + require.Equal(t, v1.GetValue(), v2.GetValue(), msg) +} + +func TestSubnetID(t *testing.T) { + apitest.TestMarshalStable(t, assertEqualSubnetIDs, []*refs.SubnetID{ + nil, + new(refs.SubnetID), + {Value: apitest.RandomInteger[uint32]()}, + }) +} diff --git a/api/reputation/encoding.go b/api/reputation/encoding.go new file mode 100644 index 00000000..1dfd5e77 --- /dev/null +++ b/api/reputation/encoding.go @@ -0,0 +1,193 @@ +package reputation + +import "github.com/nspcc-dev/neofs-sdk-go/internal/proto" + +const ( + _ = iota + fieldPeerPubKey +) + +// MarshaledSize returns size of the PeerID in Protocol Buffers V3 format in +// bytes. MarshaledSize is NPE-safe. +func (x *PeerID) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeBytes(fieldPeerPubKey, x.PublicKey) + } + return sz +} + +// MarshalStable writes the PeerID in Protocol Buffers V3 format with ascending +// order of fields by number into b. MarshalStable uses exactly +// [PeerID.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *PeerID) MarshalStable(b []byte) { + if x != nil { + proto.MarshalToBytes(b, fieldPeerPubKey, x.PublicKey) + } +} + +const ( + _ = iota + fieldTrustPeer + fieldTrustValue +) + +// MarshaledSize returns size of the Trust in Protocol Buffers V3 format in +// bytes. MarshaledSize is NPE-safe. +func (x *Trust) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldTrustPeer, x.Peer) + + proto.SizeDouble(fieldTrustValue, x.Value) + } + return sz +} + +// MarshalStable writes the Trust in Protocol Buffers V3 format with ascending +// order of fields by number into b. MarshalStable uses exactly +// [Trust.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *Trust) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToEmbedded(b, fieldTrustPeer, x.Peer) + proto.MarshalToDouble(b[off:], fieldTrustValue, x.Value) + } +} + +const ( + _ = iota + fieldP2PTrustPeer + fieldP2PTrustValue +) + +// MarshaledSize returns size of the PeerToPeerTrust in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *PeerToPeerTrust) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldP2PTrustPeer, x.TrustingPeer) + + proto.SizeEmbedded(fieldP2PTrustValue, x.Trust) + } + return sz +} + +// MarshalStable writes the PeerToPeerTrust in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [PeerToPeerTrust.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *PeerToPeerTrust) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToEmbedded(b, fieldP2PTrustPeer, x.TrustingPeer) + proto.MarshalToEmbedded(b[off:], fieldP2PTrustValue, x.Trust) + } +} + +const ( + _ = iota + fieldGlobalTrustBodyManager + fieldGlobalTrustBodyValue +) + +// MarshaledSize returns size of the GlobalTrust_Body in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *GlobalTrust_Body) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldGlobalTrustBodyManager, x.Manager) + + proto.SizeEmbedded(fieldGlobalTrustBodyValue, x.Trust) + } + return sz +} + +// MarshalStable writes the GlobalTrust_Body in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [GlobalTrust_Body.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *GlobalTrust_Body) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToEmbedded(b, fieldGlobalTrustBodyManager, x.Manager) + proto.MarshalToEmbedded(b[off:], fieldGlobalTrustBodyValue, x.Trust) + } +} + +const ( + _ = iota + fieldAnnounceLocalReqEpoch + fieldAnnounceLocalReqTrusts +) + +// MarshaledSize returns size of the AnnounceLocalTrustRequest_Body in Protocol +// Buffers V3 format in bytes. MarshaledSize is NPE-safe. +func (x *AnnounceLocalTrustRequest_Body) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeVarint(fieldAnnounceLocalReqEpoch, x.Epoch) + for i := range x.Trusts { + sz += proto.SizeEmbedded(fieldAnnounceLocalReqTrusts, x.Trusts[i]) + } + } + return sz +} + +// MarshalStable writes the AnnounceLocalTrustRequest_Body in Protocol Buffers +// V3 format with ascending order of fields by number into b. MarshalStable uses +// exactly [AnnounceLocalTrustRequest_Body.MarshaledSize] first bytes of b. +// MarshalStable is NPE-safe. +func (x *AnnounceLocalTrustRequest_Body) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToVarint(b, fieldAnnounceLocalReqEpoch, x.Epoch) + for i := range x.Trusts { + off += proto.MarshalToEmbedded(b[off:], fieldAnnounceLocalReqTrusts, x.Trusts[i]) + } + } +} + +// MarshaledSize returns size of the AnnounceLocalTrustResponse_Body in Protocol +// Buffers V3 format in bytes. MarshaledSize is NPE-safe. +func (x *AnnounceLocalTrustResponse_Body) MarshaledSize() int { return 0 } + +// MarshalStable writes the AnnounceLocalTrustResponse_Body in Protocol Buffers +// V3 format with ascending order of fields by number into b. MarshalStable uses +// exactly [AnnounceLocalTrustResponse_Body.MarshaledSize] first bytes of b. +// MarshalStable is NPE-safe. +func (x *AnnounceLocalTrustResponse_Body) MarshalStable([]byte) {} + +const ( + _ = iota + fieldAnnounceIntermediateReqEpoch + fieldAnnounceIntermediateReqIter + fieldAnnounceIntermediateReqTrust +) + +// MarshaledSize returns size of the AnnounceIntermediateResultRequest_Body in +// Protocol Buffers V3 format in bytes. MarshaledSize is NPE-safe. +func (x *AnnounceIntermediateResultRequest_Body) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeVarint(fieldAnnounceIntermediateReqEpoch, x.Epoch) + + proto.SizeVarint(fieldAnnounceIntermediateReqIter, x.Iteration) + + proto.SizeEmbedded(fieldAnnounceIntermediateReqTrust, x.Trust) + } + return sz +} + +// MarshalStable writes the AnnounceIntermediateResultRequest_Body in Protocol +// Buffers V3 format with ascending order of fields by number into b. +// MarshalStable uses exactly +// [AnnounceIntermediateResultRequest_Body.MarshaledSize] first bytes of b. +// MarshalStable is NPE-safe. +func (x *AnnounceIntermediateResultRequest_Body) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToVarint(b, fieldAnnounceIntermediateReqEpoch, x.Epoch) + off += proto.MarshalToVarint(b[off:], fieldAnnounceIntermediateReqIter, x.Iteration) + proto.MarshalToEmbedded(b[off:], fieldAnnounceIntermediateReqIter, x.Trust) + } +} + +// MarshaledSize returns size of the AnnounceIntermediateResultResponse_Body in +// Protocol Buffers V3 format in bytes. MarshaledSize is NPE-safe. +func (x *AnnounceIntermediateResultResponse_Body) MarshaledSize() int { return 0 } + +// MarshalStable writes the AnnounceIntermediateResultResponse_Body in Protocol +// Buffers V3 format with ascending order of fields by number into b. +// MarshalStable uses exactly +// [AnnounceIntermediateResultResponse_Body.MarshaledSize] first bytes of b. +// MarshalStable is NPE-safe. +func (x *AnnounceIntermediateResultResponse_Body) MarshalStable([]byte) {} diff --git a/api/reputation/encoding_test.go b/api/reputation/encoding_test.go new file mode 100644 index 00000000..8521eba5 --- /dev/null +++ b/api/reputation/encoding_test.go @@ -0,0 +1,3 @@ +package reputation_test + +// TODO diff --git a/api/session/encoding.go b/api/session/encoding.go new file mode 100644 index 00000000..755785c0 --- /dev/null +++ b/api/session/encoding.go @@ -0,0 +1,456 @@ +package session + +import ( + "fmt" + + "github.com/nspcc-dev/neofs-sdk-go/internal/proto" +) + +const ( + _ = iota + fieldTokenObjectTargetContainer + fieldTokenObjectTargetIDs +) + +// MarshaledSize returns size of the ObjectSessionContext_Target in Protocol +// Buffers V3 format in bytes. MarshaledSize is NPE-safe. +func (x *ObjectSessionContext_Target) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldTokenObjectTargetContainer, x.Container) + for i := range x.Objects { + sz += proto.SizeEmbedded(fieldTokenObjectTargetIDs, x.Objects[i]) + } + } + return sz +} + +// MarshalStable writes the ObjectSessionContext_Target in Protocol Buffers V3 +// format with ascending order of fields by number into b. MarshalStable uses +// exactly [ObjectSessionContext_Target.MarshaledSize] first bytes of b. +// MarshalStable is NPE-safe. +func (x *ObjectSessionContext_Target) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToEmbedded(b, fieldTokenObjectTargetContainer, x.Container) + for i := range x.Objects { + off += proto.MarshalToEmbedded(b[off:], fieldTokenObjectTargetIDs, x.Objects[i]) + } + } +} + +const ( + _ = iota + fieldTokenObjectVerb + fieldTokenObjectTarget +) + +// MarshaledSize returns size of the ObjectSessionContext in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *ObjectSessionContext) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeVarint(fieldTokenObjectVerb, int32(x.Verb)) + + proto.SizeEmbedded(fieldTokenObjectTarget, x.Target) + } + return sz +} + +// MarshalStable writes the ObjectSessionContext in Protocol Buffers V3 format +// with ascending order of fields by number into b. MarshalStable uses exactly +// [ObjectSessionContext.MarshaledSize] first bytes of b. MarshalStable is +// NPE-safe. +func (x *ObjectSessionContext) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToVarint(b, fieldTokenObjectVerb, int32(x.Verb)) + proto.MarshalToEmbedded(b[off:], fieldTokenObjectTarget, x.Target) + } +} + +const ( + _ = iota + fieldTokenContainerVerb + fieldTokenContainerWildcard + fieldTokenContainerID +) + +// MarshaledSize returns size of the ContainerSessionContext in Protocol Buffers +// V3 format in bytes. MarshaledSize is NPE-safe. +func (x *ContainerSessionContext) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeVarint(fieldTokenContainerVerb, int32(x.Verb)) + + proto.SizeBool(fieldTokenContainerWildcard, x.Wildcard) + + proto.SizeEmbedded(fieldTokenContainerID, x.ContainerId) + } + return sz +} + +// MarshalStable writes the ContainerSessionContext in Protocol Buffers V3 +// format with ascending order of fields by number into b. MarshalStable uses +// exactly [ContainerSessionContext.MarshaledSize] first bytes of b. +// MarshalStable is NPE-safe. +func (x *ContainerSessionContext) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToVarint(b, fieldTokenContainerVerb, int32(x.Verb)) + off += proto.MarshalToBool(b[off:], fieldTokenContainerWildcard, x.Wildcard) + proto.MarshalToEmbedded(b[off:], fieldTokenContainerID, x.ContainerId) + } +} + +const ( + _ = iota + fieldTokenExp + fieldTokenNbf + fieldTokenIat +) + +// MarshaledSize returns size of the SessionToken_Body_TokenLifetime in Protocol +// Buffers V3 format in bytes. MarshaledSize is NPE-safe. +func (x *SessionToken_Body_TokenLifetime) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeVarint(fieldTokenExp, x.Exp) + + proto.SizeVarint(fieldTokenNbf, x.Nbf) + + proto.SizeVarint(fieldTokenIat, x.Iat) + + } + return sz +} + +// MarshalStable writes the SessionToken_Body_TokenLifetime in Protocol Buffers +// V3 format with ascending order of fields by number into b. MarshalStable uses +// exactly [SessionToken_Body_TokenLifetime.MarshaledSize] first bytes of b. +// MarshalStable is NPE-safe. +func (x *SessionToken_Body_TokenLifetime) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToVarint(b, fieldTokenExp, x.Exp) + off += proto.MarshalToVarint(b[off:], fieldTokenNbf, x.Nbf) + proto.MarshalToVarint(b[off:], fieldTokenIat, x.Iat) + } +} + +const ( + _ = iota + fieldTokenID + fieldTokenOwner + fieldTokenLifetime + fieldTokenSessionKey + fieldTokenContextObject + fieldTokenContextContainer +) + +// MarshaledSize returns size of the SessionToken_Body in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *SessionToken_Body) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeBytes(fieldTokenID, x.Id) + + proto.SizeEmbedded(fieldTokenOwner, x.OwnerId) + + proto.SizeEmbedded(fieldTokenLifetime, x.Lifetime) + + proto.SizeBytes(fieldTokenSessionKey, x.SessionKey) + switch c := x.Context.(type) { + default: + panic(fmt.Sprintf("unexpected context %T", x.Context)) + case nil: + case *SessionToken_Body_Object: + sz += proto.SizeEmbedded(fieldTokenContextObject, c.Object) + case *SessionToken_Body_Container: + sz += proto.SizeEmbedded(fieldTokenContextContainer, c.Container) + } + } + return sz +} + +// MarshalStable writes the SessionToken_Body in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [SessionToken_Body.MarshaledSize] first bytes of b. MarshalStable is +// NPE-safe. +func (x *SessionToken_Body) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToBytes(b, fieldTokenID, x.Id) + off += proto.MarshalToEmbedded(b[off:], fieldTokenOwner, x.OwnerId) + off += proto.MarshalToEmbedded(b[off:], fieldTokenLifetime, x.Lifetime) + off += proto.MarshalToBytes(b[off:], fieldTokenSessionKey, x.SessionKey) + switch c := x.Context.(type) { + default: + panic(fmt.Sprintf("unexpected context %T", x.Context)) + case nil: + case *SessionToken_Body_Object: + proto.MarshalToEmbedded(b[off:], fieldTokenContextObject, c.Object) + case *SessionToken_Body_Container: + proto.MarshalToEmbedded(b[off:], fieldTokenContextContainer, c.Container) + } + } +} + +const ( + _ = iota + fieldTokenBody + fieldTokenSignature +) + +// MarshaledSize returns size of the SessionToken in Protocol Buffers V3 format +// in bytes. MarshaledSize is NPE-safe. +func (x *SessionToken) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldTokenBody, x.Body) + + proto.SizeEmbedded(fieldTokenSignature, x.Signature) + } + return sz +} + +// MarshalStable writes the SessionToken in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [SessionToken.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *SessionToken) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToEmbedded(b, fieldTokenBody, x.Body) + proto.MarshalToEmbedded(b[off:], fieldTokenSignature, x.Signature) + } +} + +const ( + _ = iota + fieldCreateReqUser + fieldCreateReqExp +) + +// MarshaledSize returns size of the CreateRequest_Body in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *CreateRequest_Body) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldCreateReqUser, x.OwnerId) + + proto.SizeVarint(fieldCreateReqExp, x.Expiration) + } + return sz +} + +// MarshalStable writes the CreateRequest_Body in Protocol Buffers V3 format +// with ascending order of fields by number into b. MarshalStable uses exactly +// [CreateRequest_Body.MarshaledSize] first bytes of b. MarshalStable is +// NPE-safe. +func (x *CreateRequest_Body) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToEmbedded(b, fieldCreateReqUser, x.OwnerId) + proto.MarshalToVarint(b[off:], fieldCreateReqExp, x.Expiration) + } +} + +const ( + _ = iota + fieldCreateRespID + fieldCreateRespSessionKey +) + +// MarshaledSize returns size of the CreateResponse_Body in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *CreateResponse_Body) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeBytes(fieldCreateRespID, x.Id) + + proto.SizeBytes(fieldCreateRespSessionKey, x.SessionKey) + } + return sz +} + +// MarshalStable writes the CreateResponse_Body in Protocol Buffers V3 format +// with ascending order of fields by number into b. MarshalStable uses exactly +// [CreateResponse_Body.MarshaledSize] first bytes of b. MarshalStable is +// NPE-safe. +func (x *CreateResponse_Body) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToBytes(b, fieldCreateRespID, x.Id) + proto.MarshalToBytes(b[off:], fieldCreateRespSessionKey, x.SessionKey) + } +} + +const ( + _ = iota + fieldXHeaderKey + fieldXHeaderValue +) + +// MarshaledSize returns size of the XHeader in Protocol Buffers V3 format in +// bytes. MarshaledSize is NPE-safe. +func (x *XHeader) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeBytes(fieldXHeaderKey, x.Key) + + proto.SizeBytes(fieldXHeaderValue, x.Value) + } + return sz +} + +// MarshalStable writes the XHeader in Protocol Buffers V3 format with ascending +// order of fields by number into b. MarshalStable uses exactly +// [XHeader.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *XHeader) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToBytes(b, fieldXHeaderKey, x.Key) + proto.MarshalToBytes(b[off:], fieldXHeaderValue, x.Value) + } +} + +const ( + _ = iota + fieldReqMetaVersion + fieldReqMetaEpoch + fieldReqMetaTTL + fieldReqMetaXHeaders + fieldReqMetaSession + fieldReqMetaBearer + fieldReqMetaOrigin + fieldReqMetaNetMagic +) + +// MarshaledSize returns size of the RequestMetaHeader in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *RequestMetaHeader) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldReqMetaVersion, x.Version) + + proto.SizeVarint(fieldReqMetaEpoch, x.Epoch) + + proto.SizeVarint(fieldReqMetaTTL, x.Ttl) + + proto.SizeEmbedded(fieldReqMetaSession, x.SessionToken) + + proto.SizeEmbedded(fieldReqMetaBearer, x.BearerToken) + + proto.SizeEmbedded(fieldReqMetaOrigin, x.Origin) + + proto.SizeVarint(fieldReqMetaNetMagic, x.MagicNumber) + for i := range x.XHeaders { + sz += proto.SizeEmbedded(fieldReqMetaXHeaders, x.XHeaders[i]) + } + } + return sz +} + +// MarshalStable writes the RequestMetaHeader in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [RequestMetaHeader.MarshaledSize] first bytes of b. MarshalStable is +// NPE-safe. +func (x *RequestMetaHeader) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToEmbedded(b, fieldReqMetaVersion, x.Version) + off += proto.MarshalToVarint(b[off:], fieldReqMetaEpoch, x.Epoch) + off += proto.MarshalToVarint(b[off:], fieldReqMetaTTL, x.Ttl) + for i := range x.XHeaders { + off += proto.MarshalToEmbedded(b[off:], fieldReqMetaXHeaders, x.XHeaders[i]) + } + off += proto.MarshalToEmbedded(b[off:], fieldReqMetaSession, x.SessionToken) + off += proto.MarshalToEmbedded(b[off:], fieldReqMetaBearer, x.BearerToken) + off += proto.MarshalToEmbedded(b[off:], fieldReqMetaOrigin, x.Origin) + off += proto.MarshalToVarint(b[off:], fieldReqMetaNetMagic, x.MagicNumber) + } +} + +const ( + _ = iota + fieldRespMetaVersion + fieldRespMetaEpoch + fieldRespMetaTTL + fieldRespMetaXHeaders + fieldRespMetaOrigin + fieldRespMetaStatus +) + +// MarshaledSize returns size of the ResponseMetaHeader in Protocol Buffers V3 +// format in bytes. MarshaledSize is NPE-safe. +func (x *ResponseMetaHeader) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldRespMetaVersion, x.Version) + + proto.SizeVarint(fieldRespMetaEpoch, x.Epoch) + + proto.SizeVarint(fieldRespMetaTTL, x.Ttl) + + proto.SizeEmbedded(fieldRespMetaOrigin, x.Origin) + + proto.SizeEmbedded(fieldRespMetaStatus, x.Status) + for i := range x.XHeaders { + sz += proto.SizeEmbedded(fieldRespMetaXHeaders, x.XHeaders[i]) + } + } + return sz +} + +// MarshalStable writes the ResponseMetaHeader in Protocol Buffers V3 format +// with ascending order of fields by number into b. MarshalStable uses exactly +// [ResponseMetaHeader.MarshaledSize] first bytes of b. MarshalStable is +// NPE-safe. +func (x *ResponseMetaHeader) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToEmbedded(b, fieldRespMetaVersion, x.Version) + off += proto.MarshalToVarint(b[off:], fieldRespMetaEpoch, x.Epoch) + off += proto.MarshalToVarint(b[off:], fieldRespMetaTTL, x.Ttl) + for i := range x.XHeaders { + off += proto.MarshalToEmbedded(b[off:], fieldRespMetaXHeaders, x.XHeaders[i]) + } + off += proto.MarshalToEmbedded(b[off:], fieldRespMetaOrigin, x.Origin) + off += proto.MarshalToEmbedded(b[off:], fieldRespMetaStatus, x.Status) + } +} + +const ( + _ = iota + fieldReqVerifyBodySignature + fieldReqVerifyMetaSignature + fieldReqVerifyOriginSignature + fieldReqVerifyOrigin +) + +// MarshaledSize returns size of the RequestVerificationHeader in Protocol +// Buffers V3 format in bytes. MarshaledSize is NPE-safe. +func (x *RequestVerificationHeader) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldReqVerifyBodySignature, x.BodySignature) + + proto.SizeEmbedded(fieldReqVerifyMetaSignature, x.MetaSignature) + + proto.SizeEmbedded(fieldReqVerifyOriginSignature, x.OriginSignature) + + proto.SizeEmbedded(fieldReqVerifyOrigin, x.Origin) + } + return sz +} + +// MarshalStable writes the RequestVerificationHeader in Protocol Buffers V3 +// format with ascending order of fields by number into b. MarshalStable uses +// exactly [RequestVerificationHeader.MarshaledSize] first bytes of b. +// MarshalStable is NPE-safe. +func (x *RequestVerificationHeader) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToEmbedded(b, fieldReqVerifyBodySignature, x.BodySignature) + off += proto.MarshalToEmbedded(b[off:], fieldReqVerifyMetaSignature, x.MetaSignature) + off += proto.MarshalToEmbedded(b[off:], fieldReqVerifyOriginSignature, x.OriginSignature) + proto.MarshalToEmbedded(b[off:], fieldReqVerifyOrigin, x.Origin) + } +} + +const ( + _ = iota + fieldRespVerifyBodySignature + fieldRespVerifyMetaSignature + fieldRespVerifyOriginSignature + fieldRespVerifyOrigin +) + +// MarshaledSize returns size of the ResponseVerificationHeader in Protocol +// Buffers V3 format in bytes. MarshaledSize is NPE-safe. +func (x *ResponseVerificationHeader) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldRespVerifyBodySignature, x.BodySignature) + + proto.SizeEmbedded(fieldRespVerifyMetaSignature, x.MetaSignature) + + proto.SizeEmbedded(fieldRespVerifyOriginSignature, x.OriginSignature) + + proto.SizeEmbedded(fieldRespVerifyOrigin, x.Origin) + } + return sz +} + +// MarshalStable writes the ResponseVerificationHeader in Protocol Buffers V3 +// format with ascending order of fields by number into b. MarshalStable uses +// exactly [ResponseVerificationHeader.MarshaledSize] first bytes of b. +// MarshalStable is NPE-safe. +func (x *ResponseVerificationHeader) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToEmbedded(b, fieldRespVerifyBodySignature, x.BodySignature) + off += proto.MarshalToEmbedded(b[off:], fieldRespVerifyMetaSignature, x.MetaSignature) + off += proto.MarshalToEmbedded(b[off:], fieldRespVerifyOriginSignature, x.OriginSignature) + proto.MarshalToEmbedded(b[off:], fieldRespVerifyOrigin, x.Origin) + } +} diff --git a/api/session/encoding_test.go b/api/session/encoding_test.go new file mode 100644 index 00000000..81f09f28 --- /dev/null +++ b/api/session/encoding_test.go @@ -0,0 +1,3 @@ +package session_test + +// TODO diff --git a/api/status/encoding.go b/api/status/encoding.go new file mode 100644 index 00000000..1a185146 --- /dev/null +++ b/api/status/encoding.go @@ -0,0 +1,66 @@ +package status + +import ( + "github.com/nspcc-dev/neofs-sdk-go/internal/proto" +) + +const ( + _ = iota + fieldDetailID + fieldDetailValue +) + +// MarshaledSize returns size of the Status_Detail in Protocol Buffers V3 format +// in bytes. MarshaledSize is NPE-safe. +func (x *Status_Detail) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeVarint(fieldDetailID, x.Id) + + proto.SizeBytes(fieldDetailValue, x.Value) + } + return sz +} + +// MarshalStable writes the Status_Detail in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [Status_Detail.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *Status_Detail) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToVarint(b, fieldDetailID, x.Id) + proto.MarshalToBytes(b[off:], fieldDetailValue, x.Value) + } +} + +const ( + _ = iota + fieldStatusCode + fieldStatusMessage + fieldStatusDetails +) + +// MarshaledSize returns size of the Status in Protocol Buffers V3 format in +// bytes. MarshaledSize is NPE-safe. +func (x *Status) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeVarint(fieldStatusCode, x.Code) + + proto.SizeBytes(fieldStatusMessage, x.Message) + for i := range x.Details { + sz += proto.SizeEmbedded(fieldStatusDetails, x.Details[i]) + } + } + return sz +} + +// MarshalStable writes the Status in Protocol Buffers V3 format with ascending +// order of fields by number into b. MarshalStable uses exactly +// [Status.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *Status) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToVarint(b, fieldStatusCode, x.Code) + off += proto.MarshalToBytes(b[off:], fieldStatusMessage, x.Message) + for i := range x.Details { + off += proto.MarshalToEmbedded(b[off:], fieldStatusDetails, x.Details[i]) + } + } +} diff --git a/api/status/encoding_test.go b/api/status/encoding_test.go new file mode 100644 index 00000000..99cdcf04 --- /dev/null +++ b/api/status/encoding_test.go @@ -0,0 +1,3 @@ +package status_test + +// TODO diff --git a/api/storagegroup/encoding.go b/api/storagegroup/encoding.go new file mode 100644 index 00000000..b25adad4 --- /dev/null +++ b/api/storagegroup/encoding.go @@ -0,0 +1,40 @@ +package storagegroup + +import "github.com/nspcc-dev/neofs-sdk-go/internal/proto" + +const ( + _ = iota + fieldStorageGroupSize + fieldStorageGroupHash + fieldStorageGroupExp + fieldStorageGroupMembers +) + +// MarshaledSize returns size of the StorageGroup in Protocol Buffers V3 format +// in bytes. MarshaledSize is NPE-safe. +func (x *StorageGroup) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeVarint(fieldStorageGroupSize, x.ValidationDataSize) + sz += proto.SizeEmbedded(fieldStorageGroupHash, x.ValidationHash) + sz += proto.SizeVarint(fieldStorageGroupExp, x.ExpirationEpoch) + for i := range x.Members { + sz += proto.SizeEmbedded(fieldStorageGroupMembers, x.Members[i]) + } + } + return sz +} + +// MarshalStable writes the StorageGroup in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [StorageGroup.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *StorageGroup) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToVarint(b, fieldStorageGroupSize, x.ValidationDataSize) + off += proto.MarshalToEmbedded(b[off:], fieldStorageGroupHash, x.ValidationHash) + off += proto.MarshalToVarint(b[off:], fieldStorageGroupExp, x.ExpirationEpoch) + for i := range x.Members { + off += proto.MarshalToEmbedded(b[off:], fieldStorageGroupMembers, x.Members[i]) + } + } +} diff --git a/api/storagegroup/encoding_test.go b/api/storagegroup/encoding_test.go new file mode 100644 index 00000000..f47fab4d --- /dev/null +++ b/api/storagegroup/encoding_test.go @@ -0,0 +1,3 @@ +package storagegroup_test + +// TODO diff --git a/api/subnet/encoding.go b/api/subnet/encoding.go new file mode 100644 index 00000000..255221eb --- /dev/null +++ b/api/subnet/encoding.go @@ -0,0 +1,30 @@ +package subnet + +import "github.com/nspcc-dev/neofs-sdk-go/internal/proto" + +const ( + _ = iota + fieldSubnetInfoID + fieldSubnetInfoOwner +) + +// MarshaledSize returns size of the SubnetInfo in Protocol Buffers V3 format in +// bytes. MarshaledSize is NPE-safe. +func (x *SubnetInfo) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeEmbedded(fieldSubnetInfoID, x.Id) + sz += proto.SizeEmbedded(fieldSubnetInfoOwner, x.Owner) + } + return sz +} + +// MarshalStable writes the SubnetInfo in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [SubnetInfo.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *SubnetInfo) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToEmbedded(b, fieldSubnetInfoID, x.Id) + proto.MarshalToEmbedded(b[off:], fieldSubnetInfoOwner, x.Owner) + } +} diff --git a/api/subnet/encoding_test.go b/api/subnet/encoding_test.go new file mode 100644 index 00000000..fb683660 --- /dev/null +++ b/api/subnet/encoding_test.go @@ -0,0 +1,3 @@ +package subnet_test + +// TODO diff --git a/api/tombstone/encoding.go b/api/tombstone/encoding.go new file mode 100644 index 00000000..accc5d02 --- /dev/null +++ b/api/tombstone/encoding.go @@ -0,0 +1,37 @@ +package tombstone + +import "github.com/nspcc-dev/neofs-sdk-go/internal/proto" + +const ( + _ = iota + fieldTombstoneExp + fieldTombstoneSplitID + fieldTombstoneMembers +) + +// MarshaledSize returns size of the Tombstone in Protocol Buffers V3 format in +// bytes. MarshaledSize is NPE-safe. +func (x *Tombstone) MarshaledSize() int { + var sz int + if x != nil { + sz = proto.SizeVarint(fieldTombstoneExp, x.ExpirationEpoch) + sz += proto.SizeBytes(fieldTombstoneSplitID, x.SplitId) + for i := range x.Members { + sz += proto.SizeEmbedded(fieldTombstoneMembers, x.Members[i]) + } + } + return sz +} + +// MarshalStable writes the Tombstone in Protocol Buffers V3 format with +// ascending order of fields by number into b. MarshalStable uses exactly +// [Tombstone.MarshaledSize] first bytes of b. MarshalStable is NPE-safe. +func (x *Tombstone) MarshalStable(b []byte) { + if x != nil { + off := proto.MarshalToVarint(b, fieldTombstoneExp, x.ExpirationEpoch) + off += proto.MarshalToBytes(b[off:], fieldTombstoneSplitID, x.SplitId) + for i := range x.Members { + off += proto.MarshalToEmbedded(b[off:], fieldTombstoneMembers, x.Members[i]) + } + } +} diff --git a/api/tombstone/encoding_test.go b/api/tombstone/encoding_test.go new file mode 100644 index 00000000..03913b48 --- /dev/null +++ b/api/tombstone/encoding_test.go @@ -0,0 +1,3 @@ +package tombstone_test + +// TODO