frostfs-api-go/object/convert.go
Evgenii Stratonikov 5e1c6a908f
All checks were successful
DCO action / DCO (pull_request) Successful in 41s
Tests and linters / Tests (1.22) (pull_request) Successful in 55s
Tests and linters / Tests (1.23) (pull_request) Successful in 57s
Tests and linters / Tests with -race (pull_request) Successful in 1m8s
Tests and linters / Lint (pull_request) Successful in 2m12s
[#111] protogen: Emit slice of messages without a pointer
```
goos: linux
goarch: amd64
pkg: git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/refs
cpu: 11th Gen Intel(R) Core(TM) i5-1135G7 @ 2.40GHz
                                              │      old      │                 new                  │
                                              │    sec/op     │    sec/op     vs base                │
ObjectIDSlice/0_elements/to_grpc_message-8       3.193n ±  2%   3.242n ±  0%   +1.50% (p=0.034 n=10)
ObjectIDSlice/0_elements/from_grpc_message-8     3.197n ±  2%   3.343n ±  1%   +4.57% (p=0.000 n=10)
ObjectIDSlice/0_elements/marshal-8               5.666n ±  3%   5.642n ±  0%   -0.42% (p=0.000 n=10)
ObjectIDSlice/1_elements/to_grpc_message-8       53.10n ±  6%   29.78n ± 12%  -43.92% (p=0.000 n=10)
ObjectIDSlice/1_elements/from_grpc_message-8     28.99n ±  5%   29.77n ±  7%        ~ (p=0.165 n=10)
ObjectIDSlice/1_elements/marshal-8               49.08n ±  7%   50.72n ±  6%        ~ (p=0.218 n=10)
ObjectIDSlice/50_elements/to_grpc_message-8     1652.5n ±  7%   277.2n ±  1%  -83.22% (p=0.000 n=10)
ObjectIDSlice/50_elements/from_grpc_message-8    261.2n ± 11%   226.7n ± 15%  -13.19% (p=0.003 n=10)
ObjectIDSlice/50_elements/marshal-8              1.512µ ±  6%   1.514µ ±  6%        ~ (p=0.955 n=10)
geomean                                          52.15n         39.99n        -23.31%

                                              │      old       │                  new                   │
                                              │      B/op      │     B/op      vs base                  │
ObjectIDSlice/0_elements/to_grpc_message-8        0.000 ± 0%       0.000 ± 0%        ~ (p=1.000 n=10) ¹
ObjectIDSlice/0_elements/from_grpc_message-8      0.000 ± 0%       0.000 ± 0%        ~ (p=1.000 n=10) ¹
ObjectIDSlice/0_elements/marshal-8                0.000 ± 0%       0.000 ± 0%        ~ (p=1.000 n=10) ¹
ObjectIDSlice/1_elements/to_grpc_message-8        32.00 ± 0%       24.00 ± 0%  -25.00% (p=0.000 n=10)
ObjectIDSlice/1_elements/from_grpc_message-8      24.00 ± 0%       24.00 ± 0%        ~ (p=1.000 n=10) ¹
ObjectIDSlice/1_elements/marshal-8                48.00 ± 0%       48.00 ± 0%        ~ (p=1.000 n=10) ¹
ObjectIDSlice/50_elements/to_grpc_message-8     1.578Ki ± 0%     1.250Ki ± 0%  -20.79% (p=0.000 n=10)
ObjectIDSlice/50_elements/from_grpc_message-8   1.250Ki ± 0%     1.250Ki ± 0%        ~ (p=1.000 n=10) ¹
ObjectIDSlice/50_elements/marshal-8             2.000Ki ± 0%     2.000Ki ± 0%        ~ (p=1.000 n=10) ¹
geomean                                                      ²                  -5.62%                ²
¹ all samples are equal
² summaries must be >0 to compute geomean

                                              │      old      │                 new                  │
                                              │   allocs/op   │ allocs/op   vs base                  │
ObjectIDSlice/0_elements/to_grpc_message-8       0.000 ± 0%     0.000 ± 0%        ~ (p=1.000 n=10) ¹
ObjectIDSlice/0_elements/from_grpc_message-8     0.000 ± 0%     0.000 ± 0%        ~ (p=1.000 n=10) ¹
ObjectIDSlice/0_elements/marshal-8               0.000 ± 0%     0.000 ± 0%        ~ (p=1.000 n=10) ¹
ObjectIDSlice/1_elements/to_grpc_message-8       2.000 ± 0%     1.000 ± 0%  -50.00% (p=0.000 n=10)
ObjectIDSlice/1_elements/from_grpc_message-8     1.000 ± 0%     1.000 ± 0%        ~ (p=1.000 n=10) ¹
ObjectIDSlice/1_elements/marshal-8               1.000 ± 0%     1.000 ± 0%        ~ (p=1.000 n=10) ¹
ObjectIDSlice/50_elements/to_grpc_message-8     51.000 ± 0%     1.000 ± 0%  -98.04% (p=0.000 n=10)
ObjectIDSlice/50_elements/from_grpc_message-8    1.000 ± 0%     1.000 ± 0%        ~ (p=1.000 n=10) ¹
ObjectIDSlice/50_elements/marshal-8              1.000 ± 0%     1.000 ± 0%        ~ (p=1.000 n=10) ¹
geomean                                                     ²               -40.18%                ²
¹ all samples are equal
² summaries must be >0 to compute geomean
```

Signed-off-by: Evgenii Stratonikov <e.stratonikov@yadro.com>
2024-08-28 11:53:08 +03:00

2555 lines
47 KiB
Go

package object
import (
"fmt"
object "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/object/grpc"
"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/refs"
refsGRPC "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/refs/grpc"
"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/rpc/grpc"
"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/rpc/message"
"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/session"
sessionGRPC "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/session/grpc"
)
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 (h *ShortHeader) ToGRPCMessage() grpc.Message {
var m *object.ShortHeader
if h != nil {
m = new(object.ShortHeader)
m.SetVersion(h.version.ToGRPCMessage().(*refsGRPC.Version))
m.SetOwnerId(h.ownerID.ToGRPCMessage().(*refsGRPC.OwnerID))
m.SetHomomorphicHash(h.homoHash.ToGRPCMessage().(*refsGRPC.Checksum))
m.SetPayloadHash(h.payloadHash.ToGRPCMessage().(*refsGRPC.Checksum))
m.SetObjectType(TypeToGRPCField(h.typ))
m.SetCreationEpoch(h.creatEpoch)
m.SetPayloadLength(h.payloadLen)
}
return m
}
func (h *ShortHeader) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.ShortHeader)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
version := v.GetVersion()
if version == nil {
h.version = nil
} else {
if h.version == nil {
h.version = new(refs.Version)
}
err = h.version.FromGRPCMessage(version)
if err != nil {
return err
}
}
ownerID := v.GetOwnerId()
if ownerID == nil {
h.ownerID = nil
} else {
if h.ownerID == nil {
h.ownerID = new(refs.OwnerID)
}
err = h.ownerID.FromGRPCMessage(ownerID)
if err != nil {
return err
}
}
homoHash := v.GetHomomorphicHash()
if homoHash == nil {
h.homoHash = nil
} else {
if h.homoHash == nil {
h.homoHash = new(refs.Checksum)
}
err = h.homoHash.FromGRPCMessage(homoHash)
if err != nil {
return err
}
}
payloadHash := v.GetPayloadHash()
if payloadHash == nil {
h.payloadHash = nil
} else {
if h.payloadHash == nil {
h.payloadHash = new(refs.Checksum)
}
err = h.payloadHash.FromGRPCMessage(payloadHash)
if err != nil {
return err
}
}
h.typ = TypeFromGRPCField(v.GetObjectType())
h.creatEpoch = v.GetCreationEpoch()
h.payloadLen = v.GetPayloadLength()
return nil
}
func (a *Attribute) ToGRPCMessage() grpc.Message {
var m *object.Header_Attribute
if a != nil {
m = new(object.Header_Attribute)
m.SetKey(a.key)
m.SetValue(a.val)
}
return m
}
func (a *Attribute) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.Header_Attribute)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
a.key = v.GetKey()
a.val = v.GetValue()
return nil
}
func AttributesToGRPC(xs []Attribute) (res []object.Header_Attribute) {
if xs != nil {
res = make([]object.Header_Attribute, 0, len(xs))
for i := range xs {
res = append(res, *xs[i].ToGRPCMessage().(*object.Header_Attribute))
}
}
return
}
func AttributesFromGRPC(xs []object.Header_Attribute) (res []Attribute, err error) {
if xs != nil {
res = make([]Attribute, len(xs))
for i := range xs {
err = res[i].FromGRPCMessage(&xs[i])
if err != nil {
return
}
}
}
return
}
func (h *SplitHeader) ToGRPCMessage() grpc.Message {
var m *object.Header_Split
if h != nil {
m = new(object.Header_Split)
m.SetParent(h.par.ToGRPCMessage().(*refsGRPC.ObjectID))
m.SetPrevious(h.prev.ToGRPCMessage().(*refsGRPC.ObjectID))
m.SetParentHeader(h.parHdr.ToGRPCMessage().(*object.Header))
m.SetParentSignature(h.parSig.ToGRPCMessage().(*refsGRPC.Signature))
m.SetChildren(refs.ObjectIDListToGRPCMessage(h.children))
m.SetSplitId(h.splitID)
}
return m
}
func (h *SplitHeader) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.Header_Split)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
par := v.GetParent()
if par == nil {
h.par = nil
} else {
if h.par == nil {
h.par = new(refs.ObjectID)
}
err = h.par.FromGRPCMessage(par)
if err != nil {
return err
}
}
prev := v.GetPrevious()
if prev == nil {
h.prev = nil
} else {
if h.prev == nil {
h.prev = new(refs.ObjectID)
}
err = h.prev.FromGRPCMessage(prev)
if err != nil {
return err
}
}
parHdr := v.GetParentHeader()
if parHdr == nil {
h.parHdr = nil
} else {
if h.parHdr == nil {
h.parHdr = new(Header)
}
err = h.parHdr.FromGRPCMessage(parHdr)
if err != nil {
return err
}
}
parSig := v.GetParentSignature()
if parSig == nil {
h.parSig = nil
} else {
if h.parSig == nil {
h.parSig = new(refs.Signature)
}
err = h.parSig.FromGRPCMessage(parSig)
if err != nil {
return err
}
}
h.children, err = refs.ObjectIDListFromGRPCMessage(v.GetChildren())
if err != nil {
return err
}
h.splitID = v.GetSplitId()
return nil
}
func (h *ECHeader) ToGRPCMessage() grpc.Message {
var m *object.Header_EC
if h != nil {
m = new(object.Header_EC)
m.Parent = h.Parent.ToGRPCMessage().(*refsGRPC.ObjectID)
m.ParentSplitId = h.ParentSplitID
m.ParentSplitParentId = h.ParentSplitParentID.ToGRPCMessage().(*refsGRPC.ObjectID)
m.ParentAttributes = AttributesToGRPC(h.ParentAttributes)
m.Index = h.Index
m.Total = h.Total
m.Header = h.Header
m.HeaderLength = h.HeaderLength
}
return m
}
func (h *ECHeader) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.Header_EC)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
par := v.GetParent()
if par == nil {
h.Parent = nil
} else {
if h.Parent == nil {
h.Parent = new(refs.ObjectID)
}
err = h.Parent.FromGRPCMessage(par)
if err != nil {
return err
}
}
h.ParentSplitID = v.GetParentSplitId()
parSplitParentID := v.GetParentSplitParentId()
if parSplitParentID == nil {
h.ParentSplitParentID = nil
} else {
if h.ParentSplitParentID == nil {
h.ParentSplitParentID = new(refs.ObjectID)
}
err = h.ParentSplitParentID.FromGRPCMessage(parSplitParentID)
if err != nil {
return err
}
}
if h.ParentAttributes, err = AttributesFromGRPC(v.GetParentAttributes()); err != nil {
return err
}
h.Index = v.GetIndex()
h.Total = v.GetTotal()
h.Header = v.GetHeader()
h.HeaderLength = v.GetHeaderLength()
return nil
}
func (h *Header) ToGRPCMessage() grpc.Message {
var m *object.Header
if h != nil {
m = new(object.Header)
m.SetVersion(h.version.ToGRPCMessage().(*refsGRPC.Version))
m.SetPayloadHash(h.payloadHash.ToGRPCMessage().(*refsGRPC.Checksum))
m.SetOwnerId(h.ownerID.ToGRPCMessage().(*refsGRPC.OwnerID))
m.SetHomomorphicHash(h.homoHash.ToGRPCMessage().(*refsGRPC.Checksum))
m.SetContainerId(h.cid.ToGRPCMessage().(*refsGRPC.ContainerID))
m.SetSessionToken(h.sessionToken.ToGRPCMessage().(*sessionGRPC.SessionToken))
m.SetSplit(h.split.ToGRPCMessage().(*object.Header_Split))
m.Ec = h.ec.ToGRPCMessage().(*object.Header_EC)
m.SetAttributes(AttributesToGRPC(h.attr))
m.SetPayloadLength(h.payloadLen)
m.SetCreationEpoch(h.creatEpoch)
m.SetObjectType(TypeToGRPCField(h.typ))
}
return m
}
func (h *Header) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.Header)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
if err := h.fillVersion(v); err != nil {
return err
}
if err := h.fillPayloadHash(v); err != nil {
return err
}
if err := h.fillOwnerID(v); err != nil {
return err
}
if err := h.fillHomomorphicHash(v); err != nil {
return err
}
if err := h.fillContainerID(v); err != nil {
return err
}
if err := h.fillSessionToken(v); err != nil {
return err
}
if err := h.fillSplitHeader(v); err != nil {
return err
}
if err := h.fillECHeader(v); err != nil {
return err
}
h.attr, err = AttributesFromGRPC(v.GetAttributes())
if err != nil {
return err
}
h.payloadLen = v.GetPayloadLength()
h.creatEpoch = v.GetCreationEpoch()
h.typ = TypeFromGRPCField(v.GetObjectType())
return nil
}
func (h *Header) fillVersion(v *object.Header) error {
version := v.GetVersion()
if version == nil {
h.version = nil
return nil
}
if h.version == nil {
h.version = new(refs.Version)
}
return h.version.FromGRPCMessage(version)
}
func (h *Header) fillPayloadHash(v *object.Header) error {
payloadHash := v.GetPayloadHash()
if payloadHash == nil {
h.payloadHash = nil
return nil
}
if h.payloadHash == nil {
h.payloadHash = new(refs.Checksum)
}
return h.payloadHash.FromGRPCMessage(payloadHash)
}
func (h *Header) fillOwnerID(v *object.Header) error {
ownerID := v.GetOwnerId()
if ownerID == nil {
h.ownerID = nil
return nil
}
if h.ownerID == nil {
h.ownerID = new(refs.OwnerID)
}
return h.ownerID.FromGRPCMessage(ownerID)
}
func (h *Header) fillHomomorphicHash(v *object.Header) error {
homoHash := v.GetHomomorphicHash()
if homoHash == nil {
h.homoHash = nil
return nil
}
if h.homoHash == nil {
h.homoHash = new(refs.Checksum)
}
return h.homoHash.FromGRPCMessage(homoHash)
}
func (h *Header) fillContainerID(v *object.Header) error {
cid := v.GetContainerId()
if cid == nil {
h.cid = nil
return nil
}
if h.cid == nil {
h.cid = new(refs.ContainerID)
}
return h.cid.FromGRPCMessage(cid)
}
func (h *Header) fillSessionToken(v *object.Header) error {
sessionToken := v.GetSessionToken()
if sessionToken == nil {
h.sessionToken = nil
return nil
}
if h.sessionToken == nil {
h.sessionToken = new(session.Token)
}
return h.sessionToken.FromGRPCMessage(sessionToken)
}
func (h *Header) fillSplitHeader(v *object.Header) error {
split := v.GetSplit()
if split == nil {
h.split = nil
return nil
}
if h.split == nil {
h.split = new(SplitHeader)
}
return h.split.FromGRPCMessage(split)
}
func (h *Header) fillECHeader(v *object.Header) error {
ec := v.GetEc()
if ec == nil {
h.ec = nil
return nil
}
if h.ec == nil {
h.ec = new(ECHeader)
}
return h.ec.FromGRPCMessage(ec)
}
func (h *HeaderWithSignature) ToGRPCMessage() grpc.Message {
var m *object.HeaderWithSignature
if h != nil {
m = new(object.HeaderWithSignature)
m.SetSignature(h.signature.ToGRPCMessage().(*refsGRPC.Signature))
m.SetHeader(h.header.ToGRPCMessage().(*object.Header))
}
return m
}
func (h *HeaderWithSignature) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.HeaderWithSignature)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
signature := v.GetSignature()
if signature == nil {
h.signature = nil
} else {
if h.signature == nil {
h.signature = new(refs.Signature)
}
err = h.signature.FromGRPCMessage(signature)
if err != nil {
return err
}
}
header := v.GetHeader()
if header == nil {
h.header = nil
} else {
if h.header == nil {
h.header = new(Header)
}
err = h.header.FromGRPCMessage(header)
}
return err
}
func (o *Object) ToGRPCMessage() grpc.Message {
var m *object.Object
if o != nil {
m = new(object.Object)
m.SetObjectId(o.objectID.ToGRPCMessage().(*refsGRPC.ObjectID))
m.SetSignature(o.idSig.ToGRPCMessage().(*refsGRPC.Signature))
m.SetHeader(o.header.ToGRPCMessage().(*object.Header))
m.SetPayload(o.payload)
}
return m
}
func (o *Object) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.Object)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
objectID := v.GetObjectId()
if objectID == nil {
o.objectID = nil
} else {
if o.objectID == nil {
o.objectID = new(refs.ObjectID)
}
err = o.objectID.FromGRPCMessage(objectID)
if err != nil {
return err
}
}
idSig := v.GetSignature()
if idSig == nil {
o.idSig = nil
} else {
if o.idSig == nil {
o.idSig = new(refs.Signature)
}
err = o.idSig.FromGRPCMessage(idSig)
if err != nil {
return err
}
}
header := v.GetHeader()
if header == nil {
o.header = nil
} else {
if o.header == nil {
o.header = new(Header)
}
err = o.header.FromGRPCMessage(header)
if err != nil {
return err
}
}
o.payload = v.GetPayload()
return nil
}
func (s *SplitInfo) ToGRPCMessage() grpc.Message {
var m *object.SplitInfo
if s != nil {
m = new(object.SplitInfo)
m.SetLastPart(s.lastPart.ToGRPCMessage().(*refsGRPC.ObjectID))
m.SetLink(s.link.ToGRPCMessage().(*refsGRPC.ObjectID))
m.SetSplitId(s.splitID)
}
return m
}
func (s *SplitInfo) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.SplitInfo)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
lastPart := v.GetLastPart()
if lastPart == nil {
s.lastPart = nil
} else {
if s.lastPart == nil {
s.lastPart = new(refs.ObjectID)
}
err = s.lastPart.FromGRPCMessage(lastPart)
if err != nil {
return err
}
}
link := v.GetLink()
if link == nil {
s.link = nil
} else {
if s.link == nil {
s.link = new(refs.ObjectID)
}
err = s.link.FromGRPCMessage(link)
if err != nil {
return err
}
}
s.splitID = v.GetSplitId()
return nil
}
func (s *ECInfo) ToGRPCMessage() grpc.Message {
var m *object.ECInfo
if s != nil {
m = new(object.ECInfo)
if s.Chunks != nil {
chunks := make([]object.ECInfo_Chunk, len(s.Chunks))
for i := range chunks {
chunks[i] = *s.Chunks[i].ToGRPCMessage().(*object.ECInfo_Chunk)
}
m.Chunks = chunks
}
}
return m
}
func (s *ECInfo) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.ECInfo)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
chunks := v.GetChunks()
if chunks == nil {
s.Chunks = nil
} else {
s.Chunks = make([]ECChunk, len(chunks))
for i := range chunks {
if err := s.Chunks[i].FromGRPCMessage(&chunks[i]); err != nil {
return err
}
}
}
return nil
}
func (c *ECChunk) ToGRPCMessage() grpc.Message {
var m *object.ECInfo_Chunk
if c != nil {
m = new(object.ECInfo_Chunk)
m.Total = c.Total
m.Index = c.Index
m.Id = c.ID.ToGRPCMessage().(*refsGRPC.ObjectID)
}
return m
}
func (c *ECChunk) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.ECInfo_Chunk)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
if err := c.ID.FromGRPCMessage(v.GetId()); err != nil {
return err
}
c.Index = v.Index
c.Total = v.Total
return nil
}
func (r *GetRequestBody) ToGRPCMessage() grpc.Message {
var m *object.GetRequest_Body
if r != nil {
m = new(object.GetRequest_Body)
m.SetAddress(r.addr.ToGRPCMessage().(*refsGRPC.Address))
m.SetRaw(r.raw)
}
return m
}
func (r *GetRequestBody) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.GetRequest_Body)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
addr := v.GetAddress()
if addr == nil {
r.addr = nil
} else {
if r.addr == nil {
r.addr = new(refs.Address)
}
err = r.addr.FromGRPCMessage(addr)
if err != nil {
return err
}
}
r.raw = v.GetRaw()
return nil
}
func (r *GetRequest) ToGRPCMessage() grpc.Message {
var m *object.GetRequest
if r != nil {
m = new(object.GetRequest)
m.SetBody(r.body.ToGRPCMessage().(*object.GetRequest_Body))
r.RequestHeaders.ToMessage(m)
}
return m
}
func (r *GetRequest) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.GetRequest)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
body := v.GetBody()
if body == nil {
r.body = nil
} else {
if r.body == nil {
r.body = new(GetRequestBody)
}
err = r.body.FromGRPCMessage(body)
if err != nil {
return err
}
}
return r.RequestHeaders.FromMessage(v)
}
func (r *GetObjectPartInit) ToGRPCMessage() grpc.Message {
var m *object.GetResponse_Body_Init
if r != nil {
m = new(object.GetResponse_Body_Init)
m.SetObjectId(r.id.ToGRPCMessage().(*refsGRPC.ObjectID))
m.SetSignature(r.sig.ToGRPCMessage().(*refsGRPC.Signature))
m.SetHeader(r.hdr.ToGRPCMessage().(*object.Header))
}
return m
}
func (r *GetObjectPartInit) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.GetResponse_Body_Init)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
id := v.GetObjectId()
if id == nil {
r.id = nil
} else {
if r.id == nil {
r.id = new(refs.ObjectID)
}
err = r.id.FromGRPCMessage(id)
if err != nil {
return err
}
}
sig := v.GetSignature()
if sig == nil {
r.sig = nil
} else {
if r.sig == nil {
r.sig = new(refs.Signature)
}
err = r.sig.FromGRPCMessage(sig)
if err != nil {
return err
}
}
hdr := v.GetHeader()
if hdr == nil {
r.hdr = nil
} else {
if r.hdr == nil {
r.hdr = new(Header)
}
err = r.hdr.FromGRPCMessage(hdr)
}
return err
}
func (r *GetObjectPartChunk) ToGRPCMessage() grpc.Message {
var m *object.GetResponse_Body_Chunk
if r != nil {
m = new(object.GetResponse_Body_Chunk)
m.SetChunk(r.chunk)
}
return m
}
func (r *GetObjectPartChunk) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.GetResponse_Body_Chunk)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
r.chunk = v.GetChunk()
return nil
}
func (r *GetResponseBody) ToGRPCMessage() grpc.Message {
var m *object.GetResponse_Body
if r != nil {
m = new(object.GetResponse_Body)
switch v := r.GetObjectPart(); t := v.(type) {
case nil:
m.ObjectPart = nil
case *GetObjectPartInit:
m.SetInit(t.ToGRPCMessage().(*object.GetResponse_Body_Init))
case *GetObjectPartChunk:
m.SetChunk(t.ToGRPCMessage().(*object.GetResponse_Body_Chunk))
case *SplitInfo:
m.SetSplitInfo(t.ToGRPCMessage().(*object.SplitInfo))
case *ECInfo:
m.SetEcInfo(t.ToGRPCMessage().(*object.ECInfo))
default:
panic(fmt.Sprintf("unknown get object part %T", t))
}
}
return m
}
func (r *GetResponseBody) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.GetResponse_Body)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
r.objPart = nil
switch pt := v.GetObjectPart().(type) {
case nil:
case *object.GetResponse_Body_Init_:
if pt != nil {
partInit := new(GetObjectPartInit)
r.objPart = partInit
err = partInit.FromGRPCMessage(pt.Init)
}
case *object.GetResponse_Body_Chunk:
if pt != nil {
partChunk := new(GetObjectPartChunk)
r.objPart = partChunk
err = partChunk.FromGRPCMessage(pt)
}
case *object.GetResponse_Body_SplitInfo:
if pt != nil {
partSplit := new(SplitInfo)
r.objPart = partSplit
err = partSplit.FromGRPCMessage(pt.SplitInfo)
}
case *object.GetResponse_Body_EcInfo:
if pt != nil {
partEC := new(ECInfo)
r.objPart = partEC
err = partEC.FromGRPCMessage(pt.EcInfo)
}
default:
err = fmt.Errorf("unknown get object part %T", pt)
}
return err
}
func (r *GetResponse) ToGRPCMessage() grpc.Message {
var m *object.GetResponse
if r != nil {
m = new(object.GetResponse)
m.SetBody(r.body.ToGRPCMessage().(*object.GetResponse_Body))
r.ResponseHeaders.ToMessage(m)
}
return m
}
func (r *GetResponse) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.GetResponse)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
body := v.GetBody()
if body == nil {
r.body = nil
} else {
if r.body == nil {
r.body = new(GetResponseBody)
}
err = r.body.FromGRPCMessage(body)
if err != nil {
return err
}
}
return r.ResponseHeaders.FromMessage(v)
}
func (r *PutObjectPartInit) ToGRPCMessage() grpc.Message {
var m *object.PutRequest_Body_Init
if r != nil {
m = new(object.PutRequest_Body_Init)
m.SetObjectId(r.id.ToGRPCMessage().(*refsGRPC.ObjectID))
m.SetSignature(r.sig.ToGRPCMessage().(*refsGRPC.Signature))
m.SetHeader(r.hdr.ToGRPCMessage().(*object.Header))
m.SetCopiesNumber(r.copyNum)
}
return m
}
func (r *PutObjectPartInit) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.PutRequest_Body_Init)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
id := v.GetObjectId()
if id == nil {
r.id = nil
} else {
if r.id == nil {
r.id = new(refs.ObjectID)
}
err = r.id.FromGRPCMessage(id)
if err != nil {
return err
}
}
sig := v.GetSignature()
if sig == nil {
r.sig = nil
} else {
if r.sig == nil {
r.sig = new(refs.Signature)
}
err = r.sig.FromGRPCMessage(sig)
if err != nil {
return err
}
}
hdr := v.GetHeader()
if hdr == nil {
r.hdr = nil
} else {
if r.hdr == nil {
r.hdr = new(Header)
}
err = r.hdr.FromGRPCMessage(hdr)
if err != nil {
return err
}
}
r.copyNum = v.GetCopiesNumber()
return nil
}
func (r *PutObjectPartChunk) ToGRPCMessage() grpc.Message {
var m *object.PutRequest_Body_Chunk
if r != nil {
m = new(object.PutRequest_Body_Chunk)
m.SetChunk(r.chunk)
}
return m
}
func (r *PutObjectPartChunk) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.PutRequest_Body_Chunk)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
r.chunk = v.GetChunk()
return nil
}
func (r *PutRequestBody) ToGRPCMessage() grpc.Message {
var m *object.PutRequest_Body
if r != nil {
m = new(object.PutRequest_Body)
switch v := r.GetObjectPart(); t := v.(type) {
case nil:
m.ObjectPart = nil
case *PutObjectPartInit:
m.SetInit(t.ToGRPCMessage().(*object.PutRequest_Body_Init))
case *PutObjectPartChunk:
m.SetChunk(t.ToGRPCMessage().(*object.PutRequest_Body_Chunk))
default:
panic(fmt.Sprintf("unknown put object part %T", t))
}
}
return m
}
func (r *PutRequestBody) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.PutRequest_Body)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
r.objPart = nil
switch pt := v.GetObjectPart().(type) {
case nil:
case *object.PutRequest_Body_Init_:
if pt != nil {
partInit := new(PutObjectPartInit)
r.objPart = partInit
err = partInit.FromGRPCMessage(pt.Init)
}
case *object.PutRequest_Body_Chunk:
if pt != nil {
partChunk := new(PutObjectPartChunk)
r.objPart = partChunk
err = partChunk.FromGRPCMessage(pt)
}
default:
err = fmt.Errorf("unknown put object part %T", pt)
}
return err
}
func (r *PutRequest) ToGRPCMessage() grpc.Message {
var m *object.PutRequest
if r != nil {
m = new(object.PutRequest)
m.SetBody(r.body.ToGRPCMessage().(*object.PutRequest_Body))
r.RequestHeaders.ToMessage(m)
}
return m
}
func (r *PutRequest) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.PutRequest)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
body := v.GetBody()
if body == nil {
r.body = nil
} else {
if r.body == nil {
r.body = new(PutRequestBody)
}
err = r.body.FromGRPCMessage(body)
if err != nil {
return err
}
}
return r.RequestHeaders.FromMessage(v)
}
func (r *PutResponseBody) ToGRPCMessage() grpc.Message {
var m *object.PutResponse_Body
if r != nil {
m = new(object.PutResponse_Body)
m.SetObjectId(r.id.ToGRPCMessage().(*refsGRPC.ObjectID))
}
return m
}
func (r *PutResponseBody) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.PutResponse_Body)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
id := v.GetObjectId()
if id == nil {
r.id = nil
} else {
if r.id == nil {
r.id = new(refs.ObjectID)
}
err = r.id.FromGRPCMessage(id)
}
return err
}
func (r *PutResponse) ToGRPCMessage() grpc.Message {
var m *object.PutResponse
if r != nil {
m = new(object.PutResponse)
m.SetBody(r.body.ToGRPCMessage().(*object.PutResponse_Body))
r.ResponseHeaders.ToMessage(m)
}
return m
}
func (r *PutResponse) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.PutResponse)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
body := v.GetBody()
if body == nil {
r.body = nil
} else {
if r.body == nil {
r.body = new(PutResponseBody)
}
err = r.body.FromGRPCMessage(body)
if err != nil {
return err
}
}
return r.ResponseHeaders.FromMessage(v)
}
func (r *DeleteRequestBody) ToGRPCMessage() grpc.Message {
var m *object.DeleteRequest_Body
if r != nil {
m = new(object.DeleteRequest_Body)
m.SetAddress(r.addr.ToGRPCMessage().(*refsGRPC.Address))
}
return m
}
func (r *DeleteRequestBody) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.DeleteRequest_Body)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
addr := v.GetAddress()
if addr == nil {
r.addr = nil
} else {
if r.addr == nil {
r.addr = new(refs.Address)
}
err = r.addr.FromGRPCMessage(addr)
}
return err
}
func (r *DeleteRequest) ToGRPCMessage() grpc.Message {
var m *object.DeleteRequest
if r != nil {
m = new(object.DeleteRequest)
m.SetBody(r.body.ToGRPCMessage().(*object.DeleteRequest_Body))
r.RequestHeaders.ToMessage(m)
}
return m
}
func (r *DeleteRequest) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.DeleteRequest)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
body := v.GetBody()
if body == nil {
r.body = nil
} else {
if r.body == nil {
r.body = new(DeleteRequestBody)
}
err = r.body.FromGRPCMessage(body)
if err != nil {
return err
}
}
return r.RequestHeaders.FromMessage(v)
}
func (r *DeleteResponseBody) ToGRPCMessage() grpc.Message {
var m *object.DeleteResponse_Body
if r != nil {
m = new(object.DeleteResponse_Body)
m.SetTombstone(r.tombstone.ToGRPCMessage().(*refsGRPC.Address))
}
return m
}
func (r *DeleteResponseBody) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.DeleteResponse_Body)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
tombstone := v.GetTombstone()
if tombstone == nil {
r.tombstone = nil
} else {
if r.tombstone == nil {
r.tombstone = new(refs.Address)
}
err = r.tombstone.FromGRPCMessage(tombstone)
}
return err
}
func (r *DeleteResponse) ToGRPCMessage() grpc.Message {
var m *object.DeleteResponse
if r != nil {
m = new(object.DeleteResponse)
m.SetBody(r.body.ToGRPCMessage().(*object.DeleteResponse_Body))
r.ResponseHeaders.ToMessage(m)
}
return m
}
func (r *DeleteResponse) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.DeleteResponse)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
body := v.GetBody()
if body == nil {
r.body = nil
} else {
if r.body == nil {
r.body = new(DeleteResponseBody)
}
err = r.body.FromGRPCMessage(body)
if err != nil {
return err
}
}
return r.ResponseHeaders.FromMessage(v)
}
func (r *HeadRequestBody) ToGRPCMessage() grpc.Message {
var m *object.HeadRequest_Body
if r != nil {
m = new(object.HeadRequest_Body)
m.SetAddress(r.addr.ToGRPCMessage().(*refsGRPC.Address))
m.SetRaw(r.raw)
m.SetMainOnly(r.mainOnly)
}
return m
}
func (r *HeadRequestBody) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.HeadRequest_Body)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
addr := v.GetAddress()
if addr == nil {
r.addr = nil
} else {
if r.addr == nil {
r.addr = new(refs.Address)
}
err = r.addr.FromGRPCMessage(addr)
if err != nil {
return err
}
}
r.raw = v.GetRaw()
r.mainOnly = v.GetMainOnly()
return nil
}
func (r *HeadRequest) ToGRPCMessage() grpc.Message {
var m *object.HeadRequest
if r != nil {
m = new(object.HeadRequest)
m.SetBody(r.body.ToGRPCMessage().(*object.HeadRequest_Body))
r.RequestHeaders.ToMessage(m)
}
return m
}
func (r *HeadRequest) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.HeadRequest)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
body := v.GetBody()
if body == nil {
r.body = nil
} else {
if r.body == nil {
r.body = new(HeadRequestBody)
}
err = r.body.FromGRPCMessage(body)
if err != nil {
return err
}
}
return r.RequestHeaders.FromMessage(v)
}
func (r *HeadResponseBody) ToGRPCMessage() grpc.Message {
var m *object.HeadResponse_Body
if r != nil {
m = new(object.HeadResponse_Body)
switch v := r.hdrPart.(type) {
case nil:
m.Head = nil
case *HeaderWithSignature:
m.SetHeader(v.ToGRPCMessage().(*object.HeaderWithSignature))
case *ShortHeader:
m.SetShortHeader(v.ToGRPCMessage().(*object.ShortHeader))
case *SplitInfo:
m.SetSplitInfo(v.ToGRPCMessage().(*object.SplitInfo))
case *ECInfo:
m.SetEcInfo(v.ToGRPCMessage().(*object.ECInfo))
default:
panic(fmt.Sprintf("unknown head part %T", v))
}
}
return m
}
func (r *HeadResponseBody) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.HeadResponse_Body)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
r.hdrPart = nil
switch pt := v.GetHead().(type) {
case nil:
case *object.HeadResponse_Body_Header:
if pt != nil {
partHdr := new(HeaderWithSignature)
r.hdrPart = partHdr
err = partHdr.FromGRPCMessage(pt.Header)
}
case *object.HeadResponse_Body_ShortHeader:
if pt != nil {
partShort := new(ShortHeader)
r.hdrPart = partShort
err = partShort.FromGRPCMessage(pt.ShortHeader)
}
case *object.HeadResponse_Body_SplitInfo:
if pt != nil {
partSplit := new(SplitInfo)
r.hdrPart = partSplit
err = partSplit.FromGRPCMessage(pt.SplitInfo)
}
case *object.HeadResponse_Body_EcInfo:
if pt != nil {
partEC := new(ECInfo)
r.hdrPart = partEC
err = partEC.FromGRPCMessage(pt.EcInfo)
}
default:
err = fmt.Errorf("unknown head part %T", pt)
}
return err
}
func (r *HeadResponse) ToGRPCMessage() grpc.Message {
var m *object.HeadResponse
if r != nil {
m = new(object.HeadResponse)
m.SetBody(r.body.ToGRPCMessage().(*object.HeadResponse_Body))
r.ResponseHeaders.ToMessage(m)
}
return m
}
func (r *HeadResponse) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.HeadResponse)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
body := v.GetBody()
if body == nil {
r.body = nil
} else {
if r.body == nil {
r.body = new(HeadResponseBody)
}
err = r.body.FromGRPCMessage(body)
if err != nil {
return err
}
}
return r.ResponseHeaders.FromMessage(v)
}
func (f *SearchFilter) ToGRPCMessage() grpc.Message {
var m *object.SearchRequest_Body_Filter
if f != nil {
m = new(object.SearchRequest_Body_Filter)
m.SetKey(f.key)
m.SetValue(f.val)
m.SetMatchType(MatchTypeToGRPCField(f.matchType))
}
return m
}
func (f *SearchFilter) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.SearchRequest_Body_Filter)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
f.key = v.GetKey()
f.val = v.GetValue()
f.matchType = MatchTypeFromGRPCField(v.GetMatchType())
return nil
}
func SearchFiltersToGRPC(fs []SearchFilter) (res []object.SearchRequest_Body_Filter) {
if fs != nil {
res = make([]object.SearchRequest_Body_Filter, 0, len(fs))
for i := range fs {
res = append(res, *fs[i].ToGRPCMessage().(*object.SearchRequest_Body_Filter))
}
}
return
}
func SearchFiltersFromGRPC(fs []object.SearchRequest_Body_Filter) (res []SearchFilter, err error) {
if fs != nil {
res = make([]SearchFilter, len(fs))
for i := range fs {
err = res[i].FromGRPCMessage(&fs[i])
if err != nil {
return
}
}
}
return
}
func (r *SearchRequestBody) ToGRPCMessage() grpc.Message {
var m *object.SearchRequest_Body
if r != nil {
m = new(object.SearchRequest_Body)
m.SetContainerId(r.cid.ToGRPCMessage().(*refsGRPC.ContainerID))
m.SetFilters(SearchFiltersToGRPC(r.filters))
m.SetVersion(r.version)
}
return m
}
func (r *SearchRequestBody) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.SearchRequest_Body)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
cid := v.GetContainerId()
if cid == nil {
r.cid = nil
} else {
if r.cid == nil {
r.cid = new(refs.ContainerID)
}
err = r.cid.FromGRPCMessage(cid)
if err != nil {
return err
}
}
r.filters, err = SearchFiltersFromGRPC(v.GetFilters())
if err != nil {
return err
}
r.version = v.GetVersion()
return nil
}
func (r *SearchRequest) ToGRPCMessage() grpc.Message {
var m *object.SearchRequest
if r != nil {
m = new(object.SearchRequest)
m.SetBody(r.body.ToGRPCMessage().(*object.SearchRequest_Body))
r.RequestHeaders.ToMessage(m)
}
return m
}
func (r *SearchRequest) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.SearchRequest)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
body := v.GetBody()
if body == nil {
r.body = nil
} else {
if r.body == nil {
r.body = new(SearchRequestBody)
}
err = r.body.FromGRPCMessage(body)
if err != nil {
return err
}
}
return r.RequestHeaders.FromMessage(v)
}
func (r *SearchResponseBody) ToGRPCMessage() grpc.Message {
var m *object.SearchResponse_Body
if r != nil {
m = new(object.SearchResponse_Body)
m.SetIdList(refs.ObjectIDListToGRPCMessage(r.idList))
}
return m
}
func (r *SearchResponseBody) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.SearchResponse_Body)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
r.idList, err = refs.ObjectIDListFromGRPCMessage(v.GetIdList())
return err
}
func (r *SearchResponse) ToGRPCMessage() grpc.Message {
var m *object.SearchResponse
if r != nil {
m = new(object.SearchResponse)
m.SetBody(r.body.ToGRPCMessage().(*object.SearchResponse_Body))
r.ResponseHeaders.ToMessage(m)
}
return m
}
func (r *SearchResponse) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.SearchResponse)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
body := v.GetBody()
if body == nil {
r.body = nil
} else {
if r.body == nil {
r.body = new(SearchResponseBody)
}
err = r.body.FromGRPCMessage(body)
if err != nil {
return err
}
}
return r.ResponseHeaders.FromMessage(v)
}
func (r *Range) ToGRPCMessage() grpc.Message {
var m *object.Range
if r != nil {
m = new(object.Range)
m.SetLength(r.len)
m.SetOffset(r.off)
}
return m
}
func (r *Range) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.Range)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
r.len = v.GetLength()
r.off = v.GetOffset()
return nil
}
func RangesToGRPC(rs []Range) (res []object.Range) {
if rs != nil {
res = make([]object.Range, 0, len(rs))
for i := range rs {
res = append(res, *rs[i].ToGRPCMessage().(*object.Range))
}
}
return
}
func RangesFromGRPC(rs []object.Range) (res []Range, err error) {
if rs != nil {
res = make([]Range, len(rs))
for i := range rs {
err = res[i].FromGRPCMessage(&rs[i])
if err != nil {
return
}
}
}
return
}
func (r *GetRangeRequestBody) ToGRPCMessage() grpc.Message {
var m *object.GetRangeRequest_Body
if r != nil {
m = new(object.GetRangeRequest_Body)
m.SetAddress(r.addr.ToGRPCMessage().(*refsGRPC.Address))
m.SetRange(r.rng.ToGRPCMessage().(*object.Range))
m.SetRaw(r.raw)
}
return m
}
func (r *GetRangeRequestBody) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.GetRangeRequest_Body)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
addr := v.GetAddress()
if addr == nil {
r.addr = nil
} else {
if r.addr == nil {
r.addr = new(refs.Address)
}
err = r.addr.FromGRPCMessage(addr)
if err != nil {
return err
}
}
rng := v.GetRange()
if rng == nil {
r.rng = nil
} else {
if r.rng == nil {
r.rng = new(Range)
}
err = r.rng.FromGRPCMessage(rng)
if err != nil {
return err
}
}
r.raw = v.GetRaw()
return nil
}
func (r *GetRangeRequest) ToGRPCMessage() grpc.Message {
var m *object.GetRangeRequest
if r != nil {
m = new(object.GetRangeRequest)
m.SetBody(r.body.ToGRPCMessage().(*object.GetRangeRequest_Body))
r.RequestHeaders.ToMessage(m)
}
return m
}
func (r *GetRangeRequest) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.GetRangeRequest)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
body := v.GetBody()
if body == nil {
r.body = nil
} else {
if r.body == nil {
r.body = new(GetRangeRequestBody)
}
err = r.body.FromGRPCMessage(body)
if err != nil {
return err
}
}
return r.RequestHeaders.FromMessage(v)
}
func (r *GetRangePartChunk) ToGRPCMessage() grpc.Message {
var m *object.GetRangeResponse_Body_Chunk
if r != nil {
m = new(object.GetRangeResponse_Body_Chunk)
m.SetChunk(r.chunk)
}
return m
}
func (r *GetRangePartChunk) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.GetRangeResponse_Body_Chunk)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
r.chunk = v.GetChunk()
return nil
}
func (r *GetRangeResponseBody) ToGRPCMessage() grpc.Message {
var m *object.GetRangeResponse_Body
if r != nil {
m = new(object.GetRangeResponse_Body)
switch v := r.rngPart.(type) {
case nil:
m.RangePart = nil
case *GetRangePartChunk:
m.SetChunk(v.ToGRPCMessage().(*object.GetRangeResponse_Body_Chunk))
case *SplitInfo:
m.SetSplitInfo(v.ToGRPCMessage().(*object.SplitInfo))
case *ECInfo:
m.SetEcInfo(v.ToGRPCMessage().(*object.ECInfo))
default:
panic(fmt.Sprintf("unknown get range part %T", v))
}
}
return m
}
func (r *GetRangeResponseBody) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.GetRangeResponse_Body)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
r.rngPart = nil
switch pt := v.GetRangePart().(type) {
case nil:
case *object.GetRangeResponse_Body_Chunk:
if pt != nil {
partChunk := new(GetRangePartChunk)
r.rngPart = partChunk
err = partChunk.FromGRPCMessage(pt)
}
case *object.GetRangeResponse_Body_SplitInfo:
if pt != nil {
partSplit := new(SplitInfo)
r.rngPart = partSplit
err = partSplit.FromGRPCMessage(pt.SplitInfo)
}
case *object.GetRangeResponse_Body_EcInfo:
if pt != nil {
partEC := new(ECInfo)
r.rngPart = partEC
err = partEC.FromGRPCMessage(pt.EcInfo)
}
default:
err = fmt.Errorf("unknown get range part %T", pt)
}
return err
}
func (r *GetRangeResponse) ToGRPCMessage() grpc.Message {
var m *object.GetRangeResponse
if r != nil {
m = new(object.GetRangeResponse)
m.SetBody(r.body.ToGRPCMessage().(*object.GetRangeResponse_Body))
r.ResponseHeaders.ToMessage(m)
}
return m
}
func (r *GetRangeResponse) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.GetRangeResponse)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
body := v.GetBody()
if body == nil {
r.body = nil
} else {
if r.body == nil {
r.body = new(GetRangeResponseBody)
}
err = r.body.FromGRPCMessage(body)
if err != nil {
return err
}
}
return r.ResponseHeaders.FromMessage(v)
}
func (r *GetRangeHashRequestBody) ToGRPCMessage() grpc.Message {
var m *object.GetRangeHashRequest_Body
if r != nil {
m = new(object.GetRangeHashRequest_Body)
m.SetAddress(r.addr.ToGRPCMessage().(*refsGRPC.Address))
m.SetRanges(RangesToGRPC(r.rngs))
m.SetType(refs.ChecksumTypeToGRPC(r.typ))
m.SetSalt(r.salt)
}
return m
}
func (r *GetRangeHashRequestBody) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.GetRangeHashRequest_Body)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
addr := v.GetAddress()
if addr == nil {
r.addr = nil
} else {
if r.addr == nil {
r.addr = new(refs.Address)
}
err = r.addr.FromGRPCMessage(addr)
if err != nil {
return err
}
}
r.rngs, err = RangesFromGRPC(v.GetRanges())
if err != nil {
return err
}
r.typ = refs.ChecksumTypeFromGRPC(v.GetType())
r.salt = v.GetSalt()
return nil
}
func (r *GetRangeHashRequest) ToGRPCMessage() grpc.Message {
var m *object.GetRangeHashRequest
if r != nil {
m = new(object.GetRangeHashRequest)
m.SetBody(r.body.ToGRPCMessage().(*object.GetRangeHashRequest_Body))
r.RequestHeaders.ToMessage(m)
}
return m
}
func (r *GetRangeHashRequest) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.GetRangeHashRequest)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
body := v.GetBody()
if body == nil {
r.body = nil
} else {
if r.body == nil {
r.body = new(GetRangeHashRequestBody)
}
err = r.body.FromGRPCMessage(body)
if err != nil {
return err
}
}
return r.RequestHeaders.FromMessage(v)
}
func (r *GetRangeHashResponseBody) ToGRPCMessage() grpc.Message {
var m *object.GetRangeHashResponse_Body
if r != nil {
m = new(object.GetRangeHashResponse_Body)
m.SetType(refs.ChecksumTypeToGRPC(r.typ))
m.SetHashList(r.hashList)
}
return m
}
func (r *GetRangeHashResponseBody) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.GetRangeHashResponse_Body)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
r.typ = refs.ChecksumTypeFromGRPC(v.GetType())
r.hashList = v.GetHashList()
return nil
}
func (r *GetRangeHashResponse) ToGRPCMessage() grpc.Message {
var m *object.GetRangeHashResponse
if r != nil {
m = new(object.GetRangeHashResponse)
m.SetBody(r.body.ToGRPCMessage().(*object.GetRangeHashResponse_Body))
r.ResponseHeaders.ToMessage(m)
}
return m
}
func (r *GetRangeHashResponse) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.GetRangeHashResponse)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
body := v.GetBody()
if body == nil {
r.body = nil
} else {
if r.body == nil {
r.body = new(GetRangeHashResponseBody)
}
err = r.body.FromGRPCMessage(body)
if err != nil {
return err
}
}
return r.ResponseHeaders.FromMessage(v)
}
func (r *PutSingleRequestBody) ToGRPCMessage() grpc.Message {
var m *object.PutSingleRequest_Body
if r != nil {
m = new(object.PutSingleRequest_Body)
m.SetObject(r.GetObject().ToGRPCMessage().(*object.Object))
m.SetCopiesNumber(r.GetCopiesNumber())
}
return m
}
func (r *PutSingleRequestBody) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.PutSingleRequest_Body)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
if v.GetObject() == nil {
r.object = nil
} else {
if r.object == nil {
r.object = new(Object)
}
err := r.object.FromGRPCMessage(v.GetObject())
if err != nil {
return err
}
}
r.copyNum = v.GetCopiesNumber()
return nil
}
func (r *PutSingleRequest) ToGRPCMessage() grpc.Message {
var m *object.PutSingleRequest
if r != nil {
m = new(object.PutSingleRequest)
m.SetBody(r.body.ToGRPCMessage().(*object.PutSingleRequest_Body))
r.RequestHeaders.ToMessage(m)
}
return m
}
func (r *PutSingleRequest) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.PutSingleRequest)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
body := v.GetBody()
if body == nil {
r.body = nil
} else {
if r.body == nil {
r.body = new(PutSingleRequestBody)
}
err := r.body.FromGRPCMessage(body)
if err != nil {
return err
}
}
return r.RequestHeaders.FromMessage(v)
}
func (r *PutSingleResponseBody) ToGRPCMessage() grpc.Message {
var b *object.PutSingleResponse_Body
if r != nil {
b = new(object.PutSingleResponse_Body)
}
return b
}
func (r *PutSingleResponseBody) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.PutSingleResponse_Body)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
return nil
}
func (r *PutSingleResponse) ToGRPCMessage() grpc.Message {
var m *object.PutSingleResponse
if r != nil {
m = new(object.PutSingleResponse)
m.SetBody(r.body.ToGRPCMessage().(*object.PutSingleResponse_Body))
r.ResponseHeaders.ToMessage(m)
}
return m
}
func (r *PutSingleResponse) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.PutSingleResponse)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
body := v.GetBody()
if body == nil {
r.body = nil
} else {
if r.body == nil {
r.body = new(PutSingleResponseBody)
}
err = r.body.FromGRPCMessage(body)
if err != nil {
return err
}
}
return r.ResponseHeaders.FromMessage(v)
}
func (r *PatchRequestBodyPatch) ToGRPCMessage() grpc.Message {
var m *object.PatchRequest_Body_Patch
if r != nil {
m = new(object.PatchRequest_Body_Patch)
m.SetSourceRange(r.GetRange().ToGRPCMessage().(*object.Range))
m.SetChunk(r.GetChunk())
}
return m
}
func (r *PatchRequestBodyPatch) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.PatchRequest_Body_Patch)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
srcRange := v.GetSourceRange()
if srcRange == nil {
r.Range = nil
} else {
if r.Range == nil {
r.Range = new(Range)
}
err = r.Range.FromGRPCMessage(srcRange)
if err != nil {
return err
}
}
r.Chunk = v.GetChunk()
return nil
}
func (r *PatchRequestBody) ToGRPCMessage() grpc.Message {
var m *object.PatchRequest_Body
if r != nil {
m = new(object.PatchRequest_Body)
m.SetAddress(r.address.ToGRPCMessage().(*refsGRPC.Address))
m.SetNewAttributes(AttributesToGRPC(r.newAttributes))
m.SetReplaceAttributes(r.replaceAttributes)
m.SetPatch(r.patch.ToGRPCMessage().(*object.PatchRequest_Body_Patch))
}
return m
}
func (r *PatchRequestBody) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.PatchRequest_Body)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
addr := v.GetAddress()
if addr == nil {
r.address = nil
} else {
if r.address == nil {
r.address = new(refs.Address)
}
err = r.address.FromGRPCMessage(addr)
if err != nil {
return err
}
}
r.newAttributes, err = AttributesFromGRPC(v.GetNewAttributes())
if err != nil {
return err
}
r.replaceAttributes = v.GetReplaceAttributes()
patch := v.GetPatch()
if patch == nil {
r.patch = nil
} else {
if r.patch == nil {
r.patch = new(PatchRequestBodyPatch)
}
err = r.patch.FromGRPCMessage(patch)
if err != nil {
return err
}
}
return nil
}
func (r *PatchRequest) ToGRPCMessage() grpc.Message {
var m *object.PatchRequest
if r != nil {
m = new(object.PatchRequest)
m.SetBody(r.body.ToGRPCMessage().(*object.PatchRequest_Body))
r.RequestHeaders.ToMessage(m)
}
return m
}
func (r *PatchRequest) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.PatchRequest)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
body := v.GetBody()
if body == nil {
r.body = nil
} else {
if r.body == nil {
r.body = new(PatchRequestBody)
}
err = r.body.FromGRPCMessage(body)
if err != nil {
return err
}
}
return r.RequestHeaders.FromMessage(v)
}
func (r *PatchResponseBody) ToGRPCMessage() grpc.Message {
var m *object.PatchResponse_Body
if r != nil {
m = new(object.PatchResponse_Body)
m.SetObjectId(r.ObjectID.ToGRPCMessage().(*refsGRPC.ObjectID))
}
return m
}
func (r *PatchResponseBody) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.PatchResponse_Body)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
objID := v.GetObjectId()
if objID == nil {
r.ObjectID = nil
} else {
if r.ObjectID == nil {
r.ObjectID = new(refs.ObjectID)
}
err = r.ObjectID.FromGRPCMessage(objID)
if err != nil {
return err
}
}
return nil
}
func (r *PatchResponse) ToGRPCMessage() grpc.Message {
var m *object.PatchResponse
if r != nil {
m = new(object.PatchResponse)
m.SetBody(r.Body.ToGRPCMessage().(*object.PatchResponse_Body))
r.ResponseHeaders.ToMessage(m)
}
return m
}
func (r *PatchResponse) FromGRPCMessage(m grpc.Message) error {
v, ok := m.(*object.PatchResponse)
if !ok {
return message.NewUnexpectedMessageType(m, v)
}
var err error
body := v.GetBody()
if body == nil {
r.Body = nil
} else {
if r.Body == nil {
r.Body = new(PatchResponseBody)
}
err = r.Body.FromGRPCMessage(body)
if err != nil {
return err
}
}
return r.ResponseHeaders.FromMessage(v)
}