Implement custom hybrid un-/marshal model

cosmos · Nov 14, 2024 · a44f9d1 · a44f9d1
1 parent a00c36a
commit a44f9d1
Show file tree

Hide file tree

Showing 2 changed files with 95 additions and 47 deletions.
diff --git a/math/dec.go b/math/dec.go
@@ -404,12 +404,54 @@ func (x Dec) Reduce() (Dec, int) {
 	return y, n
 }
 
+// Marshal serializes the decimal value into a byte slice in text format.
+// This method represents the decimal in a portable and compact hybrid notation.
+// Based on the exponent value, the number is formatted into decimal: -ddddd.ddddd, no exponent
+// or scientific notation: -d.ddddE±dd
+//
+// For example, the following transformations are made:
+//   - 0 -> 0
+//   - 123 -> 123
+//   - 10000 -> 10000
+//   - -0.001 -> -0.001
+//   - -0.000000001 -> -1E-9
+//
+// Returns:
+//   - A byte slice of the decimal in text format.
+//   - An error if the decimal cannot be reduced or marshaled properly.
 func (x Dec) Marshal() ([]byte, error) {
-	panic("not implemented")
+	var d apd.Decimal
+	if _, _, err := dec128Context.Reduce(&d, &x.dec); err != nil {
+		return nil, ErrInvalidDec.Wrap(err.Error())
+	}
+	if (d.Exponent < -5 || d.Exponent > 5) && !isEmptyExp(d) {
+		return []byte(d.Text('E')), nil
+	}
+	return []byte(d.Text('f')), nil
+}
+
+// isEmptyExp checks if the adjusted exponent of the given decimal is zero.
+func isEmptyExp(d apd.Decimal) bool {
+	var scratch [16]byte
+	digits := d.Coeff.Append(scratch[:0], 10)
+	adj := int64(d.Exponent) + int64(len(digits)) - 1
+	return adj == 0
 }
 
+// Unmarshal parses a byte slice containing a text-formatted decimal and stores the result in the receiver.
+// It returns an error if the byte slice does not represent a valid decimal.
 func (x *Dec) Unmarshal(data []byte) error {
-	panic("not implemented")
+	result, err := NewDecFromString(string(data))
+	if err != nil {
+		return ErrInvalidDec.Wrap(err.Error())
+	}
+
+	if result.dec.Form != apd.Finite {
+		return ErrInvalidDec.Wrap("unknown decimal form")
+	}
+
+	x.dec = result.dec
+	return nil
 }
 
 // MarshalTo encodes the receiver into the provided byte slice and returns the number of bytes written and any error encountered.

