forked from TrueCloudLab/frostfs-api-go
1316 lines
31 KiB
Go
1316 lines
31 KiB
Go
package object
|
|
|
|
import (
|
|
object "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/object/grpc"
|
|
"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/refs"
|
|
"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/rpc/message"
|
|
"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/util/proto"
|
|
)
|
|
|
|
const (
|
|
shortHdrVersionField = 1
|
|
shortHdrEpochField = 2
|
|
shortHdrOwnerField = 3
|
|
shortHdrObjectTypeField = 4
|
|
shortHdrPayloadLength = 5
|
|
shortHdrHashField = 6
|
|
shortHdrHomoHashField = 7
|
|
|
|
attributeKeyField = 1
|
|
attributeValueField = 2
|
|
|
|
splitHdrParentField = 1
|
|
splitHdrPreviousField = 2
|
|
splitHdrParentSignatureField = 3
|
|
splitHdrParentHeaderField = 4
|
|
splitHdrChildrenField = 5
|
|
splitHdrSplitIDField = 6
|
|
|
|
ecHdrParentField = 1
|
|
ecHdrIndexField = 2
|
|
ecHdrTotalField = 3
|
|
ecHdrHeaderLengthField = 4
|
|
ecHdrHeaderField = 5
|
|
ecHdrParentSplitID = 6
|
|
ecHdrParentSplitParentID = 7
|
|
ecHdrParentAttributes = 8
|
|
|
|
hdrVersionField = 1
|
|
hdrContainerIDField = 2
|
|
hdrOwnerIDField = 3
|
|
hdrEpochField = 4
|
|
hdrPayloadLengthField = 5
|
|
hdrPayloadHashField = 6
|
|
hdrObjectTypeField = 7
|
|
hdrHomomorphicHashField = 8
|
|
hdrSessionTokenField = 9
|
|
hdrAttributesField = 10
|
|
hdrSplitField = 11
|
|
hdrECField = 12
|
|
|
|
hdrWithSigHeaderField = 1
|
|
hdrWithSigSignatureField = 2
|
|
|
|
objIDField = 1
|
|
objSignatureField = 2
|
|
objHeaderField = 3
|
|
objPayloadField = 4
|
|
|
|
splitInfoSplitIDField = 1
|
|
splitInfoLastPartField = 2
|
|
splitInfoLinkField = 3
|
|
|
|
ecInfoChunksField = 1
|
|
|
|
ecChunkIDField = 1
|
|
ecChunkIndexField = 2
|
|
ecChunkTotalField = 3
|
|
|
|
getReqBodyAddressField = 1
|
|
getReqBodyRawFlagField = 2
|
|
|
|
getRespInitObjectIDField = 1
|
|
getRespInitSignatureField = 2
|
|
getRespInitHeaderField = 3
|
|
|
|
getRespBodyInitField = 1
|
|
getRespBodyChunkField = 2
|
|
getRespBodySplitInfoField = 3
|
|
getRespBodyECInfoField = 4
|
|
|
|
putReqInitObjectIDField = 1
|
|
putReqInitSignatureField = 2
|
|
putReqInitHeaderField = 3
|
|
putReqInitCopiesNumField = 4
|
|
|
|
putReqBodyInitField = 1
|
|
putReqBodyChunkField = 2
|
|
|
|
putRespBodyObjectIDField = 1
|
|
|
|
deleteReqBodyAddressField = 1
|
|
|
|
deleteRespBodyTombstoneFNum = 1
|
|
|
|
headReqBodyAddressField = 1
|
|
headReqBodyMainFlagField = 2
|
|
headReqBodyRawFlagField = 3
|
|
|
|
headRespBodyHeaderField = 1
|
|
headRespBodyShortHeaderField = 2
|
|
headRespBodySplitInfoField = 3
|
|
headRespBodyECInfoField = 4
|
|
|
|
searchFilterMatchField = 1
|
|
searchFilterNameField = 2
|
|
searchFilterValueField = 3
|
|
|
|
searchReqBodyContainerIDField = 1
|
|
searchReqBodyVersionField = 2
|
|
searchReqBodyFiltersField = 3
|
|
|
|
searchRespBodyObjectIDsField = 1
|
|
|
|
rangeOffsetField = 1
|
|
rangeLengthField = 2
|
|
|
|
getRangeReqBodyAddressField = 1
|
|
getRangeReqBodyRangeField = 2
|
|
getRangeReqBodyRawField = 3
|
|
|
|
getRangeRespChunkField = 1
|
|
getRangeRespSplitInfoField = 2
|
|
getRangeRespECInfoField = 3
|
|
|
|
getRangeHashReqBodyAddressField = 1
|
|
getRangeHashReqBodyRangesField = 2
|
|
getRangeHashReqBodySaltField = 3
|
|
getRangeHashReqBodyTypeField = 4
|
|
|
|
getRangeHashRespBodyTypeField = 1
|
|
getRangeHashRespBodyHashListField = 2
|
|
|
|
putSingleReqObjectField = 1
|
|
putSingleReqCopiesNumberField = 2
|
|
)
|
|
|
|
func (h *ShortHeader) StableMarshal(buf []byte) []byte {
|
|
if h == nil {
|
|
return []byte{}
|
|
}
|
|
|
|
if buf == nil {
|
|
buf = make([]byte, h.StableSize())
|
|
}
|
|
|
|
var offset int
|
|
|
|
offset += proto.NestedStructureMarshal(shortHdrVersionField, buf[offset:], h.version)
|
|
offset += proto.UInt64Marshal(shortHdrEpochField, buf[offset:], h.creatEpoch)
|
|
offset += proto.NestedStructureMarshal(shortHdrOwnerField, buf[offset:], h.ownerID)
|
|
offset += proto.EnumMarshal(shortHdrObjectTypeField, buf[offset:], int32(h.typ))
|
|
offset += proto.UInt64Marshal(shortHdrPayloadLength, buf[offset:], h.payloadLen)
|
|
offset += proto.NestedStructureMarshal(shortHdrHashField, buf[offset:], h.payloadHash)
|
|
proto.NestedStructureMarshal(shortHdrHomoHashField, buf[offset:], h.homoHash)
|
|
|
|
return buf
|
|
}
|
|
|
|
func (h *ShortHeader) StableSize() (size int) {
|
|
if h == nil {
|
|
return 0
|
|
}
|
|
|
|
size += proto.NestedStructureSize(shortHdrVersionField, h.version)
|
|
size += proto.UInt64Size(shortHdrEpochField, h.creatEpoch)
|
|
size += proto.NestedStructureSize(shortHdrOwnerField, h.ownerID)
|
|
size += proto.EnumSize(shortHdrObjectTypeField, int32(h.typ))
|
|
size += proto.UInt64Size(shortHdrPayloadLength, h.payloadLen)
|
|
size += proto.NestedStructureSize(shortHdrHashField, h.payloadHash)
|
|
size += proto.NestedStructureSize(shortHdrHomoHashField, h.homoHash)
|
|
|
|
return size
|
|
}
|
|
|
|
func (h *ShortHeader) Unmarshal(data []byte) error {
|
|
return message.Unmarshal(h, data, new(object.ShortHeader))
|
|
}
|
|
|
|
func (a *Attribute) StableMarshal(buf []byte) []byte {
|
|
if a == nil {
|
|
return []byte{}
|
|
}
|
|
|
|
if buf == nil {
|
|
buf = make([]byte, a.StableSize())
|
|
}
|
|
|
|
var offset int
|
|
|
|
offset += proto.StringMarshal(attributeKeyField, buf[offset:], a.key)
|
|
proto.StringMarshal(attributeValueField, buf[offset:], a.val)
|
|
|
|
return buf
|
|
}
|
|
|
|
func (a *Attribute) StableSize() (size int) {
|
|
if a == nil {
|
|
return 0
|
|
}
|
|
|
|
size += proto.StringSize(shortHdrVersionField, a.key)
|
|
size += proto.StringSize(shortHdrEpochField, a.val)
|
|
|
|
return size
|
|
}
|
|
|
|
func (a *Attribute) Unmarshal(data []byte) error {
|
|
return message.Unmarshal(a, data, new(object.Header_Attribute))
|
|
}
|
|
|
|
func (h *SplitHeader) StableMarshal(buf []byte) []byte {
|
|
if h == nil {
|
|
return []byte{}
|
|
}
|
|
|
|
if buf == nil {
|
|
buf = make([]byte, h.StableSize())
|
|
}
|
|
|
|
var offset int
|
|
|
|
offset += proto.NestedStructureMarshal(splitHdrParentField, buf[offset:], h.par)
|
|
offset += proto.NestedStructureMarshal(splitHdrPreviousField, buf[offset:], h.prev)
|
|
offset += proto.NestedStructureMarshal(splitHdrParentSignatureField, buf[offset:], h.parSig)
|
|
offset += proto.NestedStructureMarshal(splitHdrParentHeaderField, buf[offset:], h.parHdr)
|
|
offset += refs.ObjectIDNestedListMarshal(splitHdrChildrenField, buf[offset:], h.children)
|
|
proto.BytesMarshal(splitHdrSplitIDField, buf[offset:], h.splitID)
|
|
|
|
return buf
|
|
}
|
|
|
|
func (h *SplitHeader) StableSize() (size int) {
|
|
if h == nil {
|
|
return 0
|
|
}
|
|
|
|
size += proto.NestedStructureSize(splitHdrParentField, h.par)
|
|
size += proto.NestedStructureSize(splitHdrPreviousField, h.prev)
|
|
size += proto.NestedStructureSize(splitHdrParentSignatureField, h.parSig)
|
|
size += proto.NestedStructureSize(splitHdrParentHeaderField, h.parHdr)
|
|
size += refs.ObjectIDNestedListSize(splitHdrChildrenField, h.children)
|
|
size += proto.BytesSize(splitHdrSplitIDField, h.splitID)
|
|
|
|
return size
|
|
}
|
|
|
|
func (h *SplitHeader) Unmarshal(data []byte) error {
|
|
return message.Unmarshal(h, data, new(object.Header_Split))
|
|
}
|
|
|
|
func (h *ECHeader) StableMarshal(buf []byte) []byte {
|
|
if h == nil {
|
|
return []byte{}
|
|
}
|
|
|
|
if buf == nil {
|
|
buf = make([]byte, h.StableSize())
|
|
}
|
|
|
|
var offset int
|
|
|
|
offset += proto.NestedStructureMarshal(ecHdrParentField, buf[offset:], h.Parent)
|
|
offset += proto.UInt32Marshal(ecHdrIndexField, buf[offset:], h.Index)
|
|
offset += proto.UInt32Marshal(ecHdrTotalField, buf[offset:], h.Total)
|
|
offset += proto.UInt32Marshal(ecHdrHeaderLengthField, buf[offset:], h.HeaderLength)
|
|
offset += proto.BytesMarshal(ecHdrHeaderField, buf[offset:], h.Header)
|
|
offset += proto.BytesMarshal(ecHdrParentSplitID, buf[offset:], h.ParentSplitID)
|
|
offset += proto.NestedStructureMarshal(ecHdrParentSplitParentID, buf[offset:], h.ParentSplitParentID)
|
|
for i := range h.ParentAttributes {
|
|
offset += proto.NestedStructureMarshal(ecHdrParentAttributes, buf[offset:], &h.ParentAttributes[i])
|
|
}
|
|
return buf
|
|
}
|
|
|
|
func (h *ECHeader) StableSize() (size int) {
|
|
if h == nil {
|
|
return 0
|
|
}
|
|
|
|
size += proto.NestedStructureSize(ecHdrParentField, h.Parent)
|
|
size += proto.UInt32Size(ecHdrIndexField, h.Index)
|
|
size += proto.UInt32Size(ecHdrTotalField, h.Total)
|
|
size += proto.UInt32Size(ecHdrHeaderLengthField, h.HeaderLength)
|
|
size += proto.BytesSize(ecHdrHeaderField, h.Header)
|
|
size += proto.BytesSize(ecHdrParentSplitID, h.ParentSplitID)
|
|
size += proto.NestedStructureSize(ecHdrParentSplitParentID, h.ParentSplitParentID)
|
|
for i := range h.ParentAttributes {
|
|
size += proto.NestedStructureSize(ecHdrParentAttributes, &h.ParentAttributes[i])
|
|
}
|
|
|
|
return size
|
|
}
|
|
|
|
func (h *ECHeader) Unmarshal(data []byte) error {
|
|
return message.Unmarshal(h, data, new(object.Header_EC))
|
|
}
|
|
|
|
func (h *Header) StableMarshal(buf []byte) []byte {
|
|
if h == nil {
|
|
return []byte{}
|
|
}
|
|
|
|
if buf == nil {
|
|
buf = make([]byte, h.StableSize())
|
|
}
|
|
|
|
var offset int
|
|
|
|
offset += proto.NestedStructureMarshal(hdrVersionField, buf[offset:], h.version)
|
|
offset += proto.NestedStructureMarshal(hdrContainerIDField, buf[offset:], h.cid)
|
|
offset += proto.NestedStructureMarshal(hdrOwnerIDField, buf[offset:], h.ownerID)
|
|
offset += proto.UInt64Marshal(hdrEpochField, buf[offset:], h.creatEpoch)
|
|
offset += proto.UInt64Marshal(hdrPayloadLengthField, buf[offset:], h.payloadLen)
|
|
offset += proto.NestedStructureMarshal(hdrPayloadHashField, buf[offset:], h.payloadHash)
|
|
offset += proto.EnumMarshal(hdrObjectTypeField, buf[offset:], int32(h.typ))
|
|
offset += proto.NestedStructureMarshal(hdrHomomorphicHashField, buf[offset:], h.homoHash)
|
|
offset += proto.NestedStructureMarshal(hdrSessionTokenField, buf[offset:], h.sessionToken)
|
|
|
|
for i := range h.attr {
|
|
offset += proto.NestedStructureMarshal(hdrAttributesField, buf[offset:], &h.attr[i])
|
|
}
|
|
|
|
proto.NestedStructureMarshal(hdrSplitField, buf[offset:], h.split)
|
|
proto.NestedStructureMarshal(hdrECField, buf[offset:], h.ec)
|
|
|
|
return buf
|
|
}
|
|
|
|
func (h *Header) StableSize() (size int) {
|
|
if h == nil {
|
|
return 0
|
|
}
|
|
|
|
size += proto.NestedStructureSize(hdrVersionField, h.version)
|
|
size += proto.NestedStructureSize(hdrContainerIDField, h.cid)
|
|
size += proto.NestedStructureSize(hdrOwnerIDField, h.ownerID)
|
|
size += proto.UInt64Size(hdrEpochField, h.creatEpoch)
|
|
size += proto.UInt64Size(hdrPayloadLengthField, h.payloadLen)
|
|
size += proto.NestedStructureSize(hdrPayloadHashField, h.payloadHash)
|
|
size += proto.EnumSize(hdrObjectTypeField, int32(h.typ))
|
|
size += proto.NestedStructureSize(hdrHomomorphicHashField, h.homoHash)
|
|
size += proto.NestedStructureSize(hdrSessionTokenField, h.sessionToken)
|
|
for i := range h.attr {
|
|
size += proto.NestedStructureSize(hdrAttributesField, &h.attr[i])
|
|
}
|
|
size += proto.NestedStructureSize(hdrSplitField, h.split)
|
|
size += proto.NestedStructureSize(hdrECField, h.ec)
|
|
|
|
return size
|
|
}
|
|
|
|
func (h *Header) Unmarshal(data []byte) error {
|
|
return message.Unmarshal(h, data, new(object.Header))
|
|
}
|
|
|
|
func (h *HeaderWithSignature) StableMarshal(buf []byte) []byte {
|
|
if h == nil {
|
|
return []byte{}
|
|
}
|
|
|
|
if buf == nil {
|
|
buf = make([]byte, h.StableSize())
|
|
}
|
|
|
|
var offset int
|
|
|
|
offset += proto.NestedStructureMarshal(hdrWithSigHeaderField, buf[offset:], h.header)
|
|
proto.NestedStructureMarshal(hdrWithSigSignatureField, buf[offset:], h.signature)
|
|
|
|
return buf
|
|
}
|
|
|
|
func (h *HeaderWithSignature) StableSize() (size int) {
|
|
if h == nil {
|
|
return 0
|
|
}
|
|
|
|
size += proto.NestedStructureSize(hdrVersionField, h.header)
|
|
size += proto.NestedStructureSize(hdrContainerIDField, h.signature)
|
|
|
|
return size
|
|
}
|
|
|
|
func (h *HeaderWithSignature) Unmarshal(data []byte) error {
|
|
return message.Unmarshal(h, data, new(object.HeaderWithSignature))
|
|
}
|
|
|
|
func (o *Object) StableMarshal(buf []byte) []byte {
|
|
if o == nil {
|
|
return []byte{}
|
|
}
|
|
|
|
if o.marshalData != nil {
|
|
if buf == nil {
|
|
return o.marshalData
|
|
}
|
|
copy(buf, o.marshalData)
|
|
return buf
|
|
}
|
|
|
|
if buf == nil {
|
|
buf = make([]byte, o.StableSize())
|
|
}
|
|
|
|
var offset int
|
|
|
|
offset += proto.NestedStructureMarshal(objIDField, buf[offset:], o.objectID)
|
|
offset += proto.NestedStructureMarshal(objSignatureField, buf[offset:], o.idSig)
|
|
offset += proto.NestedStructureMarshal(objHeaderField, buf[offset:], o.header)
|
|
proto.BytesMarshal(objPayloadField, buf[offset:], o.payload)
|
|
|
|
return buf
|
|
}
|
|
|
|
// SetMarshalData sets marshal data to reduce memory allocations.
|
|
//
|
|
// It is unsafe to modify/copy object data after setting marshal data.
|
|
func (o *Object) SetMarshalData(data []byte) {
|
|
if o == nil {
|
|
return
|
|
}
|
|
o.marshalData = data
|
|
}
|
|
|
|
func (o *Object) StableSize() (size int) {
|
|
if o == nil {
|
|
return 0
|
|
}
|
|
|
|
size += proto.NestedStructureSize(objIDField, o.objectID)
|
|
size += proto.NestedStructureSize(objSignatureField, o.idSig)
|
|
size += proto.NestedStructureSize(objHeaderField, o.header)
|
|
size += proto.BytesSize(objPayloadField, o.payload)
|
|
|
|
return size
|
|
}
|
|
|
|
func (o *Object) Unmarshal(data []byte) error {
|
|
return message.Unmarshal(o, data, new(object.Object))
|
|
}
|
|
|
|
func (s *SplitInfo) StableMarshal(buf []byte) []byte {
|
|
if s == nil {
|
|
return []byte{}
|
|
}
|
|
|
|
if buf == nil {
|
|
buf = make([]byte, s.StableSize())
|
|
}
|
|
|
|
var offset int
|
|
|
|
offset += proto.BytesMarshal(splitInfoSplitIDField, buf[offset:], s.splitID)
|
|
offset += proto.NestedStructureMarshal(splitInfoLastPartField, buf[offset:], s.lastPart)
|
|
proto.NestedStructureMarshal(splitInfoLinkField, buf[offset:], s.link)
|
|
|
|
return buf
|
|
}
|
|
|
|
func (s *SplitInfo) StableSize() (size int) {
|
|
if s == nil {
|
|
return 0
|
|
}
|
|
|
|
size += proto.BytesSize(splitInfoSplitIDField, s.splitID)
|
|
size += proto.NestedStructureSize(splitInfoLastPartField, s.lastPart)
|
|
size += proto.NestedStructureSize(splitInfoLinkField, s.link)
|
|
|
|
return size
|
|
}
|
|
|
|
func (s *SplitInfo) Unmarshal(data []byte) error {
|
|
return message.Unmarshal(s, data, new(object.SplitInfo))
|
|
}
|
|
|
|
func (e *ECInfo) StableMarshal(buf []byte) []byte {
|
|
if e == nil {
|
|
return []byte{}
|
|
}
|
|
|
|
if buf == nil {
|
|
buf = make([]byte, e.StableSize())
|
|
}
|
|
|
|
var offset int
|
|
|
|
for i := range e.Chunks {
|
|
offset += proto.NestedStructureMarshal(ecInfoChunksField, buf[offset:], &e.Chunks[i])
|
|
}
|
|
|
|
return buf
|
|
}
|
|
|
|
func (e *ECInfo) StableSize() (size int) {
|
|
if e == nil {
|
|
return 0
|
|
}
|
|
|
|
for i := range e.Chunks {
|
|
size += proto.NestedStructureSize(ecInfoChunksField, &e.Chunks[i])
|
|
}
|
|
|
|
return size
|
|
}
|
|
|
|
func (e *ECInfo) Unmarshal(data []byte) error {
|
|
return message.Unmarshal(e, data, new(object.ECInfo))
|
|
}
|
|
|
|
func (c *ECChunk) StableMarshal(buf []byte) []byte {
|
|
if c == nil {
|
|
return []byte{}
|
|
}
|
|
|
|
if buf == nil {
|
|
buf = make([]byte, c.StableSize())
|
|
}
|
|
|
|
var offset int
|
|
|
|
offset += proto.NestedStructureMarshal(ecChunkIDField, buf[offset:], &c.ID)
|
|
offset += proto.UInt32Marshal(ecChunkIndexField, buf[offset:], c.Index)
|
|
proto.UInt32Marshal(ecChunkTotalField, buf[offset:], c.Total)
|
|
|
|
return buf
|
|
}
|
|
|
|
func (c *ECChunk) StableSize() (size int) {
|
|
if c == nil {
|
|
return 0
|
|
}
|
|
|
|
size += proto.NestedStructureSize(ecChunkIDField, &c.ID)
|
|
size += proto.UInt32Size(ecChunkIndexField, c.Index)
|
|
size += proto.UInt32Size(ecChunkTotalField, c.Total)
|
|
|
|
return size
|
|
}
|
|
|
|
func (c *ECChunk) Unmarshal(data []byte) error {
|
|
return message.Unmarshal(c, data, new(object.ECInfo_Chunk))
|
|
}
|
|
|
|
func (r *GetRequestBody) StableMarshal(buf []byte) []byte {
|
|
if r == nil {
|
|
return []byte{}
|
|
}
|
|
|
|
if buf == nil {
|
|
buf = make([]byte, r.StableSize())
|
|
}
|
|
|
|
var offset int
|
|
|
|
offset += proto.NestedStructureMarshal(getReqBodyAddressField, buf[offset:], r.addr)
|
|
proto.BoolMarshal(getReqBodyRawFlagField, buf[offset:], r.raw)
|
|
|
|
return buf
|
|
}
|
|
|
|
func (r *GetRequestBody) StableSize() (size int) {
|
|
if r == nil {
|
|
return 0
|
|
}
|
|
|
|
size += proto.NestedStructureSize(getReqBodyAddressField, r.addr)
|
|
size += proto.BoolSize(getReqBodyRawFlagField, r.raw)
|
|
|
|
return size
|
|
}
|
|
|
|
func (r *GetRequestBody) Unmarshal(data []byte) error {
|
|
return message.Unmarshal(r, data, new(object.GetRequest_Body))
|
|
}
|
|
|
|
func (r *GetObjectPartInit) StableMarshal(buf []byte) []byte {
|
|
if r == nil {
|
|
return []byte{}
|
|
}
|
|
|
|
if buf == nil {
|
|
buf = make([]byte, r.StableSize())
|
|
}
|
|
|
|
var offset int
|
|
|
|
offset += proto.NestedStructureMarshal(getRespInitObjectIDField, buf[offset:], r.id)
|
|
offset += proto.NestedStructureMarshal(getRespInitSignatureField, buf[offset:], r.sig)
|
|
proto.NestedStructureMarshal(getRespInitHeaderField, buf[offset:], r.hdr)
|
|
|
|
return buf
|
|
}
|
|
|
|
func (r *GetObjectPartInit) StableSize() (size int) {
|
|
if r == nil {
|
|
return 0
|
|
}
|
|
|
|
size += proto.NestedStructureSize(getRespInitObjectIDField, r.id)
|
|
size += proto.NestedStructureSize(getRespInitSignatureField, r.sig)
|
|
size += proto.NestedStructureSize(getRespInitHeaderField, r.hdr)
|
|
|
|
return size
|
|
}
|
|
|
|
func (r *GetObjectPartInit) Unmarshal(data []byte) error {
|
|
return message.Unmarshal(r, data, new(object.GetResponse_Body_Init))
|
|
}
|
|
|
|
func (r *GetResponseBody) StableMarshal(buf []byte) []byte {
|
|
if r == nil {
|
|
return []byte{}
|
|
}
|
|
|
|
if buf == nil {
|
|
buf = make([]byte, r.StableSize())
|
|
}
|
|
|
|
switch v := r.objPart.(type) {
|
|
case nil:
|
|
case *GetObjectPartInit:
|
|
proto.NestedStructureMarshal(getRespBodyInitField, buf, v)
|
|
case *GetObjectPartChunk:
|
|
if v != nil {
|
|
proto.BytesMarshal(getRespBodyChunkField, buf, v.chunk)
|
|
}
|
|
case *SplitInfo:
|
|
proto.NestedStructureMarshal(getRespBodySplitInfoField, buf, v)
|
|
case *ECInfo:
|
|
proto.NestedStructureMarshal(getRespBodyECInfoField, buf, v)
|
|
default:
|
|
panic("unknown one of object get response body type")
|
|
}
|
|
|
|
return buf
|
|
}
|
|
|
|
func (r *GetResponseBody) StableSize() (size int) {
|
|
if r == nil {
|
|
return 0
|
|
}
|
|
|
|
switch v := r.objPart.(type) {
|
|
case nil:
|
|
case *GetObjectPartInit:
|
|
size += proto.NestedStructureSize(getRespBodyInitField, v)
|
|
case *GetObjectPartChunk:
|
|
if v != nil {
|
|
size += proto.BytesSize(getRespBodyChunkField, v.chunk)
|
|
}
|
|
case *SplitInfo:
|
|
size += proto.NestedStructureSize(getRespBodySplitInfoField, v)
|
|
case *ECInfo:
|
|
size += proto.NestedStructureSize(getRespBodyECInfoField, v)
|
|
default:
|
|
panic("unknown one of object get response body type")
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (r *GetResponseBody) Unmarshal(data []byte) error {
|
|
return message.Unmarshal(r, data, new(object.GetResponse_Body))
|
|
}
|
|
|
|
func (r *PutObjectPartInit) StableMarshal(buf []byte) []byte {
|
|
if r == nil {
|
|
return []byte{}
|
|
}
|
|
|
|
if buf == nil {
|
|
buf = make([]byte, r.StableSize())
|
|
}
|
|
|
|
var offset int
|
|
|
|
offset += proto.NestedStructureMarshal(putReqInitObjectIDField, buf[offset:], r.id)
|
|
offset += proto.NestedStructureMarshal(putReqInitSignatureField, buf[offset:], r.sig)
|
|
offset += proto.NestedStructureMarshal(putReqInitHeaderField, buf[offset:], r.hdr)
|
|
proto.RepeatedUInt32Marshal(putReqInitCopiesNumField, buf[offset:], r.copyNum)
|
|
|
|
return buf
|
|
}
|
|
|
|
func (r *PutObjectPartInit) StableSize() (size int) {
|
|
if r == nil {
|
|
return 0
|
|
}
|
|
|
|
size += proto.NestedStructureSize(putReqInitObjectIDField, r.id)
|
|
size += proto.NestedStructureSize(putReqInitSignatureField, r.sig)
|
|
size += proto.NestedStructureSize(putReqInitHeaderField, r.hdr)
|
|
|
|
arrSize, _ := proto.RepeatedUInt32Size(putReqInitCopiesNumField, r.copyNum)
|
|
size += arrSize
|
|
|
|
return size
|
|
}
|
|
|
|
func (r *PutObjectPartInit) Unmarshal(data []byte) error {
|
|
return message.Unmarshal(r, data, new(object.PutRequest_Body_Init))
|
|
}
|
|
|
|
func (r *PutRequestBody) StableMarshal(buf []byte) []byte {
|
|
if r == nil {
|
|
return []byte{}
|
|
}
|
|
|
|
if buf == nil {
|
|
buf = make([]byte, r.StableSize())
|
|
}
|
|
|
|
switch v := r.objPart.(type) {
|
|
case nil:
|
|
case *PutObjectPartInit:
|
|
proto.NestedStructureMarshal(putReqBodyInitField, buf, v)
|
|
case *PutObjectPartChunk:
|
|
if v != nil {
|
|
proto.BytesMarshal(putReqBodyChunkField, buf, v.chunk)
|
|
}
|
|
default:
|
|
panic("unknown one of object put request body type")
|
|
}
|
|
|
|
return buf
|
|
}
|
|
|
|
func (r *PutRequestBody) StableSize() (size int) {
|
|
if r == nil {
|
|
return 0
|
|
}
|
|
|
|
switch v := r.objPart.(type) {
|
|
case nil:
|
|
case *PutObjectPartInit:
|
|
size += proto.NestedStructureSize(putReqBodyInitField, v)
|
|
case *PutObjectPartChunk:
|
|
if v != nil {
|
|
size += proto.BytesSize(putReqBodyChunkField, v.chunk)
|
|
}
|
|
default:
|
|
panic("unknown one of object get response body type")
|
|
}
|
|
|
|
return size
|
|
}
|
|
|
|
func (r *PutRequestBody) Unmarshal(data []byte) error {
|
|
return message.Unmarshal(r, data, new(object.PutRequest_Body))
|
|
}
|
|
|
|
func (r *PutResponseBody) StableMarshal(buf []byte) []byte {
|
|
if r == nil {
|
|
return []byte{}
|
|
}
|
|
|
|
if buf == nil {
|
|
buf = make([]byte, r.StableSize())
|
|
}
|
|
|
|
proto.NestedStructureMarshal(putRespBodyObjectIDField, buf, r.id)
|
|
|
|
return buf
|
|
}
|
|
|
|
func (r *PutResponseBody) StableSize() (size int) {
|
|
if r == nil {
|
|
return 0
|
|
}
|
|
|
|
size += proto.NestedStructureSize(putRespBodyObjectIDField, r.id)
|
|
|
|
return size
|
|
}
|
|
|
|
func (r *PutResponseBody) Unmarshal(data []byte) error {
|
|
return message.Unmarshal(r, data, new(object.PutResponse_Body))
|
|
}
|
|
|
|
func (r *DeleteRequestBody) StableMarshal(buf []byte) []byte {
|
|
if r == nil {
|
|
return []byte{}
|
|
}
|
|
|
|
if buf == nil {
|
|
buf = make([]byte, r.StableSize())
|
|
}
|
|
|
|
proto.NestedStructureMarshal(deleteReqBodyAddressField, buf, r.addr)
|
|
|
|
return buf
|
|
}
|
|
|
|
func (r *DeleteRequestBody) StableSize() (size int) {
|
|
if r == nil {
|
|
return 0
|
|
}
|
|
|
|
size += proto.NestedStructureSize(deleteReqBodyAddressField, r.addr)
|
|
|
|
return size
|
|
}
|
|
|
|
func (r *DeleteRequestBody) Unmarshal(data []byte) error {
|
|
return message.Unmarshal(r, data, new(object.DeleteRequest_Body))
|
|
}
|
|
|
|
func (r *DeleteResponseBody) StableMarshal(buf []byte) []byte {
|
|
if r == nil {
|
|
return []byte{}
|
|
}
|
|
|
|
if buf == nil {
|
|
buf = make([]byte, r.StableSize())
|
|
}
|
|
|
|
proto.NestedStructureMarshal(deleteRespBodyTombstoneFNum, buf, r.tombstone)
|
|
|
|
return buf
|
|
}
|
|
|
|
func (r *DeleteResponseBody) StableSize() (size int) {
|
|
if r == nil {
|
|
return 0
|
|
}
|
|
|
|
size += proto.NestedStructureSize(deleteRespBodyTombstoneFNum, r.tombstone)
|
|
|
|
return size
|
|
}
|
|
|
|
func (r *DeleteResponseBody) Unmarshal(data []byte) error {
|
|
return message.Unmarshal(r, data, new(object.DeleteResponse_Body))
|
|
}
|
|
|
|
func (r *HeadRequestBody) StableMarshal(buf []byte) []byte {
|
|
if r == nil {
|
|
return []byte{}
|
|
}
|
|
|
|
if buf == nil {
|
|
buf = make([]byte, r.StableSize())
|
|
}
|
|
|
|
var offset int
|
|
|
|
offset += proto.NestedStructureMarshal(headReqBodyAddressField, buf[offset:], r.addr)
|
|
offset += proto.BoolMarshal(headReqBodyMainFlagField, buf[offset:], r.mainOnly)
|
|
proto.BoolMarshal(headReqBodyRawFlagField, buf[offset:], r.raw)
|
|
|
|
return buf
|
|
}
|
|
|
|
func (r *HeadRequestBody) StableSize() (size int) {
|
|
if r == nil {
|
|
return 0
|
|
}
|
|
|
|
size += proto.NestedStructureSize(headReqBodyAddressField, r.addr)
|
|
size += proto.BoolSize(headReqBodyMainFlagField, r.mainOnly)
|
|
size += proto.BoolSize(headReqBodyRawFlagField, r.raw)
|
|
|
|
return size
|
|
}
|
|
|
|
func (r *HeadRequestBody) Unmarshal(data []byte) error {
|
|
return message.Unmarshal(r, data, new(object.HeadRequest_Body))
|
|
}
|
|
|
|
func (r *HeadResponseBody) StableMarshal(buf []byte) []byte {
|
|
if r == nil {
|
|
return []byte{}
|
|
}
|
|
|
|
if buf == nil {
|
|
buf = make([]byte, r.StableSize())
|
|
}
|
|
|
|
switch v := r.hdrPart.(type) {
|
|
case nil:
|
|
case *HeaderWithSignature:
|
|
if v != nil {
|
|
proto.NestedStructureMarshal(headRespBodyHeaderField, buf, v)
|
|
}
|
|
case *ShortHeader:
|
|
if v != nil {
|
|
proto.NestedStructureMarshal(headRespBodyShortHeaderField, buf, v)
|
|
}
|
|
case *SplitInfo:
|
|
if v != nil {
|
|
proto.NestedStructureMarshal(headRespBodySplitInfoField, buf, v)
|
|
}
|
|
case *ECInfo:
|
|
if v != nil {
|
|
proto.NestedStructureMarshal(headRespBodyECInfoField, buf, v)
|
|
}
|
|
default:
|
|
panic("unknown one of object put request body type")
|
|
}
|
|
|
|
return buf
|
|
}
|
|
|
|
func (r *HeadResponseBody) StableSize() (size int) {
|
|
if r == nil {
|
|
return 0
|
|
}
|
|
|
|
switch v := r.hdrPart.(type) {
|
|
case nil:
|
|
case *HeaderWithSignature:
|
|
if v != nil {
|
|
size += proto.NestedStructureSize(headRespBodyHeaderField, v)
|
|
}
|
|
case *ShortHeader:
|
|
if v != nil {
|
|
size += proto.NestedStructureSize(headRespBodyShortHeaderField, v)
|
|
}
|
|
case *SplitInfo:
|
|
if v != nil {
|
|
size += proto.NestedStructureSize(headRespBodySplitInfoField, v)
|
|
}
|
|
case *ECInfo:
|
|
if v != nil {
|
|
size += proto.NestedStructureSize(headRespBodyECInfoField, v)
|
|
}
|
|
default:
|
|
panic("unknown one of object put request body type")
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (r *HeadResponseBody) Unmarshal(data []byte) error {
|
|
return message.Unmarshal(r, data, new(object.HeadResponse_Body))
|
|
}
|
|
|
|
func (f *SearchFilter) StableMarshal(buf []byte) []byte {
|
|
if f == nil {
|
|
return []byte{}
|
|
}
|
|
|
|
if buf == nil {
|
|
buf = make([]byte, f.StableSize())
|
|
}
|
|
|
|
var offset int
|
|
|
|
offset += proto.EnumMarshal(searchFilterMatchField, buf[offset:], int32(f.matchType))
|
|
offset += proto.StringMarshal(searchFilterNameField, buf[offset:], f.key)
|
|
proto.StringMarshal(searchFilterValueField, buf[offset:], f.val)
|
|
|
|
return buf
|
|
}
|
|
|
|
func (f *SearchFilter) StableSize() (size int) {
|
|
if f == nil {
|
|
return 0
|
|
}
|
|
|
|
size += proto.EnumSize(searchFilterMatchField, int32(f.matchType))
|
|
size += proto.StringSize(searchFilterNameField, f.key)
|
|
size += proto.StringSize(searchFilterValueField, f.val)
|
|
|
|
return size
|
|
}
|
|
|
|
func (f *SearchFilter) Unmarshal(data []byte) error {
|
|
return message.Unmarshal(f, data, new(object.SearchRequest_Body_Filter))
|
|
}
|
|
|
|
func (r *SearchRequestBody) StableMarshal(buf []byte) []byte {
|
|
if r == nil {
|
|
return []byte{}
|
|
}
|
|
|
|
if buf == nil {
|
|
buf = make([]byte, r.StableSize())
|
|
}
|
|
|
|
var offset int
|
|
|
|
offset += proto.NestedStructureMarshal(searchReqBodyContainerIDField, buf[offset:], r.cid)
|
|
offset += proto.UInt32Marshal(searchReqBodyVersionField, buf[offset:], r.version)
|
|
|
|
for i := range r.filters {
|
|
offset += proto.NestedStructureMarshal(searchReqBodyFiltersField, buf[offset:], &r.filters[i])
|
|
}
|
|
|
|
return buf
|
|
}
|
|
|
|
func (r *SearchRequestBody) StableSize() (size int) {
|
|
if r == nil {
|
|
return 0
|
|
}
|
|
|
|
size += proto.NestedStructureSize(searchReqBodyContainerIDField, r.cid)
|
|
size += proto.UInt32Size(searchReqBodyVersionField, r.version)
|
|
|
|
for i := range r.filters {
|
|
size += proto.NestedStructureSize(searchReqBodyFiltersField, &r.filters[i])
|
|
}
|
|
|
|
return size
|
|
}
|
|
|
|
func (r *SearchRequestBody) Unmarshal(data []byte) error {
|
|
return message.Unmarshal(r, data, new(object.SearchRequest_Body))
|
|
}
|
|
|
|
func (r *SearchResponseBody) StableMarshal(buf []byte) []byte {
|
|
if r == nil {
|
|
return []byte{}
|
|
}
|
|
|
|
if buf == nil {
|
|
buf = make([]byte, r.StableSize())
|
|
}
|
|
|
|
var offset int
|
|
|
|
refs.ObjectIDNestedListMarshal(searchRespBodyObjectIDsField, buf[offset:], r.idList)
|
|
|
|
return buf
|
|
}
|
|
|
|
func (r *SearchResponseBody) StableSize() (size int) {
|
|
if r == nil {
|
|
return 0
|
|
}
|
|
|
|
size += refs.ObjectIDNestedListSize(searchRespBodyObjectIDsField, r.idList)
|
|
|
|
return size
|
|
}
|
|
|
|
func (r *SearchResponseBody) Unmarshal(data []byte) error {
|
|
return message.Unmarshal(r, data, new(object.SearchResponse_Body))
|
|
}
|
|
|
|
func (r *Range) StableMarshal(buf []byte) []byte {
|
|
if r == nil {
|
|
return []byte{}
|
|
}
|
|
|
|
if buf == nil {
|
|
buf = make([]byte, r.StableSize())
|
|
}
|
|
|
|
var offset int
|
|
|
|
offset += proto.UInt64Marshal(rangeOffsetField, buf[offset:], r.off)
|
|
proto.UInt64Marshal(rangeLengthField, buf[offset:], r.len)
|
|
|
|
return buf
|
|
}
|
|
|
|
func (r *Range) StableSize() (size int) {
|
|
if r == nil {
|
|
return 0
|
|
}
|
|
|
|
size += proto.UInt64Size(rangeOffsetField, r.off)
|
|
size += proto.UInt64Size(rangeLengthField, r.len)
|
|
|
|
return size
|
|
}
|
|
|
|
func (r *Range) Unmarshal(data []byte) error {
|
|
return message.Unmarshal(r, data, new(object.Range))
|
|
}
|
|
|
|
func (r *GetRangeRequestBody) StableMarshal(buf []byte) []byte {
|
|
if r == nil {
|
|
return []byte{}
|
|
}
|
|
|
|
if buf == nil {
|
|
buf = make([]byte, r.StableSize())
|
|
}
|
|
|
|
var offset int
|
|
|
|
offset += proto.NestedStructureMarshal(getRangeReqBodyAddressField, buf[offset:], r.addr)
|
|
offset += proto.NestedStructureMarshal(getRangeReqBodyRangeField, buf[offset:], r.rng)
|
|
proto.BoolMarshal(getRangeReqBodyRawField, buf[offset:], r.raw)
|
|
|
|
return buf
|
|
}
|
|
|
|
func (r *GetRangeRequestBody) StableSize() (size int) {
|
|
if r == nil {
|
|
return 0
|
|
}
|
|
|
|
size += proto.NestedStructureSize(getRangeReqBodyAddressField, r.addr)
|
|
size += proto.NestedStructureSize(getRangeReqBodyRangeField, r.rng)
|
|
size += proto.BoolSize(getRangeReqBodyRawField, r.raw)
|
|
|
|
return size
|
|
}
|
|
|
|
func (r *GetRangeRequestBody) Unmarshal(data []byte) error {
|
|
return message.Unmarshal(r, data, new(object.GetRangeRequest_Body))
|
|
}
|
|
|
|
func (r *GetRangeResponseBody) StableMarshal(buf []byte) []byte {
|
|
if r == nil {
|
|
return []byte{}
|
|
}
|
|
|
|
if buf == nil {
|
|
buf = make([]byte, r.StableSize())
|
|
}
|
|
|
|
switch v := r.rngPart.(type) {
|
|
case nil:
|
|
case *GetRangePartChunk:
|
|
if v != nil {
|
|
proto.BytesMarshal(getRangeRespChunkField, buf, v.chunk)
|
|
}
|
|
case *SplitInfo:
|
|
if v != nil {
|
|
proto.NestedStructureMarshal(getRangeRespSplitInfoField, buf, v)
|
|
}
|
|
case *ECInfo:
|
|
if v != nil {
|
|
proto.NestedStructureMarshal(getRangeRespECInfoField, buf, v)
|
|
}
|
|
default:
|
|
panic("unknown one of object get range request body type")
|
|
}
|
|
|
|
return buf
|
|
}
|
|
|
|
func (r *GetRangeResponseBody) StableSize() (size int) {
|
|
if r == nil {
|
|
return 0
|
|
}
|
|
|
|
switch v := r.rngPart.(type) {
|
|
case nil:
|
|
case *GetRangePartChunk:
|
|
if v != nil {
|
|
size += proto.BytesSize(getRangeRespChunkField, v.chunk)
|
|
}
|
|
case *SplitInfo:
|
|
if v != nil {
|
|
size = proto.NestedStructureSize(getRangeRespSplitInfoField, v)
|
|
}
|
|
case *ECInfo:
|
|
if v != nil {
|
|
size = proto.NestedStructureSize(getRangeRespECInfoField, v)
|
|
}
|
|
default:
|
|
panic("unknown one of object get range request body type")
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (r *GetRangeResponseBody) Unmarshal(data []byte) error {
|
|
return message.Unmarshal(r, data, new(object.GetRangeResponse_Body))
|
|
}
|
|
|
|
func (r *GetRangeHashRequestBody) StableMarshal(buf []byte) []byte {
|
|
if r == nil {
|
|
return []byte{}
|
|
}
|
|
|
|
if buf == nil {
|
|
buf = make([]byte, r.StableSize())
|
|
}
|
|
|
|
var offset int
|
|
|
|
offset += proto.NestedStructureMarshal(getRangeHashReqBodyAddressField, buf[offset:], r.addr)
|
|
|
|
for i := range r.rngs {
|
|
offset += proto.NestedStructureMarshal(getRangeHashReqBodyRangesField, buf[offset:], &r.rngs[i])
|
|
}
|
|
|
|
offset += proto.BytesMarshal(getRangeHashReqBodySaltField, buf[offset:], r.salt)
|
|
proto.EnumMarshal(getRangeHashReqBodyTypeField, buf[offset:], int32(r.typ))
|
|
|
|
return buf
|
|
}
|
|
|
|
func (r *GetRangeHashRequestBody) StableSize() (size int) {
|
|
if r == nil {
|
|
return 0
|
|
}
|
|
|
|
size += proto.NestedStructureSize(getRangeHashReqBodyAddressField, r.addr)
|
|
|
|
for i := range r.rngs {
|
|
size += proto.NestedStructureSize(getRangeHashReqBodyRangesField, &r.rngs[i])
|
|
}
|
|
|
|
size += proto.BytesSize(getRangeHashReqBodySaltField, r.salt)
|
|
size += proto.EnumSize(getRangeHashReqBodyTypeField, int32(r.typ))
|
|
|
|
return size
|
|
}
|
|
|
|
func (r *GetRangeHashRequestBody) Unmarshal(data []byte) error {
|
|
return message.Unmarshal(r, data, new(object.GetRangeHashRequest_Body))
|
|
}
|
|
|
|
func (r *GetRangeHashResponseBody) StableMarshal(buf []byte) []byte {
|
|
if r == nil {
|
|
return []byte{}
|
|
}
|
|
|
|
if buf == nil {
|
|
buf = make([]byte, r.StableSize())
|
|
}
|
|
|
|
var offset int
|
|
|
|
offset += proto.EnumMarshal(getRangeHashRespBodyTypeField, buf, int32(r.typ))
|
|
proto.RepeatedBytesMarshal(getRangeHashRespBodyHashListField, buf[offset:], r.hashList)
|
|
|
|
return buf
|
|
}
|
|
|
|
func (r *GetRangeHashResponseBody) StableSize() (size int) {
|
|
if r == nil {
|
|
return 0
|
|
}
|
|
|
|
size += proto.EnumSize(getRangeHashRespBodyTypeField, int32(r.typ))
|
|
size += proto.RepeatedBytesSize(getRangeHashRespBodyHashListField, r.hashList)
|
|
|
|
return size
|
|
}
|
|
|
|
func (r *GetRangeHashResponseBody) Unmarshal(data []byte) error {
|
|
return message.Unmarshal(r, data, new(object.GetRangeHashResponse_Body))
|
|
}
|
|
|
|
func (r *PutSingleRequestBody) StableMarshal(buf []byte) []byte {
|
|
if r == nil {
|
|
return []byte{}
|
|
}
|
|
|
|
if r.marshalData != nil {
|
|
if buf == nil {
|
|
return r.marshalData
|
|
}
|
|
copy(buf, r.marshalData)
|
|
return buf
|
|
}
|
|
|
|
if buf == nil {
|
|
buf = make([]byte, r.StableSize())
|
|
}
|
|
|
|
var offset int
|
|
offset += proto.NestedStructureMarshal(putSingleReqObjectField, buf[offset:], r.object)
|
|
proto.RepeatedUInt32Marshal(putSingleReqCopiesNumberField, buf[offset:], r.copyNum)
|
|
|
|
return buf
|
|
}
|
|
|
|
// SetMarshalData sets marshal data to reduce memory allocations.
|
|
//
|
|
// It is unsafe to modify/copy request data after setting marshal data.
|
|
func (r *PutSingleRequestBody) SetMarshalData(data []byte) {
|
|
if r == nil {
|
|
return
|
|
}
|
|
|
|
r.marshalData = data
|
|
|
|
proto.NestedStructureSetMarshalData(putSingleReqObjectField, r.marshalData, r.object)
|
|
}
|
|
|
|
func (r *PutSingleRequestBody) StableSize() int {
|
|
if r == nil {
|
|
return 0
|
|
}
|
|
|
|
var size int
|
|
size += proto.NestedStructureSize(putSingleReqObjectField, r.object)
|
|
arrSize, _ := proto.RepeatedUInt32Size(putSingleReqCopiesNumberField, r.copyNum)
|
|
size += arrSize
|
|
|
|
return size
|
|
}
|
|
|
|
func (r *PutSingleRequestBody) Unmarshal(data []byte) error {
|
|
return message.Unmarshal(r, data, new(object.PutSingleRequest_Body))
|
|
}
|
|
|
|
func (r *PutSingleResponseBody) StableMarshal(buf []byte) []byte {
|
|
if r == nil {
|
|
return []byte{}
|
|
}
|
|
|
|
if buf == nil {
|
|
buf = make([]byte, r.StableSize())
|
|
}
|
|
|
|
return buf
|
|
}
|
|
|
|
func (r *PutSingleResponseBody) StableSize() int {
|
|
return 0
|
|
}
|
|
|
|
func (r *PutSingleResponseBody) Unmarshal(data []byte) error {
|
|
return message.Unmarshal(r, data, new(object.PutSingleResponse_Body))
|
|
}
|