added support for marshalling/unmarshalling maps with non-string keys

Author: Grigory Aksentyev

bson/bson_test.go

@@ -582,6 +582,8 @@ func (s *S) TestMarshalOneWayItems(c *C) {
 // --------------------------------------------------------------------------
 // One-way unmarshaling tests.
 
+type intAlias int
+
 var unmarshalItems = []testItemType{
 	// Field is private.  Should not attempt to unmarshal it.
 	{&struct{ priv byte }{},
@@ -636,6 +638,14 @@ var unmarshalItems = []testItemType{
 	// Decode a doc within a doc in to a slice within a doc; shouldn't error
 	{&struct{ Foo []string }{},
 		"\x03\x66\x6f\x6f\x00\x05\x00\x00\x00\x00"},
+
+	// int key maps
+	{map[int]string{10: "s"},
+		"\x0210\x00\x02\x00\x00\x00s\x00"},
+
+	//// event if type is alias to int
+	{map[intAlias]string{10: "s"},
+		"\x0210\x00\x02\x00\x00\x00s\x00"},
 }
 
 func (s *S) TestUnmarshalOneWayItems(c *C) {
@@ -713,11 +723,6 @@ var unmarshalErrorItems = []unmarshalErrorType{
 		"\x10name\x00\x08\x00\x00\x00",
 		"Duplicated key 'name' in struct bson_test.structWithDupKeys"},
 
-	// Non-string map key.
-	{map[int]interface{}{},
-		"\x10name\x00\x08\x00\x00\x00",
-		"BSON map must have string keys. Got: map\\[int\\]interface \\{\\}"},
-
 	{nil,
 		"\xEEname\x00",
 		"Unknown element kind \\(0xEE\\)"},

bson/decode.go

@@ -176,9 +176,6 @@ func (d *decoder) readDocTo(out reflect.Value) {
 	switch outk {
 	case reflect.Map:
 		keyType = outt.Key()
-		if keyType.Kind() != reflect.String {
-			panic("BSON map must have string keys. Got: " + outt.String())
-		}
 		if keyType != typeString {
 			convertKey = true
 		}
@@ -240,7 +237,49 @@ func (d *decoder) readDocTo(out reflect.Value) {
 			if d.readElemTo(e, kind) {
 				k := reflect.ValueOf(name)
 				if convertKey {
-					k = k.Convert(keyType)
+					mapKeyType := out.Type().Key()
+					mapKeyKind := mapKeyType.Kind()
+
+					var parsed float64
+					if mapKeyKind != reflect.String {
+						var err error
+						parsed, err = strconv.ParseFloat(k.String(), 64)
+						if err != nil {
+							panic("Map key is defined to be a numeric type (" + mapKeyKind.String() + ") but got error " +
+								err.Error())
+						}
+					}
+
+					switch mapKeyKind {
+					case reflect.Int:
+						k = reflect.ValueOf(int(parsed))
+					case reflect.Int8:
+						k = reflect.ValueOf(int8(parsed))
+					case reflect.Int16:
+						k = reflect.ValueOf(int16(parsed))
+					case reflect.Int32:
+						k = reflect.ValueOf(int32(parsed))
+					case reflect.Int64:
+						k = reflect.ValueOf(int64(parsed))
+					case reflect.Uint:
+						k = reflect.ValueOf(uint(parsed))
+					case reflect.Uint8:
+						k = reflect.ValueOf(uint8(parsed))
+					case reflect.Uint16:
+						k = reflect.ValueOf(uint16(parsed))
+					case reflect.Uint32:
+						k = reflect.ValueOf(uint32(parsed))
+					case reflect.Uint64:
+						k = reflect.ValueOf(uint64(parsed))
+					case reflect.Float32:
+						k = reflect.ValueOf(float32(parsed))
+					case reflect.Float64:
+						k = reflect.ValueOf(float64(parsed))
+					case reflect.String:
+						mapKeyType = keyType
+					}
+
+					k = k.Convert(mapKeyType)
 				}
 				out.SetMapIndex(k, e)
 			}

bson/encode.go

@@ -194,7 +194,7 @@ func (e *encoder) addDoc(v reflect.Value) {
 
 func (e *encoder) addMap(v reflect.Value) {
 	for _, k := range v.MapKeys() {
-		e.addElem(k.String(), v.MapIndex(k), false)
+		e.addElem(fmt.Sprint(k), v.MapIndex(k), false)
 	}
 }