Add support for Maps to the reflect_codec

Support to serialize/deserialize maps with the reflect_codec. This is needed in
the subnet EMV to use it to exchange information about the upgrade configs.

This PR adds support for maps and tests it.

The internal binary format is quite simple

```
	[length: 4 bytes][key1][value1][key2][value2]
```

The length is the total number of elements and keys, therefore it should always
be a pair number.

Author: nytzuga

codec/reflectcodec/type_codec.go

@@ -204,6 +204,23 @@ func (c *genericCodec) size(value reflect.Value) (int, bool, error) {
 		}
 		return size, constSize, nil
 
+	case reflect.Map:
+		keys := value.MapKeys()
+		size := wrappers.IntLen
+		for _, key := range keys {
+			innerSize, _, err := c.size(key)
+			if err != nil {
+				return 0, false, err
+			}
+			size += innerSize
+			innerSize, _, err = c.size(value.MapIndex(key))
+			if err != nil {
+				return 0, false, err
+			}
+			size += innerSize
+		}
+		return size, false, nil
+
 	default:
 		return 0, false, fmt.Errorf("can't evaluate marshal length of unknown kind %s", valueKind)
 	}
@@ -332,6 +349,30 @@ func (c *genericCodec) marshal(value reflect.Value, p *wrappers.Packer, maxSlice
 				return err
 			}
 		}
+		return nil
+	case reflect.Map:
+		keys := value.MapKeys()
+		numElts := len(keys) * 2
+		if uint32(numElts) > maxSliceLen {
+			return fmt.Errorf("%w; slice length, %d, exceeds maximum length, %d",
+				codec.ErrMaxSliceLenExceeded,
+				numElts,
+				maxSliceLen,
+			)
+		}
+		p.PackInt(uint32(numElts)) // pack # elements
+
+		for _, key := range keys {
+			// serialize key
+			if err := c.marshal(key, p, c.maxSliceLen); err != nil {
+				return err
+			}
+			// serialize value
+			if err := c.marshal(value.MapIndex(key), p, c.maxSliceLen); err != nil {
+				return err
+			}
+		}
+
 		return nil
 	default:
 		return fmt.Errorf("%w: %s", codec.ErrUnsupportedType, valueKind)
@@ -520,6 +561,36 @@ func (c *genericCodec) unmarshal(p *wrappers.Packer, value reflect.Value, maxSli
 		// Assign to the top-level struct's member
 		value.Set(v)
 		return nil
+	case reflect.Map:
+		numElts32 := p.UnpackInt()
+		if numElts32 > c.maxSliceLen || numElts32%2 != 0 {
+			return fmt.Errorf("%w; array length, %d, exceeds maximum length, %d",
+				codec.ErrMaxSliceLenExceeded,
+				numElts32,
+				c.maxSliceLen,
+			)
+		}
+
+		numElts := int(numElts32 / 2)
+		value.Set(reflect.MakeMapWithSize(value.Type(), numElts))
+		keyType := value.Type().Key()
+		valueType := value.Type().Elem()
+
+		for i := 0; i < numElts; i++ {
+			keyValue := reflect.New(keyType).Elem()
+			valueValue := reflect.New(valueType).Elem()
+
+			if err := c.unmarshal(p, keyValue, c.maxSliceLen); err != nil {
+				return fmt.Errorf("couldn't unmarshal map key: %w", err)
+			}
+			if err := c.unmarshal(p, valueValue, c.maxSliceLen); err != nil {
+				return fmt.Errorf("couldn't unmarshal map element: %w", err)
+			}
+			value.SetMapIndex(keyValue, valueValue)
+		}
+
+		return nil
+
 	default:
 		return fmt.Errorf("can't unmarshal unknown type %s", value.Kind().String())
 	}

codec/test_codec.go

@@ -41,6 +41,9 @@ var Tests = []func(c GeneralCodec, t testing.TB){
 	TestRestrictedSlice,
 	TestExtraSpace,
 	TestSliceLengthOverflow,
+	TestMap,
+	TestMap2,
+	TestMap3,
 }
 
 var MultipleTagsTests = []func(c GeneralCodec, t testing.TB){
@@ -887,3 +890,90 @@ func TestMultipleTags(codec GeneralCodec, t testing.TB) {
 		require.Empty(output.NoTags)
 	}
 }
+
+func TestMap(codec GeneralCodec, t testing.TB) {
+	require := require.New(t)
+
+	data := make(map[string]int32)
+	data["test"] = 12
+	data["bar"] = 33
+
+	manager := NewDefaultManager()
+	require.NoError(manager.RegisterCodec(0, codec))
+
+	bytes, err := manager.Marshal(0, data)
+	require.NoError(err)
+
+	bytesLen, err := manager.Size(0, data)
+	require.NoError(err)
+	require.Equal(len(bytes), bytesLen)
+
+	var output map[string]int32
+	_, err = manager.Unmarshal(bytes, &output)
+	require.NoError(err)
+
+	require.Equal(data, output)
+}
+
+func TestMap2(codec GeneralCodec, t testing.TB) {
+	require := require.New(t)
+
+	type Foo struct {
+		A int32  `serialize:"true"`
+		B string `serialize:"true"`
+	}
+
+	data := make(map[int32]Foo)
+	data[12] = Foo{A: 1, B: "test"}
+	data[13] = Foo{A: 2, B: "more test"}
+
+	manager := NewDefaultManager()
+	require.NoError(manager.RegisterCodec(0, codec))
+
+	bytes, err := manager.Marshal(0, data)
+	require.NoError(err)
+
+	bytesLen, err := manager.Size(0, data)
+	require.NoError(err)
+	require.Equal(len(bytes), bytesLen)
+
+	var output map[int32]Foo
+	_, err = manager.Unmarshal(bytes, &output)
+	require.NoError(err)
+
+	require.Equal(data, output)
+}
+
+func TestMap3(codec GeneralCodec, t testing.TB) {
+	require := require.New(t)
+
+	type Foo struct {
+		A int32            `serialize:"true"`
+		B string           `serialize:"true"`
+		E map[int32]string `serialize:"true"`
+	}
+
+	data := Foo{
+		A: 1,
+		B: "test",
+		E: make(map[int32]string, 2),
+	}
+	data.E[12] = "test"
+	data.E[13] = "test"
+
+	manager := NewDefaultManager()
+	require.NoError(manager.RegisterCodec(0, codec))
+
+	bytes, err := manager.Marshal(0, data)
+	require.NoError(err)
+
+	bytesLen, err := manager.Size(0, data)
+	require.NoError(err)
+	require.Equal(len(bytes), bytesLen)
+
+	var output Foo
+	_, err = manager.Unmarshal(bytes, &output)
+	require.NoError(err)
+
+	require.Equal(data, output)
+}