Airat Arifullin
bc16a32c24
All checks were successful
* Add plugin option for protogen in Makefile * Fix the generator for the plugin in util/protogen * Erase convertable types, move helpful methods to gRPC protobufs * Erase helpers for convertations * Generate StableMarshlal/StableSize for protobufs by the protoc plugin Signed-off-by: Airat Arifullin a.arifullin@yadro.com
1317 lines
41 KiB
Go
Generated
1317 lines
41 KiB
Go
Generated
// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
|
|
|
|
package object
|
|
|
|
import "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/util/proto"
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *GetRequest_Body) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Address)
|
|
size += proto.BoolSize(2, x.Raw)
|
|
return size
|
|
}
|
|
|
|
// StableMarshal marshals x in protobuf binary format with stable field order.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *GetRequest_Body) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.NestedStructureMarshal(1, buf[offset:], x.Address)
|
|
offset += proto.BoolMarshal(2, buf[offset:], x.Raw)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *GetRequest) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
size += proto.NestedStructureSize(2, x.MetaHeader)
|
|
size += proto.NestedStructureSize(3, x.VerifyHeader)
|
|
return size
|
|
}
|
|
|
|
// StableMarshal marshals x in protobuf binary format with stable field order.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *GetRequest) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
|
|
offset += proto.NestedStructureMarshal(2, buf[offset:], x.MetaHeader)
|
|
offset += proto.NestedStructureMarshal(3, buf[offset:], x.VerifyHeader)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *GetResponse_Body_Init) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.ObjectId)
|
|
size += proto.NestedStructureSize(2, x.Signature)
|
|
size += proto.NestedStructureSize(3, x.Header)
|
|
return size
|
|
}
|
|
|
|
// StableMarshal marshals x in protobuf binary format with stable field order.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *GetResponse_Body_Init) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.NestedStructureMarshal(1, buf[offset:], x.ObjectId)
|
|
offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
|
|
offset += proto.NestedStructureMarshal(3, buf[offset:], x.Header)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *GetResponse_Body) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
if inner, ok := x.ObjectPart.(*GetResponse_Body_Init_); ok {
|
|
size += proto.NestedStructureSize(1, inner.Init)
|
|
}
|
|
if inner, ok := x.ObjectPart.(*GetResponse_Body_Chunk); ok {
|
|
size += proto.BytesSize(2, inner.Chunk)
|
|
}
|
|
if inner, ok := x.ObjectPart.(*GetResponse_Body_SplitInfo); ok {
|
|
size += proto.NestedStructureSize(3, inner.SplitInfo)
|
|
}
|
|
return size
|
|
}
|
|
|
|
// StableMarshal marshals x in protobuf binary format with stable field order.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *GetResponse_Body) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
if inner, ok := x.ObjectPart.(*GetResponse_Body_Init_); ok {
|
|
offset += proto.NestedStructureMarshal(1, buf[offset:], inner.Init)
|
|
}
|
|
if inner, ok := x.ObjectPart.(*GetResponse_Body_Chunk); ok {
|
|
offset += proto.BytesMarshal(2, buf[offset:], inner.Chunk)
|
|
}
|
|
if inner, ok := x.ObjectPart.(*GetResponse_Body_SplitInfo); ok {
|
|
offset += proto.NestedStructureMarshal(3, buf[offset:], inner.SplitInfo)
|
|
}
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *GetResponse) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
size += proto.NestedStructureSize(2, x.MetaHeader)
|
|
size += proto.NestedStructureSize(3, x.VerifyHeader)
|
|
return size
|
|
}
|
|
|
|
// StableMarshal marshals x in protobuf binary format with stable field order.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *GetResponse) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
|
|
offset += proto.NestedStructureMarshal(2, buf[offset:], x.MetaHeader)
|
|
offset += proto.NestedStructureMarshal(3, buf[offset:], x.VerifyHeader)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *PutRequest_Body_Init) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
var n int
|
|
size += proto.NestedStructureSize(1, x.ObjectId)
|
|
size += proto.NestedStructureSize(2, x.Signature)
|
|
size += proto.NestedStructureSize(3, x.Header)
|
|
n, _ = proto.RepeatedUInt32Size(4, x.CopiesNumber)
|
|
size += n
|
|
return size
|
|
}
|
|
|
|
// StableMarshal marshals x in protobuf binary format with stable field order.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *PutRequest_Body_Init) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.NestedStructureMarshal(1, buf[offset:], x.ObjectId)
|
|
offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
|
|
offset += proto.NestedStructureMarshal(3, buf[offset:], x.Header)
|
|
offset += proto.RepeatedUInt32Marshal(4, buf[offset:], x.CopiesNumber)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *PutRequest_Body) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
if inner, ok := x.ObjectPart.(*PutRequest_Body_Init_); ok {
|
|
size += proto.NestedStructureSize(1, inner.Init)
|
|
}
|
|
if inner, ok := x.ObjectPart.(*PutRequest_Body_Chunk); ok {
|
|
size += proto.BytesSize(2, inner.Chunk)
|
|
}
|
|
return size
|
|
}
|
|
|
|
// StableMarshal marshals x in protobuf binary format with stable field order.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *PutRequest_Body) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
if inner, ok := x.ObjectPart.(*PutRequest_Body_Init_); ok {
|
|
offset += proto.NestedStructureMarshal(1, buf[offset:], inner.Init)
|
|
}
|
|
if inner, ok := x.ObjectPart.(*PutRequest_Body_Chunk); ok {
|
|
offset += proto.BytesMarshal(2, buf[offset:], inner.Chunk)
|
|
}
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *PutRequest) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
size += proto.NestedStructureSize(2, x.MetaHeader)
|
|
size += proto.NestedStructureSize(3, x.VerifyHeader)
|
|
return size
|
|
}
|
|
|
|
// StableMarshal marshals x in protobuf binary format with stable field order.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *PutRequest) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
|
|
offset += proto.NestedStructureMarshal(2, buf[offset:], x.MetaHeader)
|
|
offset += proto.NestedStructureMarshal(3, buf[offset:], x.VerifyHeader)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *PutResponse_Body) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.ObjectId)
|
|
return size
|
|
}
|
|
|
|
// StableMarshal marshals x in protobuf binary format with stable field order.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *PutResponse_Body) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.NestedStructureMarshal(1, buf[offset:], x.ObjectId)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *PutResponse) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
size += proto.NestedStructureSize(2, x.MetaHeader)
|
|
size += proto.NestedStructureSize(3, x.VerifyHeader)
|
|
return size
|
|
}
|
|
|
|
// StableMarshal marshals x in protobuf binary format with stable field order.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *PutResponse) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
|
|
offset += proto.NestedStructureMarshal(2, buf[offset:], x.MetaHeader)
|
|
offset += proto.NestedStructureMarshal(3, buf[offset:], x.VerifyHeader)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *DeleteRequest_Body) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Address)
|
|
return size
|
|
}
|
|
|
|
// StableMarshal marshals x in protobuf binary format with stable field order.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *DeleteRequest_Body) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.NestedStructureMarshal(1, buf[offset:], x.Address)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *DeleteRequest) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
size += proto.NestedStructureSize(2, x.MetaHeader)
|
|
size += proto.NestedStructureSize(3, x.VerifyHeader)
|
|
return size
|
|
}
|
|
|
|
// StableMarshal marshals x in protobuf binary format with stable field order.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *DeleteRequest) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
|
|
offset += proto.NestedStructureMarshal(2, buf[offset:], x.MetaHeader)
|
|
offset += proto.NestedStructureMarshal(3, buf[offset:], x.VerifyHeader)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *DeleteResponse_Body) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Tombstone)
|
|
return size
|
|
}
|
|
|
|
// StableMarshal marshals x in protobuf binary format with stable field order.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *DeleteResponse_Body) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.NestedStructureMarshal(1, buf[offset:], x.Tombstone)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *DeleteResponse) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
size += proto.NestedStructureSize(2, x.MetaHeader)
|
|
size += proto.NestedStructureSize(3, x.VerifyHeader)
|
|
return size
|
|
}
|
|
|
|
// StableMarshal marshals x in protobuf binary format with stable field order.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *DeleteResponse) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
|
|
offset += proto.NestedStructureMarshal(2, buf[offset:], x.MetaHeader)
|
|
offset += proto.NestedStructureMarshal(3, buf[offset:], x.VerifyHeader)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *HeadRequest_Body) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Address)
|
|
size += proto.BoolSize(2, x.MainOnly)
|
|
size += proto.BoolSize(3, x.Raw)
|
|
return size
|
|
}
|
|
|
|
// StableMarshal marshals x in protobuf binary format with stable field order.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *HeadRequest_Body) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.NestedStructureMarshal(1, buf[offset:], x.Address)
|
|
offset += proto.BoolMarshal(2, buf[offset:], x.MainOnly)
|
|
offset += proto.BoolMarshal(3, buf[offset:], x.Raw)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *HeadRequest) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
size += proto.NestedStructureSize(2, x.MetaHeader)
|
|
size += proto.NestedStructureSize(3, x.VerifyHeader)
|
|
return size
|
|
}
|
|
|
|
// StableMarshal marshals x in protobuf binary format with stable field order.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *HeadRequest) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
|
|
offset += proto.NestedStructureMarshal(2, buf[offset:], x.MetaHeader)
|
|
offset += proto.NestedStructureMarshal(3, buf[offset:], x.VerifyHeader)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *HeaderWithSignature) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Header)
|
|
size += proto.NestedStructureSize(2, x.Signature)
|
|
return size
|
|
}
|
|
|
|
// StableMarshal marshals x in protobuf binary format with stable field order.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *HeaderWithSignature) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.NestedStructureMarshal(1, buf[offset:], x.Header)
|
|
offset += proto.NestedStructureMarshal(2, buf[offset:], x.Signature)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *HeadResponse_Body) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
if inner, ok := x.Head.(*HeadResponse_Body_Header); ok {
|
|
size += proto.NestedStructureSize(1, inner.Header)
|
|
}
|
|
if inner, ok := x.Head.(*HeadResponse_Body_ShortHeader); ok {
|
|
size += proto.NestedStructureSize(2, inner.ShortHeader)
|
|
}
|
|
if inner, ok := x.Head.(*HeadResponse_Body_SplitInfo); ok {
|
|
size += proto.NestedStructureSize(3, inner.SplitInfo)
|
|
}
|
|
return size
|
|
}
|
|
|
|
// StableMarshal marshals x in protobuf binary format with stable field order.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *HeadResponse_Body) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
if inner, ok := x.Head.(*HeadResponse_Body_Header); ok {
|
|
offset += proto.NestedStructureMarshal(1, buf[offset:], inner.Header)
|
|
}
|
|
if inner, ok := x.Head.(*HeadResponse_Body_ShortHeader); ok {
|
|
offset += proto.NestedStructureMarshal(2, buf[offset:], inner.ShortHeader)
|
|
}
|
|
if inner, ok := x.Head.(*HeadResponse_Body_SplitInfo); ok {
|
|
offset += proto.NestedStructureMarshal(3, buf[offset:], inner.SplitInfo)
|
|
}
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *HeadResponse) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
size += proto.NestedStructureSize(2, x.MetaHeader)
|
|
size += proto.NestedStructureSize(3, x.VerifyHeader)
|
|
return size
|
|
}
|
|
|
|
// StableMarshal marshals x in protobuf binary format with stable field order.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *HeadResponse) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
|
|
offset += proto.NestedStructureMarshal(2, buf[offset:], x.MetaHeader)
|
|
offset += proto.NestedStructureMarshal(3, buf[offset:], x.VerifyHeader)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *SearchRequest_Body_Filter) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.EnumSize(1, int32(x.MatchType))
|
|
size += proto.StringSize(2, x.Key)
|
|
size += proto.StringSize(3, x.Value)
|
|
return size
|
|
}
|
|
|
|
// StableMarshal marshals x in protobuf binary format with stable field order.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *SearchRequest_Body_Filter) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.EnumMarshal(1, buf[offset:], int32(x.MatchType))
|
|
offset += proto.StringMarshal(2, buf[offset:], x.Key)
|
|
offset += proto.StringMarshal(3, buf[offset:], x.Value)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *SearchRequest_Body) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.ContainerId)
|
|
size += proto.UInt32Size(2, x.Version)
|
|
for i := range x.Filters {
|
|
size += proto.NestedStructureSize(3, x.Filters[i])
|
|
}
|
|
return size
|
|
}
|
|
|
|
// StableMarshal marshals x in protobuf binary format with stable field order.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *SearchRequest_Body) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.NestedStructureMarshal(1, buf[offset:], x.ContainerId)
|
|
offset += proto.UInt32Marshal(2, buf[offset:], x.Version)
|
|
for i := range x.Filters {
|
|
offset += proto.NestedStructureMarshal(3, buf[offset:], x.Filters[i])
|
|
}
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *SearchRequest) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
size += proto.NestedStructureSize(2, x.MetaHeader)
|
|
size += proto.NestedStructureSize(3, x.VerifyHeader)
|
|
return size
|
|
}
|
|
|
|
// StableMarshal marshals x in protobuf binary format with stable field order.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *SearchRequest) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
|
|
offset += proto.NestedStructureMarshal(2, buf[offset:], x.MetaHeader)
|
|
offset += proto.NestedStructureMarshal(3, buf[offset:], x.VerifyHeader)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *SearchResponse_Body) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
for i := range x.IdList {
|
|
size += proto.NestedStructureSize(1, x.IdList[i])
|
|
}
|
|
return size
|
|
}
|
|
|
|
// StableMarshal marshals x in protobuf binary format with stable field order.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *SearchResponse_Body) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
for i := range x.IdList {
|
|
offset += proto.NestedStructureMarshal(1, buf[offset:], x.IdList[i])
|
|
}
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *SearchResponse) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
size += proto.NestedStructureSize(2, x.MetaHeader)
|
|
size += proto.NestedStructureSize(3, x.VerifyHeader)
|
|
return size
|
|
}
|
|
|
|
// StableMarshal marshals x in protobuf binary format with stable field order.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *SearchResponse) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
|
|
offset += proto.NestedStructureMarshal(2, buf[offset:], x.MetaHeader)
|
|
offset += proto.NestedStructureMarshal(3, buf[offset:], x.VerifyHeader)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *Range) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.UInt64Size(1, x.Offset)
|
|
size += proto.UInt64Size(2, x.Length)
|
|
return size
|
|
}
|
|
|
|
// StableMarshal marshals x in protobuf binary format with stable field order.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *Range) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.UInt64Marshal(1, buf[offset:], x.Offset)
|
|
offset += proto.UInt64Marshal(2, buf[offset:], x.Length)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *GetRangeRequest_Body) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Address)
|
|
size += proto.NestedStructureSize(2, x.Range)
|
|
size += proto.BoolSize(3, x.Raw)
|
|
return size
|
|
}
|
|
|
|
// StableMarshal marshals x in protobuf binary format with stable field order.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *GetRangeRequest_Body) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.NestedStructureMarshal(1, buf[offset:], x.Address)
|
|
offset += proto.NestedStructureMarshal(2, buf[offset:], x.Range)
|
|
offset += proto.BoolMarshal(3, buf[offset:], x.Raw)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *GetRangeRequest) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
size += proto.NestedStructureSize(2, x.MetaHeader)
|
|
size += proto.NestedStructureSize(3, x.VerifyHeader)
|
|
return size
|
|
}
|
|
|
|
// StableMarshal marshals x in protobuf binary format with stable field order.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *GetRangeRequest) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
|
|
offset += proto.NestedStructureMarshal(2, buf[offset:], x.MetaHeader)
|
|
offset += proto.NestedStructureMarshal(3, buf[offset:], x.VerifyHeader)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *GetRangeResponse_Body) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
if inner, ok := x.RangePart.(*GetRangeResponse_Body_Chunk); ok {
|
|
size += proto.BytesSize(1, inner.Chunk)
|
|
}
|
|
if inner, ok := x.RangePart.(*GetRangeResponse_Body_SplitInfo); ok {
|
|
size += proto.NestedStructureSize(2, inner.SplitInfo)
|
|
}
|
|
return size
|
|
}
|
|
|
|
// StableMarshal marshals x in protobuf binary format with stable field order.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *GetRangeResponse_Body) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
if inner, ok := x.RangePart.(*GetRangeResponse_Body_Chunk); ok {
|
|
offset += proto.BytesMarshal(1, buf[offset:], inner.Chunk)
|
|
}
|
|
if inner, ok := x.RangePart.(*GetRangeResponse_Body_SplitInfo); ok {
|
|
offset += proto.NestedStructureMarshal(2, buf[offset:], inner.SplitInfo)
|
|
}
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *GetRangeResponse) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
size += proto.NestedStructureSize(2, x.MetaHeader)
|
|
size += proto.NestedStructureSize(3, x.VerifyHeader)
|
|
return size
|
|
}
|
|
|
|
// StableMarshal marshals x in protobuf binary format with stable field order.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *GetRangeResponse) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
|
|
offset += proto.NestedStructureMarshal(2, buf[offset:], x.MetaHeader)
|
|
offset += proto.NestedStructureMarshal(3, buf[offset:], x.VerifyHeader)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *GetRangeHashRequest_Body) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Address)
|
|
for i := range x.Ranges {
|
|
size += proto.NestedStructureSize(2, x.Ranges[i])
|
|
}
|
|
size += proto.BytesSize(3, x.Salt)
|
|
size += proto.EnumSize(4, int32(x.Type))
|
|
return size
|
|
}
|
|
|
|
// StableMarshal marshals x in protobuf binary format with stable field order.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *GetRangeHashRequest_Body) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.NestedStructureMarshal(1, buf[offset:], x.Address)
|
|
for i := range x.Ranges {
|
|
offset += proto.NestedStructureMarshal(2, buf[offset:], x.Ranges[i])
|
|
}
|
|
offset += proto.BytesMarshal(3, buf[offset:], x.Salt)
|
|
offset += proto.EnumMarshal(4, buf[offset:], int32(x.Type))
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *GetRangeHashRequest) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
size += proto.NestedStructureSize(2, x.MetaHeader)
|
|
size += proto.NestedStructureSize(3, x.VerifyHeader)
|
|
return size
|
|
}
|
|
|
|
// StableMarshal marshals x in protobuf binary format with stable field order.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *GetRangeHashRequest) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
|
|
offset += proto.NestedStructureMarshal(2, buf[offset:], x.MetaHeader)
|
|
offset += proto.NestedStructureMarshal(3, buf[offset:], x.VerifyHeader)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *GetRangeHashResponse_Body) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.EnumSize(1, int32(x.Type))
|
|
size += proto.RepeatedBytesSize(2, x.HashList)
|
|
return size
|
|
}
|
|
|
|
// StableMarshal marshals x in protobuf binary format with stable field order.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *GetRangeHashResponse_Body) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.EnumMarshal(1, buf[offset:], int32(x.Type))
|
|
offset += proto.RepeatedBytesMarshal(2, buf[offset:], x.HashList)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *GetRangeHashResponse) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
size += proto.NestedStructureSize(2, x.MetaHeader)
|
|
size += proto.NestedStructureSize(3, x.VerifyHeader)
|
|
return size
|
|
}
|
|
|
|
// StableMarshal marshals x in protobuf binary format with stable field order.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *GetRangeHashResponse) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
|
|
offset += proto.NestedStructureMarshal(2, buf[offset:], x.MetaHeader)
|
|
offset += proto.NestedStructureMarshal(3, buf[offset:], x.VerifyHeader)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *PutSingleRequest_Body) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
var n int
|
|
size += proto.NestedStructureSize(1, x.Object)
|
|
n, _ = proto.RepeatedUInt32Size(2, x.CopiesNumber)
|
|
size += n
|
|
return size
|
|
}
|
|
|
|
// StableMarshal marshals x in protobuf binary format with stable field order.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *PutSingleRequest_Body) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.NestedStructureMarshal(1, buf[offset:], x.Object)
|
|
offset += proto.RepeatedUInt32Marshal(2, buf[offset:], x.CopiesNumber)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *PutSingleRequest) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
size += proto.NestedStructureSize(2, x.MetaHeader)
|
|
size += proto.NestedStructureSize(3, x.VerifyHeader)
|
|
return size
|
|
}
|
|
|
|
// StableMarshal marshals x in protobuf binary format with stable field order.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *PutSingleRequest) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
|
|
offset += proto.NestedStructureMarshal(2, buf[offset:], x.MetaHeader)
|
|
offset += proto.NestedStructureMarshal(3, buf[offset:], x.VerifyHeader)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *PutSingleResponse_Body) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
return size
|
|
}
|
|
|
|
// StableMarshal marshals x in protobuf binary format with stable field order.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *PutSingleResponse_Body) StableMarshal(buf []byte) []byte {
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *PutSingleResponse) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
size += proto.NestedStructureSize(2, x.MetaHeader)
|
|
size += proto.NestedStructureSize(3, x.VerifyHeader)
|
|
return size
|
|
}
|
|
|
|
// StableMarshal marshals x in protobuf binary format with stable field order.
|
|
//
|
|
// If buffer length is less than x.StableSize(), new buffer is allocated.
|
|
//
|
|
// Returns any error encountered which did not allow writing the data completely.
|
|
// Otherwise, returns the buffer in which the data is written.
|
|
//
|
|
// Structures with the same field values have the same binary format.
|
|
func (x *PutSingleResponse) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.NestedStructureMarshal(1, buf[offset:], x.Body)
|
|
offset += proto.NestedStructureMarshal(2, buf[offset:], x.MetaHeader)
|
|
offset += proto.NestedStructureMarshal(3, buf[offset:], x.VerifyHeader)
|
|
return buf
|
|
}
|