github.com/TrueCloudLab/frostfs-api-go/v2@v2.0.0-20230228134343-196241c4e79a/accounting/convert.go (about)

     1  package accounting
     2  
     3  import (
     4  	accounting "github.com/TrueCloudLab/frostfs-api-go/v2/accounting/grpc"
     5  	"github.com/TrueCloudLab/frostfs-api-go/v2/refs"
     6  	refsGRPC "github.com/TrueCloudLab/frostfs-api-go/v2/refs/grpc"
     7  	"github.com/TrueCloudLab/frostfs-api-go/v2/rpc/grpc"
     8  	"github.com/TrueCloudLab/frostfs-api-go/v2/rpc/message"
     9  )
    10  
    11  func (b *BalanceRequestBody) ToGRPCMessage() grpc.Message {
    12  	var m *accounting.BalanceRequest_Body
    13  
    14  	if b != nil {
    15  		m = new(accounting.BalanceRequest_Body)
    16  
    17  		m.SetOwnerId(b.ownerID.ToGRPCMessage().(*refsGRPC.OwnerID))
    18  	}
    19  
    20  	return m
    21  }
    22  
    23  func (b *BalanceRequestBody) FromGRPCMessage(m grpc.Message) error {
    24  	v, ok := m.(*accounting.BalanceRequest_Body)
    25  	if !ok {
    26  		return message.NewUnexpectedMessageType(m, v)
    27  	}
    28  
    29  	var err error
    30  
    31  	ownerID := v.GetOwnerId()
    32  	if ownerID == nil {
    33  		b.ownerID = nil
    34  	} else {
    35  		if b.ownerID == nil {
    36  			b.ownerID = new(refs.OwnerID)
    37  		}
    38  
    39  		err = b.ownerID.FromGRPCMessage(ownerID)
    40  	}
    41  
    42  	return err
    43  }
    44  
    45  func (b *BalanceRequest) ToGRPCMessage() grpc.Message {
    46  	var m *accounting.BalanceRequest
    47  
    48  	if b != nil {
    49  		m = new(accounting.BalanceRequest)
    50  
    51  		m.SetBody(b.body.ToGRPCMessage().(*accounting.BalanceRequest_Body))
    52  		b.RequestHeaders.ToMessage(m)
    53  	}
    54  
    55  	return m
    56  }
    57  
    58  func (b *BalanceRequest) FromGRPCMessage(m grpc.Message) error {
    59  	v, ok := m.(*accounting.BalanceRequest)
    60  	if !ok {
    61  		return message.NewUnexpectedMessageType(m, v)
    62  	}
    63  
    64  	var err error
    65  
    66  	body := v.GetBody()
    67  	if body == nil {
    68  		b.body = nil
    69  	} else {
    70  		if b.body == nil {
    71  			b.body = new(BalanceRequestBody)
    72  		}
    73  
    74  		err = b.body.FromGRPCMessage(body)
    75  		if err != nil {
    76  			return err
    77  		}
    78  	}
    79  
    80  	return b.RequestHeaders.FromMessage(v)
    81  }
    82  
    83  func (d *Decimal) ToGRPCMessage() grpc.Message {
    84  	var m *accounting.Decimal
    85  
    86  	if d != nil {
    87  		m = new(accounting.Decimal)
    88  
    89  		m.SetValue(d.val)
    90  		m.SetPrecision(d.prec)
    91  	}
    92  
    93  	return m
    94  }
    95  
    96  func (d *Decimal) FromGRPCMessage(m grpc.Message) error {
    97  	v, ok := m.(*accounting.Decimal)
    98  	if !ok {
    99  		return message.NewUnexpectedMessageType(m, v)
   100  	}
   101  
   102  	d.val = v.GetValue()
   103  	d.prec = v.GetPrecision()
   104  
   105  	return nil
   106  }
   107  
   108  func (br *BalanceResponseBody) ToGRPCMessage() grpc.Message {
   109  	var m *accounting.BalanceResponse_Body
   110  
   111  	if br != nil {
   112  		m = new(accounting.BalanceResponse_Body)
   113  
   114  		m.SetBalance(br.bal.ToGRPCMessage().(*accounting.Decimal))
   115  	}
   116  
   117  	return m
   118  }
   119  
   120  func (br *BalanceResponseBody) FromGRPCMessage(m grpc.Message) error {
   121  	v, ok := m.(*accounting.BalanceResponse_Body)
   122  	if !ok {
   123  		return message.NewUnexpectedMessageType(m, v)
   124  	}
   125  
   126  	var err error
   127  
   128  	bal := v.GetBalance()
   129  	if bal == nil {
   130  		br.bal = nil
   131  	} else {
   132  		if br.bal == nil {
   133  			br.bal = new(Decimal)
   134  		}
   135  
   136  		err = br.bal.FromGRPCMessage(bal)
   137  	}
   138  
   139  	return err
   140  }
   141  
   142  func (br *BalanceResponse) ToGRPCMessage() grpc.Message {
   143  	var m *accounting.BalanceResponse
   144  
   145  	if br != nil {
   146  		m = new(accounting.BalanceResponse)
   147  
   148  		m.SetBody(br.body.ToGRPCMessage().(*accounting.BalanceResponse_Body))
   149  		br.ResponseHeaders.ToMessage(m)
   150  	}
   151  
   152  	return m
   153  }
   154  
   155  func (br *BalanceResponse) FromGRPCMessage(m grpc.Message) error {
   156  	v, ok := m.(*accounting.BalanceResponse)
   157  	if !ok {
   158  		return message.NewUnexpectedMessageType(m, v)
   159  	}
   160  
   161  	var err error
   162  
   163  	body := v.GetBody()
   164  	if body == nil {
   165  		br.body = nil
   166  	} else {
   167  		if br.body == nil {
   168  			br.body = new(BalanceResponseBody)
   169  		}
   170  
   171  		err = br.body.FromGRPCMessage(body)
   172  		if err != nil {
   173  			return err
   174  		}
   175  	}
   176  
   177  	return br.ResponseHeaders.FromMessage(v)
   178  }