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 {
			if xs[i] != nil {
				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 {
			if fs[i] != nil {
				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 {
			if rs[i] != nil {
				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.Range.ToGRPCMessage().(*object.Range))
		m.SetChunk(r.Chunk)
	}

	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)
}