frostfs-api-go/v2/object/convert.go

1671 lines
28 KiB
Go
Raw Normal View History

package object
import (
"fmt"
object "github.com/nspcc-dev/neofs-api-go/v2/object/grpc"
"github.com/nspcc-dev/neofs-api-go/v2/refs"
refsGRPC "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
"github.com/nspcc-dev/neofs-api-go/v2/session"
)
func TypeToGRPCField(t Type) object.ObjectType {
return object.ObjectType(t)
}
func TypeFromGRPCField(t object.ObjectType) Type {
return Type(t)
}
func MatchTypeToGRPCField(t MatchType) object.MatchType {
return object.MatchType(t)
}
func MatchTypeFromGRPCField(t object.MatchType) MatchType {
return MatchType(t)
}
func ShortHeaderToGRPCMessage(h *ShortHeader) *object.ShortHeader {
if h == nil {
return nil
}
m := new(object.ShortHeader)
m.SetVersion(
refs.VersionToGRPCMessage(h.GetVersion()),
)
m.SetCreationEpoch(h.GetCreationEpoch())
m.SetOwnerId(
refs.OwnerIDToGRPCMessage(h.GetOwnerID()),
)
m.SetObjectType(
TypeToGRPCField(h.GetObjectType()),
)
m.SetPayloadLength(h.GetPayloadLength())
m.SetPayloadHash(
refs.ChecksumToGRPCMessage(h.GetPayloadHash()),
)
m.SetHomomorphicHash(
refs.ChecksumToGRPCMessage(h.GetHomomorphicHash()),
)
return m
}
func ShortHeaderFromGRPCMessage(m *object.ShortHeader) *ShortHeader {
if m == nil {
return nil
}
h := new(ShortHeader)
h.SetVersion(
refs.VersionFromGRPCMessage(m.GetVersion()),
)
h.SetCreationEpoch(m.GetCreationEpoch())
h.SetOwnerID(
refs.OwnerIDFromGRPCMessage(m.GetOwnerId()),
)
h.SetObjectType(
TypeFromGRPCField(m.GetObjectType()),
)
h.SetPayloadLength(m.GetPayloadLength())
h.SetPayloadHash(
refs.ChecksumFromGRPCMessage(m.GetPayloadHash()),
)
h.SetHomomorphicHash(
refs.ChecksumFromGRPCMessage(m.GetHomomorphicHash()),
)
return h
}
func AttributeToGRPCMessage(a *Attribute) *object.Header_Attribute {
if a == nil {
return nil
}
m := new(object.Header_Attribute)
m.SetKey(a.GetKey())
m.SetValue(a.GetValue())
return m
}
func AttributeFromGRPCMessage(m *object.Header_Attribute) *Attribute {
if m == nil {
return nil
}
h := new(Attribute)
h.SetKey(m.GetKey())
h.SetValue(m.GetValue())
return h
}
func SplitHeaderToGRPCMessage(h *SplitHeader) *object.Header_Split {
if h == nil {
return nil
}
m := new(object.Header_Split)
m.SetParent(
refs.ObjectIDToGRPCMessage(h.GetParent()),
)
m.SetPrevious(
refs.ObjectIDToGRPCMessage(h.GetPrevious()),
)
m.SetParentSignature(
refs.SignatureToGRPCMessage(h.GetParentSignature()),
)
m.SetParentHeader(
HeaderToGRPCMessage(h.GetParentHeader()),
)
children := h.GetChildren()
childMsg := make([]*refsGRPC.ObjectID, 0, len(children))
for i := range children {
childMsg = append(childMsg, refs.ObjectIDToGRPCMessage(children[i]))
}
m.SetChildren(childMsg)
m.SetSplitId(h.GetSplitID())
return m
}
func SplitHeaderFromGRPCMessage(m *object.Header_Split) *SplitHeader {
if m == nil {
return nil
}
h := new(SplitHeader)
h.SetParent(
refs.ObjectIDFromGRPCMessage(m.GetParent()),
)
h.SetPrevious(
refs.ObjectIDFromGRPCMessage(m.GetPrevious()),
)
h.SetParentSignature(
refs.SignatureFromGRPCMessage(m.GetParentSignature()),
)
h.SetParentHeader(
HeaderFromGRPCMessage(m.GetParentHeader()),
)
childMsg := m.GetChildren()
children := make([]*refs.ObjectID, 0, len(childMsg))
for i := range childMsg {
children = append(children, refs.ObjectIDFromGRPCMessage(childMsg[i]))
}
h.SetChildren(children)
h.SetSplitID(m.GetSplitId())
return h
}
func HeaderToGRPCMessage(h *Header) *object.Header {
if h == nil {
return nil
}
m := new(object.Header)
m.SetVersion(
refs.VersionToGRPCMessage(h.GetVersion()),
)
m.SetContainerId(
refs.ContainerIDToGRPCMessage(h.GetContainerID()),
)
m.SetOwnerId(
refs.OwnerIDToGRPCMessage(h.GetOwnerID()),
)
m.SetCreationEpoch(h.GetCreationEpoch())
m.SetPayloadLength(h.GetPayloadLength())
m.SetPayloadHash(
refs.ChecksumToGRPCMessage(h.GetPayloadHash()),
)
m.SetHomomorphicHash(
refs.ChecksumToGRPCMessage(h.GetHomomorphicHash()),
)
m.SetObjectType(
TypeToGRPCField(h.GetObjectType()),
)
m.SetSessionToken(
session.SessionTokenToGRPCMessage(h.GetSessionToken()),
)
attr := h.GetAttributes()
attrMsg := make([]*object.Header_Attribute, 0, len(attr))
for i := range attr {
attrMsg = append(attrMsg, AttributeToGRPCMessage(attr[i]))
}
m.SetAttributes(attrMsg)
m.SetSplit(
SplitHeaderToGRPCMessage(h.GetSplit()),
)
return m
}
func HeaderFromGRPCMessage(m *object.Header) *Header {
if m == nil {
return nil
}
h := new(Header)
h.SetVersion(
refs.VersionFromGRPCMessage(m.GetVersion()),
)
h.SetContainerID(
refs.ContainerIDFromGRPCMessage(m.GetContainerId()),
)
h.SetOwnerID(
refs.OwnerIDFromGRPCMessage(m.GetOwnerId()),
)
h.SetCreationEpoch(m.GetCreationEpoch())
h.SetPayloadLength(m.GetPayloadLength())
h.SetPayloadHash(
refs.ChecksumFromGRPCMessage(m.GetPayloadHash()),
)
h.SetHomomorphicHash(
refs.ChecksumFromGRPCMessage(m.GetHomomorphicHash()),
)
h.SetObjectType(
TypeFromGRPCField(m.GetObjectType()),
)
h.SetSessionToken(
session.SessionTokenFromGRPCMessage(m.GetSessionToken()),
)
attrMsg := m.GetAttributes()
attr := make([]*Attribute, 0, len(attrMsg))
for i := range attrMsg {
attr = append(attr, AttributeFromGRPCMessage(attrMsg[i]))
}
h.SetAttributes(attr)
h.SetSplit(
SplitHeaderFromGRPCMessage(m.GetSplit()),
)
return h
}
func HeaderWithSignatureToGRPCMessage(h *HeaderWithSignature) *object.HeaderWithSignature {
if h == nil {
return nil
}
m := new(object.HeaderWithSignature)
m.SetHeader(
HeaderToGRPCMessage(h.GetHeader()),
)
m.SetSignature(
refs.SignatureToGRPCMessage(h.GetSignature()),
)
return m
}
func HeaderWithSignatureFromGRPCMessage(m *object.HeaderWithSignature) *HeaderWithSignature {
if m == nil {
return nil
}
h := new(HeaderWithSignature)
h.SetHeader(
HeaderFromGRPCMessage(m.GetHeader()),
)
h.SetSignature(
refs.SignatureFromGRPCMessage(m.GetSignature()),
)
return h
}
func ObjectToGRPCMessage(o *Object) *object.Object {
if o == nil {
return nil
}
m := new(object.Object)
m.SetObjectId(
refs.ObjectIDToGRPCMessage(o.GetObjectID()),
)
m.SetSignature(
refs.SignatureToGRPCMessage(o.GetSignature()),
)
m.SetHeader(
HeaderToGRPCMessage(o.GetHeader()),
)
m.SetPayload(o.GetPayload())
return m
}
func ObjectFromGRPCMessage(m *object.Object) *Object {
if m == nil {
return nil
}
o := new(Object)
o.SetObjectID(
refs.ObjectIDFromGRPCMessage(m.GetObjectId()),
)
o.SetSignature(
refs.SignatureFromGRPCMessage(m.GetSignature()),
)
o.SetHeader(
HeaderFromGRPCMessage(m.GetHeader()),
)
o.SetPayload(m.GetPayload())
return o
}
func SplitInfoToGRPCMessage(s *SplitInfo) *object.SplitInfo {
if s == nil {
return nil
}
m := new(object.SplitInfo)
m.SetSplitId(s.GetSplitID())
m.SetLastPart(
refs.ObjectIDToGRPCMessage(s.GetLastPart()),
)
m.SetLink(
refs.ObjectIDToGRPCMessage(s.GetLink()),
)
return m
}
func SplitInfoFromGRPCMessage(m *object.SplitInfo) *SplitInfo {
if m == nil {
return nil
}
r := new(SplitInfo)
r.SetSplitID(m.GetSplitId())
r.SetLastPart(
refs.ObjectIDFromGRPCMessage(m.GetLastPart()),
)
r.SetLink(
refs.ObjectIDFromGRPCMessage(m.GetLink()),
)
return r
}
func GetRequestBodyToGRPCMessage(r *GetRequestBody) *object.GetRequest_Body {
if r == nil {
return nil
}
m := new(object.GetRequest_Body)
m.SetAddress(
refs.AddressToGRPCMessage(r.GetAddress()),
)
m.SetRaw(r.GetRaw())
return m
}
func GetRequestBodyFromGRPCMessage(m *object.GetRequest_Body) *GetRequestBody {
if m == nil {
return nil
}
r := new(GetRequestBody)
r.SetAddress(
refs.AddressFromGRPCMessage(m.GetAddress()),
)
r.SetRaw(m.GetRaw())
return r
}
func GetRequestToGRPCMessage(r *GetRequest) *object.GetRequest {
if r == nil {
return nil
}
m := new(object.GetRequest)
m.SetBody(
GetRequestBodyToGRPCMessage(r.GetBody()),
)
session.RequestHeadersToGRPC(r, m)
return m
}
func GetRequestFromGRPCMessage(m *object.GetRequest) *GetRequest {
if m == nil {
return nil
}
r := new(GetRequest)
r.SetBody(
GetRequestBodyFromGRPCMessage(m.GetBody()),
)
session.RequestHeadersFromGRPC(m, r)
return r
}
func GetObjectPartInitToGRPCMessage(r *GetObjectPartInit) *object.GetResponse_Body_Init {
if r == nil {
return nil
}
m := new(object.GetResponse_Body_Init)
m.SetObjectId(
refs.ObjectIDToGRPCMessage(r.GetObjectID()),
)
m.SetSignature(
refs.SignatureToGRPCMessage(r.GetSignature()),
)
m.SetHeader(
HeaderToGRPCMessage(r.GetHeader()),
)
return m
}
func GetObjectPartInitFromGRPCMessage(m *object.GetResponse_Body_Init) *GetObjectPartInit {
if m == nil {
return nil
}
r := new(GetObjectPartInit)
r.SetObjectID(
refs.ObjectIDFromGRPCMessage(m.GetObjectId()),
)
r.SetSignature(
refs.SignatureFromGRPCMessage(m.GetSignature()),
)
r.SetHeader(
HeaderFromGRPCMessage(m.GetHeader()),
)
return r
}
func GetObjectPartChunkToGRPCMessage(r *GetObjectPartChunk) *object.GetResponse_Body_Chunk {
if r == nil {
return nil
}
m := new(object.GetResponse_Body_Chunk)
m.SetChunk(r.GetChunk())
return m
}
func GetObjectPartChunkFromGRPCMessage(m *object.GetResponse_Body_Chunk) *GetObjectPartChunk {
if m == nil {
return nil
}
r := new(GetObjectPartChunk)
r.SetChunk(m.GetChunk())
return r
}
func GetResponseBodyToGRPCMessage(r *GetResponseBody) *object.GetResponse_Body {
if r == nil {
return nil
}
m := new(object.GetResponse_Body)
switch v := r.GetObjectPart(); t := v.(type) {
case nil:
case *GetObjectPartInit:
m.SetInit(
GetObjectPartInitToGRPCMessage(t),
)
case *GetObjectPartChunk:
m.SetChunk(
GetObjectPartChunkToGRPCMessage(t),
)
case *SplitInfo:
m.SetSplitInfo(
SplitInfoToGRPCMessage(t),
)
default:
panic(fmt.Sprintf("unknown object part %T", t))
}
return m
}
func GetResponseBodyFromGRPCMessage(m *object.GetResponse_Body) *GetResponseBody {
if m == nil {
return nil
}
r := new(GetResponseBody)
switch v := m.GetObjectPart().(type) {
case nil:
case *object.GetResponse_Body_Init_:
r.SetObjectPart(
GetObjectPartInitFromGRPCMessage(v.Init),
)
case *object.GetResponse_Body_Chunk:
r.SetObjectPart(
GetObjectPartChunkFromGRPCMessage(v),
)
case *object.GetResponse_Body_SplitInfo:
r.SetObjectPart(
SplitInfoFromGRPCMessage(v.SplitInfo),
)
default:
panic(fmt.Sprintf("unknown object part %T", v))
}
return r
}
func GetResponseToGRPCMessage(r *GetResponse) *object.GetResponse {
if r == nil {
return nil
}
m := new(object.GetResponse)
m.SetBody(
GetResponseBodyToGRPCMessage(r.GetBody()),
)
session.ResponseHeadersToGRPC(r, m)
return m
}
func GetResponseFromGRPCMessage(m *object.GetResponse) *GetResponse {
if m == nil {
return nil
}
r := new(GetResponse)
r.SetBody(
GetResponseBodyFromGRPCMessage(m.GetBody()),
)
session.ResponseHeadersFromGRPC(m, r)
return r
}
func PutObjectPartInitToGRPCMessage(r *PutObjectPartInit) *object.PutRequest_Body_Init {
if r == nil {
return nil
}
m := new(object.PutRequest_Body_Init)
m.SetObjectId(
refs.ObjectIDToGRPCMessage(r.GetObjectID()),
)
m.SetSignature(
refs.SignatureToGRPCMessage(r.GetSignature()),
)
m.SetHeader(
HeaderToGRPCMessage(r.GetHeader()),
)
m.SetCopiesNumber(r.GetCopiesNumber())
return m
}
func PutObjectPartInitFromGRPCMessage(m *object.PutRequest_Body_Init) *PutObjectPartInit {
if m == nil {
return nil
}
r := new(PutObjectPartInit)
r.SetObjectID(
refs.ObjectIDFromGRPCMessage(m.GetObjectId()),
)
r.SetSignature(
refs.SignatureFromGRPCMessage(m.GetSignature()),
)
r.SetHeader(
HeaderFromGRPCMessage(m.GetHeader()),
)
r.SetCopiesNumber(m.GetCopiesNumber())
return r
}
func PutObjectPartChunkToGRPCMessage(r *PutObjectPartChunk) *object.PutRequest_Body_Chunk {
if r == nil {
return nil
}
m := new(object.PutRequest_Body_Chunk)
m.SetChunk(r.GetChunk())
return m
}
func PutObjectPartChunkFromGRPCMessage(m *object.PutRequest_Body_Chunk) *PutObjectPartChunk {
if m == nil {
return nil
}
r := new(PutObjectPartChunk)
r.SetChunk(m.GetChunk())
return r
}
func PutRequestBodyToGRPCMessage(r *PutRequestBody) *object.PutRequest_Body {
if r == nil {
return nil
}
m := new(object.PutRequest_Body)
switch v := r.GetObjectPart(); t := v.(type) {
case nil:
case *PutObjectPartInit:
m.SetInit(
PutObjectPartInitToGRPCMessage(t),
)
case *PutObjectPartChunk:
m.SetChunk(
PutObjectPartChunkToGRPCMessage(t),
)
default:
panic(fmt.Sprintf("unknown object part %T", t))
}
return m
}
func PutRequestBodyFromGRPCMessage(m *object.PutRequest_Body) *PutRequestBody {
if m == nil {
return nil
}
r := new(PutRequestBody)
switch v := m.GetObjectPart().(type) {
case nil:
case *object.PutRequest_Body_Init_:
r.SetObjectPart(
PutObjectPartInitFromGRPCMessage(v.Init),
)
case *object.PutRequest_Body_Chunk:
r.SetObjectPart(
PutObjectPartChunkFromGRPCMessage(v),
)
default:
panic(fmt.Sprintf("unknown object part %T", v))
}
return r
}
func PutRequestToGRPCMessage(r *PutRequest) *object.PutRequest {
if r == nil {
return nil
}
m := new(object.PutRequest)
m.SetBody(
PutRequestBodyToGRPCMessage(r.GetBody()),
)
session.RequestHeadersToGRPC(r, m)
return m
}
func PutRequestFromGRPCMessage(m *object.PutRequest) *PutRequest {
if m == nil {
return nil
}
r := new(PutRequest)
r.SetBody(
PutRequestBodyFromGRPCMessage(m.GetBody()),
)
session.RequestHeadersFromGRPC(m, r)
return r
}
func PutResponseBodyToGRPCMessage(r *PutResponseBody) *object.PutResponse_Body {
if r == nil {
return nil
}
m := new(object.PutResponse_Body)
m.SetObjectId(
refs.ObjectIDToGRPCMessage(r.GetObjectID()),
)
return m
}
func PutResponseBodyFromGRPCMessage(m *object.PutResponse_Body) *PutResponseBody {
if m == nil {
return nil
}
r := new(PutResponseBody)
r.SetObjectID(
refs.ObjectIDFromGRPCMessage(m.GetObjectId()),
)
return r
}
func PutResponseToGRPCMessage(r *PutResponse) *object.PutResponse {
if r == nil {
return nil
}
m := new(object.PutResponse)
m.SetBody(
PutResponseBodyToGRPCMessage(r.GetBody()),
)
session.ResponseHeadersToGRPC(r, m)
return m
}
func PutResponseFromGRPCMessage(m *object.PutResponse) *PutResponse {
if m == nil {
return nil
}
r := new(PutResponse)
r.SetBody(
PutResponseBodyFromGRPCMessage(m.GetBody()),
)
session.ResponseHeadersFromGRPC(m, r)
return r
}
func DeleteRequestBodyToGRPCMessage(r *DeleteRequestBody) *object.DeleteRequest_Body {
if r == nil {
return nil
}
m := new(object.DeleteRequest_Body)
m.SetAddress(
refs.AddressToGRPCMessage(r.GetAddress()),
)
return m
}
func DeleteRequestBodyFromGRPCMessage(m *object.DeleteRequest_Body) *DeleteRequestBody {
if m == nil {
return nil
}
r := new(DeleteRequestBody)
r.SetAddress(
refs.AddressFromGRPCMessage(m.GetAddress()),
)
return r
}
func DeleteRequestToGRPCMessage(r *DeleteRequest) *object.DeleteRequest {
if r == nil {
return nil
}
m := new(object.DeleteRequest)
m.SetBody(
DeleteRequestBodyToGRPCMessage(r.GetBody()),
)
session.RequestHeadersToGRPC(r, m)
return m
}
func DeleteRequestFromGRPCMessage(m *object.DeleteRequest) *DeleteRequest {
if m == nil {
return nil
}
r := new(DeleteRequest)
r.SetBody(
DeleteRequestBodyFromGRPCMessage(m.GetBody()),
)
session.RequestHeadersFromGRPC(m, r)
return r
}
func DeleteResponseBodyToGRPCMessage(r *DeleteResponseBody) *object.DeleteResponse_Body {
if r == nil {
return nil
}
m := new(object.DeleteResponse_Body)
m.SetTombstone(
refs.AddressToGRPCMessage(r.GetTombstone()),
)
return m
}
func DeleteResponseBodyFromGRPCMessage(m *object.DeleteResponse_Body) *DeleteResponseBody {
if m == nil {
return nil
}
r := new(DeleteResponseBody)
r.SetTombstone(
refs.AddressFromGRPCMessage(m.GetTombstone()),
)
return r
}
func DeleteResponseToGRPCMessage(r *DeleteResponse) *object.DeleteResponse {
if r == nil {
return nil
}
m := new(object.DeleteResponse)
m.SetBody(
DeleteResponseBodyToGRPCMessage(r.GetBody()),
)
session.ResponseHeadersToGRPC(r, m)
return m
}
func DeleteResponseFromGRPCMessage(m *object.DeleteResponse) *DeleteResponse {
if m == nil {
return nil
}
r := new(DeleteResponse)
r.SetBody(
DeleteResponseBodyFromGRPCMessage(m.GetBody()),
)
session.ResponseHeadersFromGRPC(m, r)
return r
}
func HeadRequestBodyToGRPCMessage(r *HeadRequestBody) *object.HeadRequest_Body {
if r == nil {
return nil
}
m := new(object.HeadRequest_Body)
m.SetAddress(
refs.AddressToGRPCMessage(r.GetAddress()),
)
m.SetMainOnly(r.GetMainOnly())
m.SetRaw(r.GetRaw())
return m
}
func HeadRequestBodyFromGRPCMessage(m *object.HeadRequest_Body) *HeadRequestBody {
if m == nil {
return nil
}
r := new(HeadRequestBody)
r.SetAddress(
refs.AddressFromGRPCMessage(m.GetAddress()),
)
r.SetMainOnly(m.GetMainOnly())
r.SetRaw(m.GetRaw())
return r
}
func HeadRequestToGRPCMessage(r *HeadRequest) *object.HeadRequest {
if r == nil {
return nil
}
m := new(object.HeadRequest)
m.SetBody(
HeadRequestBodyToGRPCMessage(r.GetBody()),
)
session.RequestHeadersToGRPC(r, m)
return m
}
func HeadRequestFromGRPCMessage(m *object.HeadRequest) *HeadRequest {
if m == nil {
return nil
}
r := new(HeadRequest)
r.SetBody(
HeadRequestBodyFromGRPCMessage(m.GetBody()),
)
session.RequestHeadersFromGRPC(m, r)
return r
}
func HeadResponseBodyToGRPCMessage(r *HeadResponseBody) *object.HeadResponse_Body {
if r == nil {
return nil
}
m := new(object.HeadResponse_Body)
switch v := r.GetHeaderPart(); t := v.(type) {
case nil:
case *HeaderWithSignature:
m.SetHeader(
HeaderWithSignatureToGRPCMessage(t),
)
case *ShortHeader:
m.SetShortHeader(
ShortHeaderToGRPCMessage(t),
)
case *SplitInfo:
m.SetSplitInfo(
SplitInfoToGRPCMessage(t),
)
default:
panic(fmt.Sprintf("unknown header part %T", t))
}
return m
}
func HeadResponseBodyFromGRPCMessage(m *object.HeadResponse_Body) *HeadResponseBody {
if m == nil {
return nil
}
r := new(HeadResponseBody)
switch v := m.GetHead().(type) {
case nil:
case *object.HeadResponse_Body_Header:
r.SetHeaderPart(
HeaderWithSignatureFromGRPCMessage(v.Header),
)
case *object.HeadResponse_Body_ShortHeader:
r.SetHeaderPart(
ShortHeaderFromGRPCMessage(v.ShortHeader),
)
case *object.HeadResponse_Body_SplitInfo:
r.SetHeaderPart(
SplitInfoFromGRPCMessage(v.SplitInfo),
)
default:
panic(fmt.Sprintf("unknown header part %T", v))
}
return r
}
func HeadResponseToGRPCMessage(r *HeadResponse) *object.HeadResponse {
if r == nil {
return nil
}
m := new(object.HeadResponse)
m.SetBody(
HeadResponseBodyToGRPCMessage(r.GetBody()),
)
session.ResponseHeadersToGRPC(r, m)
return m
}
func HeadResponseFromGRPCMessage(m *object.HeadResponse) *HeadResponse {
if m == nil {
return nil
}
r := new(HeadResponse)
r.SetBody(
HeadResponseBodyFromGRPCMessage(m.GetBody()),
)
session.ResponseHeadersFromGRPC(m, r)
return r
}
func SearchFilterToGRPCMessage(f *SearchFilter) *object.SearchRequest_Body_Filter {
if f == nil {
return nil
}
m := new(object.SearchRequest_Body_Filter)
m.SetMatchType(
MatchTypeToGRPCField(f.GetMatchType()),
)
m.SetKey(f.GetKey())
m.SetValue(f.GetValue())
return m
}
func SearchFilterFromGRPCMessage(m *object.SearchRequest_Body_Filter) *SearchFilter {
if m == nil {
return nil
}
f := new(SearchFilter)
f.SetMatchType(
MatchTypeFromGRPCField(m.GetMatchType()),
)
f.SetKey(m.GetKey())
f.SetValue(m.GetValue())
return f
}
func SearchRequestBodyToGRPCMessage(r *SearchRequestBody) *object.SearchRequest_Body {
if r == nil {
return nil
}
m := new(object.SearchRequest_Body)
m.SetContainerId(
refs.ContainerIDToGRPCMessage(r.GetContainerID()),
)
m.SetVersion(r.GetVersion())
filters := r.GetFilters()
filterMsg := make([]*object.SearchRequest_Body_Filter, 0, len(filters))
for i := range filters {
filterMsg = append(filterMsg, SearchFilterToGRPCMessage(filters[i]))
}
m.SetFilters(filterMsg)
return m
}
func SearchRequestBodyFromGRPCMessage(m *object.SearchRequest_Body) *SearchRequestBody {
if m == nil {
return nil
}
r := new(SearchRequestBody)
r.SetContainerID(
refs.ContainerIDFromGRPCMessage(m.GetContainerId()),
)
r.SetVersion(m.GetVersion())
filterMsg := m.GetFilters()
filters := make([]*SearchFilter, 0, len(filterMsg))
for i := range filterMsg {
filters = append(filters, SearchFilterFromGRPCMessage(filterMsg[i]))
}
r.SetFilters(filters)
return r
}
func SearchRequestToGRPCMessage(r *SearchRequest) *object.SearchRequest {
if r == nil {
return nil
}
m := new(object.SearchRequest)
m.SetBody(
SearchRequestBodyToGRPCMessage(r.GetBody()),
)
session.RequestHeadersToGRPC(r, m)
return m
}
func SearchRequestFromGRPCMessage(m *object.SearchRequest) *SearchRequest {
if m == nil {
return nil
}
r := new(SearchRequest)
r.SetBody(
SearchRequestBodyFromGRPCMessage(m.GetBody()),
)
session.RequestHeadersFromGRPC(m, r)
return r
}
func SearchResponseBodyToGRPCMessage(r *SearchResponseBody) *object.SearchResponse_Body {
if r == nil {
return nil
}
m := new(object.SearchResponse_Body)
ids := r.GetIDList()
idMsg := make([]*refsGRPC.ObjectID, 0, len(ids))
for i := range ids {
idMsg = append(idMsg, refs.ObjectIDToGRPCMessage(ids[i]))
}
m.SetIdList(idMsg)
return m
}
func SearchResponseBodyFromGRPCMessage(m *object.SearchResponse_Body) *SearchResponseBody {
if m == nil {
return nil
}
r := new(SearchResponseBody)
idMsg := m.GetIdList()
ids := make([]*refs.ObjectID, 0, len(idMsg))
for i := range idMsg {
ids = append(ids, refs.ObjectIDFromGRPCMessage(idMsg[i]))
}
r.SetIDList(ids)
return r
}
func SearchResponseToGRPCMessage(r *SearchResponse) *object.SearchResponse {
if r == nil {
return nil
}
m := new(object.SearchResponse)
m.SetBody(
SearchResponseBodyToGRPCMessage(r.GetBody()),
)
session.ResponseHeadersToGRPC(r, m)
return m
}
func SearchResponseFromGRPCMessage(m *object.SearchResponse) *SearchResponse {
if m == nil {
return nil
}
r := new(SearchResponse)
r.SetBody(
SearchResponseBodyFromGRPCMessage(m.GetBody()),
)
session.ResponseHeadersFromGRPC(m, r)
return r
}
func RangeToGRPCMessage(r *Range) *object.Range {
if r == nil {
return nil
}
m := new(object.Range)
m.SetOffset(r.GetOffset())
m.SetLength(r.GetLength())
return m
}
func RangeFromGRPCMessage(m *object.Range) *Range {
if m == nil {
return nil
}
r := new(Range)
r.SetOffset(m.GetOffset())
r.SetLength(m.GetLength())
return r
}
func GetRangeRequestBodyToGRPCMessage(r *GetRangeRequestBody) *object.GetRangeRequest_Body {
if r == nil {
return nil
}
m := new(object.GetRangeRequest_Body)
m.SetAddress(
refs.AddressToGRPCMessage(r.GetAddress()),
)
m.SetRange(
RangeToGRPCMessage(r.GetRange()),
)
m.SetRaw(r.GetRaw())
return m
}
func GetRangeRequestBodyFromGRPCMessage(m *object.GetRangeRequest_Body) *GetRangeRequestBody {
if m == nil {
return nil
}
r := new(GetRangeRequestBody)
r.SetAddress(
refs.AddressFromGRPCMessage(m.GetAddress()),
)
r.SetRange(
RangeFromGRPCMessage(m.GetRange()),
)
r.SetRaw(m.GetRaw())
return r
}
func GetRangeRequestToGRPCMessage(r *GetRangeRequest) *object.GetRangeRequest {
if r == nil {
return nil
}
m := new(object.GetRangeRequest)
m.SetBody(
GetRangeRequestBodyToGRPCMessage(r.GetBody()),
)
session.RequestHeadersToGRPC(r, m)
return m
}
func GetRangeRequestFromGRPCMessage(m *object.GetRangeRequest) *GetRangeRequest {
if m == nil {
return nil
}
r := new(GetRangeRequest)
r.SetBody(
GetRangeRequestBodyFromGRPCMessage(m.GetBody()),
)
session.RequestHeadersFromGRPC(m, r)
return r
}
func GetRangePartChunkToGRPCMessage(r *GetRangePartChunk) *object.GetRangeResponse_Body_Chunk {
if r == nil {
return nil
}
m := new(object.GetRangeResponse_Body_Chunk)
m.SetChunk(r.GetChunk())
return m
}
func GetRangePartChunkFromGRPCMessage(m *object.GetRangeResponse_Body_Chunk) *GetRangePartChunk {
if m == nil {
return nil
}
r := new(GetRangePartChunk)
r.SetChunk(m.GetChunk())
return r
}
func GetRangeResponseBodyToGRPCMessage(r *GetRangeResponseBody) *object.GetRangeResponse_Body {
if r == nil {
return nil
}
m := new(object.GetRangeResponse_Body)
switch v := r.GetRangePart(); t := v.(type) {
case nil:
case *GetRangePartChunk:
m.SetChunk(
GetRangePartChunkToGRPCMessage(t),
)
case *SplitInfo:
m.SetSplitInfo(
SplitInfoToGRPCMessage(t),
)
default:
panic(fmt.Sprintf("unknown get range part %T", t))
}
return m
}
func GetRangeResponseBodyFromGRPCMessage(m *object.GetRangeResponse_Body) *GetRangeResponseBody {
if m == nil {
return nil
}
r := new(GetRangeResponseBody)
switch v := m.GetRangePart().(type) {
case nil:
case *object.GetRangeResponse_Body_Chunk:
r.SetRangePart(
GetRangePartChunkFromGRPCMessage(v),
)
case *object.GetRangeResponse_Body_SplitInfo:
r.SetRangePart(
SplitInfoFromGRPCMessage(v.SplitInfo),
)
default:
panic(fmt.Sprintf("unknown get range part %T", v))
}
return r
}
func GetRangeResponseToGRPCMessage(r *GetRangeResponse) *object.GetRangeResponse {
if r == nil {
return nil
}
m := new(object.GetRangeResponse)
m.SetBody(
GetRangeResponseBodyToGRPCMessage(r.GetBody()),
)
session.ResponseHeadersToGRPC(r, m)
return m
}
func GetRangeResponseFromGRPCMessage(m *object.GetRangeResponse) *GetRangeResponse {
if m == nil {
return nil
}
r := new(GetRangeResponse)
r.SetBody(
GetRangeResponseBodyFromGRPCMessage(m.GetBody()),
)
session.ResponseHeadersFromGRPC(m, r)
return r
}
func GetRangeHashRequestBodyToGRPCMessage(r *GetRangeHashRequestBody) *object.GetRangeHashRequest_Body {
if r == nil {
return nil
}
m := new(object.GetRangeHashRequest_Body)
m.SetAddress(
refs.AddressToGRPCMessage(r.GetAddress()),
)
m.SetSalt(r.GetSalt())
rngs := r.GetRanges()
rngMsg := make([]*object.Range, 0, len(rngs))
for i := range rngs {
rngMsg = append(rngMsg, RangeToGRPCMessage(rngs[i]))
}
m.SetRanges(rngMsg)
m.SetType(refsGRPC.ChecksumType(r.GetType()))
return m
}
func GetRangeHashRequestBodyFromGRPCMessage(m *object.GetRangeHashRequest_Body) *GetRangeHashRequestBody {
if m == nil {
return nil
}
r := new(GetRangeHashRequestBody)
r.SetAddress(
refs.AddressFromGRPCMessage(m.GetAddress()),
)
r.SetSalt(m.GetSalt())
rngMsg := m.GetRanges()
rngs := make([]*Range, 0, len(rngMsg))
for i := range rngMsg {
rngs = append(rngs, RangeFromGRPCMessage(rngMsg[i]))
}
r.SetRanges(rngs)
r.SetType(refs.ChecksumType(m.GetType()))
return r
}
func GetRangeHashRequestToGRPCMessage(r *GetRangeHashRequest) *object.GetRangeHashRequest {
if r == nil {
return nil
}
m := new(object.GetRangeHashRequest)
m.SetBody(
GetRangeHashRequestBodyToGRPCMessage(r.GetBody()),
)
session.RequestHeadersToGRPC(r, m)
return m
}
func GetRangeHashRequestFromGRPCMessage(m *object.GetRangeHashRequest) *GetRangeHashRequest {
if m == nil {
return nil
}
r := new(GetRangeHashRequest)
r.SetBody(
GetRangeHashRequestBodyFromGRPCMessage(m.GetBody()),
)
session.RequestHeadersFromGRPC(m, r)
return r
}
func GetRangeHashResponseBodyToGRPCMessage(r *GetRangeHashResponseBody) *object.GetRangeHashResponse_Body {
if r == nil {
return nil
}
m := new(object.GetRangeHashResponse_Body)
m.SetType(refsGRPC.ChecksumType(r.GetType()))
m.SetHashList(r.GetHashList())
return m
}
func GetRangeHashResponseBodyFromGRPCMessage(m *object.GetRangeHashResponse_Body) *GetRangeHashResponseBody {
if m == nil {
return nil
}
r := new(GetRangeHashResponseBody)
r.SetType(refs.ChecksumType(m.GetType()))
r.SetHashList(m.GetHashList())
return r
}
func GetRangeHashResponseToGRPCMessage(r *GetRangeHashResponse) *object.GetRangeHashResponse {
if r == nil {
return nil
}
m := new(object.GetRangeHashResponse)
m.SetBody(
GetRangeHashResponseBodyToGRPCMessage(r.GetBody()),
)
session.ResponseHeadersToGRPC(r, m)
return m
}
func GetRangeHashResponseFromGRPCMessage(m *object.GetRangeHashResponse) *GetRangeHashResponse {
if m == nil {
return nil
}
r := new(GetRangeHashResponse)
r.SetBody(
GetRangeHashResponseBodyFromGRPCMessage(m.GetBody()),
)
session.ResponseHeadersFromGRPC(m, r)
return r
}