]> git.immae.eu Git - github/fretlink/terraform-provider-statuscake.git/blob - vendor/github.com/mitchellh/mapstructure/mapstructure.go
Merge branch 'fix_read_test' of github.com:alexandreFre/terraform-provider-statuscake
[github/fretlink/terraform-provider-statuscake.git] / vendor / github.com / mitchellh / mapstructure / mapstructure.go
1 // Package mapstructure exposes functionality to convert an arbitrary
2 // map[string]interface{} into a native Go structure.
3 //
4 // The Go structure can be arbitrarily complex, containing slices,
5 // other structs, etc. and the decoder will properly decode nested
6 // maps and so on into the proper structures in the native Go struct.
7 // See the examples to see what the decoder is capable of.
8 package mapstructure
9
10 import (
11 "encoding/json"
12 "errors"
13 "fmt"
14 "reflect"
15 "sort"
16 "strconv"
17 "strings"
18 )
19
20 // DecodeHookFunc is the callback function that can be used for
21 // data transformations. See "DecodeHook" in the DecoderConfig
22 // struct.
23 //
24 // The type should be DecodeHookFuncType or DecodeHookFuncKind.
25 // Either is accepted. Types are a superset of Kinds (Types can return
26 // Kinds) and are generally a richer thing to use, but Kinds are simpler
27 // if you only need those.
28 //
29 // The reason DecodeHookFunc is multi-typed is for backwards compatibility:
30 // we started with Kinds and then realized Types were the better solution,
31 // but have a promise to not break backwards compat so we now support
32 // both.
33 type DecodeHookFunc interface{}
34
35 // DecodeHookFuncType is a DecodeHookFunc which has complete information about
36 // the source and target types.
37 type DecodeHookFuncType func(reflect.Type, reflect.Type, interface{}) (interface{}, error)
38
39 // DecodeHookFuncKind is a DecodeHookFunc which knows only the Kinds of the
40 // source and target types.
41 type DecodeHookFuncKind func(reflect.Kind, reflect.Kind, interface{}) (interface{}, error)
42
43 // DecoderConfig is the configuration that is used to create a new decoder
44 // and allows customization of various aspects of decoding.
45 type DecoderConfig struct {
46 // DecodeHook, if set, will be called before any decoding and any
47 // type conversion (if WeaklyTypedInput is on). This lets you modify
48 // the values before they're set down onto the resulting struct.
49 //
50 // If an error is returned, the entire decode will fail with that
51 // error.
52 DecodeHook DecodeHookFunc
53
54 // If ErrorUnused is true, then it is an error for there to exist
55 // keys in the original map that were unused in the decoding process
56 // (extra keys).
57 ErrorUnused bool
58
59 // ZeroFields, if set to true, will zero fields before writing them.
60 // For example, a map will be emptied before decoded values are put in
61 // it. If this is false, a map will be merged.
62 ZeroFields bool
63
64 // If WeaklyTypedInput is true, the decoder will make the following
65 // "weak" conversions:
66 //
67 // - bools to string (true = "1", false = "0")
68 // - numbers to string (base 10)
69 // - bools to int/uint (true = 1, false = 0)
70 // - strings to int/uint (base implied by prefix)
71 // - int to bool (true if value != 0)
72 // - string to bool (accepts: 1, t, T, TRUE, true, True, 0, f, F,
73 // FALSE, false, False. Anything else is an error)
74 // - empty array = empty map and vice versa
75 // - negative numbers to overflowed uint values (base 10)
76 // - slice of maps to a merged map
77 // - single values are converted to slices if required. Each
78 // element is weakly decoded. For example: "4" can become []int{4}
79 // if the target type is an int slice.
80 //
81 WeaklyTypedInput bool
82
83 // Metadata is the struct that will contain extra metadata about
84 // the decoding. If this is nil, then no metadata will be tracked.
85 Metadata *Metadata
86
87 // Result is a pointer to the struct that will contain the decoded
88 // value.
89 Result interface{}
90
91 // The tag name that mapstructure reads for field names. This
92 // defaults to "mapstructure"
93 TagName string
94 }
95
96 // A Decoder takes a raw interface value and turns it into structured
97 // data, keeping track of rich error information along the way in case
98 // anything goes wrong. Unlike the basic top-level Decode method, you can
99 // more finely control how the Decoder behaves using the DecoderConfig
100 // structure. The top-level Decode method is just a convenience that sets
101 // up the most basic Decoder.
102 type Decoder struct {
103 config *DecoderConfig
104 }
105
106 // Metadata contains information about decoding a structure that
107 // is tedious or difficult to get otherwise.
108 type Metadata struct {
109 // Keys are the keys of the structure which were successfully decoded
110 Keys []string
111
112 // Unused is a slice of keys that were found in the raw value but
113 // weren't decoded since there was no matching field in the result interface
114 Unused []string
115 }
116
117 // Decode takes an input structure and uses reflection to translate it to
118 // the output structure. output must be a pointer to a map or struct.
119 func Decode(input interface{}, output interface{}) error {
120 config := &DecoderConfig{
121 Metadata: nil,
122 Result: output,
123 }
124
125 decoder, err := NewDecoder(config)
126 if err != nil {
127 return err
128 }
129
130 return decoder.Decode(input)
131 }
132
133 // WeakDecode is the same as Decode but is shorthand to enable
134 // WeaklyTypedInput. See DecoderConfig for more info.
135 func WeakDecode(input, output interface{}) error {
136 config := &DecoderConfig{
137 Metadata: nil,
138 Result: output,
139 WeaklyTypedInput: true,
140 }
141
142 decoder, err := NewDecoder(config)
143 if err != nil {
144 return err
145 }
146
147 return decoder.Decode(input)
148 }
149
150 // DecodeMetadata is the same as Decode, but is shorthand to
151 // enable metadata collection. See DecoderConfig for more info.
152 func DecodeMetadata(input interface{}, output interface{}, metadata *Metadata) error {
153 config := &DecoderConfig{
154 Metadata: metadata,
155 Result: output,
156 }
157
158 decoder, err := NewDecoder(config)
159 if err != nil {
160 return err
161 }
162
163 return decoder.Decode(input)
164 }
165
166 // WeakDecodeMetadata is the same as Decode, but is shorthand to
167 // enable both WeaklyTypedInput and metadata collection. See
168 // DecoderConfig for more info.
169 func WeakDecodeMetadata(input interface{}, output interface{}, metadata *Metadata) error {
170 config := &DecoderConfig{
171 Metadata: metadata,
172 Result: output,
173 WeaklyTypedInput: true,
174 }
175
176 decoder, err := NewDecoder(config)
177 if err != nil {
178 return err
179 }
180
181 return decoder.Decode(input)
182 }
183
184 // NewDecoder returns a new decoder for the given configuration. Once
185 // a decoder has been returned, the same configuration must not be used
186 // again.
187 func NewDecoder(config *DecoderConfig) (*Decoder, error) {
188 val := reflect.ValueOf(config.Result)
189 if val.Kind() != reflect.Ptr {
190 return nil, errors.New("result must be a pointer")
191 }
192
193 val = val.Elem()
194 if !val.CanAddr() {
195 return nil, errors.New("result must be addressable (a pointer)")
196 }
197
198 if config.Metadata != nil {
199 if config.Metadata.Keys == nil {
200 config.Metadata.Keys = make([]string, 0)
201 }
202
203 if config.Metadata.Unused == nil {
204 config.Metadata.Unused = make([]string, 0)
205 }
206 }
207
208 if config.TagName == "" {
209 config.TagName = "mapstructure"
210 }
211
212 result := &Decoder{
213 config: config,
214 }
215
216 return result, nil
217 }
218
219 // Decode decodes the given raw interface to the target pointer specified
220 // by the configuration.
221 func (d *Decoder) Decode(input interface{}) error {
222 return d.decode("", input, reflect.ValueOf(d.config.Result).Elem())
223 }
224
225 // Decodes an unknown data type into a specific reflection value.
226 func (d *Decoder) decode(name string, input interface{}, outVal reflect.Value) error {
227 var inputVal reflect.Value
228 if input != nil {
229 inputVal = reflect.ValueOf(input)
230
231 // We need to check here if input is a typed nil. Typed nils won't
232 // match the "input == nil" below so we check that here.
233 if inputVal.Kind() == reflect.Ptr && inputVal.IsNil() {
234 input = nil
235 }
236 }
237
238 if input == nil {
239 // If the data is nil, then we don't set anything, unless ZeroFields is set
240 // to true.
241 if d.config.ZeroFields {
242 outVal.Set(reflect.Zero(outVal.Type()))
243
244 if d.config.Metadata != nil && name != "" {
245 d.config.Metadata.Keys = append(d.config.Metadata.Keys, name)
246 }
247 }
248 return nil
249 }
250
251 if !inputVal.IsValid() {
252 // If the input value is invalid, then we just set the value
253 // to be the zero value.
254 outVal.Set(reflect.Zero(outVal.Type()))
255 if d.config.Metadata != nil && name != "" {
256 d.config.Metadata.Keys = append(d.config.Metadata.Keys, name)
257 }
258 return nil
259 }
260
261 if d.config.DecodeHook != nil {
262 // We have a DecodeHook, so let's pre-process the input.
263 var err error
264 input, err = DecodeHookExec(
265 d.config.DecodeHook,
266 inputVal.Type(), outVal.Type(), input)
267 if err != nil {
268 return fmt.Errorf("error decoding '%s': %s", name, err)
269 }
270 }
271
272 var err error
273 outputKind := getKind(outVal)
274 switch outputKind {
275 case reflect.Bool:
276 err = d.decodeBool(name, input, outVal)
277 case reflect.Interface:
278 err = d.decodeBasic(name, input, outVal)
279 case reflect.String:
280 err = d.decodeString(name, input, outVal)
281 case reflect.Int:
282 err = d.decodeInt(name, input, outVal)
283 case reflect.Uint:
284 err = d.decodeUint(name, input, outVal)
285 case reflect.Float32:
286 err = d.decodeFloat(name, input, outVal)
287 case reflect.Struct:
288 err = d.decodeStruct(name, input, outVal)
289 case reflect.Map:
290 err = d.decodeMap(name, input, outVal)
291 case reflect.Ptr:
292 err = d.decodePtr(name, input, outVal)
293 case reflect.Slice:
294 err = d.decodeSlice(name, input, outVal)
295 case reflect.Array:
296 err = d.decodeArray(name, input, outVal)
297 case reflect.Func:
298 err = d.decodeFunc(name, input, outVal)
299 default:
300 // If we reached this point then we weren't able to decode it
301 return fmt.Errorf("%s: unsupported type: %s", name, outputKind)
302 }
303
304 // If we reached here, then we successfully decoded SOMETHING, so
305 // mark the key as used if we're tracking metainput.
306 if d.config.Metadata != nil && name != "" {
307 d.config.Metadata.Keys = append(d.config.Metadata.Keys, name)
308 }
309
310 return err
311 }
312
313 // This decodes a basic type (bool, int, string, etc.) and sets the
314 // value to "data" of that type.
315 func (d *Decoder) decodeBasic(name string, data interface{}, val reflect.Value) error {
316 if val.IsValid() && val.Elem().IsValid() {
317 return d.decode(name, data, val.Elem())
318 }
319
320 dataVal := reflect.ValueOf(data)
321
322 // If the input data is a pointer, and the assigned type is the dereference
323 // of that exact pointer, then indirect it so that we can assign it.
324 // Example: *string to string
325 if dataVal.Kind() == reflect.Ptr && dataVal.Type().Elem() == val.Type() {
326 dataVal = reflect.Indirect(dataVal)
327 }
328
329 if !dataVal.IsValid() {
330 dataVal = reflect.Zero(val.Type())
331 }
332
333 dataValType := dataVal.Type()
334 if !dataValType.AssignableTo(val.Type()) {
335 return fmt.Errorf(
336 "'%s' expected type '%s', got '%s'",
337 name, val.Type(), dataValType)
338 }
339
340 val.Set(dataVal)
341 return nil
342 }
343
344 func (d *Decoder) decodeString(name string, data interface{}, val reflect.Value) error {
345 dataVal := reflect.Indirect(reflect.ValueOf(data))
346 dataKind := getKind(dataVal)
347
348 converted := true
349 switch {
350 case dataKind == reflect.String:
351 val.SetString(dataVal.String())
352 case dataKind == reflect.Bool && d.config.WeaklyTypedInput:
353 if dataVal.Bool() {
354 val.SetString("1")
355 } else {
356 val.SetString("0")
357 }
358 case dataKind == reflect.Int && d.config.WeaklyTypedInput:
359 val.SetString(strconv.FormatInt(dataVal.Int(), 10))
360 case dataKind == reflect.Uint && d.config.WeaklyTypedInput:
361 val.SetString(strconv.FormatUint(dataVal.Uint(), 10))
362 case dataKind == reflect.Float32 && d.config.WeaklyTypedInput:
363 val.SetString(strconv.FormatFloat(dataVal.Float(), 'f', -1, 64))
364 case dataKind == reflect.Slice && d.config.WeaklyTypedInput,
365 dataKind == reflect.Array && d.config.WeaklyTypedInput:
366 dataType := dataVal.Type()
367 elemKind := dataType.Elem().Kind()
368 switch elemKind {
369 case reflect.Uint8:
370 var uints []uint8
371 if dataKind == reflect.Array {
372 uints = make([]uint8, dataVal.Len(), dataVal.Len())
373 for i := range uints {
374 uints[i] = dataVal.Index(i).Interface().(uint8)
375 }
376 } else {
377 uints = dataVal.Interface().([]uint8)
378 }
379 val.SetString(string(uints))
380 default:
381 converted = false
382 }
383 default:
384 converted = false
385 }
386
387 if !converted {
388 return fmt.Errorf(
389 "'%s' expected type '%s', got unconvertible type '%s'",
390 name, val.Type(), dataVal.Type())
391 }
392
393 return nil
394 }
395
396 func (d *Decoder) decodeInt(name string, data interface{}, val reflect.Value) error {
397 dataVal := reflect.Indirect(reflect.ValueOf(data))
398 dataKind := getKind(dataVal)
399 dataType := dataVal.Type()
400
401 switch {
402 case dataKind == reflect.Int:
403 val.SetInt(dataVal.Int())
404 case dataKind == reflect.Uint:
405 val.SetInt(int64(dataVal.Uint()))
406 case dataKind == reflect.Float32:
407 val.SetInt(int64(dataVal.Float()))
408 case dataKind == reflect.Bool && d.config.WeaklyTypedInput:
409 if dataVal.Bool() {
410 val.SetInt(1)
411 } else {
412 val.SetInt(0)
413 }
414 case dataKind == reflect.String && d.config.WeaklyTypedInput:
415 i, err := strconv.ParseInt(dataVal.String(), 0, val.Type().Bits())
416 if err == nil {
417 val.SetInt(i)
418 } else {
419 return fmt.Errorf("cannot parse '%s' as int: %s", name, err)
420 }
421 case dataType.PkgPath() == "encoding/json" && dataType.Name() == "Number":
422 jn := data.(json.Number)
423 i, err := jn.Int64()
424 if err != nil {
425 return fmt.Errorf(
426 "error decoding json.Number into %s: %s", name, err)
427 }
428 val.SetInt(i)
429 default:
430 return fmt.Errorf(
431 "'%s' expected type '%s', got unconvertible type '%s'",
432 name, val.Type(), dataVal.Type())
433 }
434
435 return nil
436 }
437
438 func (d *Decoder) decodeUint(name string, data interface{}, val reflect.Value) error {
439 dataVal := reflect.Indirect(reflect.ValueOf(data))
440 dataKind := getKind(dataVal)
441
442 switch {
443 case dataKind == reflect.Int:
444 i := dataVal.Int()
445 if i < 0 && !d.config.WeaklyTypedInput {
446 return fmt.Errorf("cannot parse '%s', %d overflows uint",
447 name, i)
448 }
449 val.SetUint(uint64(i))
450 case dataKind == reflect.Uint:
451 val.SetUint(dataVal.Uint())
452 case dataKind == reflect.Float32:
453 f := dataVal.Float()
454 if f < 0 && !d.config.WeaklyTypedInput {
455 return fmt.Errorf("cannot parse '%s', %f overflows uint",
456 name, f)
457 }
458 val.SetUint(uint64(f))
459 case dataKind == reflect.Bool && d.config.WeaklyTypedInput:
460 if dataVal.Bool() {
461 val.SetUint(1)
462 } else {
463 val.SetUint(0)
464 }
465 case dataKind == reflect.String && d.config.WeaklyTypedInput:
466 i, err := strconv.ParseUint(dataVal.String(), 0, val.Type().Bits())
467 if err == nil {
468 val.SetUint(i)
469 } else {
470 return fmt.Errorf("cannot parse '%s' as uint: %s", name, err)
471 }
472 default:
473 return fmt.Errorf(
474 "'%s' expected type '%s', got unconvertible type '%s'",
475 name, val.Type(), dataVal.Type())
476 }
477
478 return nil
479 }
480
481 func (d *Decoder) decodeBool(name string, data interface{}, val reflect.Value) error {
482 dataVal := reflect.Indirect(reflect.ValueOf(data))
483 dataKind := getKind(dataVal)
484
485 switch {
486 case dataKind == reflect.Bool:
487 val.SetBool(dataVal.Bool())
488 case dataKind == reflect.Int && d.config.WeaklyTypedInput:
489 val.SetBool(dataVal.Int() != 0)
490 case dataKind == reflect.Uint && d.config.WeaklyTypedInput:
491 val.SetBool(dataVal.Uint() != 0)
492 case dataKind == reflect.Float32 && d.config.WeaklyTypedInput:
493 val.SetBool(dataVal.Float() != 0)
494 case dataKind == reflect.String && d.config.WeaklyTypedInput:
495 b, err := strconv.ParseBool(dataVal.String())
496 if err == nil {
497 val.SetBool(b)
498 } else if dataVal.String() == "" {
499 val.SetBool(false)
500 } else {
501 return fmt.Errorf("cannot parse '%s' as bool: %s", name, err)
502 }
503 default:
504 return fmt.Errorf(
505 "'%s' expected type '%s', got unconvertible type '%s'",
506 name, val.Type(), dataVal.Type())
507 }
508
509 return nil
510 }
511
512 func (d *Decoder) decodeFloat(name string, data interface{}, val reflect.Value) error {
513 dataVal := reflect.Indirect(reflect.ValueOf(data))
514 dataKind := getKind(dataVal)
515 dataType := dataVal.Type()
516
517 switch {
518 case dataKind == reflect.Int:
519 val.SetFloat(float64(dataVal.Int()))
520 case dataKind == reflect.Uint:
521 val.SetFloat(float64(dataVal.Uint()))
522 case dataKind == reflect.Float32:
523 val.SetFloat(dataVal.Float())
524 case dataKind == reflect.Bool && d.config.WeaklyTypedInput:
525 if dataVal.Bool() {
526 val.SetFloat(1)
527 } else {
528 val.SetFloat(0)
529 }
530 case dataKind == reflect.String && d.config.WeaklyTypedInput:
531 f, err := strconv.ParseFloat(dataVal.String(), val.Type().Bits())
532 if err == nil {
533 val.SetFloat(f)
534 } else {
535 return fmt.Errorf("cannot parse '%s' as float: %s", name, err)
536 }
537 case dataType.PkgPath() == "encoding/json" && dataType.Name() == "Number":
538 jn := data.(json.Number)
539 i, err := jn.Float64()
540 if err != nil {
541 return fmt.Errorf(
542 "error decoding json.Number into %s: %s", name, err)
543 }
544 val.SetFloat(i)
545 default:
546 return fmt.Errorf(
547 "'%s' expected type '%s', got unconvertible type '%s'",
548 name, val.Type(), dataVal.Type())
549 }
550
551 return nil
552 }
553
554 func (d *Decoder) decodeMap(name string, data interface{}, val reflect.Value) error {
555 valType := val.Type()
556 valKeyType := valType.Key()
557 valElemType := valType.Elem()
558
559 // By default we overwrite keys in the current map
560 valMap := val
561
562 // If the map is nil or we're purposely zeroing fields, make a new map
563 if valMap.IsNil() || d.config.ZeroFields {
564 // Make a new map to hold our result
565 mapType := reflect.MapOf(valKeyType, valElemType)
566 valMap = reflect.MakeMap(mapType)
567 }
568
569 // Check input type and based on the input type jump to the proper func
570 dataVal := reflect.Indirect(reflect.ValueOf(data))
571 switch dataVal.Kind() {
572 case reflect.Map:
573 return d.decodeMapFromMap(name, dataVal, val, valMap)
574
575 case reflect.Struct:
576 return d.decodeMapFromStruct(name, dataVal, val, valMap)
577
578 case reflect.Array, reflect.Slice:
579 if d.config.WeaklyTypedInput {
580 return d.decodeMapFromSlice(name, dataVal, val, valMap)
581 }
582
583 fallthrough
584
585 default:
586 return fmt.Errorf("'%s' expected a map, got '%s'", name, dataVal.Kind())
587 }
588 }
589
590 func (d *Decoder) decodeMapFromSlice(name string, dataVal reflect.Value, val reflect.Value, valMap reflect.Value) error {
591 // Special case for BC reasons (covered by tests)
592 if dataVal.Len() == 0 {
593 val.Set(valMap)
594 return nil
595 }
596
597 for i := 0; i < dataVal.Len(); i++ {
598 err := d.decode(
599 fmt.Sprintf("%s[%d]", name, i),
600 dataVal.Index(i).Interface(), val)
601 if err != nil {
602 return err
603 }
604 }
605
606 return nil
607 }
608
609 func (d *Decoder) decodeMapFromMap(name string, dataVal reflect.Value, val reflect.Value, valMap reflect.Value) error {
610 valType := val.Type()
611 valKeyType := valType.Key()
612 valElemType := valType.Elem()
613
614 // Accumulate errors
615 errors := make([]string, 0)
616
617 // If the input data is empty, then we just match what the input data is.
618 if dataVal.Len() == 0 {
619 if dataVal.IsNil() {
620 if !val.IsNil() {
621 val.Set(dataVal)
622 }
623 } else {
624 // Set to empty allocated value
625 val.Set(valMap)
626 }
627
628 return nil
629 }
630
631 for _, k := range dataVal.MapKeys() {
632 fieldName := fmt.Sprintf("%s[%s]", name, k)
633
634 // First decode the key into the proper type
635 currentKey := reflect.Indirect(reflect.New(valKeyType))
636 if err := d.decode(fieldName, k.Interface(), currentKey); err != nil {
637 errors = appendErrors(errors, err)
638 continue
639 }
640
641 // Next decode the data into the proper type
642 v := dataVal.MapIndex(k).Interface()
643 currentVal := reflect.Indirect(reflect.New(valElemType))
644 if err := d.decode(fieldName, v, currentVal); err != nil {
645 errors = appendErrors(errors, err)
646 continue
647 }
648
649 valMap.SetMapIndex(currentKey, currentVal)
650 }
651
652 // Set the built up map to the value
653 val.Set(valMap)
654
655 // If we had errors, return those
656 if len(errors) > 0 {
657 return &Error{errors}
658 }
659
660 return nil
661 }
662
663 func (d *Decoder) decodeMapFromStruct(name string, dataVal reflect.Value, val reflect.Value, valMap reflect.Value) error {
664 typ := dataVal.Type()
665 for i := 0; i < typ.NumField(); i++ {
666 // Get the StructField first since this is a cheap operation. If the
667 // field is unexported, then ignore it.
668 f := typ.Field(i)
669 if f.PkgPath != "" {
670 continue
671 }
672
673 // Next get the actual value of this field and verify it is assignable
674 // to the map value.
675 v := dataVal.Field(i)
676 if !v.Type().AssignableTo(valMap.Type().Elem()) {
677 return fmt.Errorf("cannot assign type '%s' to map value field of type '%s'", v.Type(), valMap.Type().Elem())
678 }
679
680 tagValue := f.Tag.Get(d.config.TagName)
681 tagParts := strings.Split(tagValue, ",")
682
683 // Determine the name of the key in the map
684 keyName := f.Name
685 if tagParts[0] != "" {
686 if tagParts[0] == "-" {
687 continue
688 }
689 keyName = tagParts[0]
690 }
691
692 // If "squash" is specified in the tag, we squash the field down.
693 squash := false
694 for _, tag := range tagParts[1:] {
695 if tag == "squash" {
696 squash = true
697 break
698 }
699 }
700 if squash && v.Kind() != reflect.Struct {
701 return fmt.Errorf("cannot squash non-struct type '%s'", v.Type())
702 }
703
704 switch v.Kind() {
705 // this is an embedded struct, so handle it differently
706 case reflect.Struct:
707 x := reflect.New(v.Type())
708 x.Elem().Set(v)
709
710 vType := valMap.Type()
711 vKeyType := vType.Key()
712 vElemType := vType.Elem()
713 mType := reflect.MapOf(vKeyType, vElemType)
714 vMap := reflect.MakeMap(mType)
715
716 err := d.decode(keyName, x.Interface(), vMap)
717 if err != nil {
718 return err
719 }
720
721 if squash {
722 for _, k := range vMap.MapKeys() {
723 valMap.SetMapIndex(k, vMap.MapIndex(k))
724 }
725 } else {
726 valMap.SetMapIndex(reflect.ValueOf(keyName), vMap)
727 }
728
729 default:
730 valMap.SetMapIndex(reflect.ValueOf(keyName), v)
731 }
732 }
733
734 if val.CanAddr() {
735 val.Set(valMap)
736 }
737
738 return nil
739 }
740
741 func (d *Decoder) decodePtr(name string, data interface{}, val reflect.Value) error {
742 // If the input data is nil, then we want to just set the output
743 // pointer to be nil as well.
744 isNil := data == nil
745 if !isNil {
746 switch v := reflect.Indirect(reflect.ValueOf(data)); v.Kind() {
747 case reflect.Chan,
748 reflect.Func,
749 reflect.Interface,
750 reflect.Map,
751 reflect.Ptr,
752 reflect.Slice:
753 isNil = v.IsNil()
754 }
755 }
756 if isNil {
757 if !val.IsNil() && val.CanSet() {
758 nilValue := reflect.New(val.Type()).Elem()
759 val.Set(nilValue)
760 }
761
762 return nil
763 }
764
765 // Create an element of the concrete (non pointer) type and decode
766 // into that. Then set the value of the pointer to this type.
767 valType := val.Type()
768 valElemType := valType.Elem()
769 if val.CanSet() {
770 realVal := val
771 if realVal.IsNil() || d.config.ZeroFields {
772 realVal = reflect.New(valElemType)
773 }
774
775 if err := d.decode(name, data, reflect.Indirect(realVal)); err != nil {
776 return err
777 }
778
779 val.Set(realVal)
780 } else {
781 if err := d.decode(name, data, reflect.Indirect(val)); err != nil {
782 return err
783 }
784 }
785 return nil
786 }
787
788 func (d *Decoder) decodeFunc(name string, data interface{}, val reflect.Value) error {
789 // Create an element of the concrete (non pointer) type and decode
790 // into that. Then set the value of the pointer to this type.
791 dataVal := reflect.Indirect(reflect.ValueOf(data))
792 if val.Type() != dataVal.Type() {
793 return fmt.Errorf(
794 "'%s' expected type '%s', got unconvertible type '%s'",
795 name, val.Type(), dataVal.Type())
796 }
797 val.Set(dataVal)
798 return nil
799 }
800
801 func (d *Decoder) decodeSlice(name string, data interface{}, val reflect.Value) error {
802 dataVal := reflect.Indirect(reflect.ValueOf(data))
803 dataValKind := dataVal.Kind()
804 valType := val.Type()
805 valElemType := valType.Elem()
806 sliceType := reflect.SliceOf(valElemType)
807
808 valSlice := val
809 if valSlice.IsNil() || d.config.ZeroFields {
810 if d.config.WeaklyTypedInput {
811 switch {
812 // Slice and array we use the normal logic
813 case dataValKind == reflect.Slice, dataValKind == reflect.Array:
814 break
815
816 // Empty maps turn into empty slices
817 case dataValKind == reflect.Map:
818 if dataVal.Len() == 0 {
819 val.Set(reflect.MakeSlice(sliceType, 0, 0))
820 return nil
821 }
822 // Create slice of maps of other sizes
823 return d.decodeSlice(name, []interface{}{data}, val)
824
825 case dataValKind == reflect.String && valElemType.Kind() == reflect.Uint8:
826 return d.decodeSlice(name, []byte(dataVal.String()), val)
827
828 // All other types we try to convert to the slice type
829 // and "lift" it into it. i.e. a string becomes a string slice.
830 default:
831 // Just re-try this function with data as a slice.
832 return d.decodeSlice(name, []interface{}{data}, val)
833 }
834 }
835
836 // Check input type
837 if dataValKind != reflect.Array && dataValKind != reflect.Slice {
838 return fmt.Errorf(
839 "'%s': source data must be an array or slice, got %s", name, dataValKind)
840
841 }
842
843 // If the input value is empty, then don't allocate since non-nil != nil
844 if dataVal.Len() == 0 {
845 return nil
846 }
847
848 // Make a new slice to hold our result, same size as the original data.
849 valSlice = reflect.MakeSlice(sliceType, dataVal.Len(), dataVal.Len())
850 }
851
852 // Accumulate any errors
853 errors := make([]string, 0)
854
855 for i := 0; i < dataVal.Len(); i++ {
856 currentData := dataVal.Index(i).Interface()
857 for valSlice.Len() <= i {
858 valSlice = reflect.Append(valSlice, reflect.Zero(valElemType))
859 }
860 currentField := valSlice.Index(i)
861
862 fieldName := fmt.Sprintf("%s[%d]", name, i)
863 if err := d.decode(fieldName, currentData, currentField); err != nil {
864 errors = appendErrors(errors, err)
865 }
866 }
867
868 // Finally, set the value to the slice we built up
869 val.Set(valSlice)
870
871 // If there were errors, we return those
872 if len(errors) > 0 {
873 return &Error{errors}
874 }
875
876 return nil
877 }
878
879 func (d *Decoder) decodeArray(name string, data interface{}, val reflect.Value) error {
880 dataVal := reflect.Indirect(reflect.ValueOf(data))
881 dataValKind := dataVal.Kind()
882 valType := val.Type()
883 valElemType := valType.Elem()
884 arrayType := reflect.ArrayOf(valType.Len(), valElemType)
885
886 valArray := val
887
888 if valArray.Interface() == reflect.Zero(valArray.Type()).Interface() || d.config.ZeroFields {
889 // Check input type
890 if dataValKind != reflect.Array && dataValKind != reflect.Slice {
891 if d.config.WeaklyTypedInput {
892 switch {
893 // Empty maps turn into empty arrays
894 case dataValKind == reflect.Map:
895 if dataVal.Len() == 0 {
896 val.Set(reflect.Zero(arrayType))
897 return nil
898 }
899
900 // All other types we try to convert to the array type
901 // and "lift" it into it. i.e. a string becomes a string array.
902 default:
903 // Just re-try this function with data as a slice.
904 return d.decodeArray(name, []interface{}{data}, val)
905 }
906 }
907
908 return fmt.Errorf(
909 "'%s': source data must be an array or slice, got %s", name, dataValKind)
910
911 }
912 if dataVal.Len() > arrayType.Len() {
913 return fmt.Errorf(
914 "'%s': expected source data to have length less or equal to %d, got %d", name, arrayType.Len(), dataVal.Len())
915
916 }
917
918 // Make a new array to hold our result, same size as the original data.
919 valArray = reflect.New(arrayType).Elem()
920 }
921
922 // Accumulate any errors
923 errors := make([]string, 0)
924
925 for i := 0; i < dataVal.Len(); i++ {
926 currentData := dataVal.Index(i).Interface()
927 currentField := valArray.Index(i)
928
929 fieldName := fmt.Sprintf("%s[%d]", name, i)
930 if err := d.decode(fieldName, currentData, currentField); err != nil {
931 errors = appendErrors(errors, err)
932 }
933 }
934
935 // Finally, set the value to the array we built up
936 val.Set(valArray)
937
938 // If there were errors, we return those
939 if len(errors) > 0 {
940 return &Error{errors}
941 }
942
943 return nil
944 }
945
946 func (d *Decoder) decodeStruct(name string, data interface{}, val reflect.Value) error {
947 dataVal := reflect.Indirect(reflect.ValueOf(data))
948
949 // If the type of the value to write to and the data match directly,
950 // then we just set it directly instead of recursing into the structure.
951 if dataVal.Type() == val.Type() {
952 val.Set(dataVal)
953 return nil
954 }
955
956 dataValKind := dataVal.Kind()
957 switch dataValKind {
958 case reflect.Map:
959 return d.decodeStructFromMap(name, dataVal, val)
960
961 case reflect.Struct:
962 // Not the most efficient way to do this but we can optimize later if
963 // we want to. To convert from struct to struct we go to map first
964 // as an intermediary.
965 m := make(map[string]interface{})
966 mval := reflect.Indirect(reflect.ValueOf(&m))
967 if err := d.decodeMapFromStruct(name, dataVal, mval, mval); err != nil {
968 return err
969 }
970
971 result := d.decodeStructFromMap(name, mval, val)
972 return result
973
974 default:
975 return fmt.Errorf("'%s' expected a map, got '%s'", name, dataVal.Kind())
976 }
977 }
978
979 func (d *Decoder) decodeStructFromMap(name string, dataVal, val reflect.Value) error {
980 dataValType := dataVal.Type()
981 if kind := dataValType.Key().Kind(); kind != reflect.String && kind != reflect.Interface {
982 return fmt.Errorf(
983 "'%s' needs a map with string keys, has '%s' keys",
984 name, dataValType.Key().Kind())
985 }
986
987 dataValKeys := make(map[reflect.Value]struct{})
988 dataValKeysUnused := make(map[interface{}]struct{})
989 for _, dataValKey := range dataVal.MapKeys() {
990 dataValKeys[dataValKey] = struct{}{}
991 dataValKeysUnused[dataValKey.Interface()] = struct{}{}
992 }
993
994 errors := make([]string, 0)
995
996 // This slice will keep track of all the structs we'll be decoding.
997 // There can be more than one struct if there are embedded structs
998 // that are squashed.
999 structs := make([]reflect.Value, 1, 5)
1000 structs[0] = val
1001
1002 // Compile the list of all the fields that we're going to be decoding
1003 // from all the structs.
1004 type field struct {
1005 field reflect.StructField
1006 val reflect.Value
1007 }
1008 fields := []field{}
1009 for len(structs) > 0 {
1010 structVal := structs[0]
1011 structs = structs[1:]
1012
1013 structType := structVal.Type()
1014
1015 for i := 0; i < structType.NumField(); i++ {
1016 fieldType := structType.Field(i)
1017 fieldKind := fieldType.Type.Kind()
1018
1019 // If "squash" is specified in the tag, we squash the field down.
1020 squash := false
1021 tagParts := strings.Split(fieldType.Tag.Get(d.config.TagName), ",")
1022 for _, tag := range tagParts[1:] {
1023 if tag == "squash" {
1024 squash = true
1025 break
1026 }
1027 }
1028
1029 if squash {
1030 if fieldKind != reflect.Struct {
1031 errors = appendErrors(errors,
1032 fmt.Errorf("%s: unsupported type for squash: %s", fieldType.Name, fieldKind))
1033 } else {
1034 structs = append(structs, structVal.FieldByName(fieldType.Name))
1035 }
1036 continue
1037 }
1038
1039 // Normal struct field, store it away
1040 fields = append(fields, field{fieldType, structVal.Field(i)})
1041 }
1042 }
1043
1044 // for fieldType, field := range fields {
1045 for _, f := range fields {
1046 field, fieldValue := f.field, f.val
1047 fieldName := field.Name
1048
1049 tagValue := field.Tag.Get(d.config.TagName)
1050 tagValue = strings.SplitN(tagValue, ",", 2)[0]
1051 if tagValue != "" {
1052 fieldName = tagValue
1053 }
1054
1055 rawMapKey := reflect.ValueOf(fieldName)
1056 rawMapVal := dataVal.MapIndex(rawMapKey)
1057 if !rawMapVal.IsValid() {
1058 // Do a slower search by iterating over each key and
1059 // doing case-insensitive search.
1060 for dataValKey := range dataValKeys {
1061 mK, ok := dataValKey.Interface().(string)
1062 if !ok {
1063 // Not a string key
1064 continue
1065 }
1066
1067 if strings.EqualFold(mK, fieldName) {
1068 rawMapKey = dataValKey
1069 rawMapVal = dataVal.MapIndex(dataValKey)
1070 break
1071 }
1072 }
1073
1074 if !rawMapVal.IsValid() {
1075 // There was no matching key in the map for the value in
1076 // the struct. Just ignore.
1077 continue
1078 }
1079 }
1080
1081 // Delete the key we're using from the unused map so we stop tracking
1082 delete(dataValKeysUnused, rawMapKey.Interface())
1083
1084 if !fieldValue.IsValid() {
1085 // This should never happen
1086 panic("field is not valid")
1087 }
1088
1089 // If we can't set the field, then it is unexported or something,
1090 // and we just continue onwards.
1091 if !fieldValue.CanSet() {
1092 continue
1093 }
1094
1095 // If the name is empty string, then we're at the root, and we
1096 // don't dot-join the fields.
1097 if name != "" {
1098 fieldName = fmt.Sprintf("%s.%s", name, fieldName)
1099 }
1100
1101 if err := d.decode(fieldName, rawMapVal.Interface(), fieldValue); err != nil {
1102 errors = appendErrors(errors, err)
1103 }
1104 }
1105
1106 if d.config.ErrorUnused && len(dataValKeysUnused) > 0 {
1107 keys := make([]string, 0, len(dataValKeysUnused))
1108 for rawKey := range dataValKeysUnused {
1109 keys = append(keys, rawKey.(string))
1110 }
1111 sort.Strings(keys)
1112
1113 err := fmt.Errorf("'%s' has invalid keys: %s", name, strings.Join(keys, ", "))
1114 errors = appendErrors(errors, err)
1115 }
1116
1117 if len(errors) > 0 {
1118 return &Error{errors}
1119 }
1120
1121 // Add the unused keys to the list of unused keys if we're tracking metadata
1122 if d.config.Metadata != nil {
1123 for rawKey := range dataValKeysUnused {
1124 key := rawKey.(string)
1125 if name != "" {
1126 key = fmt.Sprintf("%s.%s", name, key)
1127 }
1128
1129 d.config.Metadata.Unused = append(d.config.Metadata.Unused, key)
1130 }
1131 }
1132
1133 return nil
1134 }
1135
1136 func getKind(val reflect.Value) reflect.Kind {
1137 kind := val.Kind()
1138
1139 switch {
1140 case kind >= reflect.Int && kind <= reflect.Int64:
1141 return reflect.Int
1142 case kind >= reflect.Uint && kind <= reflect.Uint64:
1143 return reflect.Uint
1144 case kind >= reflect.Float32 && kind <= reflect.Float64:
1145 return reflect.Float32
1146 default:
1147 return kind
1148 }
1149 }