WIP

Signed-off-by: Leonard Lyubich <[email protected]>

accounting/decimal.go

@@ -1,93 +1,107 @@
 package accounting
 
 import (
- "github.com/nspcc-dev/neofs-api-go/v2/accounting"
+ "fmt"
+
+ "github.com/nspcc-dev/neofs-sdk-go/api/accounting"
+ "google.golang.org/protobuf/proto"
 )
 
 // Decimal represents decimal number for accounting operations.
 //
-// Decimal is mutually compatible with github.com/nspcc-dev/neofs-api-go/v2/accounting.Decimal
-// message. See ReadFromV2 / WriteToV2 methods.
+// Decimal is mutually compatible with [accounting.Decimal] message. See
+// [Decimal.ReadFromV2] / [Decimal.WriteToV2] methods.
 //
 // Instances can be created using built-in var declaration.
-//
-// Note that direct typecast is not safe and may result in loss of compatibility:
-//
-// _ = Decimal(accounting.Decimal{}) // not recommended
-type Decimal accounting.Decimal
+type Decimal struct {
+ val int64
+ prec uint32
+}
 
-// ReadFromV2 reads Decimal from the accounting.Decimal message. Checks if the
-// message conforms to NeoFS API V2 protocol.
+// ReadFromV2 reads Decimal from the [accounting.Decimal] message. Returns an
+// error if the message is malformed according to the NeoFS API V2 protocol. The
+// message must not be nil.
 //
