frostfs-api-go/v2/service/marshal.go
Alex Vanin c214d4d763 Add stable marshal for service package
Signed-off-by: Alex Vanin <alexey@nspcc.ru>
2020-09-18 10:42:46 +03:00

1118 lines
22 KiB
Go

package service
import (
"encoding/binary"
"github.com/nspcc-dev/neofs-api-go/util/proto"
)
const (
signatureKeyField = 1
signatureValueField = 2
versionMajorField = 1
versionMinorField = 2
xheaderKeyField = 1
xheaderValueField = 2
lifetimeExpirationField = 1
lifetimeNotValidBeforeField = 2
lifetimeIssuedAtField = 3
objectCtxVerbField = 1
objectCtxAddressField = 2
sessionTokenBodyIDField = 1
sessionTokenBodyOwnerField = 2
sessionTokenBodyLifetimeField = 3
sessionTokenBodyKeyField = 4
sessionTokenBodyObjectCtxField = 5
sessionTokenBodyField = 1
sessionTokenSignatureField = 2
bearerTokenBodyACLField = 1
bearerTokenBodyOwnerField = 2
bearerTokenBodyLifetimeField = 3
bearerTokenBodyField = 1
bearerTokenSignatureField = 2
reqMetaHeaderVersionField = 1
reqMetaHeaderEpochField = 2
reqMetaHeaderTTLField = 3
reqMetaHeaderXHeadersField = 4
reqMetaHeaderSessionTokenField = 5
reqMetaHeaderBearerTokenField = 6
reqMetaHeaderOriginField = 7
reqVerifHeaderBodySignatureField = 1
reqVerifHeaderMetaSignatureField = 2
reqVerifHeaderOriginSignatureField = 3
reqVerifHeaderOriginField = 4
respMetaHeaderVersionField = 1
respMetaHeaderEpochField = 2
respMetaHeaderTTLField = 3
respMetaHeaderXHeadersField = 4
respMetaHeaderOriginField = 5
respVerifHeaderBodySignatureField = 1
respVerifHeaderMetaSignatureField = 2
respVerifHeaderOriginSignatureField = 3
respVerifHeaderOriginField = 4
)
func (s *Signature) StableMarshal(buf []byte) ([]byte, error) {
if s == nil {
return []byte{}, nil
}
if buf == nil {
buf = make([]byte, s.StableSize())
}
var (
offset, n int
err error
)
n, err = proto.BytesMarshal(signatureKeyField, buf, s.key)
if err != nil {
return nil, err
}
offset += n
_, err = proto.BytesMarshal(signatureValueField, buf[offset:], s.sign)
if err != nil {
return nil, err
}
return buf, nil
}
func (s *Signature) StableSize() (size int) {
if s == nil {
return 0
}
size += proto.BytesSize(signatureKeyField, s.key)
size += proto.BytesSize(signatureValueField, s.sign)
return size
}
func (v *Version) StableMarshal(buf []byte) ([]byte, error) {
if v == nil {
return []byte{}, nil
}
if buf == nil {
buf = make([]byte, v.StableSize())
}
var (
offset, n int
err error
)
n, err = proto.UInt32Marshal(versionMajorField, buf, v.major)
if err != nil {
return nil, err
}
offset += n
_, err = proto.UInt32Marshal(versionMinorField, buf[offset:], v.minor)
if err != nil {
return nil, err
}
return buf, nil
}
func (v *Version) StableSize() (size int) {
if v == nil {
return 0
}
size += proto.UInt32Size(versionMajorField, v.major)
size += proto.UInt32Size(versionMinorField, v.minor)
return size
}
func (x *XHeader) StableMarshal(buf []byte) ([]byte, error) {
if x == nil {
return []byte{}, nil
}
if buf == nil {
buf = make([]byte, x.StableSize())
}
var (
offset, n int
err error
)
n, err = proto.StringMarshal(xheaderKeyField, buf, x.key)
if err != nil {
return nil, err
}
offset += n
_, err = proto.StringMarshal(xheaderValueField, buf[offset:], x.val)
if err != nil {
return nil, err
}
return buf, nil
}
func (x *XHeader) StableSize() (size int) {
if x == nil {
return 0
}
size += proto.StringSize(xheaderKeyField, x.key)
size += proto.StringSize(xheaderValueField, x.val)
return size
}
func (l *TokenLifetime) StableMarshal(buf []byte) ([]byte, error) {
if l == nil {
return []byte{}, nil
}
if buf == nil {
buf = make([]byte, l.StableSize())
}
var (
offset, n int
err error
)
n, err = proto.UInt64Marshal(lifetimeExpirationField, buf, l.exp)
if err != nil {
return nil, err
}
offset += n
n, err = proto.UInt64Marshal(lifetimeNotValidBeforeField, buf[offset:], l.nbf)
if err != nil {
return nil, err
}
offset += n
_, err = proto.UInt64Marshal(lifetimeIssuedAtField, buf[offset:], l.iat)
if err != nil {
return nil, err
}
return buf, nil
}
func (l *TokenLifetime) StableSize() (size int) {
if l == nil {
return 0
}
size += proto.UInt64Size(lifetimeExpirationField, l.exp)
size += proto.UInt64Size(lifetimeNotValidBeforeField, l.nbf)
size += proto.UInt64Size(lifetimeIssuedAtField, l.iat)
return size
}
func (c *ObjectSessionContext) StableMarshal(buf []byte) ([]byte, error) {
if c == nil {
return []byte{}, nil
}
if buf == nil {
buf = make([]byte, c.StableSize())
}
var (
offset, n int
prefix uint64
err error
)
n, err = proto.EnumMarshal(objectCtxVerbField, buf, int32(c.verb))
if err != nil {
return nil, err
}
offset += n
if c.addr != nil {
prefix, _ = proto.NestedStructurePrefix(objectCtxAddressField)
offset += binary.PutUvarint(buf[offset:], prefix)
n = c.addr.StableSize()
offset += binary.PutUvarint(buf[offset:], uint64(n))
_, err = c.addr.StableMarshal(buf[offset:])
if err != nil {
return nil, err
}
}
return buf, nil
}
func (c *ObjectSessionContext) StableSize() (size int) {
if c == nil {
return 0
}
size += proto.EnumSize(objectCtxVerbField, int32(c.verb))
if c.addr != nil {
_, ln := proto.NestedStructurePrefix(objectCtxAddressField)
n := c.addr.StableSize()
size += ln + proto.VarUIntSize(uint64(n)) + n
}
return size
}
func (t *SessionTokenBody) StableMarshal(buf []byte) ([]byte, error) {
if t == nil {
return []byte{}, nil
}
if buf == nil {
buf = make([]byte, t.StableSize())
}
var (
offset, n int
prefix uint64
err error
)
n, err = proto.BytesMarshal(sessionTokenBodyIDField, buf, t.id)
if err != nil {
return nil, err
}
offset += n
if t.ownerID != nil {
prefix, _ = proto.NestedStructurePrefix(sessionTokenBodyOwnerField)
offset += binary.PutUvarint(buf[offset:], prefix)
n = t.ownerID.StableSize()
offset += binary.PutUvarint(buf[offset:], uint64(n))
_, err = t.ownerID.StableMarshal(buf[offset:])
if err != nil {
return nil, err
}
offset += n
}
if t.lifetime != nil {
prefix, _ = proto.NestedStructurePrefix(sessionTokenBodyLifetimeField)
offset += binary.PutUvarint(buf[offset:], prefix)
n = t.lifetime.StableSize()
offset += binary.PutUvarint(buf[offset:], uint64(n))
_, err = t.lifetime.StableMarshal(buf[offset:])
if err != nil {
return nil, err
}
offset += n
}
n, err = proto.BytesMarshal(sessionTokenBodyKeyField, buf[offset:], t.sessionKey)
if err != nil {
return nil, err
}
offset += n
if t.ctx != nil {
switch v := t.ctx.(type) {
case *ObjectSessionContext:
prefix, _ = proto.NestedStructurePrefix(sessionTokenBodyObjectCtxField)
offset += binary.PutUvarint(buf[offset:], prefix)
n = v.StableSize()
offset += binary.PutUvarint(buf[offset:], uint64(n))
_, err = v.StableMarshal(buf[offset:])
if err != nil {
return nil, err
}
default:
panic("cannot marshal unknown session token context")
}
}
return buf, nil
}
func (t *SessionTokenBody) StableSize() (size int) {
if t == nil {
return 0
}
size += proto.BytesSize(sessionTokenBodyIDField, t.id)
if t.ownerID != nil {
_, ln := proto.NestedStructurePrefix(sessionTokenBodyOwnerField)
n := t.ownerID.StableSize()
size += ln + proto.VarUIntSize(uint64(n)) + n
}
if t.lifetime != nil {
_, ln := proto.NestedStructurePrefix(sessionTokenBodyLifetimeField)
n := t.lifetime.StableSize()
size += ln + proto.VarUIntSize(uint64(n)) + n
}
size += proto.BytesSize(sessionTokenBodyKeyField, t.sessionKey)
if t.ctx != nil {
switch v := t.ctx.(type) {
case *ObjectSessionContext:
_, ln := proto.NestedStructurePrefix(sessionTokenBodyObjectCtxField)
n := v.StableSize()
size += ln + proto.VarUIntSize(uint64(n)) + n
default:
panic("cannot marshal unknown session token context")
}
}
return size
}
func (t *SessionToken) StableMarshal(buf []byte) ([]byte, error) {
if t == nil {
return []byte{}, nil
}
if buf == nil {
buf = make([]byte, t.StableSize())
}
var (
offset, n int
prefix uint64
err error
)
if t.body != nil {
prefix, _ = proto.NestedStructurePrefix(sessionTokenBodyField)
offset += binary.PutUvarint(buf[offset:], prefix)
n = t.body.StableSize()
offset += binary.PutUvarint(buf[offset:], uint64(n))
_, err = t.body.StableMarshal(buf[offset:])
if err != nil {
return nil, err
}
offset += n
}
if t.sig != nil {
prefix, _ = proto.NestedStructurePrefix(sessionTokenSignatureField)
offset += binary.PutUvarint(buf[offset:], prefix)
n = t.sig.StableSize()
offset += binary.PutUvarint(buf[offset:], uint64(n))
_, err = t.sig.StableMarshal(buf[offset:])
if err != nil {
return nil, err
}
}
return buf, nil
}
func (t *SessionToken) StableSize() (size int) {
if t == nil {
return 0
}
if t.body != nil {
_, ln := proto.NestedStructurePrefix(sessionTokenBodyField)
n := t.body.StableSize()
size += ln + proto.VarUIntSize(uint64(n)) + n
}
if t.sig != nil {
_, ln := proto.NestedStructurePrefix(sessionTokenSignatureField)
n := t.sig.StableSize()
size += ln + proto.VarUIntSize(uint64(n)) + n
}
return size
}
func (bt *BearerTokenBody) StableMarshal(buf []byte) ([]byte, error) {
if bt == nil {
return []byte{}, nil
}
if buf == nil {
buf = make([]byte, bt.StableSize())
}
var (
offset, n int
prefix uint64
err error
)
if bt.eacl != nil {
prefix, _ = proto.NestedStructurePrefix(bearerTokenBodyACLField)
offset += binary.PutUvarint(buf[offset:], prefix)
n = bt.eacl.StableSize()
offset += binary.PutUvarint(buf[offset:], uint64(n))
_, err = bt.eacl.StableMarshal(buf[offset:])
if err != nil {
return nil, err
}
offset += n
}
if bt.ownerID != nil {
prefix, _ = proto.NestedStructurePrefix(bearerTokenBodyOwnerField)
offset += binary.PutUvarint(buf[offset:], prefix)
n = bt.ownerID.StableSize()
offset += binary.PutUvarint(buf[offset:], uint64(n))
_, err = bt.ownerID.StableMarshal(buf[offset:])
if err != nil {
return nil, err
}
offset += n
}
if bt.lifetime != nil {
prefix, _ = proto.NestedStructurePrefix(bearerTokenBodyLifetimeField)
offset += binary.PutUvarint(buf[offset:], prefix)
n = bt.lifetime.StableSize()
offset += binary.PutUvarint(buf[offset:], uint64(n))
_, err = bt.lifetime.StableMarshal(buf[offset:])
if err != nil {
return nil, err
}
}
return buf, nil
}
func (bt *BearerTokenBody) StableSize() (size int) {
if bt == nil {
return 0
}
if bt.eacl != nil {
_, ln := proto.NestedStructurePrefix(bearerTokenBodyACLField)
n := bt.eacl.StableSize()
size += ln + proto.VarUIntSize(uint64(n)) + n
}
if bt.ownerID != nil {
_, ln := proto.NestedStructurePrefix(bearerTokenBodyOwnerField)
n := bt.ownerID.StableSize()
size += ln + proto.VarUIntSize(uint64(n)) + n
}
if bt.lifetime != nil {
_, ln := proto.NestedStructurePrefix(bearerTokenBodyLifetimeField)
n := bt.lifetime.StableSize()
size += ln + proto.VarUIntSize(uint64(n)) + n
}
return size
}
func (bt *BearerToken) StableMarshal(buf []byte) ([]byte, error) {
if bt == nil {
return []byte{}, nil
}
if buf == nil {
buf = make([]byte, bt.StableSize())
}
var (
offset, n int
prefix uint64
err error
)
if bt.body != nil {
prefix, _ = proto.NestedStructurePrefix(bearerTokenBodyField)
offset += binary.PutUvarint(buf[offset:], prefix)
n = bt.body.StableSize()
offset += binary.PutUvarint(buf[offset:], uint64(n))
_, err = bt.body.StableMarshal(buf[offset:])
if err != nil {
return nil, err
}
offset += n
}
if bt.sig != nil {
prefix, _ = proto.NestedStructurePrefix(bearerTokenSignatureField)
offset += binary.PutUvarint(buf[offset:], prefix)
n = bt.sig.StableSize()
offset += binary.PutUvarint(buf[offset:], uint64(n))
_, err = bt.sig.StableMarshal(buf[offset:])
if err != nil {
return nil, err
}
}
return buf, nil
}
func (bt *BearerToken) StableSize() (size int) {
if bt == nil {
return 0
}
if bt.body != nil {
_, ln := proto.NestedStructurePrefix(bearerTokenBodyField)
n := bt.body.StableSize()
size += ln + proto.VarUIntSize(uint64(n)) + n
}
if bt.sig != nil {
_, ln := proto.NestedStructurePrefix(bearerTokenSignatureField)
n := bt.sig.StableSize()
size += ln + proto.VarUIntSize(uint64(n)) + n
}
return size
}
func (r *RequestMetaHeader) StableMarshal(buf []byte) ([]byte, error) {
if r == nil {
return []byte{}, nil
}
if buf == nil {
buf = make([]byte, r.StableSize())
}
var (
offset, n int
prefix uint64
err error
)
if r.version != nil {
prefix, _ = proto.NestedStructurePrefix(reqMetaHeaderVersionField)
offset += binary.PutUvarint(buf[offset:], prefix)
n = r.version.StableSize()
offset += binary.PutUvarint(buf[offset:], uint64(n))
_, err = r.version.StableMarshal(buf[offset:])
if err != nil {
return nil, err
}
offset += n
}
n, err = proto.UInt64Marshal(reqMetaHeaderEpochField, buf[offset:], r.epoch)
if err != nil {
return nil, err
}
offset += n
n, err = proto.UInt32Marshal(reqMetaHeaderTTLField, buf[offset:], r.ttl)
if err != nil {
return nil, err
}
offset += n
prefix, _ = proto.NestedStructurePrefix(reqMetaHeaderXHeadersField)
for i := range r.xHeaders {
offset += binary.PutUvarint(buf[offset:], prefix)
n = r.xHeaders[i].StableSize()
offset += binary.PutUvarint(buf[offset:], uint64(n))
_, err = r.xHeaders[i].StableMarshal(buf[offset:])
if err != nil {
return nil, err
}
offset += n
}
if r.sessionToken != nil {
prefix, _ = proto.NestedStructurePrefix(reqMetaHeaderSessionTokenField)
offset += binary.PutUvarint(buf[offset:], prefix)
n = r.sessionToken.StableSize()
offset += binary.PutUvarint(buf[offset:], uint64(n))
_, err = r.sessionToken.StableMarshal(buf[offset:])
if err != nil {
return nil, err
}
offset += n
}
if r.bearerToken != nil {
prefix, _ = proto.NestedStructurePrefix(reqMetaHeaderBearerTokenField)
offset += binary.PutUvarint(buf[offset:], prefix)
n = r.bearerToken.StableSize()
offset += binary.PutUvarint(buf[offset:], uint64(n))
_, err = r.bearerToken.StableMarshal(buf[offset:])
if err != nil {
return nil, err
}
offset += n
}
if r.origin != nil {
prefix, _ = proto.NestedStructurePrefix(reqMetaHeaderOriginField)
offset += binary.PutUvarint(buf[offset:], prefix)
n = r.origin.StableSize()
offset += binary.PutUvarint(buf[offset:], uint64(n))
_, err = r.origin.StableMarshal(buf[offset:])
if err != nil {
return nil, err
}
}
return buf, nil
}
func (r *RequestMetaHeader) StableSize() (size int) {
if r == nil {
return 0
}
if r.version != nil {
_, ln := proto.NestedStructurePrefix(reqMetaHeaderVersionField)
n := r.version.StableSize()
size += ln + proto.VarUIntSize(uint64(n)) + n
}
size += proto.UInt64Size(reqMetaHeaderEpochField, r.epoch)
size += proto.UInt32Size(reqMetaHeaderTTLField, r.ttl)
_, ln := proto.NestedStructurePrefix(reqMetaHeaderXHeadersField)
for i := range r.xHeaders {
n := r.xHeaders[i].StableSize()
size += ln + proto.VarUIntSize(uint64(n)) + n
}
if r.sessionToken != nil {
_, ln := proto.NestedStructurePrefix(reqMetaHeaderSessionTokenField)
n := r.sessionToken.StableSize()
size += ln + proto.VarUIntSize(uint64(n)) + n
}
if r.bearerToken != nil {
_, ln := proto.NestedStructurePrefix(reqMetaHeaderBearerTokenField)
n := r.bearerToken.StableSize()
size += ln + proto.VarUIntSize(uint64(n)) + n
}
if r.origin != nil {
_, ln := proto.NestedStructurePrefix(reqMetaHeaderOriginField)
n := r.origin.StableSize()
size += ln + proto.VarUIntSize(uint64(n)) + n
}
return size
}
func (r *RequestVerificationHeader) StableMarshal(buf []byte) ([]byte, error) {
if r == nil {
return []byte{}, nil
}
if buf == nil {
buf = make([]byte, r.StableSize())
}
var (
offset, n int
prefix uint64
err error
)
if r.bodySig != nil {
prefix, _ = proto.NestedStructurePrefix(reqVerifHeaderBodySignatureField)
offset += binary.PutUvarint(buf[offset:], prefix)
n = r.bodySig.StableSize()
offset += binary.PutUvarint(buf[offset:], uint64(n))
_, err = r.bodySig.StableMarshal(buf[offset:])
if err != nil {
return nil, err
}
offset += n
}
if r.metaSig != nil {
prefix, _ = proto.NestedStructurePrefix(reqVerifHeaderMetaSignatureField)
offset += binary.PutUvarint(buf[offset:], prefix)
n = r.metaSig.StableSize()
offset += binary.PutUvarint(buf[offset:], uint64(n))
_, err = r.metaSig.StableMarshal(buf[offset:])
if err != nil {
return nil, err
}
offset += n
}
if r.originSig != nil {
prefix, _ = proto.NestedStructurePrefix(reqVerifHeaderOriginSignatureField)
offset += binary.PutUvarint(buf[offset:], prefix)
n = r.originSig.StableSize()
offset += binary.PutUvarint(buf[offset:], uint64(n))
_, err = r.originSig.StableMarshal(buf[offset:])
if err != nil {
return nil, err
}
offset += n
}
if r.origin != nil {
prefix, _ = proto.NestedStructurePrefix(reqVerifHeaderOriginField)
offset += binary.PutUvarint(buf[offset:], prefix)
n = r.origin.StableSize()
offset += binary.PutUvarint(buf[offset:], uint64(n))
_, err = r.origin.StableMarshal(buf[offset:])
if err != nil {
return nil, err
}
}
return buf, nil
}
func (r *RequestVerificationHeader) StableSize() (size int) {
if r == nil {
return 0
}
if r.bodySig != nil {
_, ln := proto.NestedStructurePrefix(reqVerifHeaderBodySignatureField)
n := r.bodySig.StableSize()
size += ln + proto.VarUIntSize(uint64(n)) + n
}
if r.metaSig != nil {
_, ln := proto.NestedStructurePrefix(reqVerifHeaderMetaSignatureField)
n := r.metaSig.StableSize()
size += ln + proto.VarUIntSize(uint64(n)) + n
}
if r.originSig != nil {
_, ln := proto.NestedStructurePrefix(reqVerifHeaderOriginSignatureField)
n := r.originSig.StableSize()
size += ln + proto.VarUIntSize(uint64(n)) + n
}
if r.origin != nil {
_, ln := proto.NestedStructurePrefix(reqVerifHeaderOriginField)
n := r.origin.StableSize()
size += ln + proto.VarUIntSize(uint64(n)) + n
}
return size
}
func (r *ResponseMetaHeader) StableMarshal(buf []byte) ([]byte, error) {
if r == nil {
return []byte{}, nil
}
if buf == nil {
buf = make([]byte, r.StableSize())
}
var (
offset, n int
prefix uint64
err error
)
if r.version != nil {
prefix, _ = proto.NestedStructurePrefix(respMetaHeaderVersionField)
offset += binary.PutUvarint(buf[offset:], prefix)
n = r.version.StableSize()
offset += binary.PutUvarint(buf[offset:], uint64(n))
_, err = r.version.StableMarshal(buf[offset:])
if err != nil {
return nil, err
}
offset += n
}
n, err = proto.UInt64Marshal(respMetaHeaderEpochField, buf[offset:], r.epoch)
if err != nil {
return nil, err
}
offset += n
n, err = proto.UInt32Marshal(respMetaHeaderTTLField, buf[offset:], r.ttl)
if err != nil {
return nil, err
}
offset += n
prefix, _ = proto.NestedStructurePrefix(respMetaHeaderXHeadersField)
for i := range r.xHeaders {
offset += binary.PutUvarint(buf[offset:], prefix)
n = r.xHeaders[i].StableSize()
offset += binary.PutUvarint(buf[offset:], uint64(n))
_, err = r.xHeaders[i].StableMarshal(buf[offset:])
if err != nil {
return nil, err
}
offset += n
}
if r.origin != nil {
prefix, _ = proto.NestedStructurePrefix(respMetaHeaderOriginField)
offset += binary.PutUvarint(buf[offset:], prefix)
n = r.origin.StableSize()
offset += binary.PutUvarint(buf[offset:], uint64(n))
_, err = r.origin.StableMarshal(buf[offset:])
if err != nil {
return nil, err
}
}
return buf, nil
}
func (r *ResponseMetaHeader) StableSize() (size int) {
if r == nil {
return 0
}
if r.version != nil {
_, ln := proto.NestedStructurePrefix(respMetaHeaderVersionField)
n := r.version.StableSize()
size += ln + proto.VarUIntSize(uint64(n)) + n
}
size += proto.UInt64Size(respMetaHeaderEpochField, r.epoch)
size += proto.UInt32Size(respMetaHeaderTTLField, r.ttl)
_, ln := proto.NestedStructurePrefix(respMetaHeaderXHeadersField)
for i := range r.xHeaders {
n := r.xHeaders[i].StableSize()
size += ln + proto.VarUIntSize(uint64(n)) + n
}
if r.origin != nil {
_, ln := proto.NestedStructurePrefix(respMetaHeaderOriginField)
n := r.origin.StableSize()
size += ln + proto.VarUIntSize(uint64(n)) + n
}
return size
}
func (r *ResponseVerificationHeader) StableMarshal(buf []byte) ([]byte, error) {
if r == nil {
return []byte{}, nil
}
if buf == nil {
buf = make([]byte, r.StableSize())
}
var (
offset, n int
prefix uint64
err error
)
if r.bodySig != nil {
prefix, _ = proto.NestedStructurePrefix(respVerifHeaderBodySignatureField)
offset += binary.PutUvarint(buf[offset:], prefix)
n = r.bodySig.StableSize()
offset += binary.PutUvarint(buf[offset:], uint64(n))
_, err = r.bodySig.StableMarshal(buf[offset:])
if err != nil {
return nil, err
}
offset += n
}
if r.metaSig != nil {
prefix, _ = proto.NestedStructurePrefix(respVerifHeaderMetaSignatureField)
offset += binary.PutUvarint(buf[offset:], prefix)
n = r.metaSig.StableSize()
offset += binary.PutUvarint(buf[offset:], uint64(n))
_, err = r.metaSig.StableMarshal(buf[offset:])
if err != nil {
return nil, err
}
offset += n
}
if r.originSig != nil {
prefix, _ = proto.NestedStructurePrefix(respVerifHeaderOriginSignatureField)
offset += binary.PutUvarint(buf[offset:], prefix)
n = r.originSig.StableSize()
offset += binary.PutUvarint(buf[offset:], uint64(n))
_, err = r.originSig.StableMarshal(buf[offset:])
if err != nil {
return nil, err
}
offset += n
}
if r.origin != nil {
prefix, _ = proto.NestedStructurePrefix(respVerifHeaderOriginField)
offset += binary.PutUvarint(buf[offset:], prefix)
n = r.origin.StableSize()
offset += binary.PutUvarint(buf[offset:], uint64(n))
_, err = r.origin.StableMarshal(buf[offset:])
if err != nil {
return nil, err
}
}
return buf, nil
}
func (r *ResponseVerificationHeader) StableSize() (size int) {
if r == nil {
return 0
}
if r.bodySig != nil {
_, ln := proto.NestedStructurePrefix(respVerifHeaderBodySignatureField)
n := r.bodySig.StableSize()
size += ln + proto.VarUIntSize(uint64(n)) + n
}
if r.metaSig != nil {
_, ln := proto.NestedStructurePrefix(respVerifHeaderMetaSignatureField)
n := r.metaSig.StableSize()
size += ln + proto.VarUIntSize(uint64(n)) + n
}
if r.originSig != nil {
_, ln := proto.NestedStructurePrefix(respVerifHeaderOriginSignatureField)
n := r.originSig.StableSize()
size += ln + proto.VarUIntSize(uint64(n)) + n
}
if r.origin != nil {
_, ln := proto.NestedStructurePrefix(respVerifHeaderOriginField)
n := r.origin.StableSize()
size += ln + proto.VarUIntSize(uint64(n)) + n
}
return size
}