default_value_decoders.go raw
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: %v", 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 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 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 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 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