-// See also WriteToV2.
-func (d *Decimal) ReadFromV2(m accounting.Decimal) error {
- *d = Decimal(m)
+// ReadFromV2 is intended to be used by the NeoFS API V2 client/server
+// implementation only and is not expected to be directly used by applications.
+//
+// See also [Decimal.WriteToV2].
+func (d *Decimal) ReadFromV2(m *accounting.Decimal) error {
+ d.val = m.Value
+ d.prec = m.Precision
  return nil
 }
 
-// WriteToV2 writes Decimal to the accounting.Decimal message.
-// The message must not be nil.
+// WriteToV2 writes Decimal to the [accounting.Decimal] message of the NeoFS API
+// protocol.
+//
+// WriteToV2 is intended to be used by the NeoFS API V2 client/server
+// implementation only and is not expected to be directly used by applications.
 //
-// See also ReadFromV2.
+// See also [Decimal.ReadFromV2].
 func (d Decimal) WriteToV2(m *accounting.Decimal) {
- *m = (accounting.Decimal)(d)
+ m.Value = d.val
+ m.Precision = d.prec
 }
 
 // Value returns value of the decimal number.
 //
 // Zero Decimal has zero value.
 //
-// See also SetValue.
+// See also [Decimal.SetValue].
 func (d Decimal) Value() int64 {
- return (*accounting.Decimal)(&d).GetValue()
+ return d.val
 }
 
 // SetValue sets value of the decimal number.
 //
-// See also Value.
+// See also [Decimal.Value].
 func (d *Decimal) SetValue(v int64) {
- (*accounting.Decimal)(d).SetValue(v)
+ d.val = v
 }
 
 // Precision returns precision of the decimal number.
 //
 // Zero Decimal has zero precision.
 //
-// See also SetPrecision.
+// See also [Decimal.SetPrecision].
 func (d Decimal) Precision() uint32 {
- return (*accounting.Decimal)(&d).GetPrecision()
+ return d.prec
 }
 
 // SetPrecision sets precision of the decimal number.
 //
-// See also Precision.
+// See also [Decimal.Precision].
 func (d *Decimal) SetPrecision(p uint32) {
- (*accounting.Decimal)(d).SetPrecision(p)
+ d.prec = p
 }
 
+// TODO: why needed? if so, can be non-deterministic?
+
 // Marshal encodes Decimal into a binary format of the NeoFS API protocol
 // (Protocol Buffers with direct field order).
 //
-// See also Unmarshal.
+// See also [Decimal.Unmarshal].
 func (d Decimal) Marshal() []byte {
  var m accounting.Decimal
  d.WriteToV2(&m)
 
- return m.StableMarshal(nil)
+ b := make([]byte, m.MarshaledSize())
+ m.MarshalStable(b)
+ return b
 }
 
 // Unmarshal decodes NeoFS API protocol binary format into the Decimal
 // (Protocol Buffers with direct field order). Returns an error describing
 // a format violation.
 //
-// See also Marshal.
+// See also [Decimal.Marshal].
 func (d *Decimal) Unmarshal(data []byte) error {
  var m accounting.Decimal
-
- err := m.Unmarshal(data)
+ err := proto.Unmarshal(data, &m)
  if err != nil {
- return err
+ return fmt.Errorf("decode protobuf")
  }
 
- return d.ReadFromV2(m)
+ return d.ReadFromV2(&m)
 }

accounting/decimal_test.go

@@ -3,54 +3,74 @@ package accounting_test
 import (
  "testing"
 
- v2accounting "github.com/nspcc-dev/neofs-api-go/v2/accounting"
  "github.com/nspcc-dev/neofs-sdk-go/accounting"
- accountingtest "github.com/nspcc-dev/neofs-sdk-go/accounting/test"
+ apiaccounting "github.com/nspcc-dev/neofs-sdk-go/api/accounting"
  "github.com/stretchr/testify/require"
 )
 
-func TestDecimalData(t *testing.T) {
- const v, p = 4, 2
+func TestDecimal_Unmarshal(t *testing.T) {
+ t.Run("invalid binary", func(t *testing.T) {
+ var d accounting.Decimal
+ msg := []byte("definitely_not_protobuf")
+ err := d.Unmarshal(msg)
+ require.ErrorContains(t, err, "decode protobuf")
+ })
+}
 
+func testDecimalField[Type uint32 | int64](t *testing.T, get func(accounting.Decimal) Type, set func(*accounting.Decimal, Type),
+ getAPI func(info *apiaccounting.Decimal) Type) {
  var d accounting.Decimal
 
- require.Zero(t, d.Value())
- require.Zero(t, d.Precision())
+ require.Zero(t, get(d))
 
- d.SetValue(v)
- d.SetPrecision(p)
+ const val = 13
+ set(&d, val)
+ require.EqualValues(t, val, get(d))
 
- require.EqualValues(t, v, d.Value())
- require.EqualValues(t, p, d.Precision())
-}
+ const valOther = 42
+ set(&d, valOther)
+ require.EqualValues(t, valOther, get(d))
 
-func TestDecimalMessageV2(t *testing.T) {
- var (
- d accounting.Decimal
- m v2accounting.Decimal
- )
+ t.Run("encoding", func(t *testing.T) {
+ t.Run("binary", func(t *testing.T) {
+ var src, dst accounting.Decimal
 
- m.SetValue(7)
- m.SetPrecision(8)
+ set(&dst, val)
 
- require.NoError(t, d.ReadFromV2(m))
+ require.NoError(t, dst.Unmarshal(src.Marshal()))
+ require.Zero(t, get(dst))
 
- require.EqualValues(t, m.GetValue(), d.Value())
- require.EqualValues(t, m.GetPrecision(), d.Precision())
+ set(&src, val)
 
- var m2 v2accounting.Decimal
+ require.NoError(t, dst.Unmarshal(src.Marshal()))
+ require.EqualValues(t, val, get(dst))
+ })
+ t.Run("api", func(t *testing.T) {
+ var src, dst accounting.Decimal
+ var msg apiaccounting.Decimal
 
- d.WriteToV2(&m2)
+  set(&dst, val)
 
- require.EqualValues(t, d.Value(), m2.GetValue())
- require.EqualValues(t, d.Precision(), m2.GetPrecision())
-}
+ src.WriteToV2(&msg)
+ require.Zero(t, getAPI(&msg))
+ require.NoError(t, dst.ReadFromV2(&msg))
+ require.Zero(t, get(dst))
 
-func TestDecimal_Marshal(t *testing.T) {
- d := accountingtest.Decimal()
+ set(&src, val)
 
- var d2 accounting.Decimal
- require.NoError(t, d2.Unmarshal(d.Marshal()))
+ src.WriteToV2(&msg)
+ require.EqualValues(t, val, getAPI(&msg))
+ err := dst.ReadFromV2(&msg)
+ require.NoError(t, err)
+ require.EqualValues(t, val, get(dst))
+ })
+ })
+}
+
+func TestDecimal_SetValue(t *testing.T) {
+ testDecimalField(t, accounting.Decimal.Value, (*accounting.Decimal).SetValue, (*apiaccounting.Decimal).GetValue)
+}
 
- require.Equal(t, d, d2)
+func TestDecimal_SetPrecision(t *testing.T) {
+ testDecimalField(t, accounting.Decimal.Precision, (*accounting.Decimal).SetPrecision, (*apiaccounting.Decimal).GetPrecision)
 }

accounting/example_test.go

@@ -1,8 +1,8 @@
 package accounting_test
 
 import (
- apiGoAccounting "github.com/nspcc-dev/neofs-api-go/v2/accounting"
  "github.com/nspcc-dev/neofs-sdk-go/accounting"
+ apiaccounting "github.com/nspcc-dev/neofs-sdk-go/api/accounting"
 )
 
 func Example() {
@@ -16,11 +16,10 @@ func Example() {
 
  // On the client side.
 
- // import apiGoAccounting "github.com/nspcc-dev/neofs-api-go/v2/accounting"
- var msg apiGoAccounting.Decimal
+ var msg apiaccounting.Decimal
  dec.WriteToV2(&msg)
  // *send message*
 
  // On the server side.
- _ = dec.ReadFromV2(msg)
+ _ = dec.ReadFromV2(&msg)
 }

accounting/test/decimal_test.go

@@ -0,0 +1,25 @@
+package accountingtest_test
+
+import (
+ "testing"
+
+ "github.com/nspcc-dev/neofs-sdk-go/accounting"
+ accountingtest "github.com/nspcc-dev/neofs-sdk-go/accounting/test"
+ apiaccounting "github.com/nspcc-dev/neofs-sdk-go/api/accounting"
+ "github.com/stretchr/testify/require"
+)
+
+func TestDecimal(t *testing.T) {
+ d := accountingtest.Decimal()
+ require.NotEqual(t, d, accountingtest.Decimal())
+
+ var d2 accounting.Decimal
+ require.NoError(t, d2.Unmarshal(d.Marshal()))
+ require.Equal(t, d, d2)
+
+ var m apiaccounting.Decimal
+ d.WriteToV2(&m)
+ var d3 accounting.Decimal
+ require.NoError(t, d3.ReadFromV2(&m))
+ require.Equal(t, d, d3)
+}

api/accounting/encoding.go

@@ -0,0 +1,65 @@
+package accounting
+
+import (
+ "github.com/nspcc-dev/neofs-sdk-go/internal/proto"
+)
+
+const (
+ _ = iota
+ fieldDecimalValue
+ fieldDecimalPrecision
+)
+
+func (x *Decimal) MarshaledSize() int {
+ var sz int
+ if x != nil {
+ sz = proto.SizeVarint(fieldDecimalValue, x.Value) +
+ proto.SizeVarint(fieldDecimalPrecision, x.Precision)
+ }
+ return sz
+}
+
+func (x *Decimal) MarshalStable(b []byte) {
+ if x != nil {
+ off := proto.MarshalVarint(b, fieldDecimalValue, x.Value)
+ proto.MarshalVarint(b[off:], fieldDecimalPrecision, x.Precision)
+ }
+}
+
+const (
+ _ = iota
+ fieldBalanceReqOwner
+)
+
+func (x *BalanceRequest_Body) MarshaledSize() int {
+ var sz int
+ if x != nil {
+ sz = proto.SizeNested(fieldBalanceReqOwner, x.OwnerId)
+ }
+ return sz
+}
+
+func (x *BalanceRequest_Body) MarshalStable(b []byte) {
+ if x != nil {
+ proto.MarshalNested(b, fieldBalanceReqOwner, x.OwnerId)
+ }
+}
+
+const (
+ _ = iota
+ fieldBalanceRespBalance
+)
+
+func (x *BalanceResponse_Body) MarshaledSize() int {
+ var sz int
+ if x != nil {
+ sz = proto.SizeNested(fieldBalanceRespBalance, x.Balance)
+ }
+ return sz
+}
+
+func (x *BalanceResponse_Body) MarshalStable(b []byte) {
+ if x != nil {
+ proto.MarshalNested(b, fieldBalanceRespBalance, x.Balance)
+ }
+}