2971 lines
94 KiB
Go
2971 lines
94 KiB
Go
// Code generated by protoc-gen-go-frostfs. DO NOT EDIT.
|
|
|
|
package control
|
|
|
|
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 *HealthCheckRequest_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 *HealthCheckRequest_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 *HealthCheckRequest) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
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 *HealthCheckRequest) 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.Signature)
|
|
return buf
|
|
}
|
|
|
|
// ReadSignedData fills buf with signed data of x.
|
|
// If buffer length is less than x.SignedDataSize(), 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 signed data.
|
|
func (x *HealthCheckRequest) SignedDataSize() int {
|
|
return x.GetBody().StableSize()
|
|
}
|
|
|
|
// SignedDataSize returns size of the request signed data in bytes.
|
|
//
|
|
// Structures with the same field values have the same signed data size.
|
|
func (x *HealthCheckRequest) ReadSignedData(buf []byte) ([]byte, error) {
|
|
return x.GetBody().StableMarshal(buf), nil
|
|
}
|
|
|
|
func (x *HealthCheckRequest) SetSignature(sig *Signature) {
|
|
x.Signature = sig
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *HealthCheckResponse_Body) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.EnumSize(1, int32(x.NetmapStatus))
|
|
size += proto.EnumSize(2, int32(x.HealthStatus))
|
|
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 *HealthCheckResponse_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.NetmapStatus))
|
|
offset += proto.EnumMarshal(2, buf[offset:], int32(x.HealthStatus))
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *HealthCheckResponse) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
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 *HealthCheckResponse) 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.Signature)
|
|
return buf
|
|
}
|
|
|
|
// ReadSignedData fills buf with signed data of x.
|
|
// If buffer length is less than x.SignedDataSize(), 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 signed data.
|
|
func (x *HealthCheckResponse) SignedDataSize() int {
|
|
return x.GetBody().StableSize()
|
|
}
|
|
|
|
// SignedDataSize returns size of the request signed data in bytes.
|
|
//
|
|
// Structures with the same field values have the same signed data size.
|
|
func (x *HealthCheckResponse) ReadSignedData(buf []byte) ([]byte, error) {
|
|
return x.GetBody().StableMarshal(buf), nil
|
|
}
|
|
|
|
func (x *HealthCheckResponse) SetSignature(sig *Signature) {
|
|
x.Signature = sig
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *SetNetmapStatusRequest_Body) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.EnumSize(1, int32(x.Status))
|
|
size += proto.BoolSize(2, x.ForceMaintenance)
|
|
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 *SetNetmapStatusRequest_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.Status))
|
|
offset += proto.BoolMarshal(2, buf[offset:], x.ForceMaintenance)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *SetNetmapStatusRequest) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
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 *SetNetmapStatusRequest) 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.Signature)
|
|
return buf
|
|
}
|
|
|
|
// ReadSignedData fills buf with signed data of x.
|
|
// If buffer length is less than x.SignedDataSize(), 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 signed data.
|
|
func (x *SetNetmapStatusRequest) SignedDataSize() int {
|
|
return x.GetBody().StableSize()
|
|
}
|
|
|
|
// SignedDataSize returns size of the request signed data in bytes.
|
|
//
|
|
// Structures with the same field values have the same signed data size.
|
|
func (x *SetNetmapStatusRequest) ReadSignedData(buf []byte) ([]byte, error) {
|
|
return x.GetBody().StableMarshal(buf), nil
|
|
}
|
|
|
|
func (x *SetNetmapStatusRequest) SetSignature(sig *Signature) {
|
|
x.Signature = sig
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *SetNetmapStatusResponse_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 *SetNetmapStatusResponse_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 *SetNetmapStatusResponse) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
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 *SetNetmapStatusResponse) 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.Signature)
|
|
return buf
|
|
}
|
|
|
|
// ReadSignedData fills buf with signed data of x.
|
|
// If buffer length is less than x.SignedDataSize(), 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 signed data.
|
|
func (x *SetNetmapStatusResponse) SignedDataSize() int {
|
|
return x.GetBody().StableSize()
|
|
}
|
|
|
|
// SignedDataSize returns size of the request signed data in bytes.
|
|
//
|
|
// Structures with the same field values have the same signed data size.
|
|
func (x *SetNetmapStatusResponse) ReadSignedData(buf []byte) ([]byte, error) {
|
|
return x.GetBody().StableMarshal(buf), nil
|
|
}
|
|
|
|
func (x *SetNetmapStatusResponse) SetSignature(sig *Signature) {
|
|
x.Signature = sig
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *DropObjectsRequest_Body) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.RepeatedBytesSize(1, x.AddressList)
|
|
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 *DropObjectsRequest_Body) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.RepeatedBytesMarshal(1, buf[offset:], x.AddressList)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *DropObjectsRequest) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
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 *DropObjectsRequest) 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.Signature)
|
|
return buf
|
|
}
|
|
|
|
// ReadSignedData fills buf with signed data of x.
|
|
// If buffer length is less than x.SignedDataSize(), 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 signed data.
|
|
func (x *DropObjectsRequest) SignedDataSize() int {
|
|
return x.GetBody().StableSize()
|
|
}
|
|
|
|
// SignedDataSize returns size of the request signed data in bytes.
|
|
//
|
|
// Structures with the same field values have the same signed data size.
|
|
func (x *DropObjectsRequest) ReadSignedData(buf []byte) ([]byte, error) {
|
|
return x.GetBody().StableMarshal(buf), nil
|
|
}
|
|
|
|
func (x *DropObjectsRequest) SetSignature(sig *Signature) {
|
|
x.Signature = sig
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *DropObjectsResponse_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 *DropObjectsResponse_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 *DropObjectsResponse) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
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 *DropObjectsResponse) 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.Signature)
|
|
return buf
|
|
}
|
|
|
|
// ReadSignedData fills buf with signed data of x.
|
|
// If buffer length is less than x.SignedDataSize(), 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 signed data.
|
|
func (x *DropObjectsResponse) SignedDataSize() int {
|
|
return x.GetBody().StableSize()
|
|
}
|
|
|
|
// SignedDataSize returns size of the request signed data in bytes.
|
|
//
|
|
// Structures with the same field values have the same signed data size.
|
|
func (x *DropObjectsResponse) ReadSignedData(buf []byte) ([]byte, error) {
|
|
return x.GetBody().StableMarshal(buf), nil
|
|
}
|
|
|
|
func (x *DropObjectsResponse) SetSignature(sig *Signature) {
|
|
x.Signature = sig
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *ListShardsRequest_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 *ListShardsRequest_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 *ListShardsRequest) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
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 *ListShardsRequest) 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.Signature)
|
|
return buf
|
|
}
|
|
|
|
// ReadSignedData fills buf with signed data of x.
|
|
// If buffer length is less than x.SignedDataSize(), 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 signed data.
|
|
func (x *ListShardsRequest) SignedDataSize() int {
|
|
return x.GetBody().StableSize()
|
|
}
|
|
|
|
// SignedDataSize returns size of the request signed data in bytes.
|
|
//
|
|
// Structures with the same field values have the same signed data size.
|
|
func (x *ListShardsRequest) ReadSignedData(buf []byte) ([]byte, error) {
|
|
return x.GetBody().StableMarshal(buf), nil
|
|
}
|
|
|
|
func (x *ListShardsRequest) SetSignature(sig *Signature) {
|
|
x.Signature = sig
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *ListShardsResponse_Body) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
for i := range x.Shards {
|
|
size += proto.NestedStructureSize(1, x.Shards[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 *ListShardsResponse_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.Shards {
|
|
offset += proto.NestedStructureMarshal(1, buf[offset:], x.Shards[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 *ListShardsResponse) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
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 *ListShardsResponse) 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.Signature)
|
|
return buf
|
|
}
|
|
|
|
// ReadSignedData fills buf with signed data of x.
|
|
// If buffer length is less than x.SignedDataSize(), 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 signed data.
|
|
func (x *ListShardsResponse) SignedDataSize() int {
|
|
return x.GetBody().StableSize()
|
|
}
|
|
|
|
// SignedDataSize returns size of the request signed data in bytes.
|
|
//
|
|
// Structures with the same field values have the same signed data size.
|
|
func (x *ListShardsResponse) ReadSignedData(buf []byte) ([]byte, error) {
|
|
return x.GetBody().StableMarshal(buf), nil
|
|
}
|
|
|
|
func (x *ListShardsResponse) SetSignature(sig *Signature) {
|
|
x.Signature = sig
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *SetShardModeRequest_Body) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.RepeatedBytesSize(1, x.Shard_ID)
|
|
size += proto.EnumSize(2, int32(x.Mode))
|
|
size += proto.BoolSize(3, x.ResetErrorCounter)
|
|
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 *SetShardModeRequest_Body) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.RepeatedBytesMarshal(1, buf[offset:], x.Shard_ID)
|
|
offset += proto.EnumMarshal(2, buf[offset:], int32(x.Mode))
|
|
offset += proto.BoolMarshal(3, buf[offset:], x.ResetErrorCounter)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *SetShardModeRequest) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
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 *SetShardModeRequest) 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.Signature)
|
|
return buf
|
|
}
|
|
|
|
// ReadSignedData fills buf with signed data of x.
|
|
// If buffer length is less than x.SignedDataSize(), 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 signed data.
|
|
func (x *SetShardModeRequest) SignedDataSize() int {
|
|
return x.GetBody().StableSize()
|
|
}
|
|
|
|
// SignedDataSize returns size of the request signed data in bytes.
|
|
//
|
|
// Structures with the same field values have the same signed data size.
|
|
func (x *SetShardModeRequest) ReadSignedData(buf []byte) ([]byte, error) {
|
|
return x.GetBody().StableMarshal(buf), nil
|
|
}
|
|
|
|
func (x *SetShardModeRequest) SetSignature(sig *Signature) {
|
|
x.Signature = sig
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *SetShardModeResponse_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 *SetShardModeResponse_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 *SetShardModeResponse) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
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 *SetShardModeResponse) 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.Signature)
|
|
return buf
|
|
}
|
|
|
|
// ReadSignedData fills buf with signed data of x.
|
|
// If buffer length is less than x.SignedDataSize(), 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 signed data.
|
|
func (x *SetShardModeResponse) SignedDataSize() int {
|
|
return x.GetBody().StableSize()
|
|
}
|
|
|
|
// SignedDataSize returns size of the request signed data in bytes.
|
|
//
|
|
// Structures with the same field values have the same signed data size.
|
|
func (x *SetShardModeResponse) ReadSignedData(buf []byte) ([]byte, error) {
|
|
return x.GetBody().StableMarshal(buf), nil
|
|
}
|
|
|
|
func (x *SetShardModeResponse) SetSignature(sig *Signature) {
|
|
x.Signature = sig
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *SynchronizeTreeRequest_Body) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.BytesSize(1, x.ContainerId)
|
|
size += proto.StringSize(2, x.TreeId)
|
|
size += proto.UInt64Size(3, x.Height)
|
|
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 *SynchronizeTreeRequest_Body) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.BytesMarshal(1, buf[offset:], x.ContainerId)
|
|
offset += proto.StringMarshal(2, buf[offset:], x.TreeId)
|
|
offset += proto.UInt64Marshal(3, buf[offset:], x.Height)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *SynchronizeTreeRequest) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
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 *SynchronizeTreeRequest) 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.Signature)
|
|
return buf
|
|
}
|
|
|
|
// ReadSignedData fills buf with signed data of x.
|
|
// If buffer length is less than x.SignedDataSize(), 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 signed data.
|
|
func (x *SynchronizeTreeRequest) SignedDataSize() int {
|
|
return x.GetBody().StableSize()
|
|
}
|
|
|
|
// SignedDataSize returns size of the request signed data in bytes.
|
|
//
|
|
// Structures with the same field values have the same signed data size.
|
|
func (x *SynchronizeTreeRequest) ReadSignedData(buf []byte) ([]byte, error) {
|
|
return x.GetBody().StableMarshal(buf), nil
|
|
}
|
|
|
|
func (x *SynchronizeTreeRequest) SetSignature(sig *Signature) {
|
|
x.Signature = sig
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *SynchronizeTreeResponse_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 *SynchronizeTreeResponse_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 *SynchronizeTreeResponse) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
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 *SynchronizeTreeResponse) 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.Signature)
|
|
return buf
|
|
}
|
|
|
|
// ReadSignedData fills buf with signed data of x.
|
|
// If buffer length is less than x.SignedDataSize(), 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 signed data.
|
|
func (x *SynchronizeTreeResponse) SignedDataSize() int {
|
|
return x.GetBody().StableSize()
|
|
}
|
|
|
|
// SignedDataSize returns size of the request signed data in bytes.
|
|
//
|
|
// Structures with the same field values have the same signed data size.
|
|
func (x *SynchronizeTreeResponse) ReadSignedData(buf []byte) ([]byte, error) {
|
|
return x.GetBody().StableMarshal(buf), nil
|
|
}
|
|
|
|
func (x *SynchronizeTreeResponse) SetSignature(sig *Signature) {
|
|
x.Signature = sig
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *EvacuateShardRequest_Body) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.RepeatedBytesSize(1, x.Shard_ID)
|
|
size += proto.BoolSize(2, x.IgnoreErrors)
|
|
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 *EvacuateShardRequest_Body) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.RepeatedBytesMarshal(1, buf[offset:], x.Shard_ID)
|
|
offset += proto.BoolMarshal(2, buf[offset:], x.IgnoreErrors)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *EvacuateShardRequest) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
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 *EvacuateShardRequest) 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.Signature)
|
|
return buf
|
|
}
|
|
|
|
// ReadSignedData fills buf with signed data of x.
|
|
// If buffer length is less than x.SignedDataSize(), 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 signed data.
|
|
func (x *EvacuateShardRequest) SignedDataSize() int {
|
|
return x.GetBody().StableSize()
|
|
}
|
|
|
|
// SignedDataSize returns size of the request signed data in bytes.
|
|
//
|
|
// Structures with the same field values have the same signed data size.
|
|
func (x *EvacuateShardRequest) ReadSignedData(buf []byte) ([]byte, error) {
|
|
return x.GetBody().StableMarshal(buf), nil
|
|
}
|
|
|
|
func (x *EvacuateShardRequest) SetSignature(sig *Signature) {
|
|
x.Signature = sig
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *EvacuateShardResponse_Body) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.UInt32Size(1, x.Count)
|
|
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 *EvacuateShardResponse_Body) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.UInt32Marshal(1, buf[offset:], x.Count)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *EvacuateShardResponse) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
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 *EvacuateShardResponse) 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.Signature)
|
|
return buf
|
|
}
|
|
|
|
// ReadSignedData fills buf with signed data of x.
|
|
// If buffer length is less than x.SignedDataSize(), 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 signed data.
|
|
func (x *EvacuateShardResponse) SignedDataSize() int {
|
|
return x.GetBody().StableSize()
|
|
}
|
|
|
|
// SignedDataSize returns size of the request signed data in bytes.
|
|
//
|
|
// Structures with the same field values have the same signed data size.
|
|
func (x *EvacuateShardResponse) ReadSignedData(buf []byte) ([]byte, error) {
|
|
return x.GetBody().StableMarshal(buf), nil
|
|
}
|
|
|
|
func (x *EvacuateShardResponse) SetSignature(sig *Signature) {
|
|
x.Signature = sig
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *FlushCacheRequest_Body) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.RepeatedBytesSize(1, x.Shard_ID)
|
|
size += proto.BoolSize(2, x.Seal)
|
|
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 *FlushCacheRequest_Body) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.RepeatedBytesMarshal(1, buf[offset:], x.Shard_ID)
|
|
offset += proto.BoolMarshal(2, buf[offset:], x.Seal)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *FlushCacheRequest) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
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 *FlushCacheRequest) 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.Signature)
|
|
return buf
|
|
}
|
|
|
|
// ReadSignedData fills buf with signed data of x.
|
|
// If buffer length is less than x.SignedDataSize(), 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 signed data.
|
|
func (x *FlushCacheRequest) SignedDataSize() int {
|
|
return x.GetBody().StableSize()
|
|
}
|
|
|
|
// SignedDataSize returns size of the request signed data in bytes.
|
|
//
|
|
// Structures with the same field values have the same signed data size.
|
|
func (x *FlushCacheRequest) ReadSignedData(buf []byte) ([]byte, error) {
|
|
return x.GetBody().StableMarshal(buf), nil
|
|
}
|
|
|
|
func (x *FlushCacheRequest) SetSignature(sig *Signature) {
|
|
x.Signature = sig
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *FlushCacheResponse_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 *FlushCacheResponse_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 *FlushCacheResponse) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
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 *FlushCacheResponse) 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.Signature)
|
|
return buf
|
|
}
|
|
|
|
// ReadSignedData fills buf with signed data of x.
|
|
// If buffer length is less than x.SignedDataSize(), 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 signed data.
|
|
func (x *FlushCacheResponse) SignedDataSize() int {
|
|
return x.GetBody().StableSize()
|
|
}
|
|
|
|
// SignedDataSize returns size of the request signed data in bytes.
|
|
//
|
|
// Structures with the same field values have the same signed data size.
|
|
func (x *FlushCacheResponse) ReadSignedData(buf []byte) ([]byte, error) {
|
|
return x.GetBody().StableMarshal(buf), nil
|
|
}
|
|
|
|
func (x *FlushCacheResponse) SetSignature(sig *Signature) {
|
|
x.Signature = sig
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *DoctorRequest_Body) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.UInt32Size(1, x.Concurrency)
|
|
size += proto.BoolSize(2, x.RemoveDuplicates)
|
|
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 *DoctorRequest_Body) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.UInt32Marshal(1, buf[offset:], x.Concurrency)
|
|
offset += proto.BoolMarshal(2, buf[offset:], x.RemoveDuplicates)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *DoctorRequest) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
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 *DoctorRequest) 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.Signature)
|
|
return buf
|
|
}
|
|
|
|
// ReadSignedData fills buf with signed data of x.
|
|
// If buffer length is less than x.SignedDataSize(), 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 signed data.
|
|
func (x *DoctorRequest) SignedDataSize() int {
|
|
return x.GetBody().StableSize()
|
|
}
|
|
|
|
// SignedDataSize returns size of the request signed data in bytes.
|
|
//
|
|
// Structures with the same field values have the same signed data size.
|
|
func (x *DoctorRequest) ReadSignedData(buf []byte) ([]byte, error) {
|
|
return x.GetBody().StableMarshal(buf), nil
|
|
}
|
|
|
|
func (x *DoctorRequest) SetSignature(sig *Signature) {
|
|
x.Signature = sig
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *DoctorResponse_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 *DoctorResponse_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 *DoctorResponse) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
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 *DoctorResponse) 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.Signature)
|
|
return buf
|
|
}
|
|
|
|
// ReadSignedData fills buf with signed data of x.
|
|
// If buffer length is less than x.SignedDataSize(), 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 signed data.
|
|
func (x *DoctorResponse) SignedDataSize() int {
|
|
return x.GetBody().StableSize()
|
|
}
|
|
|
|
// SignedDataSize returns size of the request signed data in bytes.
|
|
//
|
|
// Structures with the same field values have the same signed data size.
|
|
func (x *DoctorResponse) ReadSignedData(buf []byte) ([]byte, error) {
|
|
return x.GetBody().StableMarshal(buf), nil
|
|
}
|
|
|
|
func (x *DoctorResponse) SetSignature(sig *Signature) {
|
|
x.Signature = sig
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *StartShardEvacuationRequest_Body) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.RepeatedBytesSize(1, x.Shard_ID)
|
|
size += proto.BoolSize(2, x.IgnoreErrors)
|
|
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 *StartShardEvacuationRequest_Body) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.RepeatedBytesMarshal(1, buf[offset:], x.Shard_ID)
|
|
offset += proto.BoolMarshal(2, buf[offset:], x.IgnoreErrors)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *StartShardEvacuationRequest) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
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 *StartShardEvacuationRequest) 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.Signature)
|
|
return buf
|
|
}
|
|
|
|
// ReadSignedData fills buf with signed data of x.
|
|
// If buffer length is less than x.SignedDataSize(), 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 signed data.
|
|
func (x *StartShardEvacuationRequest) SignedDataSize() int {
|
|
return x.GetBody().StableSize()
|
|
}
|
|
|
|
// SignedDataSize returns size of the request signed data in bytes.
|
|
//
|
|
// Structures with the same field values have the same signed data size.
|
|
func (x *StartShardEvacuationRequest) ReadSignedData(buf []byte) ([]byte, error) {
|
|
return x.GetBody().StableMarshal(buf), nil
|
|
}
|
|
|
|
func (x *StartShardEvacuationRequest) SetSignature(sig *Signature) {
|
|
x.Signature = sig
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *StartShardEvacuationResponse_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 *StartShardEvacuationResponse_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 *StartShardEvacuationResponse) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
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 *StartShardEvacuationResponse) 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.Signature)
|
|
return buf
|
|
}
|
|
|
|
// ReadSignedData fills buf with signed data of x.
|
|
// If buffer length is less than x.SignedDataSize(), 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 signed data.
|
|
func (x *StartShardEvacuationResponse) SignedDataSize() int {
|
|
return x.GetBody().StableSize()
|
|
}
|
|
|
|
// SignedDataSize returns size of the request signed data in bytes.
|
|
//
|
|
// Structures with the same field values have the same signed data size.
|
|
func (x *StartShardEvacuationResponse) ReadSignedData(buf []byte) ([]byte, error) {
|
|
return x.GetBody().StableMarshal(buf), nil
|
|
}
|
|
|
|
func (x *StartShardEvacuationResponse) SetSignature(sig *Signature) {
|
|
x.Signature = sig
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *GetShardEvacuationStatusRequest_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 *GetShardEvacuationStatusRequest_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 *GetShardEvacuationStatusRequest) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
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 *GetShardEvacuationStatusRequest) 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.Signature)
|
|
return buf
|
|
}
|
|
|
|
// ReadSignedData fills buf with signed data of x.
|
|
// If buffer length is less than x.SignedDataSize(), 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 signed data.
|
|
func (x *GetShardEvacuationStatusRequest) SignedDataSize() int {
|
|
return x.GetBody().StableSize()
|
|
}
|
|
|
|
// SignedDataSize returns size of the request signed data in bytes.
|
|
//
|
|
// Structures with the same field values have the same signed data size.
|
|
func (x *GetShardEvacuationStatusRequest) ReadSignedData(buf []byte) ([]byte, error) {
|
|
return x.GetBody().StableMarshal(buf), nil
|
|
}
|
|
|
|
func (x *GetShardEvacuationStatusRequest) SetSignature(sig *Signature) {
|
|
x.Signature = sig
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *GetShardEvacuationStatusResponse_Body_UnixTimestamp) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.Int64Size(1, 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 *GetShardEvacuationStatusResponse_Body_UnixTimestamp) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.Int64Marshal(1, 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 *GetShardEvacuationStatusResponse_Body_Duration) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.Int64Size(1, x.Seconds)
|
|
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 *GetShardEvacuationStatusResponse_Body_Duration) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.Int64Marshal(1, buf[offset:], x.Seconds)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *GetShardEvacuationStatusResponse_Body) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.UInt64Size(1, x.Total)
|
|
size += proto.UInt64Size(2, x.Evacuated)
|
|
size += proto.UInt64Size(3, x.Failed)
|
|
size += proto.RepeatedBytesSize(4, x.Shard_ID)
|
|
size += proto.EnumSize(5, int32(x.Status))
|
|
size += proto.NestedStructureSize(6, x.Duration)
|
|
size += proto.NestedStructureSize(7, x.StartedAt)
|
|
size += proto.StringSize(8, x.ErrorMessage)
|
|
size += proto.UInt64Size(9, x.Skipped)
|
|
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 *GetShardEvacuationStatusResponse_Body) 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.Total)
|
|
offset += proto.UInt64Marshal(2, buf[offset:], x.Evacuated)
|
|
offset += proto.UInt64Marshal(3, buf[offset:], x.Failed)
|
|
offset += proto.RepeatedBytesMarshal(4, buf[offset:], x.Shard_ID)
|
|
offset += proto.EnumMarshal(5, buf[offset:], int32(x.Status))
|
|
offset += proto.NestedStructureMarshal(6, buf[offset:], x.Duration)
|
|
offset += proto.NestedStructureMarshal(7, buf[offset:], x.StartedAt)
|
|
offset += proto.StringMarshal(8, buf[offset:], x.ErrorMessage)
|
|
offset += proto.UInt64Marshal(9, buf[offset:], x.Skipped)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *GetShardEvacuationStatusResponse) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
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 *GetShardEvacuationStatusResponse) 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.Signature)
|
|
return buf
|
|
}
|
|
|
|
// ReadSignedData fills buf with signed data of x.
|
|
// If buffer length is less than x.SignedDataSize(), 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 signed data.
|
|
func (x *GetShardEvacuationStatusResponse) SignedDataSize() int {
|
|
return x.GetBody().StableSize()
|
|
}
|
|
|
|
// SignedDataSize returns size of the request signed data in bytes.
|
|
//
|
|
// Structures with the same field values have the same signed data size.
|
|
func (x *GetShardEvacuationStatusResponse) ReadSignedData(buf []byte) ([]byte, error) {
|
|
return x.GetBody().StableMarshal(buf), nil
|
|
}
|
|
|
|
func (x *GetShardEvacuationStatusResponse) SetSignature(sig *Signature) {
|
|
x.Signature = sig
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *StopShardEvacuationRequest_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 *StopShardEvacuationRequest_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 *StopShardEvacuationRequest) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
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 *StopShardEvacuationRequest) 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.Signature)
|
|
return buf
|
|
}
|
|
|
|
// ReadSignedData fills buf with signed data of x.
|
|
// If buffer length is less than x.SignedDataSize(), 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 signed data.
|
|
func (x *StopShardEvacuationRequest) SignedDataSize() int {
|
|
return x.GetBody().StableSize()
|
|
}
|
|
|
|
// SignedDataSize returns size of the request signed data in bytes.
|
|
//
|
|
// Structures with the same field values have the same signed data size.
|
|
func (x *StopShardEvacuationRequest) ReadSignedData(buf []byte) ([]byte, error) {
|
|
return x.GetBody().StableMarshal(buf), nil
|
|
}
|
|
|
|
func (x *StopShardEvacuationRequest) SetSignature(sig *Signature) {
|
|
x.Signature = sig
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *StopShardEvacuationResponse_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 *StopShardEvacuationResponse_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 *StopShardEvacuationResponse) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
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 *StopShardEvacuationResponse) 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.Signature)
|
|
return buf
|
|
}
|
|
|
|
// ReadSignedData fills buf with signed data of x.
|
|
// If buffer length is less than x.SignedDataSize(), 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 signed data.
|
|
func (x *StopShardEvacuationResponse) SignedDataSize() int {
|
|
return x.GetBody().StableSize()
|
|
}
|
|
|
|
// SignedDataSize returns size of the request signed data in bytes.
|
|
//
|
|
// Structures with the same field values have the same signed data size.
|
|
func (x *StopShardEvacuationResponse) ReadSignedData(buf []byte) ([]byte, error) {
|
|
return x.GetBody().StableMarshal(buf), nil
|
|
}
|
|
|
|
func (x *StopShardEvacuationResponse) SetSignature(sig *Signature) {
|
|
x.Signature = sig
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *AddChainLocalOverrideRequest_Body) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Target)
|
|
size += proto.BytesSize(2, x.Chain)
|
|
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 *AddChainLocalOverrideRequest_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.Target)
|
|
offset += proto.BytesMarshal(2, buf[offset:], x.Chain)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *AddChainLocalOverrideRequest) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
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 *AddChainLocalOverrideRequest) 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.Signature)
|
|
return buf
|
|
}
|
|
|
|
// ReadSignedData fills buf with signed data of x.
|
|
// If buffer length is less than x.SignedDataSize(), 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 signed data.
|
|
func (x *AddChainLocalOverrideRequest) SignedDataSize() int {
|
|
return x.GetBody().StableSize()
|
|
}
|
|
|
|
// SignedDataSize returns size of the request signed data in bytes.
|
|
//
|
|
// Structures with the same field values have the same signed data size.
|
|
func (x *AddChainLocalOverrideRequest) ReadSignedData(buf []byte) ([]byte, error) {
|
|
return x.GetBody().StableMarshal(buf), nil
|
|
}
|
|
|
|
func (x *AddChainLocalOverrideRequest) SetSignature(sig *Signature) {
|
|
x.Signature = sig
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *AddChainLocalOverrideResponse_Body) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.BytesSize(1, x.ChainId)
|
|
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 *AddChainLocalOverrideResponse_Body) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.BytesMarshal(1, buf[offset:], x.ChainId)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *AddChainLocalOverrideResponse) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
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 *AddChainLocalOverrideResponse) 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.Signature)
|
|
return buf
|
|
}
|
|
|
|
// ReadSignedData fills buf with signed data of x.
|
|
// If buffer length is less than x.SignedDataSize(), 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 signed data.
|
|
func (x *AddChainLocalOverrideResponse) SignedDataSize() int {
|
|
return x.GetBody().StableSize()
|
|
}
|
|
|
|
// SignedDataSize returns size of the request signed data in bytes.
|
|
//
|
|
// Structures with the same field values have the same signed data size.
|
|
func (x *AddChainLocalOverrideResponse) ReadSignedData(buf []byte) ([]byte, error) {
|
|
return x.GetBody().StableMarshal(buf), nil
|
|
}
|
|
|
|
func (x *AddChainLocalOverrideResponse) SetSignature(sig *Signature) {
|
|
x.Signature = sig
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *GetChainLocalOverrideRequest_Body) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Target)
|
|
size += proto.BytesSize(2, x.ChainId)
|
|
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 *GetChainLocalOverrideRequest_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.Target)
|
|
offset += proto.BytesMarshal(2, buf[offset:], x.ChainId)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *GetChainLocalOverrideRequest) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
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 *GetChainLocalOverrideRequest) 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.Signature)
|
|
return buf
|
|
}
|
|
|
|
// ReadSignedData fills buf with signed data of x.
|
|
// If buffer length is less than x.SignedDataSize(), 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 signed data.
|
|
func (x *GetChainLocalOverrideRequest) SignedDataSize() int {
|
|
return x.GetBody().StableSize()
|
|
}
|
|
|
|
// SignedDataSize returns size of the request signed data in bytes.
|
|
//
|
|
// Structures with the same field values have the same signed data size.
|
|
func (x *GetChainLocalOverrideRequest) ReadSignedData(buf []byte) ([]byte, error) {
|
|
return x.GetBody().StableMarshal(buf), nil
|
|
}
|
|
|
|
func (x *GetChainLocalOverrideRequest) SetSignature(sig *Signature) {
|
|
x.Signature = sig
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *GetChainLocalOverrideResponse_Body) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.BytesSize(1, x.Chain)
|
|
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 *GetChainLocalOverrideResponse_Body) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.BytesMarshal(1, buf[offset:], x.Chain)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *GetChainLocalOverrideResponse) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
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 *GetChainLocalOverrideResponse) 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.Signature)
|
|
return buf
|
|
}
|
|
|
|
// ReadSignedData fills buf with signed data of x.
|
|
// If buffer length is less than x.SignedDataSize(), 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 signed data.
|
|
func (x *GetChainLocalOverrideResponse) SignedDataSize() int {
|
|
return x.GetBody().StableSize()
|
|
}
|
|
|
|
// SignedDataSize returns size of the request signed data in bytes.
|
|
//
|
|
// Structures with the same field values have the same signed data size.
|
|
func (x *GetChainLocalOverrideResponse) ReadSignedData(buf []byte) ([]byte, error) {
|
|
return x.GetBody().StableMarshal(buf), nil
|
|
}
|
|
|
|
func (x *GetChainLocalOverrideResponse) SetSignature(sig *Signature) {
|
|
x.Signature = sig
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *ListChainLocalOverridesRequest_Body) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Target)
|
|
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 *ListChainLocalOverridesRequest_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.Target)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *ListChainLocalOverridesRequest) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
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 *ListChainLocalOverridesRequest) 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.Signature)
|
|
return buf
|
|
}
|
|
|
|
// ReadSignedData fills buf with signed data of x.
|
|
// If buffer length is less than x.SignedDataSize(), 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 signed data.
|
|
func (x *ListChainLocalOverridesRequest) SignedDataSize() int {
|
|
return x.GetBody().StableSize()
|
|
}
|
|
|
|
// SignedDataSize returns size of the request signed data in bytes.
|
|
//
|
|
// Structures with the same field values have the same signed data size.
|
|
func (x *ListChainLocalOverridesRequest) ReadSignedData(buf []byte) ([]byte, error) {
|
|
return x.GetBody().StableMarshal(buf), nil
|
|
}
|
|
|
|
func (x *ListChainLocalOverridesRequest) SetSignature(sig *Signature) {
|
|
x.Signature = sig
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *ListChainLocalOverridesResponse_Body) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.RepeatedBytesSize(1, x.Chains)
|
|
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 *ListChainLocalOverridesResponse_Body) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.RepeatedBytesMarshal(1, buf[offset:], x.Chains)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *ListChainLocalOverridesResponse) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
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 *ListChainLocalOverridesResponse) 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.Signature)
|
|
return buf
|
|
}
|
|
|
|
// ReadSignedData fills buf with signed data of x.
|
|
// If buffer length is less than x.SignedDataSize(), 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 signed data.
|
|
func (x *ListChainLocalOverridesResponse) SignedDataSize() int {
|
|
return x.GetBody().StableSize()
|
|
}
|
|
|
|
// SignedDataSize returns size of the request signed data in bytes.
|
|
//
|
|
// Structures with the same field values have the same signed data size.
|
|
func (x *ListChainLocalOverridesResponse) ReadSignedData(buf []byte) ([]byte, error) {
|
|
return x.GetBody().StableMarshal(buf), nil
|
|
}
|
|
|
|
func (x *ListChainLocalOverridesResponse) SetSignature(sig *Signature) {
|
|
x.Signature = sig
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *RemoveChainLocalOverrideRequest_Body) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Target)
|
|
size += proto.BytesSize(2, x.ChainId)
|
|
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 *RemoveChainLocalOverrideRequest_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.Target)
|
|
offset += proto.BytesMarshal(2, buf[offset:], x.ChainId)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *RemoveChainLocalOverrideRequest) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
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 *RemoveChainLocalOverrideRequest) 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.Signature)
|
|
return buf
|
|
}
|
|
|
|
// ReadSignedData fills buf with signed data of x.
|
|
// If buffer length is less than x.SignedDataSize(), 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 signed data.
|
|
func (x *RemoveChainLocalOverrideRequest) SignedDataSize() int {
|
|
return x.GetBody().StableSize()
|
|
}
|
|
|
|
// SignedDataSize returns size of the request signed data in bytes.
|
|
//
|
|
// Structures with the same field values have the same signed data size.
|
|
func (x *RemoveChainLocalOverrideRequest) ReadSignedData(buf []byte) ([]byte, error) {
|
|
return x.GetBody().StableMarshal(buf), nil
|
|
}
|
|
|
|
func (x *RemoveChainLocalOverrideRequest) SetSignature(sig *Signature) {
|
|
x.Signature = sig
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *RemoveChainLocalOverrideResponse_Body) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.BoolSize(1, x.Removed)
|
|
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 *RemoveChainLocalOverrideResponse_Body) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.BoolMarshal(1, buf[offset:], x.Removed)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *RemoveChainLocalOverrideResponse) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
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 *RemoveChainLocalOverrideResponse) 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.Signature)
|
|
return buf
|
|
}
|
|
|
|
// ReadSignedData fills buf with signed data of x.
|
|
// If buffer length is less than x.SignedDataSize(), 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 signed data.
|
|
func (x *RemoveChainLocalOverrideResponse) SignedDataSize() int {
|
|
return x.GetBody().StableSize()
|
|
}
|
|
|
|
// SignedDataSize returns size of the request signed data in bytes.
|
|
//
|
|
// Structures with the same field values have the same signed data size.
|
|
func (x *RemoveChainLocalOverrideResponse) ReadSignedData(buf []byte) ([]byte, error) {
|
|
return x.GetBody().StableMarshal(buf), nil
|
|
}
|
|
|
|
func (x *RemoveChainLocalOverrideResponse) SetSignature(sig *Signature) {
|
|
x.Signature = sig
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *SealWriteCacheRequest_Body) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.RepeatedBytesSize(1, x.Shard_ID)
|
|
size += proto.BoolSize(2, x.IgnoreErrors)
|
|
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 *SealWriteCacheRequest_Body) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.RepeatedBytesMarshal(1, buf[offset:], x.Shard_ID)
|
|
offset += proto.BoolMarshal(2, buf[offset:], x.IgnoreErrors)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *SealWriteCacheRequest) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
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 *SealWriteCacheRequest) 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.Signature)
|
|
return buf
|
|
}
|
|
|
|
// ReadSignedData fills buf with signed data of x.
|
|
// If buffer length is less than x.SignedDataSize(), 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 signed data.
|
|
func (x *SealWriteCacheRequest) SignedDataSize() int {
|
|
return x.GetBody().StableSize()
|
|
}
|
|
|
|
// SignedDataSize returns size of the request signed data in bytes.
|
|
//
|
|
// Structures with the same field values have the same signed data size.
|
|
func (x *SealWriteCacheRequest) ReadSignedData(buf []byte) ([]byte, error) {
|
|
return x.GetBody().StableMarshal(buf), nil
|
|
}
|
|
|
|
func (x *SealWriteCacheRequest) SetSignature(sig *Signature) {
|
|
x.Signature = sig
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *SealWriteCacheResponse_Body_Status) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.BytesSize(1, x.Shard_ID)
|
|
size += proto.BoolSize(2, x.Success)
|
|
size += proto.StringSize(3, x.Error)
|
|
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 *SealWriteCacheResponse_Body_Status) StableMarshal(buf []byte) []byte {
|
|
if x == nil {
|
|
return []byte{}
|
|
}
|
|
if buf == nil {
|
|
buf = make([]byte, x.StableSize())
|
|
}
|
|
var offset int
|
|
offset += proto.BytesMarshal(1, buf[offset:], x.Shard_ID)
|
|
offset += proto.BoolMarshal(2, buf[offset:], x.Success)
|
|
offset += proto.StringMarshal(3, buf[offset:], x.Error)
|
|
return buf
|
|
}
|
|
|
|
// StableSize returns the size of x in protobuf format.
|
|
//
|
|
// Structures with the same field values have the same binary size.
|
|
func (x *SealWriteCacheResponse_Body) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
for i := range x.Results {
|
|
size += proto.NestedStructureSize(1, x.Results[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 *SealWriteCacheResponse_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.Results {
|
|
offset += proto.NestedStructureMarshal(1, buf[offset:], x.Results[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 *SealWriteCacheResponse) StableSize() (size int) {
|
|
if x == nil {
|
|
return 0
|
|
}
|
|
size += proto.NestedStructureSize(1, x.Body)
|
|
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 *SealWriteCacheResponse) 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.Signature)
|
|
return buf
|
|
}
|
|
|
|
// ReadSignedData fills buf with signed data of x.
|
|
// If buffer length is less than x.SignedDataSize(), 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 signed data.
|
|
func (x *SealWriteCacheResponse) SignedDataSize() int {
|
|
return x.GetBody().StableSize()
|
|
}
|
|
|
|
// SignedDataSize returns size of the request signed data in bytes.
|
|
//
|
|
// Structures with the same field values have the same signed data size.
|
|
func (x *SealWriteCacheResponse) ReadSignedData(buf []byte) ([]byte, error) {
|
|
return x.GetBody().StableMarshal(buf), nil
|
|
}
|
|
|
|
func (x *SealWriteCacheResponse) SetSignature(sig *Signature) {
|
|
x.Signature = sig
|
|
}
|