Source file src/go.mongodb.org/mongo-driver/bson/bsoncodec/default_value_decoders.go

Documentation: go.mongodb.org/mongo-driver/bson/bsoncodec

     1  // Copyright (C) MongoDB, Inc. 2017-present.
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License"); you may
     4  // not use this file except in compliance with the License. You may obtain
     5  // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
     6  
     7  package bsoncodec
     8  
     9  import (
    10  	"encoding/json"
    11  	"errors"
    12  	"fmt"
    13  	"math"
    14  	"net/url"
    15  	"reflect"
    16  	"strconv"
    17  	"time"
    18  
    19  	"go.mongodb.org/mongo-driver/bson/bsonrw"
    20  	"go.mongodb.org/mongo-driver/bson/bsontype"
    21  	"go.mongodb.org/mongo-driver/bson/primitive"
    22  	"go.mongodb.org/mongo-driver/x/bsonx/bsoncore"
    23  )
    24  
    25  var (
    26  	defaultValueDecoders DefaultValueDecoders
    27  	errCannotTruncate    = errors.New("float64 can only be truncated to a lower precision type when truncation is enabled")
    28  )
    29  
    30  type decodeBinaryError struct {
    31  	subtype  byte
    32  	typeName string
    33  }
    34  
    35  func (d decodeBinaryError) Error() string {
    36  	return fmt.Sprintf("only binary values with subtype 0x00 or 0x02 can be decoded into %s, but got subtype %v", d.typeName, d.subtype)
    37  }
    38  
    39  func newDefaultStructCodec() *StructCodec {
    40  	codec, err := NewStructCodec(DefaultStructTagParser)
    41  	if err != nil {
    42  		// This function is called from the codec registration path, so errors can't be propagated. If there's an error
    43  		// constructing the StructCodec, we panic to avoid losing it.
    44  		panic(fmt.Errorf("error creating default StructCodec: %w", err))
    45  	}
    46  	return codec
    47  }
    48  
    49  // DefaultValueDecoders is a namespace type for the default ValueDecoders used
    50  // when creating a registry.
    51  //
    52  // Deprecated: Use [go.mongodb.org/mongo-driver/bson.NewRegistry] to get a registry with all default
    53  // value decoders registered.
    54  type DefaultValueDecoders struct{}
    55  
    56  // RegisterDefaultDecoders will register the decoder methods attached to DefaultValueDecoders with
    57  // the provided RegistryBuilder.
    58  //
    59  // There is no support for decoding map[string]interface{} because there is no decoder for
    60  // interface{}, so users must either register this decoder themselves or use the
    61  // EmptyInterfaceDecoder available in the bson package.
    62  //
    63  // Deprecated: Use [go.mongodb.org/mongo-driver/bson.NewRegistry] to get a registry with all default
    64  // value decoders registered.
    65  func (dvd DefaultValueDecoders) RegisterDefaultDecoders(rb *RegistryBuilder) {
    66  	if rb == nil {
    67  		panic(errors.New("argument to RegisterDefaultDecoders must not be nil"))
    68  	}
    69  
    70  	intDecoder := decodeAdapter{dvd.IntDecodeValue, dvd.intDecodeType}
    71  	floatDecoder := decodeAdapter{dvd.FloatDecodeValue, dvd.floatDecodeType}
    72  
    73  	rb.
    74  		RegisterTypeDecoder(tD, ValueDecoderFunc(dvd.DDecodeValue)).
    75  		RegisterTypeDecoder(tBinary, decodeAdapter{dvd.BinaryDecodeValue, dvd.binaryDecodeType}).
    76  		RegisterTypeDecoder(tUndefined, decodeAdapter{dvd.UndefinedDecodeValue, dvd.undefinedDecodeType}).
    77  		RegisterTypeDecoder(tDateTime, decodeAdapter{dvd.DateTimeDecodeValue, dvd.dateTimeDecodeType}).
    78  		RegisterTypeDecoder(tNull, decodeAdapter{dvd.NullDecodeValue, dvd.nullDecodeType}).
    79  		RegisterTypeDecoder(tRegex, decodeAdapter{dvd.RegexDecodeValue, dvd.regexDecodeType}).
    80  		RegisterTypeDecoder(tDBPointer, decodeAdapter{dvd.DBPointerDecodeValue, dvd.dBPointerDecodeType}).
    81  		RegisterTypeDecoder(tTimestamp, decodeAdapter{dvd.TimestampDecodeValue, dvd.timestampDecodeType}).
    82  		RegisterTypeDecoder(tMinKey, decodeAdapter{dvd.MinKeyDecodeValue, dvd.minKeyDecodeType}).
    83  		RegisterTypeDecoder(tMaxKey, decodeAdapter{dvd.MaxKeyDecodeValue, dvd.maxKeyDecodeType}).
    84  		RegisterTypeDecoder(tJavaScript, decodeAdapter{dvd.JavaScriptDecodeValue, dvd.javaScriptDecodeType}).
    85  		RegisterTypeDecoder(tSymbol, decodeAdapter{dvd.SymbolDecodeValue, dvd.symbolDecodeType}).
    86  		RegisterTypeDecoder(tByteSlice, defaultByteSliceCodec).
    87  		RegisterTypeDecoder(tTime, defaultTimeCodec).
    88  		RegisterTypeDecoder(tEmpty, defaultEmptyInterfaceCodec).
    89  		RegisterTypeDecoder(tCoreArray, defaultArrayCodec).
    90  		RegisterTypeDecoder(tOID, decodeAdapter{dvd.ObjectIDDecodeValue, dvd.objectIDDecodeType}).
    91  		RegisterTypeDecoder(tDecimal, decodeAdapter{dvd.Decimal128DecodeValue, dvd.decimal128DecodeType}).
    92  		RegisterTypeDecoder(tJSONNumber, decodeAdapter{dvd.JSONNumberDecodeValue, dvd.jsonNumberDecodeType}).
    93  		RegisterTypeDecoder(tURL, decodeAdapter{dvd.URLDecodeValue, dvd.urlDecodeType}).
    94  		RegisterTypeDecoder(tCoreDocument, ValueDecoderFunc(dvd.CoreDocumentDecodeValue)).
    95  		RegisterTypeDecoder(tCodeWithScope, decodeAdapter{dvd.CodeWithScopeDecodeValue, dvd.codeWithScopeDecodeType}).
    96  		RegisterDefaultDecoder(reflect.Bool, decodeAdapter{dvd.BooleanDecodeValue, dvd.booleanDecodeType}).
    97  		RegisterDefaultDecoder(reflect.Int, intDecoder).
    98  		RegisterDefaultDecoder(reflect.Int8, intDecoder).
    99  		RegisterDefaultDecoder(reflect.Int16, intDecoder).
   100  		RegisterDefaultDecoder(reflect.Int32, intDecoder).
   101  		RegisterDefaultDecoder(reflect.Int64, intDecoder).
   102  		RegisterDefaultDecoder(reflect.Uint, defaultUIntCodec).
   103  		RegisterDefaultDecoder(reflect.Uint8, defaultUIntCodec).
   104  		RegisterDefaultDecoder(reflect.Uint16, defaultUIntCodec).
   105  		RegisterDefaultDecoder(reflect.Uint32, defaultUIntCodec).
   106  		RegisterDefaultDecoder(reflect.Uint64, defaultUIntCodec).
   107  		RegisterDefaultDecoder(reflect.Float32, floatDecoder).
   108  		RegisterDefaultDecoder(reflect.Float64, floatDecoder).
   109  		RegisterDefaultDecoder(reflect.Array, ValueDecoderFunc(dvd.ArrayDecodeValue)).
   110  		RegisterDefaultDecoder(reflect.Map, defaultMapCodec).
   111  		RegisterDefaultDecoder(reflect.Slice, defaultSliceCodec).
   112  		RegisterDefaultDecoder(reflect.String, defaultStringCodec).
   113  		RegisterDefaultDecoder(reflect.Struct, newDefaultStructCodec()).
   114  		RegisterDefaultDecoder(reflect.Ptr, NewPointerCodec()).
   115  		RegisterTypeMapEntry(bsontype.Double, tFloat64).
   116  		RegisterTypeMapEntry(bsontype.String, tString).
   117  		RegisterTypeMapEntry(bsontype.Array, tA).
   118  		RegisterTypeMapEntry(bsontype.Binary, tBinary).
   119  		RegisterTypeMapEntry(bsontype.Undefined, tUndefined).
   120  		RegisterTypeMapEntry(bsontype.ObjectID, tOID).
   121  		RegisterTypeMapEntry(bsontype.Boolean, tBool).
   122  		RegisterTypeMapEntry(bsontype.DateTime, tDateTime).
   123  		RegisterTypeMapEntry(bsontype.Regex, tRegex).
   124  		RegisterTypeMapEntry(bsontype.DBPointer, tDBPointer).
   125  		RegisterTypeMapEntry(bsontype.JavaScript, tJavaScript).
   126  		RegisterTypeMapEntry(bsontype.Symbol, tSymbol).
   127  		RegisterTypeMapEntry(bsontype.CodeWithScope, tCodeWithScope).
   128  		RegisterTypeMapEntry(bsontype.Int32, tInt32).
   129  		RegisterTypeMapEntry(bsontype.Int64, tInt64).
   130  		RegisterTypeMapEntry(bsontype.Timestamp, tTimestamp).
   131  		RegisterTypeMapEntry(bsontype.Decimal128, tDecimal).
   132  		RegisterTypeMapEntry(bsontype.MinKey, tMinKey).
   133  		RegisterTypeMapEntry(bsontype.MaxKey, tMaxKey).
   134  		RegisterTypeMapEntry(bsontype.Type(0), tD).
   135  		RegisterTypeMapEntry(bsontype.EmbeddedDocument, tD).
   136  		RegisterHookDecoder(tValueUnmarshaler, ValueDecoderFunc(dvd.ValueUnmarshalerDecodeValue)).
   137  		RegisterHookDecoder(tUnmarshaler, ValueDecoderFunc(dvd.UnmarshalerDecodeValue))
   138  }
   139  
   140  // DDecodeValue is the ValueDecoderFunc for primitive.D instances.
   141  //
   142  // Deprecated: Use [go.mongodb.org/mongo-driver/bson.NewRegistry] to get a registry with all default
   143  // value decoders registered.
   144  func (dvd DefaultValueDecoders) DDecodeValue(dc DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
   145  	if !val.IsValid() || !val.CanSet() || val.Type() != tD {
   146  		return ValueDecoderError{Name: "DDecodeValue", Kinds: []reflect.Kind{reflect.Slice}, Received: val}
   147  	}
   148  
   149  	switch vrType := vr.Type(); vrType {
   150  	case bsontype.Type(0), bsontype.EmbeddedDocument:
   151  		dc.Ancestor = tD
   152  	case bsontype.Null:
   153  		val.Set(reflect.Zero(val.Type()))
   154  		return vr.ReadNull()
   155  	default:
   156  		return fmt.Errorf("cannot decode %v into a primitive.D", vrType)
   157  	}
   158  
   159  	dr, err := vr.ReadDocument()
   160  	if err != nil {
   161  		return err
   162  	}
   163  
   164  	decoder, err := dc.LookupDecoder(tEmpty)
   165  	if err != nil {
   166  		return err
   167  	}
   168  	tEmptyTypeDecoder, _ := decoder.(typeDecoder)
   169  
   170  	// Use the elements in the provided value if it's non nil. Otherwise, allocate a new D instance.
   171  	var elems primitive.D
   172  	if !val.IsNil() {
   173  		val.SetLen(0)
   174  		elems = val.Interface().(primitive.D)
   175  	} else {
   176  		elems = make(primitive.D, 0)
   177  	}
   178  
   179  	for {
   180  		key, elemVr, err := dr.ReadElement()
   181  		if errors.Is(err, bsonrw.ErrEOD) {
   182  			break
   183  		} else if err != nil {
   184  			return err
   185  		}
   186  
   187  		// Pass false for convert because we don't need to call reflect.Value.Convert for tEmpty.
   188  		elem, err := decodeTypeOrValueWithInfo(decoder, tEmptyTypeDecoder, dc, elemVr, tEmpty, false)
   189  		if err != nil {
   190  			return err
   191  		}
   192  
   193  		elems = append(elems, primitive.E{Key: key, Value: elem.Interface()})
   194  	}
   195  
   196  	val.Set(reflect.ValueOf(elems))
   197  	return nil
   198  }
   199  
   200  func (dvd DefaultValueDecoders) booleanDecodeType(_ DecodeContext, vr bsonrw.ValueReader, t reflect.Type) (reflect.Value, error) {
   201  	if t.Kind() != reflect.Bool {
   202  		return emptyValue, ValueDecoderError{
   203  			Name:     "BooleanDecodeValue",
   204  			Kinds:    []reflect.Kind{reflect.Bool},
   205  			Received: reflect.Zero(t),
   206  		}
   207  	}
   208  
   209  	var b bool
   210  	var err error
   211  	switch vrType := vr.Type(); vrType {
   212  	case bsontype.Int32:
   213  		i32, err := vr.ReadInt32()
   214  		if err != nil {
   215  			return emptyValue, err
   216  		}
   217  		b = (i32 != 0)
   218  	case bsontype.Int64:
   219  		i64, err := vr.ReadInt64()
   220  		if err != nil {
   221  			return emptyValue, err
   222  		}
   223  		b = (i64 != 0)
   224  	case bsontype.Double:
   225  		f64, err := vr.ReadDouble()
   226  		if err != nil {
   227  			return emptyValue, err
   228  		}
   229  		b = (f64 != 0)
   230  	case bsontype.Boolean:
   231  		b, err = vr.ReadBoolean()
   232  	case bsontype.Null:
   233  		err = vr.ReadNull()
   234  	case bsontype.Undefined:
   235  		err = vr.ReadUndefined()
   236  	default:
   237  		return emptyValue, fmt.Errorf("cannot decode %v into a boolean", vrType)
   238  	}
   239  	if err != nil {
   240  		return emptyValue, err
   241  	}
   242  
   243  	return reflect.ValueOf(b), nil
   244  }
   245  
   246  // BooleanDecodeValue is the ValueDecoderFunc for bool types.
   247  //
   248  // Deprecated: Use [go.mongodb.org/mongo-driver/bson.NewRegistry] to get a registry with all default
   249  // value decoders registered.
   250  func (dvd DefaultValueDecoders) BooleanDecodeValue(dctx DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
   251  	if !val.IsValid() || !val.CanSet() || val.Kind() != reflect.Bool {
   252  		return ValueDecoderError{Name: "BooleanDecodeValue", Kinds: []reflect.Kind{reflect.Bool}, Received: val}
   253  	}
   254  
   255  	elem, err := dvd.booleanDecodeType(dctx, vr, val.Type())
   256  	if err != nil {
   257  		return err
   258  	}
   259  
   260  	val.SetBool(elem.Bool())
   261  	return nil
   262  }
   263  
   264  func (DefaultValueDecoders) intDecodeType(dc DecodeContext, vr bsonrw.ValueReader, t reflect.Type) (reflect.Value, error) {
   265  	var i64 int64
   266  	var err error
   267  	switch vrType := vr.Type(); vrType {
   268  	case bsontype.Int32:
   269  		i32, err := vr.ReadInt32()
   270  		if err != nil {
   271  			return emptyValue, err
   272  		}
   273  		i64 = int64(i32)
   274  	case bsontype.Int64:
   275  		i64, err = vr.ReadInt64()
   276  		if err != nil {
   277  			return emptyValue, err
   278  		}
   279  	case bsontype.Double:
   280  		f64, err := vr.ReadDouble()
   281  		if err != nil {
   282  			return emptyValue, err
   283  		}
   284  		if !dc.Truncate && math.Floor(f64) != f64 {
   285  			return emptyValue, errCannotTruncate
   286  		}
   287  		if f64 > float64(math.MaxInt64) {
   288  			return emptyValue, fmt.Errorf("%g overflows int64", f64)
   289  		}
   290  		i64 = int64(f64)
   291  	case bsontype.Boolean:
   292  		b, err := vr.ReadBoolean()
   293  		if err != nil {
   294  			return emptyValue, err
   295  		}
   296  		if b {
   297  			i64 = 1
   298  		}
   299  	case bsontype.Null:
   300  		if err = vr.ReadNull(); err != nil {
   301  			return emptyValue, err
   302  		}
   303  	case bsontype.Undefined:
   304  		if err = vr.ReadUndefined(); err != nil {
   305  			return emptyValue, err
   306  		}
   307  	default:
   308  		return emptyValue, fmt.Errorf("cannot decode %v into an integer type", vrType)
   309  	}
   310  
   311  	switch t.Kind() {
   312  	case reflect.Int8:
   313  		if i64 < math.MinInt8 || i64 > math.MaxInt8 {
   314  			return emptyValue, fmt.Errorf("%d overflows int8", i64)
   315  		}
   316  
   317  		return reflect.ValueOf(int8(i64)), nil
   318  	case reflect.Int16:
   319  		if i64 < math.MinInt16 || i64 > math.MaxInt16 {
   320  			return emptyValue, fmt.Errorf("%d overflows int16", i64)
   321  		}
   322  
   323  		return reflect.ValueOf(int16(i64)), nil
   324  	case reflect.Int32:
   325  		if i64 < math.MinInt32 || i64 > math.MaxInt32 {
   326  			return emptyValue, fmt.Errorf("%d overflows int32", i64)
   327  		}
   328  
   329  		return reflect.ValueOf(int32(i64)), nil
   330  	case reflect.Int64:
   331  		return reflect.ValueOf(i64), nil
   332  	case reflect.Int:
   333  		if int64(int(i64)) != i64 { // Can we fit this inside of an int
   334  			return emptyValue, fmt.Errorf("%d overflows int", i64)
   335  		}
   336  
   337  		return reflect.ValueOf(int(i64)), nil
   338  	default:
   339  		return emptyValue, ValueDecoderError{
   340  			Name:     "IntDecodeValue",
   341  			Kinds:    []reflect.Kind{reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int},
   342  			Received: reflect.Zero(t),
   343  		}
   344  	}
   345  }
   346  
   347  // IntDecodeValue is the ValueDecoderFunc for int types.
   348  //
   349  // Deprecated: Use [go.mongodb.org/mongo-driver/bson.NewRegistry] to get a registry with all default
   350  // value decoders registered.
   351  func (dvd DefaultValueDecoders) IntDecodeValue(dc DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
   352  	if !val.CanSet() {
   353  		return ValueDecoderError{
   354  			Name:     "IntDecodeValue",
   355  			Kinds:    []reflect.Kind{reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int},
   356  			Received: val,
   357  		}
   358  	}
   359  
   360  	elem, err := dvd.intDecodeType(dc, vr, val.Type())
   361  	if err != nil {
   362  		return err
   363  	}
   364  
   365  	val.SetInt(elem.Int())
   366  	return nil
   367  }
   368  
   369  // UintDecodeValue is the ValueDecoderFunc for uint types.
   370  //
   371  // Deprecated: UintDecodeValue is not registered by default. Use UintCodec.DecodeValue instead.
   372  func (dvd DefaultValueDecoders) UintDecodeValue(dc DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
   373  	var i64 int64
   374  	var err error
   375  	switch vr.Type() {
   376  	case bsontype.Int32:
   377  		i32, err := vr.ReadInt32()
   378  		if err != nil {
   379  			return err
   380  		}
   381  		i64 = int64(i32)
   382  	case bsontype.Int64:
   383  		i64, err = vr.ReadInt64()
   384  		if err != nil {
   385  			return err
   386  		}
   387  	case bsontype.Double:
   388  		f64, err := vr.ReadDouble()
   389  		if err != nil {
   390  			return err
   391  		}
   392  		if !dc.Truncate && math.Floor(f64) != f64 {
   393  			return errors.New("UintDecodeValue can only truncate float64 to an integer type when truncation is enabled")
   394  		}
   395  		if f64 > float64(math.MaxInt64) {
   396  			return fmt.Errorf("%g overflows int64", f64)
   397  		}
   398  		i64 = int64(f64)
   399  	case bsontype.Boolean:
   400  		b, err := vr.ReadBoolean()
   401  		if err != nil {
   402  			return err
   403  		}
   404  		if b {
   405  			i64 = 1
   406  		}
   407  	default:
   408  		return fmt.Errorf("cannot decode %v into an integer type", vr.Type())
   409  	}
   410  
   411  	if !val.CanSet() {
   412  		return ValueDecoderError{
   413  			Name:     "UintDecodeValue",
   414  			Kinds:    []reflect.Kind{reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint},
   415  			Received: val,
   416  		}
   417  	}
   418  
   419  	switch val.Kind() {
   420  	case reflect.Uint8:
   421  		if i64 < 0 || i64 > math.MaxUint8 {
   422  			return fmt.Errorf("%d overflows uint8", i64)
   423  		}
   424  	case reflect.Uint16:
   425  		if i64 < 0 || i64 > math.MaxUint16 {
   426  			return fmt.Errorf("%d overflows uint16", i64)
   427  		}
   428  	case reflect.Uint32:
   429  		if i64 < 0 || i64 > math.MaxUint32 {
   430  			return fmt.Errorf("%d overflows uint32", i64)
   431  		}
   432  	case reflect.Uint64:
   433  		if i64 < 0 {
   434  			return fmt.Errorf("%d overflows uint64", i64)
   435  		}
   436  	case reflect.Uint:
   437  		if i64 < 0 || int64(uint(i64)) != i64 { // Can we fit this inside of an uint
   438  			return fmt.Errorf("%d overflows uint", i64)
   439  		}
   440  	default:
   441  		return ValueDecoderError{
   442  			Name:     "UintDecodeValue",
   443  			Kinds:    []reflect.Kind{reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint},
   444  			Received: val,
   445  		}
   446  	}
   447  
   448  	val.SetUint(uint64(i64))
   449  	return nil
   450  }
   451  
   452  func (dvd DefaultValueDecoders) floatDecodeType(dc DecodeContext, vr bsonrw.ValueReader, t reflect.Type) (reflect.Value, error) {
   453  	var f float64
   454  	var err error
   455  	switch vrType := vr.Type(); vrType {
   456  	case bsontype.Int32:
   457  		i32, err := vr.ReadInt32()
   458  		if err != nil {
   459  			return emptyValue, err
   460  		}
   461  		f = float64(i32)
   462  	case bsontype.Int64:
   463  		i64, err := vr.ReadInt64()
   464  		if err != nil {
   465  			return emptyValue, err
   466  		}
   467  		f = float64(i64)
   468  	case bsontype.Double:
   469  		f, err = vr.ReadDouble()
   470  		if err != nil {
   471  			return emptyValue, err
   472  		}
   473  	case bsontype.Boolean:
   474  		b, err := vr.ReadBoolean()
   475  		if err != nil {
   476  			return emptyValue, err
   477  		}
   478  		if b {
   479  			f = 1
   480  		}
   481  	case bsontype.Null:
   482  		if err = vr.ReadNull(); err != nil {
   483  			return emptyValue, err
   484  		}
   485  	case bsontype.Undefined:
   486  		if err = vr.ReadUndefined(); err != nil {
   487  			return emptyValue, err
   488  		}
   489  	default:
   490  		return emptyValue, fmt.Errorf("cannot decode %v into a float32 or float64 type", vrType)
   491  	}
   492  
   493  	switch t.Kind() {
   494  	case reflect.Float32:
   495  		if !dc.Truncate && float64(float32(f)) != f {
   496  			return emptyValue, errCannotTruncate
   497  		}
   498  
   499  		return reflect.ValueOf(float32(f)), nil
   500  	case reflect.Float64:
   501  		return reflect.ValueOf(f), nil
   502  	default:
   503  		return emptyValue, ValueDecoderError{
   504  			Name:     "FloatDecodeValue",
   505  			Kinds:    []reflect.Kind{reflect.Float32, reflect.Float64},
   506  			Received: reflect.Zero(t),
   507  		}
   508  	}
   509  }
   510  
   511  // FloatDecodeValue is the ValueDecoderFunc for float types.
   512  //
   513  // Deprecated: Use [go.mongodb.org/mongo-driver/bson.NewRegistry] to get a registry with all default
   514  // value decoders registered.
   515  func (dvd DefaultValueDecoders) FloatDecodeValue(ec DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
   516  	if !val.CanSet() {
   517  		return ValueDecoderError{
   518  			Name:     "FloatDecodeValue",
   519  			Kinds:    []reflect.Kind{reflect.Float32, reflect.Float64},
   520  			Received: val,
   521  		}
   522  	}
   523  
   524  	elem, err := dvd.floatDecodeType(ec, vr, val.Type())
   525  	if err != nil {
   526  		return err
   527  	}
   528  
   529  	val.SetFloat(elem.Float())
   530  	return nil
   531  }
   532  
   533  // StringDecodeValue is the ValueDecoderFunc for string types.
   534  //
   535  // Deprecated: StringDecodeValue is not registered by default. Use StringCodec.DecodeValue instead.
   536  func (dvd DefaultValueDecoders) StringDecodeValue(_ DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
   537  	var str string
   538  	var err error
   539  	switch vr.Type() {
   540  	// TODO(GODRIVER-577): Handle JavaScript and Symbol BSON types when allowed.
   541  	case bsontype.String:
   542  		str, err = vr.ReadString()
   543  		if err != nil {
   544  			return err
   545  		}
   546  	default:
   547  		return fmt.Errorf("cannot decode %v into a string type", vr.Type())
   548  	}
   549  	if !val.CanSet() || val.Kind() != reflect.String {
   550  		return ValueDecoderError{Name: "StringDecodeValue", Kinds: []reflect.Kind{reflect.String}, Received: val}
   551  	}
   552  
   553  	val.SetString(str)
   554  	return nil
   555  }
   556  
   557  func (DefaultValueDecoders) javaScriptDecodeType(_ DecodeContext, vr bsonrw.ValueReader, t reflect.Type) (reflect.Value, error) {
   558  	if t != tJavaScript {
   559  		return emptyValue, ValueDecoderError{
   560  			Name:     "JavaScriptDecodeValue",
   561  			Types:    []reflect.Type{tJavaScript},
   562  			Received: reflect.Zero(t),
   563  		}
   564  	}
   565  
   566  	var js string
   567  	var err error
   568  	switch vrType := vr.Type(); vrType {
   569  	case bsontype.JavaScript:
   570  		js, err = vr.ReadJavascript()
   571  	case bsontype.Null:
   572  		err = vr.ReadNull()
   573  	case bsontype.Undefined:
   574  		err = vr.ReadUndefined()
   575  	default:
   576  		return emptyValue, fmt.Errorf("cannot decode %v into a primitive.JavaScript", vrType)
   577  	}
   578  	if err != nil {
   579  		return emptyValue, err
   580  	}
   581  
   582  	return reflect.ValueOf(primitive.JavaScript(js)), nil
   583  }
   584  
   585  // JavaScriptDecodeValue is the ValueDecoderFunc for the primitive.JavaScript type.
   586  //
   587  // Deprecated: Use [go.mongodb.org/mongo-driver/bson.NewRegistry] to get a registry with all default
   588  // value decoders registered.
   589  func (dvd DefaultValueDecoders) JavaScriptDecodeValue(dctx DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
   590  	if !val.CanSet() || val.Type() != tJavaScript {
   591  		return ValueDecoderError{Name: "JavaScriptDecodeValue", Types: []reflect.Type{tJavaScript}, Received: val}
   592  	}
   593  
   594  	elem, err := dvd.javaScriptDecodeType(dctx, vr, tJavaScript)
   595  	if err != nil {
   596  		return err
   597  	}
   598  
   599  	val.SetString(elem.String())
   600  	return nil
   601  }
   602  
   603  func (DefaultValueDecoders) symbolDecodeType(_ DecodeContext, vr bsonrw.ValueReader, t reflect.Type) (reflect.Value, error) {
   604  	if t != tSymbol {
   605  		return emptyValue, ValueDecoderError{
   606  			Name:     "SymbolDecodeValue",
   607  			Types:    []reflect.Type{tSymbol},
   608  			Received: reflect.Zero(t),
   609  		}
   610  	}
   611  
   612  	var symbol string
   613  	var err error
   614  	switch vrType := vr.Type(); vrType {
   615  	case bsontype.String:
   616  		symbol, err = vr.ReadString()
   617  	case bsontype.Symbol:
   618  		symbol, err = vr.ReadSymbol()
   619  	case bsontype.Binary:
   620  		data, subtype, err := vr.ReadBinary()
   621  		if err != nil {
   622  			return emptyValue, err
   623  		}
   624  
   625  		if subtype != bsontype.BinaryGeneric && subtype != bsontype.BinaryBinaryOld {
   626  			return emptyValue, decodeBinaryError{subtype: subtype, typeName: "primitive.Symbol"}
   627  		}
   628  		symbol = string(data)
   629  	case bsontype.Null:
   630  		err = vr.ReadNull()
   631  	case bsontype.Undefined:
   632  		err = vr.ReadUndefined()
   633  	default:
   634  		return emptyValue, fmt.Errorf("cannot decode %v into a primitive.Symbol", vrType)
   635  	}
   636  	if err != nil {
   637  		return emptyValue, err
   638  	}
   639  
   640  	return reflect.ValueOf(primitive.Symbol(symbol)), nil
   641  }
   642  
   643  // SymbolDecodeValue is the ValueDecoderFunc for the primitive.Symbol type.
   644  //
   645  // Deprecated: Use [go.mongodb.org/mongo-driver/bson.NewRegistry] to get a registry with all default
   646  // value decoders registered.
   647  func (dvd DefaultValueDecoders) SymbolDecodeValue(dctx DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
   648  	if !val.CanSet() || val.Type() != tSymbol {
   649  		return ValueDecoderError{Name: "SymbolDecodeValue", Types: []reflect.Type{tSymbol}, Received: val}
   650  	}
   651  
   652  	elem, err := dvd.symbolDecodeType(dctx, vr, tSymbol)
   653  	if err != nil {
   654  		return err
   655  	}
   656  
   657  	val.SetString(elem.String())
   658  	return nil
   659  }
   660  
   661  func (DefaultValueDecoders) binaryDecodeType(_ DecodeContext, vr bsonrw.ValueReader, t reflect.Type) (reflect.Value, error) {
   662  	if t != tBinary {
   663  		return emptyValue, ValueDecoderError{
   664  			Name:     "BinaryDecodeValue",
   665  			Types:    []reflect.Type{tBinary},
   666  			Received: reflect.Zero(t),
   667  		}
   668  	}
   669  
   670  	var data []byte
   671  	var subtype byte
   672  	var err error
   673  	switch vrType := vr.Type(); vrType {
   674  	case bsontype.Binary:
   675  		data, subtype, err = vr.ReadBinary()
   676  	case bsontype.Null:
   677  		err = vr.ReadNull()
   678  	case bsontype.Undefined:
   679  		err = vr.ReadUndefined()
   680  	default:
   681  		return emptyValue, fmt.Errorf("cannot decode %v into a Binary", vrType)
   682  	}
   683  	if err != nil {
   684  		return emptyValue, err
   685  	}
   686  
   687  	return reflect.ValueOf(primitive.Binary{Subtype: subtype, Data: data}), nil
   688  }
   689  
   690  // BinaryDecodeValue is the ValueDecoderFunc for Binary.
   691  //
   692  // Deprecated: Use [go.mongodb.org/mongo-driver/bson.NewRegistry] to get a registry with all default
   693  // value decoders registered.
   694  func (dvd DefaultValueDecoders) BinaryDecodeValue(dc DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
   695  	if !val.CanSet() || val.Type() != tBinary {
   696  		return ValueDecoderError{Name: "BinaryDecodeValue", Types: []reflect.Type{tBinary}, Received: val}
   697  	}
   698  
   699  	elem, err := dvd.binaryDecodeType(dc, vr, tBinary)
   700  	if err != nil {
   701  		return err
   702  	}
   703  
   704  	val.Set(elem)
   705  	return nil
   706  }
   707  
   708  func (DefaultValueDecoders) undefinedDecodeType(_ DecodeContext, vr bsonrw.ValueReader, t reflect.Type) (reflect.Value, error) {
   709  	if t != tUndefined {
   710  		return emptyValue, ValueDecoderError{
   711  			Name:     "UndefinedDecodeValue",
   712  			Types:    []reflect.Type{tUndefined},
   713  			Received: reflect.Zero(t),
   714  		}
   715  	}
   716  
   717  	var err error
   718  	switch vrType := vr.Type(); vrType {
   719  	case bsontype.Undefined:
   720  		err = vr.ReadUndefined()
   721  	case bsontype.Null:
   722  		err = vr.ReadNull()
   723  	default:
   724  		return emptyValue, fmt.Errorf("cannot decode %v into an Undefined", vr.Type())
   725  	}
   726  	if err != nil {
   727  		return emptyValue, err
   728  	}
   729  
   730  	return reflect.ValueOf(primitive.Undefined{}), nil
   731  }
   732  
   733  // UndefinedDecodeValue is the ValueDecoderFunc for Undefined.
   734  //
   735  // Deprecated: Use [go.mongodb.org/mongo-driver/bson.NewRegistry] to get a registry with all default
   736  // value decoders registered.
   737  func (dvd DefaultValueDecoders) UndefinedDecodeValue(dc DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
   738  	if !val.CanSet() || val.Type() != tUndefined {
   739  		return ValueDecoderError{Name: "UndefinedDecodeValue", Types: []reflect.Type{tUndefined}, Received: val}
   740  	}
   741  
   742  	elem, err := dvd.undefinedDecodeType(dc, vr, tUndefined)
   743  	if err != nil {
   744  		return err
   745  	}
   746  
   747  	val.Set(elem)
   748  	return nil
   749  }
   750  
   751  // Accept both 12-byte string and pretty-printed 24-byte hex string formats.
   752  func (dvd DefaultValueDecoders) objectIDDecodeType(_ DecodeContext, vr bsonrw.ValueReader, t reflect.Type) (reflect.Value, error) {
   753  	if t != tOID {
   754  		return emptyValue, ValueDecoderError{
   755  			Name:     "ObjectIDDecodeValue",
   756  			Types:    []reflect.Type{tOID},
   757  			Received: reflect.Zero(t),
   758  		}
   759  	}
   760  
   761  	var oid primitive.ObjectID
   762  	var err error
   763  	switch vrType := vr.Type(); vrType {
   764  	case bsontype.ObjectID:
   765  		oid, err = vr.ReadObjectID()
   766  		if err != nil {
   767  			return emptyValue, err
   768  		}
   769  	case bsontype.String:
   770  		str, err := vr.ReadString()
   771  		if err != nil {
   772  			return emptyValue, err
   773  		}
   774  		if oid, err = primitive.ObjectIDFromHex(str); err == nil {
   775  			break
   776  		}
   777  		if len(str) != 12 {
   778  			return emptyValue, fmt.Errorf("an ObjectID string must be exactly 12 bytes long (got %v)", len(str))
   779  		}
   780  		byteArr := []byte(str)
   781  		copy(oid[:], byteArr)
   782  	case bsontype.Null:
   783  		if err = vr.ReadNull(); err != nil {
   784  			return emptyValue, err
   785  		}
   786  	case bsontype.Undefined:
   787  		if err = vr.ReadUndefined(); err != nil {
   788  			return emptyValue, err
   789  		}
   790  	default:
   791  		return emptyValue, fmt.Errorf("cannot decode %v into an ObjectID", vrType)
   792  	}
   793  
   794  	return reflect.ValueOf(oid), nil
   795  }
   796  
   797  // ObjectIDDecodeValue is the ValueDecoderFunc for primitive.ObjectID.
   798  //
   799  // Deprecated: Use [go.mongodb.org/mongo-driver/bson.NewRegistry] to get a registry with all default
   800  // value decoders registered.
   801  func (dvd DefaultValueDecoders) ObjectIDDecodeValue(dc DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
   802  	if !val.CanSet() || val.Type() != tOID {
   803  		return ValueDecoderError{Name: "ObjectIDDecodeValue", Types: []reflect.Type{tOID}, Received: val}
   804  	}
   805  
   806  	elem, err := dvd.objectIDDecodeType(dc, vr, tOID)
   807  	if err != nil {
   808  		return err
   809  	}
   810  
   811  	val.Set(elem)
   812  	return nil
   813  }
   814  
   815  func (DefaultValueDecoders) dateTimeDecodeType(_ DecodeContext, vr bsonrw.ValueReader, t reflect.Type) (reflect.Value, error) {
   816  	if t != tDateTime {
   817  		return emptyValue, ValueDecoderError{
   818  			Name:     "DateTimeDecodeValue",
   819  			Types:    []reflect.Type{tDateTime},
   820  			Received: reflect.Zero(t),
   821  		}
   822  	}
   823  
   824  	var dt int64
   825  	var err error
   826  	switch vrType := vr.Type(); vrType {
   827  	case bsontype.DateTime:
   828  		dt, err = vr.ReadDateTime()
   829  	case bsontype.Null:
   830  		err = vr.ReadNull()
   831  	case bsontype.Undefined:
   832  		err = vr.ReadUndefined()
   833  	default:
   834  		return emptyValue, fmt.Errorf("cannot decode %v into a DateTime", vrType)
   835  	}
   836  	if err != nil {
   837  		return emptyValue, err
   838  	}
   839  
   840  	return reflect.ValueOf(primitive.DateTime(dt)), nil
   841  }
   842  
   843  // DateTimeDecodeValue is the ValueDecoderFunc for DateTime.
   844  //
   845  // Deprecated: Use [go.mongodb.org/mongo-driver/bson.NewRegistry] to get a registry with all default
   846  // value decoders registered.
   847  func (dvd DefaultValueDecoders) DateTimeDecodeValue(dc DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
   848  	if !val.CanSet() || val.Type() != tDateTime {
   849  		return ValueDecoderError{Name: "DateTimeDecodeValue", Types: []reflect.Type{tDateTime}, Received: val}
   850  	}
   851  
   852  	elem, err := dvd.dateTimeDecodeType(dc, vr, tDateTime)
   853  	if err != nil {
   854  		return err
   855  	}
   856  
   857  	val.Set(elem)
   858  	return nil
   859  }
   860  
   861  func (DefaultValueDecoders) nullDecodeType(_ DecodeContext, vr bsonrw.ValueReader, t reflect.Type) (reflect.Value, error) {
   862  	if t != tNull {
   863  		return emptyValue, ValueDecoderError{
   864  			Name:     "NullDecodeValue",
   865  			Types:    []reflect.Type{tNull},
   866  			Received: reflect.Zero(t),
   867  		}
   868  	}
   869  
   870  	var err error
   871  	switch vrType := vr.Type(); vrType {
   872  	case bsontype.Undefined:
   873  		err = vr.ReadUndefined()
   874  	case bsontype.Null:
   875  		err = vr.ReadNull()
   876  	default:
   877  		return emptyValue, fmt.Errorf("cannot decode %v into a Null", vr.Type())
   878  	}
   879  	if err != nil {
   880  		return emptyValue, err
   881  	}
   882  
   883  	return reflect.ValueOf(primitive.Null{}), nil
   884  }
   885  
   886  // NullDecodeValue is the ValueDecoderFunc for Null.
   887  //
   888  // Deprecated: Use [go.mongodb.org/mongo-driver/bson.NewRegistry] to get a registry with all default
   889  // value decoders registered.
   890  func (dvd DefaultValueDecoders) NullDecodeValue(dc DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
   891  	if !val.CanSet() || val.Type() != tNull {
   892  		return ValueDecoderError{Name: "NullDecodeValue", Types: []reflect.Type{tNull}, Received: val}
   893  	}
   894  
   895  	elem, err := dvd.nullDecodeType(dc, vr, tNull)
   896  	if err != nil {
   897  		return err
   898  	}
   899  
   900  	val.Set(elem)
   901  	return nil
   902  }
   903  
   904  func (DefaultValueDecoders) regexDecodeType(_ DecodeContext, vr bsonrw.ValueReader, t reflect.Type) (reflect.Value, error) {
   905  	if t != tRegex {
   906  		return emptyValue, ValueDecoderError{
   907  			Name:     "RegexDecodeValue",
   908  			Types:    []reflect.Type{tRegex},
   909  			Received: reflect.Zero(t),
   910  		}
   911  	}
   912  
   913  	var pattern, options string
   914  	var err error
   915  	switch vrType := vr.Type(); vrType {
   916  	case bsontype.Regex:
   917  		pattern, options, err = vr.ReadRegex()
   918  	case bsontype.Null:
   919  		err = vr.ReadNull()
   920  	case bsontype.Undefined:
   921  		err = vr.ReadUndefined()
   922  	default:
   923  		return emptyValue, fmt.Errorf("cannot decode %v into a Regex", vrType)
   924  	}
   925  	if err != nil {
   926  		return emptyValue, err
   927  	}
   928  
   929  	return reflect.ValueOf(primitive.Regex{Pattern: pattern, Options: options}), nil
   930  }
   931  
   932  // RegexDecodeValue is the ValueDecoderFunc for Regex.
   933  //
   934  // Deprecated: Use [go.mongodb.org/mongo-driver/bson.NewRegistry] to get a registry with all default
   935  // value decoders registered.
   936  func (dvd DefaultValueDecoders) RegexDecodeValue(dc DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
   937  	if !val.CanSet() || val.Type() != tRegex {
   938  		return ValueDecoderError{Name: "RegexDecodeValue", Types: []reflect.Type{tRegex}, Received: val}
   939  	}
   940  
   941  	elem, err := dvd.regexDecodeType(dc, vr, tRegex)
   942  	if err != nil {
   943  		return err
   944  	}
   945  
   946  	val.Set(elem)
   947  	return nil
   948  }
   949  
   950  func (DefaultValueDecoders) dBPointerDecodeType(_ DecodeContext, vr bsonrw.ValueReader, t reflect.Type) (reflect.Value, error) {
   951  	if t != tDBPointer {
   952  		return emptyValue, ValueDecoderError{
   953  			Name:     "DBPointerDecodeValue",
   954  			Types:    []reflect.Type{tDBPointer},
   955  			Received: reflect.Zero(t),
   956  		}
   957  	}
   958  
   959  	var ns string
   960  	var pointer primitive.ObjectID
   961  	var err error
   962  	switch vrType := vr.Type(); vrType {
   963  	case bsontype.DBPointer:
   964  		ns, pointer, err = vr.ReadDBPointer()
   965  	case bsontype.Null:
   966  		err = vr.ReadNull()
   967  	case bsontype.Undefined:
   968  		err = vr.ReadUndefined()
   969  	default:
   970  		return emptyValue, fmt.Errorf("cannot decode %v into a DBPointer", vrType)
   971  	}
   972  	if err != nil {
   973  		return emptyValue, err
   974  	}
   975  
   976  	return reflect.ValueOf(primitive.DBPointer{DB: ns, Pointer: pointer}), nil
   977  }
   978  
   979  // DBPointerDecodeValue is the ValueDecoderFunc for DBPointer.
   980  //
   981  // Deprecated: Use [go.mongodb.org/mongo-driver/bson.NewRegistry] to get a registry with all default
   982  // value decoders registered.
   983  func (dvd DefaultValueDecoders) DBPointerDecodeValue(dc DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
   984  	if !val.CanSet() || val.Type() != tDBPointer {
   985  		return ValueDecoderError{Name: "DBPointerDecodeValue", Types: []reflect.Type{tDBPointer}, Received: val}
   986  	}
   987  
   988  	elem, err := dvd.dBPointerDecodeType(dc, vr, tDBPointer)
   989  	if err != nil {
   990  		return err
   991  	}
   992  
   993  	val.Set(elem)
   994  	return nil
   995  }
   996  
   997  func (DefaultValueDecoders) timestampDecodeType(_ DecodeContext, vr bsonrw.ValueReader, reflectType reflect.Type) (reflect.Value, error) {
   998  	if reflectType != tTimestamp {
   999  		return emptyValue, ValueDecoderError{
  1000  			Name:     "TimestampDecodeValue",
  1001  			Types:    []reflect.Type{tTimestamp},
  1002  			Received: reflect.Zero(reflectType),
  1003  		}
  1004  	}
  1005  
  1006  	var t, incr uint32
  1007  	var err error
  1008  	switch vrType := vr.Type(); vrType {
  1009  	case bsontype.Timestamp:
  1010  		t, incr, err = vr.ReadTimestamp()
  1011  	case bsontype.Null:
  1012  		err = vr.ReadNull()
  1013  	case bsontype.Undefined:
  1014  		err = vr.ReadUndefined()
  1015  	default:
  1016  		return emptyValue, fmt.Errorf("cannot decode %v into a Timestamp", vrType)
  1017  	}
  1018  	if err != nil {
  1019  		return emptyValue, err
  1020  	}
  1021  
  1022  	return reflect.ValueOf(primitive.Timestamp{T: t, I: incr}), nil
  1023  }
  1024  
  1025  // TimestampDecodeValue is the ValueDecoderFunc for Timestamp.
  1026  //
  1027  // Deprecated: Use [go.mongodb.org/mongo-driver/bson.NewRegistry] to get a registry with all default
  1028  // value decoders registered.
  1029  func (dvd DefaultValueDecoders) TimestampDecodeValue(dc DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
  1030  	if !val.CanSet() || val.Type() != tTimestamp {
  1031  		return ValueDecoderError{Name: "TimestampDecodeValue", Types: []reflect.Type{tTimestamp}, Received: val}
  1032  	}
  1033  
  1034  	elem, err := dvd.timestampDecodeType(dc, vr, tTimestamp)
  1035  	if err != nil {
  1036  		return err
  1037  	}
  1038  
  1039  	val.Set(elem)
  1040  	return nil
  1041  }
  1042  
  1043  func (DefaultValueDecoders) minKeyDecodeType(_ DecodeContext, vr bsonrw.ValueReader, t reflect.Type) (reflect.Value, error) {
  1044  	if t != tMinKey {
  1045  		return emptyValue, ValueDecoderError{
  1046  			Name:     "MinKeyDecodeValue",
  1047  			Types:    []reflect.Type{tMinKey},
  1048  			Received: reflect.Zero(t),
  1049  		}
  1050  	}
  1051  
  1052  	var err error
  1053  	switch vrType := vr.Type(); vrType {
  1054  	case bsontype.MinKey:
  1055  		err = vr.ReadMinKey()
  1056  	case bsontype.Null:
  1057  		err = vr.ReadNull()
  1058  	case bsontype.Undefined:
  1059  		err = vr.ReadUndefined()
  1060  	default:
  1061  		return emptyValue, fmt.Errorf("cannot decode %v into a MinKey", vr.Type())
  1062  	}
  1063  	if err != nil {
  1064  		return emptyValue, err
  1065  	}
  1066  
  1067  	return reflect.ValueOf(primitive.MinKey{}), nil
  1068  }
  1069  
  1070  // MinKeyDecodeValue is the ValueDecoderFunc for MinKey.
  1071  //
  1072  // Deprecated: Use [go.mongodb.org/mongo-driver/bson.NewRegistry] to get a registry with all default
  1073  // value decoders registered.
  1074  func (dvd DefaultValueDecoders) MinKeyDecodeValue(dc DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
  1075  	if !val.CanSet() || val.Type() != tMinKey {
  1076  		return ValueDecoderError{Name: "MinKeyDecodeValue", Types: []reflect.Type{tMinKey}, Received: val}
  1077  	}
  1078  
  1079  	elem, err := dvd.minKeyDecodeType(dc, vr, tMinKey)
  1080  	if err != nil {
  1081  		return err
  1082  	}
  1083  
  1084  	val.Set(elem)
  1085  	return nil
  1086  }
  1087  
  1088  func (DefaultValueDecoders) maxKeyDecodeType(_ DecodeContext, vr bsonrw.ValueReader, t reflect.Type) (reflect.Value, error) {
  1089  	if t != tMaxKey {
  1090  		return emptyValue, ValueDecoderError{
  1091  			Name:     "MaxKeyDecodeValue",
  1092  			Types:    []reflect.Type{tMaxKey},
  1093  			Received: reflect.Zero(t),
  1094  		}
  1095  	}
  1096  
  1097  	var err error
  1098  	switch vrType := vr.Type(); vrType {
  1099  	case bsontype.MaxKey:
  1100  		err = vr.ReadMaxKey()
  1101  	case bsontype.Null:
  1102  		err = vr.ReadNull()
  1103  	case bsontype.Undefined:
  1104  		err = vr.ReadUndefined()
  1105  	default:
  1106  		return emptyValue, fmt.Errorf("cannot decode %v into a MaxKey", vr.Type())
  1107  	}
  1108  	if err != nil {
  1109  		return emptyValue, err
  1110  	}
  1111  
  1112  	return reflect.ValueOf(primitive.MaxKey{}), nil
  1113  }
  1114  
  1115  // MaxKeyDecodeValue is the ValueDecoderFunc for MaxKey.
  1116  //
  1117  // Deprecated: Use [go.mongodb.org/mongo-driver/bson.NewRegistry] to get a registry with all default
  1118  // value decoders registered.
  1119  func (dvd DefaultValueDecoders) MaxKeyDecodeValue(dc DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
  1120  	if !val.CanSet() || val.Type() != tMaxKey {
  1121  		return ValueDecoderError{Name: "MaxKeyDecodeValue", Types: []reflect.Type{tMaxKey}, Received: val}
  1122  	}
  1123  
  1124  	elem, err := dvd.maxKeyDecodeType(dc, vr, tMaxKey)
  1125  	if err != nil {
  1126  		return err
  1127  	}
  1128  
  1129  	val.Set(elem)
  1130  	return nil
  1131  }
  1132  
  1133  func (dvd DefaultValueDecoders) decimal128DecodeType(_ DecodeContext, vr bsonrw.ValueReader, t reflect.Type) (reflect.Value, error) {
  1134  	if t != tDecimal {
  1135  		return emptyValue, ValueDecoderError{
  1136  			Name:     "Decimal128DecodeValue",
  1137  			Types:    []reflect.Type{tDecimal},
  1138  			Received: reflect.Zero(t),
  1139  		}
  1140  	}
  1141  
  1142  	var d128 primitive.Decimal128
  1143  	var err error
  1144  	switch vrType := vr.Type(); vrType {
  1145  	case bsontype.Decimal128:
  1146  		d128, err = vr.ReadDecimal128()
  1147  	case bsontype.Null:
  1148  		err = vr.ReadNull()
  1149  	case bsontype.Undefined:
  1150  		err = vr.ReadUndefined()
  1151  	default:
  1152  		return emptyValue, fmt.Errorf("cannot decode %v into a primitive.Decimal128", vr.Type())
  1153  	}
  1154  	if err != nil {
  1155  		return emptyValue, err
  1156  	}
  1157  
  1158  	return reflect.ValueOf(d128), nil
  1159  }
  1160  
  1161  // Decimal128DecodeValue is the ValueDecoderFunc for primitive.Decimal128.
  1162  //
  1163  // Deprecated: Use [go.mongodb.org/mongo-driver/bson.NewRegistry] to get a registry with all default
  1164  // value decoders registered.
  1165  func (dvd DefaultValueDecoders) Decimal128DecodeValue(dctx DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
  1166  	if !val.CanSet() || val.Type() != tDecimal {
  1167  		return ValueDecoderError{Name: "Decimal128DecodeValue", Types: []reflect.Type{tDecimal}, Received: val}
  1168  	}
  1169  
  1170  	elem, err := dvd.decimal128DecodeType(dctx, vr, tDecimal)
  1171  	if err != nil {
  1172  		return err
  1173  	}
  1174  
  1175  	val.Set(elem)
  1176  	return nil
  1177  }
  1178  
  1179  func (dvd DefaultValueDecoders) jsonNumberDecodeType(_ DecodeContext, vr bsonrw.ValueReader, t reflect.Type) (reflect.Value, error) {
  1180  	if t != tJSONNumber {
  1181  		return emptyValue, ValueDecoderError{
  1182  			Name:     "JSONNumberDecodeValue",
  1183  			Types:    []reflect.Type{tJSONNumber},
  1184  			Received: reflect.Zero(t),
  1185  		}
  1186  	}
  1187  
  1188  	var jsonNum json.Number
  1189  	var err error
  1190  	switch vrType := vr.Type(); vrType {
  1191  	case bsontype.Double:
  1192  		f64, err := vr.ReadDouble()
  1193  		if err != nil {
  1194  			return emptyValue, err
  1195  		}
  1196  		jsonNum = json.Number(strconv.FormatFloat(f64, 'f', -1, 64))
  1197  	case bsontype.Int32:
  1198  		i32, err := vr.ReadInt32()
  1199  		if err != nil {
  1200  			return emptyValue, err
  1201  		}
  1202  		jsonNum = json.Number(strconv.FormatInt(int64(i32), 10))
  1203  	case bsontype.Int64:
  1204  		i64, err := vr.ReadInt64()
  1205  		if err != nil {
  1206  			return emptyValue, err
  1207  		}
  1208  		jsonNum = json.Number(strconv.FormatInt(i64, 10))
  1209  	case bsontype.Null:
  1210  		err = vr.ReadNull()
  1211  	case bsontype.Undefined:
  1212  		err = vr.ReadUndefined()
  1213  	default:
  1214  		return emptyValue, fmt.Errorf("cannot decode %v into a json.Number", vrType)
  1215  	}
  1216  	if err != nil {
  1217  		return emptyValue, err
  1218  	}
  1219  
  1220  	return reflect.ValueOf(jsonNum), nil
  1221  }
  1222  
  1223  // JSONNumberDecodeValue is the ValueDecoderFunc for json.Number.
  1224  //
  1225  // Deprecated: Use [go.mongodb.org/mongo-driver/bson.NewRegistry] to get a registry with all default
  1226  // value decoders registered.
  1227  func (dvd DefaultValueDecoders) JSONNumberDecodeValue(dc DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
  1228  	if !val.CanSet() || val.Type() != tJSONNumber {
  1229  		return ValueDecoderError{Name: "JSONNumberDecodeValue", Types: []reflect.Type{tJSONNumber}, Received: val}
  1230  	}
  1231  
  1232  	elem, err := dvd.jsonNumberDecodeType(dc, vr, tJSONNumber)
  1233  	if err != nil {
  1234  		return err
  1235  	}
  1236  
  1237  	val.Set(elem)
  1238  	return nil
  1239  }
  1240  
  1241  func (dvd DefaultValueDecoders) urlDecodeType(_ DecodeContext, vr bsonrw.ValueReader, t reflect.Type) (reflect.Value, error) {
  1242  	if t != tURL {
  1243  		return emptyValue, ValueDecoderError{
  1244  			Name:     "URLDecodeValue",
  1245  			Types:    []reflect.Type{tURL},
  1246  			Received: reflect.Zero(t),
  1247  		}
  1248  	}
  1249  
  1250  	urlPtr := &url.URL{}
  1251  	var err error
  1252  	switch vrType := vr.Type(); vrType {
  1253  	case bsontype.String:
  1254  		var str string // Declare str here to avoid shadowing err during the ReadString call.
  1255  		str, err = vr.ReadString()
  1256  		if err != nil {
  1257  			return emptyValue, err
  1258  		}
  1259  
  1260  		urlPtr, err = url.Parse(str)
  1261  	case bsontype.Null:
  1262  		err = vr.ReadNull()
  1263  	case bsontype.Undefined:
  1264  		err = vr.ReadUndefined()
  1265  	default:
  1266  		return emptyValue, fmt.Errorf("cannot decode %v into a *url.URL", vrType)
  1267  	}
  1268  	if err != nil {
  1269  		return emptyValue, err
  1270  	}
  1271  
  1272  	return reflect.ValueOf(urlPtr).Elem(), nil
  1273  }
  1274  
  1275  // URLDecodeValue is the ValueDecoderFunc for url.URL.
  1276  //
  1277  // Deprecated: Use [go.mongodb.org/mongo-driver/bson.NewRegistry] to get a registry with all default
  1278  // value decoders registered.
  1279  func (dvd DefaultValueDecoders) URLDecodeValue(dc DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
  1280  	if !val.CanSet() || val.Type() != tURL {
  1281  		return ValueDecoderError{Name: "URLDecodeValue", Types: []reflect.Type{tURL}, Received: val}
  1282  	}
  1283  
  1284  	elem, err := dvd.urlDecodeType(dc, vr, tURL)
  1285  	if err != nil {
  1286  		return err
  1287  	}
  1288  
  1289  	val.Set(elem)
  1290  	return nil
  1291  }
  1292  
  1293  // TimeDecodeValue is the ValueDecoderFunc for time.Time.
  1294  //
  1295  // Deprecated: TimeDecodeValue is not registered by default. Use TimeCodec.DecodeValue instead.
  1296  func (dvd DefaultValueDecoders) TimeDecodeValue(_ DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
  1297  	if vr.Type() != bsontype.DateTime {
  1298  		return fmt.Errorf("cannot decode %v into a time.Time", vr.Type())
  1299  	}
  1300  
  1301  	dt, err := vr.ReadDateTime()
  1302  	if err != nil {
  1303  		return err
  1304  	}
  1305  
  1306  	if !val.CanSet() || val.Type() != tTime {
  1307  		return ValueDecoderError{Name: "TimeDecodeValue", Types: []reflect.Type{tTime}, Received: val}
  1308  	}
  1309  
  1310  	val.Set(reflect.ValueOf(time.Unix(dt/1000, dt%1000*1000000).UTC()))
  1311  	return nil
  1312  }
  1313  
  1314  // ByteSliceDecodeValue is the ValueDecoderFunc for []byte.
  1315  //
  1316  // Deprecated: ByteSliceDecodeValue is not registered by default. Use ByteSliceCodec.DecodeValue instead.
  1317  func (dvd DefaultValueDecoders) ByteSliceDecodeValue(_ DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
  1318  	if vr.Type() != bsontype.Binary && vr.Type() != bsontype.Null {
  1319  		return fmt.Errorf("cannot decode %v into a []byte", vr.Type())
  1320  	}
  1321  
  1322  	if !val.CanSet() || val.Type() != tByteSlice {
  1323  		return ValueDecoderError{Name: "ByteSliceDecodeValue", Types: []reflect.Type{tByteSlice}, Received: val}
  1324  	}
  1325  
  1326  	if vr.Type() == bsontype.Null {
  1327  		val.Set(reflect.Zero(val.Type()))
  1328  		return vr.ReadNull()
  1329  	}
  1330  
  1331  	data, subtype, err := vr.ReadBinary()
  1332  	if err != nil {
  1333  		return err
  1334  	}
  1335  	if subtype != 0x00 {
  1336  		return fmt.Errorf("ByteSliceDecodeValue can only be used to decode subtype 0x00 for %s, got %v", bsontype.Binary, subtype)
  1337  	}
  1338  
  1339  	val.Set(reflect.ValueOf(data))
  1340  	return nil
  1341  }
  1342  
  1343  // MapDecodeValue is the ValueDecoderFunc for map[string]* types.
  1344  //
  1345  // Deprecated: MapDecodeValue is not registered by default. Use MapCodec.DecodeValue instead.
  1346  func (dvd DefaultValueDecoders) MapDecodeValue(dc DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
  1347  	if !val.CanSet() || val.Kind() != reflect.Map || val.Type().Key().Kind() != reflect.String {
  1348  		return ValueDecoderError{Name: "MapDecodeValue", Kinds: []reflect.Kind{reflect.Map}, Received: val}
  1349  	}
  1350  
  1351  	switch vr.Type() {
  1352  	case bsontype.Type(0), bsontype.EmbeddedDocument:
  1353  	case bsontype.Null:
  1354  		val.Set(reflect.Zero(val.Type()))
  1355  		return vr.ReadNull()
  1356  	default:
  1357  		return fmt.Errorf("cannot decode %v into a %s", vr.Type(), val.Type())
  1358  	}
  1359  
  1360  	dr, err := vr.ReadDocument()
  1361  	if err != nil {
  1362  		return err
  1363  	}
  1364  
  1365  	if val.IsNil() {
  1366  		val.Set(reflect.MakeMap(val.Type()))
  1367  	}
  1368  
  1369  	eType := val.Type().Elem()
  1370  	decoder, err := dc.LookupDecoder(eType)
  1371  	if err != nil {
  1372  		return err
  1373  	}
  1374  
  1375  	if eType == tEmpty {
  1376  		dc.Ancestor = val.Type()
  1377  	}
  1378  
  1379  	keyType := val.Type().Key()
  1380  	for {
  1381  		key, vr, err := dr.ReadElement()
  1382  		if errors.Is(err, bsonrw.ErrEOD) {
  1383  			break
  1384  		}
  1385  		if err != nil {
  1386  			return err
  1387  		}
  1388  
  1389  		elem := reflect.New(eType).Elem()
  1390  
  1391  		err = decoder.DecodeValue(dc, vr, elem)
  1392  		if err != nil {
  1393  			return err
  1394  		}
  1395  
  1396  		val.SetMapIndex(reflect.ValueOf(key).Convert(keyType), elem)
  1397  	}
  1398  	return nil
  1399  }
  1400  
  1401  // ArrayDecodeValue is the ValueDecoderFunc for array types.
  1402  //
  1403  // Deprecated: Use [go.mongodb.org/mongo-driver/bson.NewRegistry] to get a registry with all default
  1404  // value decoders registered.
  1405  func (dvd DefaultValueDecoders) ArrayDecodeValue(dc DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
  1406  	if !val.IsValid() || val.Kind() != reflect.Array {
  1407  		return ValueDecoderError{Name: "ArrayDecodeValue", Kinds: []reflect.Kind{reflect.Array}, Received: val}
  1408  	}
  1409  
  1410  	switch vrType := vr.Type(); vrType {
  1411  	case bsontype.Array:
  1412  	case bsontype.Type(0), bsontype.EmbeddedDocument:
  1413  		if val.Type().Elem() != tE {
  1414  			return fmt.Errorf("cannot decode document into %s", val.Type())
  1415  		}
  1416  	case bsontype.Binary:
  1417  		if val.Type().Elem() != tByte {
  1418  			return fmt.Errorf("ArrayDecodeValue can only be used to decode binary into a byte array, got %v", vrType)
  1419  		}
  1420  		data, subtype, err := vr.ReadBinary()
  1421  		if err != nil {
  1422  			return err
  1423  		}
  1424  		if subtype != bsontype.BinaryGeneric && subtype != bsontype.BinaryBinaryOld {
  1425  			return fmt.Errorf("ArrayDecodeValue can only be used to decode subtype 0x00 or 0x02 for %s, got %v", bsontype.Binary, subtype)
  1426  		}
  1427  
  1428  		if len(data) > val.Len() {
  1429  			return fmt.Errorf("more elements returned in array than can fit inside %s", val.Type())
  1430  		}
  1431  
  1432  		for idx, elem := range data {
  1433  			val.Index(idx).Set(reflect.ValueOf(elem))
  1434  		}
  1435  		return nil
  1436  	case bsontype.Null:
  1437  		val.Set(reflect.Zero(val.Type()))
  1438  		return vr.ReadNull()
  1439  	case bsontype.Undefined:
  1440  		val.Set(reflect.Zero(val.Type()))
  1441  		return vr.ReadUndefined()
  1442  	default:
  1443  		return fmt.Errorf("cannot decode %v into an array", vrType)
  1444  	}
  1445  
  1446  	var elemsFunc func(DecodeContext, bsonrw.ValueReader, reflect.Value) ([]reflect.Value, error)
  1447  	switch val.Type().Elem() {
  1448  	case tE:
  1449  		elemsFunc = dvd.decodeD
  1450  	default:
  1451  		elemsFunc = dvd.decodeDefault
  1452  	}
  1453  
  1454  	elems, err := elemsFunc(dc, vr, val)
  1455  	if err != nil {
  1456  		return err
  1457  	}
  1458  
  1459  	if len(elems) > val.Len() {
  1460  		return fmt.Errorf("more elements returned in array than can fit inside %s, got %v elements", val.Type(), len(elems))
  1461  	}
  1462  
  1463  	for idx, elem := range elems {
  1464  		val.Index(idx).Set(elem)
  1465  	}
  1466  
  1467  	return nil
  1468  }
  1469  
  1470  // SliceDecodeValue is the ValueDecoderFunc for slice types.
  1471  //
  1472  // Deprecated: SliceDecodeValue is not registered by default. Use SliceCodec.DecodeValue instead.
  1473  func (dvd DefaultValueDecoders) SliceDecodeValue(dc DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
  1474  	if !val.CanSet() || val.Kind() != reflect.Slice {
  1475  		return ValueDecoderError{Name: "SliceDecodeValue", Kinds: []reflect.Kind{reflect.Slice}, Received: val}
  1476  	}
  1477  
  1478  	switch vr.Type() {
  1479  	case bsontype.Array:
  1480  	case bsontype.Null:
  1481  		val.Set(reflect.Zero(val.Type()))
  1482  		return vr.ReadNull()
  1483  	case bsontype.Type(0), bsontype.EmbeddedDocument:
  1484  		if val.Type().Elem() != tE {
  1485  			return fmt.Errorf("cannot decode document into %s", val.Type())
  1486  		}
  1487  	default:
  1488  		return fmt.Errorf("cannot decode %v into a slice", vr.Type())
  1489  	}
  1490  
  1491  	var elemsFunc func(DecodeContext, bsonrw.ValueReader, reflect.Value) ([]reflect.Value, error)
  1492  	switch val.Type().Elem() {
  1493  	case tE:
  1494  		dc.Ancestor = val.Type()
  1495  		elemsFunc = dvd.decodeD
  1496  	default:
  1497  		elemsFunc = dvd.decodeDefault
  1498  	}
  1499  
  1500  	elems, err := elemsFunc(dc, vr, val)
  1501  	if err != nil {
  1502  		return err
  1503  	}
  1504  
  1505  	if val.IsNil() {
  1506  		val.Set(reflect.MakeSlice(val.Type(), 0, len(elems)))
  1507  	}
  1508  
  1509  	val.SetLen(0)
  1510  	val.Set(reflect.Append(val, elems...))
  1511  
  1512  	return nil
  1513  }
  1514  
  1515  // ValueUnmarshalerDecodeValue is the ValueDecoderFunc for ValueUnmarshaler implementations.
  1516  //
  1517  // Deprecated: Use [go.mongodb.org/mongo-driver/bson.NewRegistry] to get a registry with all default
  1518  // value decoders registered.
  1519  func (dvd DefaultValueDecoders) ValueUnmarshalerDecodeValue(_ DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
  1520  	if !val.IsValid() || (!val.Type().Implements(tValueUnmarshaler) && !reflect.PtrTo(val.Type()).Implements(tValueUnmarshaler)) {
  1521  		return ValueDecoderError{Name: "ValueUnmarshalerDecodeValue", Types: []reflect.Type{tValueUnmarshaler}, Received: val}
  1522  	}
  1523  
  1524  	if val.Kind() == reflect.Ptr && val.IsNil() {
  1525  		if !val.CanSet() {
  1526  			return ValueDecoderError{Name: "ValueUnmarshalerDecodeValue", Types: []reflect.Type{tValueUnmarshaler}, Received: val}
  1527  		}
  1528  		val.Set(reflect.New(val.Type().Elem()))
  1529  	}
  1530  
  1531  	if !val.Type().Implements(tValueUnmarshaler) {
  1532  		if !val.CanAddr() {
  1533  			return ValueDecoderError{Name: "ValueUnmarshalerDecodeValue", Types: []reflect.Type{tValueUnmarshaler}, Received: val}
  1534  		}
  1535  		val = val.Addr() // If the type doesn't implement the interface, a pointer to it must.
  1536  	}
  1537  
  1538  	t, src, err := bsonrw.Copier{}.CopyValueToBytes(vr)
  1539  	if err != nil {
  1540  		return err
  1541  	}
  1542  
  1543  	m, ok := val.Interface().(ValueUnmarshaler)
  1544  	if !ok {
  1545  		// NB: this error should be unreachable due to the above checks
  1546  		return ValueDecoderError{Name: "ValueUnmarshalerDecodeValue", Types: []reflect.Type{tValueUnmarshaler}, Received: val}
  1547  	}
  1548  	return m.UnmarshalBSONValue(t, src)
  1549  }
  1550  
  1551  // UnmarshalerDecodeValue is the ValueDecoderFunc for Unmarshaler implementations.
  1552  //
  1553  // Deprecated: Use [go.mongodb.org/mongo-driver/bson.NewRegistry] to get a registry with all default
  1554  // value decoders registered.
  1555  func (dvd DefaultValueDecoders) UnmarshalerDecodeValue(_ DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
  1556  	if !val.IsValid() || (!val.Type().Implements(tUnmarshaler) && !reflect.PtrTo(val.Type()).Implements(tUnmarshaler)) {
  1557  		return ValueDecoderError{Name: "UnmarshalerDecodeValue", Types: []reflect.Type{tUnmarshaler}, Received: val}
  1558  	}
  1559  
  1560  	if val.Kind() == reflect.Ptr && val.IsNil() {
  1561  		if !val.CanSet() {
  1562  			return ValueDecoderError{Name: "UnmarshalerDecodeValue", Types: []reflect.Type{tUnmarshaler}, Received: val}
  1563  		}
  1564  		val.Set(reflect.New(val.Type().Elem()))
  1565  	}
  1566  
  1567  	_, src, err := bsonrw.Copier{}.CopyValueToBytes(vr)
  1568  	if err != nil {
  1569  		return err
  1570  	}
  1571  
  1572  	// If the target Go value is a pointer and the BSON field value is empty, set the value to the
  1573  	// zero value of the pointer (nil) and don't call UnmarshalBSON. UnmarshalBSON has no way to
  1574  	// change the pointer value from within the function (only the value at the pointer address),
  1575  	// so it can't set the pointer to "nil" itself. Since the most common Go value for an empty BSON
  1576  	// field value is "nil", we set "nil" here and don't call UnmarshalBSON. This behavior matches
  1577  	// the behavior of the Go "encoding/json" unmarshaler when the target Go value is a pointer and
  1578  	// the JSON field value is "null".
  1579  	if val.Kind() == reflect.Ptr && len(src) == 0 {
  1580  		val.Set(reflect.Zero(val.Type()))
  1581  		return nil
  1582  	}
  1583  
  1584  	if !val.Type().Implements(tUnmarshaler) {
  1585  		if !val.CanAddr() {
  1586  			return ValueDecoderError{Name: "UnmarshalerDecodeValue", Types: []reflect.Type{tUnmarshaler}, Received: val}
  1587  		}
  1588  		val = val.Addr() // If the type doesn't implement the interface, a pointer to it must.
  1589  	}
  1590  
  1591  	m, ok := val.Interface().(Unmarshaler)
  1592  	if !ok {
  1593  		// NB: this error should be unreachable due to the above checks
  1594  		return ValueDecoderError{Name: "UnmarshalerDecodeValue", Types: []reflect.Type{tUnmarshaler}, Received: val}
  1595  	}
  1596  	return m.UnmarshalBSON(src)
  1597  }
  1598  
  1599  // EmptyInterfaceDecodeValue is the ValueDecoderFunc for interface{}.
  1600  //
  1601  // Deprecated: EmptyInterfaceDecodeValue is not registered by default. Use EmptyInterfaceCodec.DecodeValue instead.
  1602  func (dvd DefaultValueDecoders) EmptyInterfaceDecodeValue(dc DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
  1603  	if !val.CanSet() || val.Type() != tEmpty {
  1604  		return ValueDecoderError{Name: "EmptyInterfaceDecodeValue", Types: []reflect.Type{tEmpty}, Received: val}
  1605  	}
  1606  
  1607  	rtype, err := dc.LookupTypeMapEntry(vr.Type())
  1608  	if err != nil {
  1609  		switch vr.Type() {
  1610  		case bsontype.EmbeddedDocument:
  1611  			if dc.Ancestor != nil {
  1612  				rtype = dc.Ancestor
  1613  				break
  1614  			}
  1615  			rtype = tD
  1616  		case bsontype.Null:
  1617  			val.Set(reflect.Zero(val.Type()))
  1618  			return vr.ReadNull()
  1619  		default:
  1620  			return err
  1621  		}
  1622  	}
  1623  
  1624  	decoder, err := dc.LookupDecoder(rtype)
  1625  	if err != nil {
  1626  		return err
  1627  	}
  1628  
  1629  	elem := reflect.New(rtype).Elem()
  1630  	err = decoder.DecodeValue(dc, vr, elem)
  1631  	if err != nil {
  1632  		return err
  1633  	}
  1634  
  1635  	val.Set(elem)
  1636  	return nil
  1637  }
  1638  
  1639  // CoreDocumentDecodeValue is the ValueDecoderFunc for bsoncore.Document.
  1640  //
  1641  // Deprecated: Use [go.mongodb.org/mongo-driver/bson.NewRegistry] to get a registry with all default
  1642  // value decoders registered.
  1643  func (DefaultValueDecoders) CoreDocumentDecodeValue(_ DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
  1644  	if !val.CanSet() || val.Type() != tCoreDocument {
  1645  		return ValueDecoderError{Name: "CoreDocumentDecodeValue", Types: []reflect.Type{tCoreDocument}, Received: val}
  1646  	}
  1647  
  1648  	if val.IsNil() {
  1649  		val.Set(reflect.MakeSlice(val.Type(), 0, 0))
  1650  	}
  1651  
  1652  	val.SetLen(0)
  1653  
  1654  	cdoc, err := bsonrw.Copier{}.AppendDocumentBytes(val.Interface().(bsoncore.Document), vr)
  1655  	val.Set(reflect.ValueOf(cdoc))
  1656  	return err
  1657  }
  1658  
  1659  func (dvd DefaultValueDecoders) decodeDefault(dc DecodeContext, vr bsonrw.ValueReader, val reflect.Value) ([]reflect.Value, error) {
  1660  	elems := make([]reflect.Value, 0)
  1661  
  1662  	ar, err := vr.ReadArray()
  1663  	if err != nil {
  1664  		return nil, err
  1665  	}
  1666  
  1667  	eType := val.Type().Elem()
  1668  
  1669  	decoder, err := dc.LookupDecoder(eType)
  1670  	if err != nil {
  1671  		return nil, err
  1672  	}
  1673  	eTypeDecoder, _ := decoder.(typeDecoder)
  1674  
  1675  	idx := 0
  1676  	for {
  1677  		vr, err := ar.ReadValue()
  1678  		if errors.Is(err, bsonrw.ErrEOA) {
  1679  			break
  1680  		}
  1681  		if err != nil {
  1682  			return nil, err
  1683  		}
  1684  
  1685  		elem, err := decodeTypeOrValueWithInfo(decoder, eTypeDecoder, dc, vr, eType, true)
  1686  		if err != nil {
  1687  			return nil, newDecodeError(strconv.Itoa(idx), err)
  1688  		}
  1689  		elems = append(elems, elem)
  1690  		idx++
  1691  	}
  1692  
  1693  	return elems, nil
  1694  }
  1695  
  1696  func (dvd DefaultValueDecoders) readCodeWithScope(dc DecodeContext, vr bsonrw.ValueReader) (primitive.CodeWithScope, error) {
  1697  	var cws primitive.CodeWithScope
  1698  
  1699  	code, dr, err := vr.ReadCodeWithScope()
  1700  	if err != nil {
  1701  		return cws, err
  1702  	}
  1703  
  1704  	scope := reflect.New(tD).Elem()
  1705  	elems, err := dvd.decodeElemsFromDocumentReader(dc, dr)
  1706  	if err != nil {
  1707  		return cws, err
  1708  	}
  1709  
  1710  	scope.Set(reflect.MakeSlice(tD, 0, len(elems)))
  1711  	scope.Set(reflect.Append(scope, elems...))
  1712  
  1713  	cws = primitive.CodeWithScope{
  1714  		Code:  primitive.JavaScript(code),
  1715  		Scope: scope.Interface().(primitive.D),
  1716  	}
  1717  	return cws, nil
  1718  }
  1719  
  1720  func (dvd DefaultValueDecoders) codeWithScopeDecodeType(dc DecodeContext, vr bsonrw.ValueReader, t reflect.Type) (reflect.Value, error) {
  1721  	if t != tCodeWithScope {
  1722  		return emptyValue, ValueDecoderError{
  1723  			Name:     "CodeWithScopeDecodeValue",
  1724  			Types:    []reflect.Type{tCodeWithScope},
  1725  			Received: reflect.Zero(t),
  1726  		}
  1727  	}
  1728  
  1729  	var cws primitive.CodeWithScope
  1730  	var err error
  1731  	switch vrType := vr.Type(); vrType {
  1732  	case bsontype.CodeWithScope:
  1733  		cws, err = dvd.readCodeWithScope(dc, vr)
  1734  	case bsontype.Null:
  1735  		err = vr.ReadNull()
  1736  	case bsontype.Undefined:
  1737  		err = vr.ReadUndefined()
  1738  	default:
  1739  		return emptyValue, fmt.Errorf("cannot decode %v into a primitive.CodeWithScope", vrType)
  1740  	}
  1741  	if err != nil {
  1742  		return emptyValue, err
  1743  	}
  1744  
  1745  	return reflect.ValueOf(cws), nil
  1746  }
  1747  
  1748  // CodeWithScopeDecodeValue is the ValueDecoderFunc for CodeWithScope.
  1749  //
  1750  // Deprecated: Use [go.mongodb.org/mongo-driver/bson.NewRegistry] to get a registry with all default
  1751  // value decoders registered.
  1752  func (dvd DefaultValueDecoders) CodeWithScopeDecodeValue(dc DecodeContext, vr bsonrw.ValueReader, val reflect.Value) error {
  1753  	if !val.CanSet() || val.Type() != tCodeWithScope {
  1754  		return ValueDecoderError{Name: "CodeWithScopeDecodeValue", Types: []reflect.Type{tCodeWithScope}, Received: val}
  1755  	}
  1756  
  1757  	elem, err := dvd.codeWithScopeDecodeType(dc, vr, tCodeWithScope)
  1758  	if err != nil {
  1759  		return err
  1760  	}
  1761  
  1762  	val.Set(elem)
  1763  	return nil
  1764  }
  1765  
  1766  func (dvd DefaultValueDecoders) decodeD(dc DecodeContext, vr bsonrw.ValueReader, _ reflect.Value) ([]reflect.Value, error) {
  1767  	switch vr.Type() {
  1768  	case bsontype.Type(0), bsontype.EmbeddedDocument:
  1769  	default:
  1770  		return nil, fmt.Errorf("cannot decode %v into a D", vr.Type())
  1771  	}
  1772  
  1773  	dr, err := vr.ReadDocument()
  1774  	if err != nil {
  1775  		return nil, err
  1776  	}
  1777  
  1778  	return dvd.decodeElemsFromDocumentReader(dc, dr)
  1779  }
  1780  
  1781  func (DefaultValueDecoders) decodeElemsFromDocumentReader(dc DecodeContext, dr bsonrw.DocumentReader) ([]reflect.Value, error) {
  1782  	decoder, err := dc.LookupDecoder(tEmpty)
  1783  	if err != nil {
  1784  		return nil, err
  1785  	}
  1786  
  1787  	elems := make([]reflect.Value, 0)
  1788  	for {
  1789  		key, vr, err := dr.ReadElement()
  1790  		if errors.Is(err, bsonrw.ErrEOD) {
  1791  			break
  1792  		}
  1793  		if err != nil {
  1794  			return nil, err
  1795  		}
  1796  
  1797  		val := reflect.New(tEmpty).Elem()
  1798  		err = decoder.DecodeValue(dc, vr, val)
  1799  		if err != nil {
  1800  			return nil, newDecodeError(key, err)
  1801  		}
  1802  
  1803  		elems = append(elems, reflect.ValueOf(primitive.E{Key: key, Value: val.Interface()}))
  1804  	}
  1805  
  1806  	return elems, nil
  1807  }
  1808  

View as plain text