diff --git a/math/dec_test.go b/math/dec_test.go
@@ -1323,55 +1323,30 @@ func must[T any](r T, err error) T {
 }
 
 func TestMarshalUnmarshal(t *testing.T) {
-	t.Skip("not supported, yet")
 	specs := map[string]struct {
 		x      Dec
 		exp    string
 		expErr error
 	}{
-		"No trailing zeros": {
-			x:   NewDecFromInt64(123456),
-			exp: "1.23456E+5",
-		},
-		"Trailing zeros": {
-			x:   NewDecFromInt64(123456000),
-			exp: "1.23456E+8",
-		},
 		"Zero value": {
 			x:   NewDecFromInt64(0),
-			exp: "0E+0",
+			exp: "0",
 		},
 		"-0": {
 			x:   NewDecFromInt64(-0),
-			exp: "0E+0",
-		},
-		"Decimal value": {
-			x:   must(NewDecFromString("1.30000")),
-			exp: "1.3E+0",
-		},
-		"Positive value": {
-			x:   NewDecFromInt64(10),
-			exp: "1E+1",
-		},
-		"negative 10": {
-			x:   NewDecFromInt64(-10),
-			exp: "-1E+1",
-		},
-		"9 with trailing zeros": {
-			x:   must(NewDecFromString("9." + strings.Repeat("0", 34))),
-			exp: "9E+0",
+			exp: "0",
 		},
-		"negative 1 with negative exponent zeros": {
-			x:   must(NewDecFromString("-1.000001")),
-			exp: "-1.000001E+0",
+		"3 decimal places": {
+			x:   must(NewDecFromString("0.001")),
+			exp: "0.001",
 		},
-		"negative 1 with trailing zeros": {
-			x:   must(NewDecFromString("-1." + strings.Repeat("0", 34))),
-			exp: "-1E+0",
+		"4 decimal places": {
+			x:   must(NewDecFromString("0.0001")),
+			exp: "0.0001",
 		},
 		"5 decimal places": {
 			x:   must(NewDecFromString("0.00001")),
-			exp: "1E-5",
+			exp: "0.00001",
 		},
 		"6 decimal places": {
 			x:   must(NewDecFromString("0.000001")),
@@ -1381,17 +1356,45 @@ func TestMarshalUnmarshal(t *testing.T) {
 			x:   must(NewDecFromString("0.0000001")),
 			exp: "1E-7",
 		},
+		"1234567": {
+			x:   must(NewDecFromString("1234567")),
+			exp: "1234567",
+		},
+		"12345678": {
+			x:   must(NewDecFromString("12345678")),
+			exp: "12345678",
+		},
+		"123456789": {
+			x:   must(NewDecFromString("123456789")),
+			exp: "123456789",
+		},
+		"1234567890": {
+			x:   must(NewDecFromString("1234567890")),
+			exp: "1234567890",
+		},
+		"12345678900": {
+			x:   must(NewDecFromString("12345678900")),
+			exp: "12345678900",
+		},
+		"negative 1 with negative exponent zeros": {
+			x:   must(NewDecFromString("-1.000001")),
+			exp: "-1.000001",
+		},
+		"3 decimal places before the comma": {
+			x:   must(NewDecFromString("100")),
+			exp: "100",
+		},
 		"4 decimal places before the comma": {
 			x:   must(NewDecFromString("1000")),
-			exp: "1E+3",
+			exp: "1000",
 		},
 		"5 decimal places before the comma": {
 			x:   must(NewDecFromString("10000")),
-			exp: "1E+4",
+			exp: "10000",
 		},
 		"6 decimal places before the comma": {
 			x:   must(NewDecFromString("100000")),
-			exp: "1E+5",
+			exp: "100000",
 		},
 		"7 decimal places before the comma": {
 			x:   must(NewDecFromString("1000000")),
@@ -1402,12 +1405,12 @@ func TestMarshalUnmarshal(t *testing.T) {
 			exp: "1E+100000",
 		},
 		"1.1e100000": {
-			x:      NewDecWithExp(11, 100_000),
-			expErr: ErrInvalidDec,
+			x:   must(NewDecFromString("1.1e100000")),
+			exp: "1.1E+100000",
 		},
-		"1.e100000": {
-			x:   NewDecWithExp(1, 100_000),
-			exp: "1E+100000",
+		"1e100001": {
+			x:      NewDecWithExp(1, 100_001),
+			expErr: ErrInvalidDec,
 		},
 	}
 	for name, spec := range specs {
@@ -1418,9 +1421,12 @@ func TestMarshalUnmarshal(t *testing.T) {
 				return
 			}
 			require.NoError(t, gotErr)
-			unmarshalled := new(Dec)
-			require.NoError(t, unmarshalled.Unmarshal(marshaled))
-			assert.Equal(t, spec.exp, unmarshalled.dec.Text('E'))
+			assert.Equal(t, spec.exp, string(marshaled))
+			// and backwards
+			unmarshalledDec := new(Dec)
+			require.NoError(t, unmarshalledDec.Unmarshal(marshaled))
+			assert.Equal(t, spec.x.String(), unmarshalledDec.String())
+			assert.True(t, spec.x.Equal(*unmarshalledDec))
 		})
 	}
 }