Extension throws error: Decode(nonaddressable main.MyDecimal)

[schalekamp]

When I try the run the following code I get the following error:

error encoding message with encoder msgpack: Decode(nonaddressable main.MyDecimal)
encoded bytes: [131 204 204 204 188 205 1 44 207 0 0 1 119 10 189 34 219 204 208]
error decoding message EOF
decoded map: map[204:188 300:1610792903387]

package main

import (
	"bytes"
	"fmt"
	"github.com/shopspring/decimal"
	"github.com/vmihailenco/msgpack/v5"
)

func init() {
	msgpack.RegisterExt(4, (*MyDecimal)(nil))
}

type MyDecimal struct {
	decimal.Decimal
}

var (
	_ msgpack.Marshaler   = (*MyDecimal)(nil)
	_ msgpack.Unmarshaler = (*MyDecimal)(nil)
)

func (md *MyDecimal) MarshalMsgpack() ([]byte, error) {
	return []byte(md.String()), nil
}

func (md *MyDecimal) UnmarshalMsgpack(b []byte) error {
	dec, err := decimal.NewFromString(string(b))
	if err != nil {
		return err
	}
	md.Decimal = dec
	return nil
}

func test_mpack_extension() {

	var msg2 = make(map[int]interface{})
	msg2[204] = 188
	msg2[300] = 1610792903387
	d, _ := decimal.NewFromString("3.25")
	var md MyDecimal
	md.Decimal = d
	msg2[208] = md

	var bmsg bytes.Buffer
	enc2 := msgpack.NewEncoder(&bmsg)
	enc2.UseCompactInts(true)
	enc2.UseCompactFloats(true)
	err := enc2.Encode(msg2)
	if err != nil {
		fmt.Printf("error encoding message with encoder %v\n", err)
	}

	fmt.Printf("encoded bytes: %v \n", bmsg.Bytes())

	var v2 map[int]interface{}
	err = msgpack.Unmarshal(bmsg.Bytes(), &v2)
	if err != nil {
		fmt.Printf("error decoding message %v\n", err)
	}
	fmt.Printf("decoded map: %v \n", v2)
}

func main() {
	test_mpack_extension()
}

[vmihailenco]

If you can, change the code to msg2[208] = &md. Proper fix requires changes to the library.

[schalekamp]

this seems to work btw

func decimalDecoder(dec *msgpack.Decoder, v reflect.Value, extLen int) error {
	rdr := dec.Buffered()
	data := make([]byte, extLen)
	rdr.Read(data)
	d, err := decimal.NewFromString(string(data))
	if err != nil {
		return err
	}
	if d_ptr, ok := v.Addr().Interface().(*decimal.Decimal); ok {
		*d_ptr = d
		return nil
	} else {
		return errors.New("decoding msgpack decimal value to wrong type")
	}
}

func decimalEncoder(enc *msgpack.Encoder, v reflect.Value) ([]byte, error) {
	if d, ok := v.Interface().(decimal.Decimal); ok {
		s := d.String()
		return []byte(s), nil
	} else {
		return nil, errors.New("could not convert value to *decimal.Decimal")
	}
}

func init() {
	msgpack.RegisterExtDecoder(4, decimal.Decimal{}, decimalDecoder)
	msgpack.RegisterExtEncoder(4, decimal.Decimal{}, decimalEncoder)
}

[vmihailenco]

Yes, you got the right idea. Ideally, the library should handle such situations better automatically...

[schalekamp]

I agree. whenever you have time for that ofcourse. Meanwhile thank you for writing and maintaining the library. It is great.

[id01]

For those of you who are still having issues with this, I used this function. Essentially, I made all the encoding into non-pointer functions and made an "asymmetric ext registration". It's a workaround that works, I suppose, but you don't get that nice clean everything-is-a-pointer declaration.

func RegisterAsymmetricExt(extID int8, marshalType msgpack.Marshaler, unmarshalType msgpack.Unmarshaler) {
	msgpack.RegisterExtEncoder(extID, marshalType, func(e *msgpack.Encoder, v reflect.Value) ([]byte, error) {
		marshaler := v.Interface().(msgpack.Marshaler)
		return marshaler.MarshalMsgpack()
	})
	msgpack.RegisterExtDecoder(extID, unmarshalType, func(d *msgpack.Decoder, v reflect.Value, extLen int) error {
		b := make([]byte, extLen)
		err := d.ReadFull(b)
//		b, err := d.readN(extLen)
		if err != nil {
			return err
		}
		return v.Interface().(msgpack.Unmarshaler).UnmarshalMsgpack(b)
	})
}

func init() {
	RegisterAsymmetricExt(int8(VECTOR4_TYPE_CODE), Vector4{}, (*Vector4)(nil))
}

func (v Vector4) MarshalMsgpack() ([]byte, error) {
	buf := new(bytes.Buffer)
	err := binary.Write(buf, binary.BigEndian, v)
	if err != nil {
		return nil, err
	}
	return buf.Bytes(), err
}

func (v *Vector4) UnmarshalMsgpack(b []byte) error {
	if len(b) != 16 {
		return fmt.Errorf("invalid data length: got %d, wanted 16", len(b))
	}
	r := bytes.NewReader(b)
	return binary.Read(r, binary.BigEndian, v)
}

[giautm]

this seems to work btw

Thank you, I suggest another solution that will work on other types too.

// RegisterBinaryExt registers a binary marshaler/unmarshaler for the given type.
// The type must be implemented both interfaces.
func RegisterBinaryExt[T encoding.BinaryMarshaler, _ interface {
	encoding.BinaryUnmarshaler
	*T
}](extID int8) {
	var zero T
	msgpack.RegisterExtEncoder(extID, zero, func(e *msgpack.Encoder, v reflect.Value) ([]byte, error) {
		m := v.Interface().(encoding.BinaryMarshaler)
		return m.MarshalBinary()
	})
	msgpack.RegisterExtDecoder(extID, zero, func(d *msgpack.Decoder, v reflect.Value, extLen int) error {
		u := v.Addr().Interface().(encoding.BinaryUnmarshaler)
		b := make([]byte, extLen)
		if err := d.ReadFull(b); err != nil {
			return err
		}
		return u.UnmarshalBinary(b)
	})
}

func init() {
	RegisterBinaryExt[decimal.Decimal](1)
}