GODRIVER-1407 add MapCodec for mgocompat (#242)

Author: iwysiu

bson/bsoncodec/default_value_decoders.go

@@ -76,7 +76,7 @@ func (dvd DefaultValueDecoders) RegisterDefaultDecoders(rb *RegistryBuilder) {
 		RegisterDefaultDecoder(reflect.Float32, ValueDecoderFunc(dvd.FloatDecodeValue)).
 		RegisterDefaultDecoder(reflect.Float64, ValueDecoderFunc(dvd.FloatDecodeValue)).
 		RegisterDefaultDecoder(reflect.Array, ValueDecoderFunc(dvd.ArrayDecodeValue)).
-		RegisterDefaultDecoder(reflect.Map, ValueDecoderFunc(dvd.MapDecodeValue)).
+		RegisterDefaultDecoder(reflect.Map, defaultMapCodec).
 		RegisterDefaultDecoder(reflect.Slice, ValueDecoderFunc(dvd.SliceDecodeValue)).
 		RegisterDefaultDecoder(reflect.String, defaultStringCodec).
 		RegisterDefaultDecoder(reflect.Struct, defaultStructCodec).

bson/bsoncodec/default_value_encoders.go

@@ -104,7 +104,7 @@ func (dve DefaultValueEncoders) RegisterDefaultEncoders(rb *RegistryBuilder) {
 		RegisterDefaultEncoder(reflect.Float32, ValueEncoderFunc(dve.FloatEncodeValue)).
 		RegisterDefaultEncoder(reflect.Float64, ValueEncoderFunc(dve.FloatEncodeValue)).
 		RegisterDefaultEncoder(reflect.Array, ValueEncoderFunc(dve.ArrayEncodeValue)).
-		RegisterDefaultEncoder(reflect.Map, ValueEncoderFunc(dve.MapEncodeValue)).
+		RegisterDefaultEncoder(reflect.Map, defaultMapCodec).
 		RegisterDefaultEncoder(reflect.Slice, ValueEncoderFunc(dve.SliceEncodeValue)).
 		RegisterDefaultEncoder(reflect.String, defaultStringCodec).
 		RegisterDefaultEncoder(reflect.Struct, defaultStructCodec).

bson/bsoncodec/map_codec.go

@@ -0,0 +1,203 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bsoncodec
+
+import (
+	"fmt"
+	"reflect"
+	"strconv"
+
+	"go.mongodb.org/mongo-driver/bson/bsonoptions"
+	"go.mongodb.org/mongo-driver/bson/bsonrw"
+	"go.mongodb.org/mongo-driver/bson/bsontype"
+)
+
+var defaultMapCodec = NewMapCodec()
+
+// MapCodec is the Codec used for map values.
+type MapCodec struct {
+	DecodeZerosMap bool
+}
+
+var _ ValueCodec = &MapCodec{}
+
+// NewMapCodec returns a MapCodec with options opts.
+func NewMapCodec(opts ...*bsonoptions.MapCodecOptions) *MapCodec {
+	mapOpt := bsonoptions.MergeMapCodecOptions(opts...)
+
+	codec := MapCodec{}
+	if mapOpt.DecodeZerosMap != nil {
+		codec.DecodeZerosMap = *mapOpt.DecodeZerosMap
+	}
+	return &codec
+}
+
+// EncodeValue is the ValueEncoder for map[*]* types.
+func (mc *MapCodec) EncodeValue(ec EncodeContext, vw bsonrw.ValueWriter, val reflect.Value) error {
+	if !val.IsValid() || val.Kind() != reflect.Map {
+		return ValueEncoderError{Name: "MapEncodeValue", Kinds: []reflect.Kind{reflect.Map}, Received: val}
+	}
+
+	if val.IsNil() {
+		// If we have a nil map but we can't WriteNull, that means we're probably trying to encode
+		// to a TopLevel document. We can't currently tell if this is what actually happened, but if
+		// there's a deeper underlying problem, the error will also be returned from WriteDocument,
+		// so just continue. The operations on a map reflection value are valid, so we can call
+		// MapKeys within mapEncodeValue without a problem.
+		err := vw.WriteNull()
+		if err == nil {
+			return nil
+		}
+	}
+
+	dw, err := vw.WriteDocument()
+	if err != nil {
+		return err
+	}
+
+	return mc.mapEncodeValue(ec, dw, val, nil)
+}
+
+// mapEncodeValue handles encoding of the values of a map. The collisionFn returns
+// true if the provided key exists, this is mainly used for inline maps in the
+// struct codec.
+func (mc *MapCodec) mapEncodeValue(ec EncodeContext, dw bsonrw.DocumentWriter, val reflect.Value, collisionFn func(string) bool) error {
+
+	elemType := val.Type().Elem()
+	encoder, err := ec.LookupEncoder(elemType)
+	if err != nil && elemType.Kind() != reflect.Interface {
+		return err
+	}
+
+	keys := val.MapKeys()
+	for _, key := range keys {
+		keyStr := fmt.Sprint(key)
+		if collisionFn != nil && collisionFn(keyStr) {
+			return fmt.Errorf("Key %s of inlined map conflicts with a struct field name", key)
+		}
+
+		currEncoder, currVal, lookupErr := defaultValueEncoders.lookupElementEncoder(ec, encoder, val.MapIndex(key))
+		if lookupErr != nil && lookupErr != errInvalidValue {
+			return lookupErr
+		}
+
+		vw, err := dw.WriteDocumentElement(key.String())
+		if err != nil {
+			return err
+		}
+
+		if lookupErr == errInvalidValue {
+			err = vw.WriteNull()
+			if err != nil {
+				return err
+			}
+			continue
+		}
+
+		if enc, ok := currEncoder.(ValueEncoder); ok {
+			err = enc.EncodeValue(ec, vw, currVal)
+			if err != nil {
+				return err
+			}
+			continue
+		}
+		err = encoder.EncodeValue(ec, vw, currVal)
+		if err != nil {
+			return err
+		}
+	}
+
+	return dw.WriteDocumentEnd()
+}
+
+// DecodeValue is the ValueDecoder for map[string/decimal]* types.
+func (mc *MapCodec) DecodeValue(dc DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
+	if (!val.CanSet() && val.IsNil()) || val.Kind() != reflect.Map {
+		return ValueDecoderError{Name: "MapDecodeValue", Kinds: []reflect.Kind{reflect.Map}, Received: val}
+	}
+
+	switch vr.Type() {
+	case bsontype.Type(0), bsontype.EmbeddedDocument:
+	case bsontype.Null:
+		val.Set(reflect.Zero(val.Type()))
+		return vr.ReadNull()
+	default:
+		return fmt.Errorf("cannot decode %v into a %s", vr.Type(), val.Type())
+	}
+
+	dr, err := vr.ReadDocument()
+	if err != nil {
+		return err
+	}
+
+	if val.IsNil() {
+		val.Set(reflect.MakeMap(val.Type()))
+	}
+
+	if val.Len() > 0 && mc.DecodeZerosMap {
+		clearMap(val)
+	}
+
+	eType := val.Type().Elem()
+	decoder, err := dc.LookupDecoder(eType)
+	if err != nil {
+		return err
+	}
+
+	if eType == tEmpty {
+		dc.Ancestor = val.Type()
+	}
+
+	keyType := val.Type().Key()
+	keyKind := keyType.Kind()
+
+	for {
+		key, vr, err := dr.ReadElement()
+		if err == bsonrw.ErrEOD {
+			break
+		}
+		if err != nil {
+			return err
+		}
+
+		elem := reflect.New(eType).Elem()
+
+		err = decoder.DecodeValue(dc, vr, elem)
+		if err != nil {
+			return err
+		}
+
+		k := reflect.ValueOf(key)
+		if keyType != tString {
+			switch keyKind {
+			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
+				reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
+				reflect.Float32, reflect.Float64:
+				parsed, err := strconv.ParseFloat(k.String(), 64)
+				if err != nil {
+					return fmt.Errorf("Map key is defined to be a decimal type (%v) but got error %v", keyKind, err)
+				}
+				k = reflect.ValueOf(parsed)
+			case reflect.String: // if keyType wraps string
+			default:
+				return fmt.Errorf("BSON map must have string or decimal keys. Got:%v", val)
+			}
+
+			k = k.Convert(keyType)
+		}
+
+		val.SetMapIndex(k, elem)
+	}
+	return nil
+}
+
+func clearMap(m reflect.Value) {
+	var none reflect.Value
+	for _, k := range m.MapKeys() {
+		m.SetMapIndex(k, none)
+	}
+}

bson/bsoncodec/struct_codec.go

@@ -39,6 +39,7 @@ type StructCodec struct {
 	DecodeZeroStruct        bool
 	DecodeDeepZeroInline    bool
 	EncodeOmitDefaultStruct bool
+	AllowUnexportedFields   bool
 }
 
 var _ ValueEncoder = &StructCodec{}
@@ -66,6 +67,9 @@ func NewStructCodec(p StructTagParser, opts ...*bsonoptions.StructCodecOptions)
 	if structOpt.EncodeOmitDefaultStruct != nil {
 		codec.EncodeOmitDefaultStruct = *structOpt.EncodeOmitDefaultStruct
 	}
+	if structOpt.AllowUnexportedFields != nil {
+		codec.AllowUnexportedFields = *structOpt.AllowUnexportedFields
+	}
 
 	return codec, nil
 }
@@ -151,7 +155,7 @@ func (sc *StructCodec) EncodeValue(r EncodeContext, vw bsonrw.ValueWriter, val r
 			return exists
 		}
 
-		return defaultValueEncoders.mapEncodeValue(r, dw, rv, collisionFn)
+		return defaultMapCodec.mapEncodeValue(r, dw, rv, collisionFn)
 	}
 
 	return dw.WriteDocumentEnd()
@@ -187,9 +191,6 @@ func (sc *StructCodec) DecodeValue(r DecodeContext, vr bsonrw.ValueReader, val r
 	var inlineMap reflect.Value
 	if sd.inlineMap >= 0 {
 		inlineMap = val.Field(sd.inlineMap)
-		if inlineMap.IsNil() {
-			inlineMap.Set(reflect.MakeMap(inlineMap.Type()))
-		}
 		decoder, err = r.LookupDecoder(inlineMap.Type().Elem())
 		if err != nil {
 			return err
@@ -229,6 +230,10 @@ func (sc *StructCodec) DecodeValue(r DecodeContext, vr bsonrw.ValueReader, val r
 				continue
 			}
 
+			if inlineMap.IsNil() {
+				inlineMap.Set(reflect.MakeMap(inlineMap.Type()))
+			}
+
 			elem := reflect.New(inlineMap.Type().Elem()).Elem()
 			err = decoder.DecodeValue(r, vr, elem)
 			if err != nil {
@@ -361,8 +366,8 @@ func (sc *StructCodec) describeStruct(r *Registry, t reflect.Type) (*structDescr
 
 	for i := 0; i < numFields; i++ {
 		sf := t.Field(i)
-		if sf.PkgPath != "" {
-			// unexported, ignore
+		if sf.PkgPath != "" && (!sc.AllowUnexportedFields || !sf.Anonymous) {
+			// field is private or unexported fields aren't allowed, ignore
 			continue
 		}
 

bson/bsonoptions/map_codec_options.go

@@ -0,0 +1,38 @@
+// Copyright (C) MongoDB, Inc. 2017-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+package bsonoptions
+
+// MapCodecOptions represents all possible options for map encoding and decoding.
+type MapCodecOptions struct {
+	DecodeZerosMap *bool // Specifies if the map should be zeroed before decoding into it. Defaults to false.
+}
+
+// MapCodec creates a new *MapCodecOptions
+func MapCodec() *MapCodecOptions {
+	return &MapCodecOptions{}
+}
+
+// SetDecodeZerosMap specifies if the map should be zeroed before decoding into it. Defaults to false.
+func (t *MapCodecOptions) SetDecodeZerosMap(b bool) *MapCodecOptions {
+	t.DecodeZerosMap = &b
+	return t
+}
+
+// MergeMapCodecOptions combines the given *MapCodecOptions into a single *MapCodecOptions in a last one wins fashion.
+func MergeMapCodecOptions(opts ...*MapCodecOptions) *MapCodecOptions {
+	s := MapCodec()
+	for _, opt := range opts {
+		if opt == nil {
+			continue
+		}
+		if opt.DecodeZerosMap != nil {
+			s.DecodeZerosMap = opt.DecodeZerosMap
+		}
+	}
+
+	return s
+}

bson/bsonoptions/string_codec_options.go

@@ -15,7 +15,7 @@ type StringCodecOptions struct {
 
 // StringCodec creates a new *StringCodecOptions
 func StringCodec() *StringCodecOptions {
-	return &StringCodecOptions{&defaultDecodeOIDAsHex}
+	return &StringCodecOptions{}
 }
 
 // SetDecodeObjectIDAsHex specifies if object IDs should be decoded as their hex representation. If false, a string made
@@ -27,7 +27,7 @@ func (t *StringCodecOptions) SetDecodeObjectIDAsHex(b bool) *StringCodecOptions
 
 // MergeStringCodecOptions combines the given *StringCodecOptions into a single *StringCodecOptions in a last one wins fashion.
 func MergeStringCodecOptions(opts ...*StringCodecOptions) *StringCodecOptions {
-	s := StringCodec()
+	s := &StringCodecOptions{&defaultDecodeOIDAsHex}
 	for _, opt := range opts {
 		if opt == nil {
 			continue

bson/bsonoptions/struct_codec_options.go

@@ -11,6 +11,7 @@ type StructCodecOptions struct {
 	DecodeZeroStruct        *bool // Specifies if structs should be zeroed before decoding into them. Defaults to false.
 	DecodeDeepZeroInline    *bool // Specifies if structs should be recursively zeroed when a inline value is decoded. Defaults to false.
 	EncodeOmitDefaultStruct *bool // Specifies if default structs should be considered empty by omitempty. Defaults to false.
+	AllowUnexportedFields   *bool // Specifies if unexported fields should be marshaled/unmarshaled. Defaults to false.
 }
 
 // StructCodec creates a new *StructCodecOptions
@@ -37,6 +38,12 @@ func (t *StructCodecOptions) SetEncodeOmitDefaultStruct(b bool) *StructCodecOpti
 	return t
 }
 
+// SetAllowUnexportedFields specifies if unexported fields should be marshaled/unmarshaled. Defaults to false.
+func (t *StructCodecOptions) SetAllowUnexportedFields(b bool) *StructCodecOptions {
+	t.AllowUnexportedFields = &b
+	return t
+}
+
 // MergeStructCodecOptions combines the given *StructCodecOptions into a single *StructCodecOptions in a last one wins fashion.
 func MergeStructCodecOptions(opts ...*StructCodecOptions) *StructCodecOptions {
 	s := StructCodec()
@@ -54,6 +61,9 @@ func MergeStructCodecOptions(opts ...*StructCodecOptions) *StructCodecOptions {
 		if opt.EncodeOmitDefaultStruct != nil {
 			s.EncodeOmitDefaultStruct = opt.EncodeOmitDefaultStruct
 		}
+		if opt.AllowUnexportedFields != nil {
+			s.AllowUnexportedFields = opt.AllowUnexportedFields
+		}
 	}
 
 	return s

bson/decoder.go

@@ -78,13 +78,19 @@ func (d *Decoder) Decode(val interface{}) error {
 	}
 
 	rval := reflect.ValueOf(val)
-	if rval.Kind() != reflect.Ptr {
-		return fmt.Errorf("argument to Decode must be a pointer to a type, but got %v", rval)
-	}
-	if rval.IsNil() {
-		return ErrDecodeToNil
+	switch rval.Kind() {
+	case reflect.Ptr:
+		if rval.IsNil() {
+			return ErrDecodeToNil
+		}
+		rval = rval.Elem()
+	case reflect.Map:
+		if rval.IsNil() {
+			return ErrDecodeToNil
+		}
+	default:
+		return fmt.Errorf("argument to Decode must be a pointer or a map, but got %v", rval)
 	}
-	rval = rval.Elem()
 	decoder, err := d.dc.LookupDecoder(rval.Type())
 	if err != nil {
 		return err