niki/vendor/github.com/mitchellh/mapstructure/mapstructure.go

// Package mapstructure exposes functionality to convert one arbitrary

// Go type into another, typically to convert a map[string]interface{}

// into a native Go structure.

//

// The Go structure can be arbitrarily complex, containing slices,

// other structs, etc. and the decoder will properly decode nested

// maps and so on into the proper structures in the native Go struct.

// See the examples to see what the decoder is capable of.

//

// The simplest function to start with is Decode.

//

// # Field Tags

//

// When decoding to a struct, mapstructure will use the field name by

// default to perform the mapping. For example, if a struct has a field

// "Username" then mapstructure will look for a key in the source value

// of "username" (case insensitive).

//

//	type User struct {

//	    Username string

//	}

//

// You can change the behavior of mapstructure by using struct tags.

// The default struct tag that mapstructure looks for is "mapstructure"

// but you can customize it using DecoderConfig.

//

// # Renaming Fields

//

// To rename the key that mapstructure looks for, use the "mapstructure"

// tag and set a value directly. For example, to change the "username" example

// above to "user":

//

//	type User struct {

//	    Username string `mapstructure:"user"`

//	}

//

// # Embedded Structs and Squashing

//

// Embedded structs are treated as if they're another field with that name.

// By default, the two structs below are equivalent when decoding with

// mapstructure:

//

//	type Person struct {

//	    Name string

//	}

//

//	type Friend struct {

//	    Person

//	}

//

//	type Friend struct {

//	    Person Person

//	}

//

// This would require an input that looks like below:

//

//	map[string]interface{}{

//	    "person": map[string]interface{}{"name": "alice"},

//	}

//

// If your "person" value is NOT nested, then you can append ",squash" to

// your tag value and mapstructure will treat it as if the embedded struct

// were part of the struct directly. Example:

//

//	type Friend struct {

//	    Person `mapstructure:",squash"`

//	}

//

// Now the following input would be accepted:

//

//	map[string]interface{}{

//	    "name": "alice",

//	}

//

// When decoding from a struct to a map, the squash tag squashes the struct

// fields into a single map. Using the example structs from above:

//

//	Friend{Person: Person{Name: "alice"}}

//

// Will be decoded into a map:

//

//	map[string]interface{}{

//	    "name": "alice",

//	}

//

// DecoderConfig has a field that changes the behavior of mapstructure

// to always squash embedded structs.

//

// # Remainder Values

//

// If there are any unmapped keys in the source value, mapstructure by

// default will silently ignore them. You can error by setting ErrorUnused

// in DecoderConfig. If you're using Metadata you can also maintain a slice

// of the unused keys.

//

// You can also use the ",remain" suffix on your tag to collect all unused

// values in a map. The field with this tag MUST be a map type and should

// probably be a "map[string]interface{}" or "map[interface{}]interface{}".

// See example below:

//

//	type Friend struct {

//	    Name  string

//	    Other map[string]interface{} `mapstructure:",remain"`

//	}

//

// Given the input below, Other would be populated with the other

// values that weren't used (everything but "name"):

//

//	map[string]interface{}{

//	    "name":    "bob",

//	    "address": "123 Maple St.",

//	}

//

// # Omit Empty Values

//

// When decoding from a struct to any other value, you may use the

// ",omitempty" suffix on your tag to omit that value if it equates to

// the zero value. The zero value of all types is specified in the Go

// specification.

//

// For example, the zero type of a numeric type is zero ("0"). If the struct

// field value is zero and a numeric type, the field is empty, and it won't

// be encoded into the destination type.

//

//	type Source struct {

//	    Age int `mapstructure:",omitempty"`

//	}

//

// # Unexported fields

//

// Since unexported (private) struct fields cannot be set outside the package

// where they are defined, the decoder will simply skip them.

//

// For this output type definition:

//

//	type Exported struct {

//	    private string // this unexported field will be skipped

//	    Public string

//	}

//

// Using this map as input:

//

//	map[string]interface{}{

//	    "private": "I will be ignored",

//	    "Public":  "I made it through!",

//	}

//

// The following struct will be decoded:

//

//	type Exported struct {

//	    private: "" // field is left with an empty string (zero value)

//	    Public: "I made it through!"

//	}

//

// # Other Configuration

//

// mapstructure is highly configurable. See the DecoderConfig struct

// for other features and options that are supported.

package mapstructure

import (
	"encoding/json"
	"errors"
	"fmt"
	"reflect"
	"sort"
	"strconv"
	"strings"
)

// DecodeHookFunc is the callback function that can be used for

// data transformations. See "DecodeHook" in the DecoderConfig

// struct.

//

// The type must be one of DecodeHookFuncType, DecodeHookFuncKind, or

// DecodeHookFuncValue.

// Values are a superset of Types (Values can return types), and Types are a

// superset of Kinds (Types can return Kinds) and are generally a richer thing

// to use, but Kinds are simpler if you only need those.

//

// The reason DecodeHookFunc is multi-typed is for backwards compatibility:

// we started with Kinds and then realized Types were the better solution,

// but have a promise to not break backwards compat so we now support

// both.

type DecodeHookFunc interface{}

// DecodeHookFuncType is a DecodeHookFunc which has complete information about

// the source and target types.

type DecodeHookFuncType func(reflect.Type, reflect.Type, interface{}) (interface{}, error)

// DecodeHookFuncKind is a DecodeHookFunc which knows only the Kinds of the

// source and target types.

type DecodeHookFuncKind func(reflect.Kind, reflect.Kind, interface{}) (interface{}, error)

// DecodeHookFuncValue is a DecodeHookFunc which has complete access to both the source and target

// values.

type DecodeHookFuncValue func(from reflect.Value, to reflect.Value) (interface{}, error)

// DecoderConfig is the configuration that is used to create a new decoder

// and allows customization of various aspects of decoding.

type DecoderConfig struct {

	// DecodeHook, if set, will be called before any decoding and any

	// type conversion (if WeaklyTypedInput is on). This lets you modify

	// the values before they're set down onto the resulting struct. The

	// DecodeHook is called for every map and value in the input. This means

	// that if a struct has embedded fields with squash tags the decode hook

	// is called only once with all of the input data, not once for each

	// embedded struct.

	//

	// If an error is returned, the entire decode will fail with that error.

	DecodeHook DecodeHookFunc

	// If ErrorUnused is true, then it is an error for there to exist

	// keys in the original map that were unused in the decoding process

	// (extra keys).

	ErrorUnused bool

	// If ErrorUnset is true, then it is an error for there to exist

	// fields in the result that were not set in the decoding process

	// (extra fields). This only applies to decoding to a struct. This

	// will affect all nested structs as well.

	ErrorUnset bool

	// ZeroFields, if set to true, will zero fields before writing them.

	// For example, a map will be emptied before decoded values are put in

	// it. If this is false, a map will be merged.

	ZeroFields bool

	// If WeaklyTypedInput is true, the decoder will make the following

	// "weak" conversions:

	//

	//   - bools to string (true = "1", false = "0")

	//   - numbers to string (base 10)

	//   - bools to int/uint (true = 1, false = 0)

	//   - strings to int/uint (base implied by prefix)

	//   - int to bool (true if value != 0)

	//   - string to bool (accepts: 1, t, T, TRUE, true, True, 0, f, F,

	//     FALSE, false, False. Anything else is an error)

	//   - empty array = empty map and vice versa

	//   - negative numbers to overflowed uint values (base 10)

	//   - slice of maps to a merged map

	//   - single values are converted to slices if required. Each

	//     element is weakly decoded. For example: "4" can become []int{4}

	//     if the target type is an int slice.

	//

	WeaklyTypedInput bool

	// Squash will squash embedded structs.  A squash tag may also be

	// added to an individual struct field using a tag.  For example:

	//

	//  type Parent struct {

	//      Child `mapstructure:",squash"`

	//  }

	Squash bool

	// Metadata is the struct that will contain extra metadata about

	// the decoding. If this is nil, then no metadata will be tracked.

	Metadata *Metadata

	// Result is a pointer to the struct that will contain the decoded

	// value.

	Result interface{}

	// The tag name that mapstructure reads for field names. This

	// defaults to "mapstructure"

	TagName string

	// IgnoreUntaggedFields ignores all struct fields without explicit

	// TagName, comparable to `mapstructure:"-"` as default behaviour.

	IgnoreUntaggedFields bool

	// MatchName is the function used to match the map key to the struct

	// field name or tag. Defaults to `strings.EqualFold`. This can be used

	// to implement case-sensitive tag values, support snake casing, etc.

	MatchName func(mapKey, fieldName string) bool
}

// A Decoder takes a raw interface value and turns it into structured

// data, keeping track of rich error information along the way in case

// anything goes wrong. Unlike the basic top-level Decode method, you can

// more finely control how the Decoder behaves using the DecoderConfig

// structure. The top-level Decode method is just a convenience that sets

// up the most basic Decoder.

type Decoder struct {
	config *DecoderConfig
}

// Metadata contains information about decoding a structure that

// is tedious or difficult to get otherwise.

type Metadata struct {

	// Keys are the keys of the structure which were successfully decoded

	Keys []string

	// Unused is a slice of keys that were found in the raw value but

	// weren't decoded since there was no matching field in the result interface

	Unused []string

	// Unset is a slice of field names that were found in the result interface

	// but weren't set in the decoding process since there was no matching value

	// in the input

	Unset []string
}

// Decode takes an input structure and uses reflection to translate it to

// the output structure. output must be a pointer to a map or struct.

func Decode(input interface{}, output interface{}) error {

	config := &DecoderConfig{

		Metadata: nil,

		Result: output,
	}

	decoder, err := NewDecoder(config)

	if err != nil {

		return err

	}

	return decoder.Decode(input)

}

// WeakDecode is the same as Decode but is shorthand to enable

// WeaklyTypedInput. See DecoderConfig for more info.

func WeakDecode(input, output interface{}) error {

	config := &DecoderConfig{

		Metadata: nil,

		Result: output,

		WeaklyTypedInput: true,
	}

	decoder, err := NewDecoder(config)

	if err != nil {

		return err

	}

	return decoder.Decode(input)

}

// DecodeMetadata is the same as Decode, but is shorthand to

// enable metadata collection. See DecoderConfig for more info.

func DecodeMetadata(input interface{}, output interface{}, metadata *Metadata) error {

	config := &DecoderConfig{

		Metadata: metadata,

		Result: output,
	}

	decoder, err := NewDecoder(config)

	if err != nil {

		return err

	}

	return decoder.Decode(input)

}

// WeakDecodeMetadata is the same as Decode, but is shorthand to

// enable both WeaklyTypedInput and metadata collection. See

// DecoderConfig for more info.

func WeakDecodeMetadata(input interface{}, output interface{}, metadata *Metadata) error {

	config := &DecoderConfig{

		Metadata: metadata,

		Result: output,

		WeaklyTypedInput: true,
	}

	decoder, err := NewDecoder(config)

	if err != nil {

		return err

	}

	return decoder.Decode(input)

}

// NewDecoder returns a new decoder for the given configuration. Once

// a decoder has been returned, the same configuration must not be used

// again.

func NewDecoder(config *DecoderConfig) (*Decoder, error) {

	val := reflect.ValueOf(config.Result)

	if val.Kind() != reflect.Ptr {

		return nil, errors.New("result must be a pointer")

	}

	val = val.Elem()

	if !val.CanAddr() {

		return nil, errors.New("result must be addressable (a pointer)")

	}

	if config.Metadata != nil {

		if config.Metadata.Keys == nil {

			config.Metadata.Keys = make([]string, 0)

		}

		if config.Metadata.Unused == nil {

			config.Metadata.Unused = make([]string, 0)

		}

		if config.Metadata.Unset == nil {

			config.Metadata.Unset = make([]string, 0)

		}

	}

	if config.TagName == "" {

		config.TagName = "mapstructure"

	}

	if config.MatchName == nil {

		config.MatchName = strings.EqualFold

	}

	result := &Decoder{

		config: config,
	}

	return result, nil

}

// Decode decodes the given raw interface to the target pointer specified

// by the configuration.

func (d *Decoder) Decode(input interface{}) error {

	return d.decode("", input, reflect.ValueOf(d.config.Result).Elem())

}

// Decodes an unknown data type into a specific reflection value.

func (d *Decoder) decode(name string, input interface{}, outVal reflect.Value) error {

	var inputVal reflect.Value

	if input != nil {

		inputVal = reflect.ValueOf(input)

		// We need to check here if input is a typed nil. Typed nils won't

		// match the "input == nil" below so we check that here.

		if inputVal.Kind() == reflect.Ptr && inputVal.IsNil() {

			input = nil

		}

	}

	if input == nil {

		// If the data is nil, then we don't set anything, unless ZeroFields is set

		// to true.

		if d.config.ZeroFields {

			outVal.Set(reflect.Zero(outVal.Type()))

			if d.config.Metadata != nil && name != "" {

				d.config.Metadata.Keys = append(d.config.Metadata.Keys, name)

			}

		}

		return nil

	}

	if !inputVal.IsValid() {

		// If the input value is invalid, then we just set the value

		// to be the zero value.

		outVal.Set(reflect.Zero(outVal.Type()))

		if d.config.Metadata != nil && name != "" {

			d.config.Metadata.Keys = append(d.config.Metadata.Keys, name)

		}

		return nil

	}

	if d.config.DecodeHook != nil {

		// We have a DecodeHook, so let's pre-process the input.

		var err error

		input, err = DecodeHookExec(d.config.DecodeHook, inputVal, outVal)

		if err != nil {

			return fmt.Errorf("error decoding '%s': %s", name, err)

		}

	}

	var err error

	outputKind := getKind(outVal)

	addMetaKey := true

	switch outputKind {

	case reflect.Bool:

		err = d.decodeBool(name, input, outVal)

	case reflect.Interface:

		err = d.decodeBasic(name, input, outVal)

	case reflect.String:

		err = d.decodeString(name, input, outVal)

	case reflect.Int:

		err = d.decodeInt(name, input, outVal)

	case reflect.Uint:

		err = d.decodeUint(name, input, outVal)

	case reflect.Float32:

		err = d.decodeFloat(name, input, outVal)

	case reflect.Struct:

		err = d.decodeStruct(name, input, outVal)

	case reflect.Map:

		err = d.decodeMap(name, input, outVal)

	case reflect.Ptr:

		addMetaKey, err = d.decodePtr(name, input, outVal)

	case reflect.Slice:

		err = d.decodeSlice(name, input, outVal)

	case reflect.Array:

		err = d.decodeArray(name, input, outVal)

	case reflect.Func:

		err = d.decodeFunc(name, input, outVal)

	default:

		// If we reached this point then we weren't able to decode it

		return fmt.Errorf("%s: unsupported type: %s", name, outputKind)

	}

	// If we reached here, then we successfully decoded SOMETHING, so

	// mark the key as used if we're tracking metainput.

	if addMetaKey && d.config.Metadata != nil && name != "" {

		d.config.Metadata.Keys = append(d.config.Metadata.Keys, name)

	}

	return err

}

// This decodes a basic type (bool, int, string, etc.) and sets the

// value to "data" of that type.

func (d *Decoder) decodeBasic(name string, data interface{}, val reflect.Value) error {

	if val.IsValid() && val.Elem().IsValid() {

		elem := val.Elem()

		// If we can't address this element, then its not writable. Instead,

		// we make a copy of the value (which is a pointer and therefore

		// writable), decode into that, and replace the whole value.

		copied := false

		if !elem.CanAddr() {

			copied = true

			// Make *T

			copy := reflect.New(elem.Type())

			// *T = elem

			copy.Elem().Set(elem)

			// Set elem so we decode into it

			elem = copy

		}

		// Decode. If we have an error then return. We also return right

		// away if we're not a copy because that means we decoded directly.

		if err := d.decode(name, data, elem); err != nil || !copied {

			return err

		}

		// If we're a copy, we need to set te final result

		val.Set(elem.Elem())

		return nil

	}

	dataVal := reflect.ValueOf(data)

	// If the input data is a pointer, and the assigned type is the dereference

	// of that exact pointer, then indirect it so that we can assign it.

	// Example: *string to string

	if dataVal.Kind() == reflect.Ptr && dataVal.Type().Elem() == val.Type() {

		dataVal = reflect.Indirect(dataVal)

	}

	if !dataVal.IsValid() {

		dataVal = reflect.Zero(val.Type())

	}

	dataValType := dataVal.Type()

	if !dataValType.AssignableTo(val.Type()) {

		return fmt.Errorf(

			"'%s' expected type '%s', got '%s'",

			name, val.Type(), dataValType)

	}

	val.Set(dataVal)

	return nil

}

func (d *Decoder) decodeString(name string, data interface{}, val reflect.Value) error {

	dataVal := reflect.Indirect(reflect.ValueOf(data))

	dataKind := getKind(dataVal)

	converted := true

	switch {

	case dataKind == reflect.String:

		val.SetString(dataVal.String())

	case dataKind == reflect.Bool && d.config.WeaklyTypedInput:

		if dataVal.Bool() {

			val.SetString("1")

		} else {

			val.SetString("0")

		}

	case dataKind == reflect.Int && d.config.WeaklyTypedInput:

		val.SetString(strconv.FormatInt(dataVal.Int(), 10))

	case dataKind == reflect.Uint && d.config.WeaklyTypedInput:

		val.SetString(strconv.FormatUint(dataVal.Uint(), 10))

	case dataKind == reflect.Float32 && d.config.WeaklyTypedInput:

		val.SetString(strconv.FormatFloat(dataVal.Float(), 'f', -1, 64))

	case dataKind == reflect.Slice && d.config.WeaklyTypedInput,

		dataKind == reflect.Array && d.config.WeaklyTypedInput:

		dataType := dataVal.Type()

		elemKind := dataType.Elem().Kind()

		switch elemKind {

		case reflect.Uint8:

			var uints []uint8

			if dataKind == reflect.Array {

				uints = make([]uint8, dataVal.Len(), dataVal.Len())

				for i := range uints {

					uints[i] = dataVal.Index(i).Interface().(uint8)

				}

			} else {

				uints = dataVal.Interface().([]uint8)

			}

			val.SetString(string(uints))

		default:

			converted = false

		}

	default:

		converted = false

	}

	if !converted {

		return fmt.Errorf(

			"'%s' expected type '%s', got unconvertible type '%s', value: '%v'",

			name, val.Type(), dataVal.Type(), data)

	}

	return nil

}

func (d *Decoder) decodeInt(name string, data interface{}, val reflect.Value) error {

	dataVal := reflect.Indirect(reflect.ValueOf(data))

	dataKind := getKind(dataVal)

	dataType := dataVal.Type()

	switch {

	case dataKind == reflect.Int:

		val.SetInt(dataVal.Int())

	case dataKind == reflect.Uint:

		val.SetInt(int64(dataVal.Uint()))

	case dataKind == reflect.Float32:

		val.SetInt(int64(dataVal.Float()))

	case dataKind == reflect.Bool && d.config.WeaklyTypedInput:

		if dataVal.Bool() {

			val.SetInt(1)

		} else {

			val.SetInt(0)

		}

	case dataKind == reflect.String && d.config.WeaklyTypedInput:

		str := dataVal.String()

		if str == "" {

			str = "0"

		}

		i, err := strconv.ParseInt(str, 0, val.Type().Bits())

		if err == nil {

			val.SetInt(i)

		} else {

			return fmt.Errorf("cannot parse '%s' as int: %s", name, err)

		}

	case dataType.PkgPath() == "encoding/json" && dataType.Name() == "Number":

		jn := data.(json.Number)

		i, err := jn.Int64()

		if err != nil {

			return fmt.Errorf(

				"error decoding json.Number into %s: %s", name, err)

		}

		val.SetInt(i)

	default:

		return fmt.Errorf(

			"'%s' expected type '%s', got unconvertible type '%s', value: '%v'",

			name, val.Type(), dataVal.Type(), data)

	}

	return nil

}

func (d *Decoder) decodeUint(name string, data interface{}, val reflect.Value) error {

	dataVal := reflect.Indirect(reflect.ValueOf(data))

	dataKind := getKind(dataVal)

	dataType := dataVal.Type()

	switch {

	case dataKind == reflect.Int:

		i := dataVal.Int()

		if i < 0 && !d.config.WeaklyTypedInput {

			return fmt.Errorf("cannot parse '%s', %d overflows uint",

				name, i)

		}

		val.SetUint(uint64(i))

	case dataKind == reflect.Uint:

		val.SetUint(dataVal.Uint())

	case dataKind == reflect.Float32:

		f := dataVal.Float()

		if f < 0 && !d.config.WeaklyTypedInput {

			return fmt.Errorf("cannot parse '%s', %f overflows uint",

				name, f)

		}

		val.SetUint(uint64(f))

	case dataKind == reflect.Bool && d.config.WeaklyTypedInput:

		if dataVal.Bool() {

			val.SetUint(1)

		} else {

			val.SetUint(0)

		}

	case dataKind == reflect.String && d.config.WeaklyTypedInput:

		str := dataVal.String()

		if str == "" {

			str = "0"

		}

		i, err := strconv.ParseUint(str, 0, val.Type().Bits())

		if err == nil {

			val.SetUint(i)

		} else {

			return fmt.Errorf("cannot parse '%s' as uint: %s", name, err)

		}

	case dataType.PkgPath() == "encoding/json" && dataType.Name() == "Number":

		jn := data.(json.Number)

		i, err := strconv.ParseUint(string(jn), 0, 64)

		if err != nil {

			return fmt.Errorf(

				"error decoding json.Number into %s: %s", name, err)

		}

		val.SetUint(i)

	default:

		return fmt.Errorf(

			"'%s' expected type '%s', got unconvertible type '%s', value: '%v'",

			name, val.Type(), dataVal.Type(), data)

	}

	return nil

}

func (d *Decoder) decodeBool(name string, data interface{}, val reflect.Value) error {

	dataVal := reflect.Indirect(reflect.ValueOf(data))

	dataKind := getKind(dataVal)

	switch {

	case dataKind == reflect.Bool:

		val.SetBool(dataVal.Bool())

	case dataKind == reflect.Int && d.config.WeaklyTypedInput:

		val.SetBool(dataVal.Int() != 0)

	case dataKind == reflect.Uint && d.config.WeaklyTypedInput:

		val.SetBool(dataVal.Uint() != 0)

	case dataKind == reflect.Float32 && d.config.WeaklyTypedInput:

		val.SetBool(dataVal.Float() != 0)

	case dataKind == reflect.String && d.config.WeaklyTypedInput:

		b, err := strconv.ParseBool(dataVal.String())

		if err == nil {

			val.SetBool(b)

		} else if dataVal.String() == "" {

			val.SetBool(false)

		} else {

			return fmt.Errorf("cannot parse '%s' as bool: %s", name, err)

		}

	default:

		return fmt.Errorf(

			"'%s' expected type '%s', got unconvertible type '%s', value: '%v'",

			name, val.Type(), dataVal.Type(), data)

	}

	return nil

}

func (d *Decoder) decodeFloat(name string, data interface{}, val reflect.Value) error {

	dataVal := reflect.Indirect(reflect.ValueOf(data))

	dataKind := getKind(dataVal)

	dataType := dataVal.Type()

	switch {

	case dataKind == reflect.Int:

		val.SetFloat(float64(dataVal.Int()))

	case dataKind == reflect.Uint:

		val.SetFloat(float64(dataVal.Uint()))

	case dataKind == reflect.Float32:

		val.SetFloat(dataVal.Float())

	case dataKind == reflect.Bool && d.config.WeaklyTypedInput:

		if dataVal.Bool() {

			val.SetFloat(1)

		} else {

			val.SetFloat(0)

		}

	case dataKind == reflect.String && d.config.WeaklyTypedInput:

		str := dataVal.String()

		if str == "" {

			str = "0"

		}

		f, err := strconv.ParseFloat(str, val.Type().Bits())

		if err == nil {

			val.SetFloat(f)

		} else {

			return fmt.Errorf("cannot parse '%s' as float: %s", name, err)

		}

	case dataType.PkgPath() == "encoding/json" && dataType.Name() == "Number":

		jn := data.(json.Number)

		i, err := jn.Float64()

		if err != nil {

			return fmt.Errorf(

				"error decoding json.Number into %s: %s", name, err)

		}

		val.SetFloat(i)

	default:

		return fmt.Errorf(

			"'%s' expected type '%s', got unconvertible type '%s', value: '%v'",

			name, val.Type(), dataVal.Type(), data)

	}

	return nil

}

func (d *Decoder) decodeMap(name string, data interface{}, val reflect.Value) error {

	valType := val.Type()

	valKeyType := valType.Key()

	valElemType := valType.Elem()

	// By default we overwrite keys in the current map

	valMap := val

	// If the map is nil or we're purposely zeroing fields, make a new map

	if valMap.IsNil() || d.config.ZeroFields {

		// Make a new map to hold our result

		mapType := reflect.MapOf(valKeyType, valElemType)

		valMap = reflect.MakeMap(mapType)

	}

	// Check input type and based on the input type jump to the proper func

	dataVal := reflect.Indirect(reflect.ValueOf(data))

	switch dataVal.Kind() {

	case reflect.Map:

		return d.decodeMapFromMap(name, dataVal, val, valMap)

	case reflect.Struct:

		return d.decodeMapFromStruct(name, dataVal, val, valMap)

	case reflect.Array, reflect.Slice:

		if d.config.WeaklyTypedInput {

			return d.decodeMapFromSlice(name, dataVal, val, valMap)

		}

		fallthrough

	default:

		return fmt.Errorf("'%s' expected a map, got '%s'", name, dataVal.Kind())

	}

}

func (d *Decoder) decodeMapFromSlice(name string, dataVal reflect.Value, val reflect.Value, valMap reflect.Value) error {

	// Special case for BC reasons (covered by tests)

	if dataVal.Len() == 0 {

		val.Set(valMap)

		return nil

	}

	for i := 0; i < dataVal.Len(); i++ {

		err := d.decode(

			name+"["+strconv.Itoa(i)+"]",

			dataVal.Index(i).Interface(), val)

		if err != nil {

			return err

		}

	}

	return nil

}

func (d *Decoder) decodeMapFromMap(name string, dataVal reflect.Value, val reflect.Value, valMap reflect.Value) error {

	valType := val.Type()

	valKeyType := valType.Key()

	valElemType := valType.Elem()

	// Accumulate errors

	errors := make([]string, 0)

	// If the input data is empty, then we just match what the input data is.

	if dataVal.Len() == 0 {

		if dataVal.IsNil() {

			if !val.IsNil() {

				val.Set(dataVal)

			}

		} else {

			// Set to empty allocated value

			val.Set(valMap)

		}

		return nil

	}

	for _, k := range dataVal.MapKeys() {

		fieldName := name + "[" + k.String() + "]"

		// First decode the key into the proper type

		currentKey := reflect.Indirect(reflect.New(valKeyType))

		if err := d.decode(fieldName, k.Interface(), currentKey); err != nil {

			errors = appendErrors(errors, err)

			continue

		}

		// Next decode the data into the proper type

		v := dataVal.MapIndex(k).Interface()

		currentVal := reflect.Indirect(reflect.New(valElemType))

		if err := d.decode(fieldName, v, currentVal); err != nil {

			errors = appendErrors(errors, err)

			continue

		}

		valMap.SetMapIndex(currentKey, currentVal)

	}

	// Set the built up map to the value

	val.Set(valMap)

	// If we had errors, return those

	if len(errors) > 0 {

		return &Error{errors}

	}

	return nil

}

func (d *Decoder) decodeMapFromStruct(name string, dataVal reflect.Value, val reflect.Value, valMap reflect.Value) error {

	typ := dataVal.Type()

	for i := 0; i < typ.NumField(); i++ {

		// Get the StructField first since this is a cheap operation. If the

		// field is unexported, then ignore it.

		f := typ.Field(i)

		if f.PkgPath != "" {

			continue

		}

		// Next get the actual value of this field and verify it is assignable

		// to the map value.

		v := dataVal.Field(i)

		if !v.Type().AssignableTo(valMap.Type().Elem()) {

			return fmt.Errorf("cannot assign type '%s' to map value field of type '%s'", v.Type(), valMap.Type().Elem())

		}

		tagValue := f.Tag.Get(d.config.TagName)

		keyName := f.Name

		if tagValue == "" && d.config.IgnoreUntaggedFields {

			continue

		}

		// If Squash is set in the config, we squash the field down.

		squash := d.config.Squash && v.Kind() == reflect.Struct && f.Anonymous

		v = dereferencePtrToStructIfNeeded(v, d.config.TagName)

		// Determine the name of the key in the map

		if index := strings.Index(tagValue, ","); index != -1 {

			if tagValue[:index] == "-" {

				continue

			}

			// If "omitempty" is specified in the tag, it ignores empty values.

			if strings.Index(tagValue[index+1:], "omitempty") != -1 && isEmptyValue(v) {

				continue

			}

			// If "squash" is specified in the tag, we squash the field down.

			squash = squash || strings.Index(tagValue[index+1:], "squash") != -1

			if squash {

				// When squashing, the embedded type can be a pointer to a struct.

				if v.Kind() == reflect.Ptr && v.Elem().Kind() == reflect.Struct {

					v = v.Elem()

				}

				// The final type must be a struct

				if v.Kind() != reflect.Struct {

					return fmt.Errorf("cannot squash non-struct type '%s'", v.Type())

				}

			}

			if keyNameTagValue := tagValue[:index]; keyNameTagValue != "" {

				keyName = keyNameTagValue

			}

		} else if len(tagValue) > 0 {

			if tagValue == "-" {

				continue

			}

			keyName = tagValue

		}

		switch v.Kind() {

		// this is an embedded struct, so handle it differently

		case reflect.Struct:

			x := reflect.New(v.Type())

			x.Elem().Set(v)

			vType := valMap.Type()

			vKeyType := vType.Key()

			vElemType := vType.Elem()

			mType := reflect.MapOf(vKeyType, vElemType)

			vMap := reflect.MakeMap(mType)

			// Creating a pointer to a map so that other methods can completely

			// overwrite the map if need be (looking at you decodeMapFromMap). The

			// indirection allows the underlying map to be settable (CanSet() == true)

			// where as reflect.MakeMap returns an unsettable map.

			addrVal := reflect.New(vMap.Type())

			reflect.Indirect(addrVal).Set(vMap)

			err := d.decode(keyName, x.Interface(), reflect.Indirect(addrVal))

			if err != nil {

				return err

			}

			// the underlying map may have been completely overwritten so pull

			// it indirectly out of the enclosing value.

			vMap = reflect.Indirect(addrVal)

			if squash {

				for _, k := range vMap.MapKeys() {

					valMap.SetMapIndex(k, vMap.MapIndex(k))

				}

			} else {

				valMap.SetMapIndex(reflect.ValueOf(keyName), vMap)

			}

		default:

			valMap.SetMapIndex(reflect.ValueOf(keyName), v)

		}

	}

	if val.CanAddr() {

		val.Set(valMap)

	}

	return nil

}

func (d *Decoder) decodePtr(name string, data interface{}, val reflect.Value) (bool, error) {

	// If the input data is nil, then we want to just set the output

	// pointer to be nil as well.

	isNil := data == nil

	if !isNil {

		switch v := reflect.Indirect(reflect.ValueOf(data)); v.Kind() {

		case reflect.Chan,

			reflect.Func,

			reflect.Interface,

			reflect.Map,

			reflect.Ptr,

			reflect.Slice:

			isNil = v.IsNil()

		}

	}

	if isNil {

		if !val.IsNil() && val.CanSet() {

			nilValue := reflect.New(val.Type()).Elem()

			val.Set(nilValue)

		}

		return true, nil

	}

	// Create an element of the concrete (non pointer) type and decode

	// into that. Then set the value of the pointer to this type.

	valType := val.Type()

	valElemType := valType.Elem()

	if val.CanSet() {

		realVal := val

		if realVal.IsNil() || d.config.ZeroFields {

			realVal = reflect.New(valElemType)

		}

		if err := d.decode(name, data, reflect.Indirect(realVal)); err != nil {

			return false, err

		}

		val.Set(realVal)

	} else {

		if err := d.decode(name, data, reflect.Indirect(val)); err != nil {

			return false, err

		}

	}

	return false, nil

}

func (d *Decoder) decodeFunc(name string, data interface{}, val reflect.Value) error {

	// Create an element of the concrete (non pointer) type and decode

	// into that. Then set the value of the pointer to this type.

	dataVal := reflect.Indirect(reflect.ValueOf(data))

	if val.Type() != dataVal.Type() {

		return fmt.Errorf(

			"'%s' expected type '%s', got unconvertible type '%s', value: '%v'",

			name, val.Type(), dataVal.Type(), data)

	}

	val.Set(dataVal)

	return nil

}

func (d *Decoder) decodeSlice(name string, data interface{}, val reflect.Value) error {

	dataVal := reflect.Indirect(reflect.ValueOf(data))

	dataValKind := dataVal.Kind()

	valType := val.Type()

	valElemType := valType.Elem()

	sliceType := reflect.SliceOf(valElemType)

	// If we have a non array/slice type then we first attempt to convert.

	if dataValKind != reflect.Array && dataValKind != reflect.Slice {

		if d.config.WeaklyTypedInput {

			switch {

			// Slice and array we use the normal logic

			case dataValKind == reflect.Slice, dataValKind == reflect.Array:

				break

			// Empty maps turn into empty slices

			case dataValKind == reflect.Map:

				if dataVal.Len() == 0 {

					val.Set(reflect.MakeSlice(sliceType, 0, 0))

					return nil

				}

				// Create slice of maps of other sizes

				return d.decodeSlice(name, []interface{}{data}, val)

			case dataValKind == reflect.String && valElemType.Kind() == reflect.Uint8:

				return d.decodeSlice(name, []byte(dataVal.String()), val)

			// All other types we try to convert to the slice type

			// and "lift" it into it. i.e. a string becomes a string slice.

			default:

				// Just re-try this function with data as a slice.

				return d.decodeSlice(name, []interface{}{data}, val)

			}

		}

		return fmt.Errorf(

			"'%s': source data must be an array or slice, got %s", name, dataValKind)

	}

	// If the input value is nil, then don't allocate since empty != nil

	if dataValKind != reflect.Array && dataVal.IsNil() {

		return nil

	}

	valSlice := val

	if valSlice.IsNil() || d.config.ZeroFields {

		// Make a new slice to hold our result, same size as the original data.

		valSlice = reflect.MakeSlice(sliceType, dataVal.Len(), dataVal.Len())

	}

	// Accumulate any errors

	errors := make([]string, 0)

	for i := 0; i < dataVal.Len(); i++ {

		currentData := dataVal.Index(i).Interface()

		for valSlice.Len() <= i {

			valSlice = reflect.Append(valSlice, reflect.Zero(valElemType))

		}

		currentField := valSlice.Index(i)

		fieldName := name + "[" + strconv.Itoa(i) + "]"

		if err := d.decode(fieldName, currentData, currentField); err != nil {

			errors = appendErrors(errors, err)

		}

	}

	// Finally, set the value to the slice we built up

	val.Set(valSlice)

	// If there were errors, we return those

	if len(errors) > 0 {

		return &Error{errors}

	}

	return nil

}

func (d *Decoder) decodeArray(name string, data interface{}, val reflect.Value) error {

	dataVal := reflect.Indirect(reflect.ValueOf(data))

	dataValKind := dataVal.Kind()

	valType := val.Type()

	valElemType := valType.Elem()

	arrayType := reflect.ArrayOf(valType.Len(), valElemType)

	valArray := val

	if valArray.Interface() == reflect.Zero(valArray.Type()).Interface() || d.config.ZeroFields {

		// Check input type

		if dataValKind != reflect.Array && dataValKind != reflect.Slice {

			if d.config.WeaklyTypedInput {

				switch {

				// Empty maps turn into empty arrays

				case dataValKind == reflect.Map:

					if dataVal.Len() == 0 {

						val.Set(reflect.Zero(arrayType))

						return nil

					}

				// All other types we try to convert to the array type

				// and "lift" it into it. i.e. a string becomes a string array.

				default:

					// Just re-try this function with data as a slice.

					return d.decodeArray(name, []interface{}{data}, val)

				}

			}

			return fmt.Errorf(

				"'%s': source data must be an array or slice, got %s", name, dataValKind)

		}

		if dataVal.Len() > arrayType.Len() {

			return fmt.Errorf(

				"'%s': expected source data to have length less or equal to %d, got %d", name, arrayType.Len(), dataVal.Len())

		}

		// Make a new array to hold our result, same size as the original data.

		valArray = reflect.New(arrayType).Elem()

	}

	// Accumulate any errors

	errors := make([]string, 0)

	for i := 0; i < dataVal.Len(); i++ {

		currentData := dataVal.Index(i).Interface()

		currentField := valArray.Index(i)

		fieldName := name + "[" + strconv.Itoa(i) + "]"

		if err := d.decode(fieldName, currentData, currentField); err != nil {

			errors = appendErrors(errors, err)

		}

	}

	// Finally, set the value to the array we built up

	val.Set(valArray)

	// If there were errors, we return those

	if len(errors) > 0 {

		return &Error{errors}

	}

	return nil

}

func (d *Decoder) decodeStruct(name string, data interface{}, val reflect.Value) error {

	dataVal := reflect.Indirect(reflect.ValueOf(data))

	// If the type of the value to write to and the data match directly,

	// then we just set it directly instead of recursing into the structure.

	if dataVal.Type() == val.Type() {

		val.Set(dataVal)

		return nil

	}

	dataValKind := dataVal.Kind()

	switch dataValKind {

	case reflect.Map:

		return d.decodeStructFromMap(name, dataVal, val)

	case reflect.Struct:

		// Not the most efficient way to do this but we can optimize later if

		// we want to. To convert from struct to struct we go to map first

		// as an intermediary.

		// Make a new map to hold our result

		mapType := reflect.TypeOf((map[string]interface{})(nil))

		mval := reflect.MakeMap(mapType)

		// Creating a pointer to a map so that other methods can completely

		// overwrite the map if need be (looking at you decodeMapFromMap). The

		// indirection allows the underlying map to be settable (CanSet() == true)

		// where as reflect.MakeMap returns an unsettable map.

		addrVal := reflect.New(mval.Type())

		reflect.Indirect(addrVal).Set(mval)

		if err := d.decodeMapFromStruct(name, dataVal, reflect.Indirect(addrVal), mval); err != nil {

			return err

		}

		result := d.decodeStructFromMap(name, reflect.Indirect(addrVal), val)

		return result

	default:

		return fmt.Errorf("'%s' expected a map, got '%s'", name, dataVal.Kind())

	}

}

func (d *Decoder) decodeStructFromMap(name string, dataVal, val reflect.Value) error {

	dataValType := dataVal.Type()

	if kind := dataValType.Key().Kind(); kind != reflect.String && kind != reflect.Interface {

		return fmt.Errorf(

			"'%s' needs a map with string keys, has '%s' keys",

			name, dataValType.Key().Kind())

	}

	dataValKeys := make(map[reflect.Value]struct{})

	dataValKeysUnused := make(map[interface{}]struct{})

	for _, dataValKey := range dataVal.MapKeys() {

		dataValKeys[dataValKey] = struct{}{}

		dataValKeysUnused[dataValKey.Interface()] = struct{}{}

	}

	targetValKeysUnused := make(map[interface{}]struct{})

	errors := make([]string, 0)

	// This slice will keep track of all the structs we'll be decoding.

	// There can be more than one struct if there are embedded structs

	// that are squashed.

	structs := make([]reflect.Value, 1, 5)

	structs[0] = val

	// Compile the list of all the fields that we're going to be decoding

	// from all the structs.

	type field struct {
		field reflect.StructField

		val reflect.Value
	}

	// remainField is set to a valid field set with the "remain" tag if

	// we are keeping track of remaining values.

	var remainField *field

	fields := []field{}

	for len(structs) > 0 {

		structVal := structs[0]

		structs = structs[1:]

		structType := structVal.Type()

		for i := 0; i < structType.NumField(); i++ {

			fieldType := structType.Field(i)

			fieldVal := structVal.Field(i)

			if fieldVal.Kind() == reflect.Ptr && fieldVal.Elem().Kind() == reflect.Struct {

				// Handle embedded struct pointers as embedded structs.

				fieldVal = fieldVal.Elem()

			}

			// If "squash" is specified in the tag, we squash the field down.

			squash := d.config.Squash && fieldVal.Kind() == reflect.Struct && fieldType.Anonymous

			remain := false

			// We always parse the tags cause we're looking for other tags too

			tagParts := strings.Split(fieldType.Tag.Get(d.config.TagName), ",")

			for _, tag := range tagParts[1:] {

				if tag == "squash" {

					squash = true

					break

				}

				if tag == "remain" {

					remain = true

					break

				}

			}

			if squash {

				if fieldVal.Kind() != reflect.Struct {

					errors = appendErrors(errors,

						fmt.Errorf("%s: unsupported type for squash: %s", fieldType.Name, fieldVal.Kind()))

				} else {

					structs = append(structs, fieldVal)

				}

				continue

			}

			// Build our field

			if remain {

				remainField = &field{fieldType, fieldVal}

			} else {

				// Normal struct field, store it away

				fields = append(fields, field{fieldType, fieldVal})

			}

		}

	}

	// for fieldType, field := range fields {

	for _, f := range fields {

		field, fieldValue := f.field, f.val

		fieldName := field.Name

		tagValue := field.Tag.Get(d.config.TagName)

		tagValue = strings.SplitN(tagValue, ",", 2)[0]

		if tagValue != "" {

			fieldName = tagValue

		}

		rawMapKey := reflect.ValueOf(fieldName)

		rawMapVal := dataVal.MapIndex(rawMapKey)

		if !rawMapVal.IsValid() {

			// Do a slower search by iterating over each key and

			// doing case-insensitive search.

			for dataValKey := range dataValKeys {

				mK, ok := dataValKey.Interface().(string)

				if !ok {

					// Not a string key

					continue

				}

				if d.config.MatchName(mK, fieldName) {

					rawMapKey = dataValKey

					rawMapVal = dataVal.MapIndex(dataValKey)

					break

				}

			}

			if !rawMapVal.IsValid() {

				// There was no matching key in the map for the value in

				// the struct. Remember it for potential errors and metadata.

				targetValKeysUnused[fieldName] = struct{}{}

				continue

			}

		}

		if !fieldValue.IsValid() {

			// This should never happen

			panic("field is not valid")

		}

		// If we can't set the field, then it is unexported or something,

		// and we just continue onwards.

		if !fieldValue.CanSet() {

			continue

		}

		// Delete the key we're using from the unused map so we stop tracking

		delete(dataValKeysUnused, rawMapKey.Interface())

		// If the name is empty string, then we're at the root, and we

		// don't dot-join the fields.

		if name != "" {

			fieldName = name + "." + fieldName

		}

		if err := d.decode(fieldName, rawMapVal.Interface(), fieldValue); err != nil {

			errors = appendErrors(errors, err)

		}

	}

	// If we have a "remain"-tagged field and we have unused keys then

	// we put the unused keys directly into the remain field.

	if remainField != nil && len(dataValKeysUnused) > 0 {

		// Build a map of only the unused values

		remain := map[interface{}]interface{}{}

		for key := range dataValKeysUnused {

			remain[key] = dataVal.MapIndex(reflect.ValueOf(key)).Interface()

		}

		// Decode it as-if we were just decoding this map onto our map.

		if err := d.decodeMap(name, remain, remainField.val); err != nil {

			errors = appendErrors(errors, err)

		}

		// Set the map to nil so we have none so that the next check will

		// not error (ErrorUnused)

		dataValKeysUnused = nil

	}

	if d.config.ErrorUnused && len(dataValKeysUnused) > 0 {

		keys := make([]string, 0, len(dataValKeysUnused))

		for rawKey := range dataValKeysUnused {

			keys = append(keys, rawKey.(string))

		}

		sort.Strings(keys)

		err := fmt.Errorf("'%s' has invalid keys: %s", name, strings.Join(keys, ", "))

		errors = appendErrors(errors, err)

	}

	if d.config.ErrorUnset && len(targetValKeysUnused) > 0 {

		keys := make([]string, 0, len(targetValKeysUnused))

		for rawKey := range targetValKeysUnused {

			keys = append(keys, rawKey.(string))

		}

		sort.Strings(keys)

		err := fmt.Errorf("'%s' has unset fields: %s", name, strings.Join(keys, ", "))

		errors = appendErrors(errors, err)

	}

	if len(errors) > 0 {

		return &Error{errors}

	}

	// Add the unused keys to the list of unused keys if we're tracking metadata

	if d.config.Metadata != nil {

		for rawKey := range dataValKeysUnused {

			key := rawKey.(string)

			if name != "" {

				key = name + "." + key

			}

			d.config.Metadata.Unused = append(d.config.Metadata.Unused, key)

		}

		for rawKey := range targetValKeysUnused {

			key := rawKey.(string)

			if name != "" {

				key = name + "." + key

			}

			d.config.Metadata.Unset = append(d.config.Metadata.Unset, key)

		}

	}

	return nil

}

func isEmptyValue(v reflect.Value) bool {

	switch getKind(v) {

	case reflect.Array, reflect.Map, reflect.Slice, reflect.String:

		return v.Len() == 0

	case reflect.Bool:

		return !v.Bool()

	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:

		return v.Int() == 0

	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:

		return v.Uint() == 0

	case reflect.Float32, reflect.Float64:

		return v.Float() == 0

	case reflect.Interface, reflect.Ptr:

		return v.IsNil()

	}

	return false

}

func getKind(val reflect.Value) reflect.Kind {

	kind := val.Kind()

	switch {

	case kind >= reflect.Int && kind <= reflect.Int64:

		return reflect.Int

	case kind >= reflect.Uint && kind <= reflect.Uint64:

		return reflect.Uint

	case kind >= reflect.Float32 && kind <= reflect.Float64:

		return reflect.Float32

	default:

		return kind

	}

}

func isStructTypeConvertibleToMap(typ reflect.Type, checkMapstructureTags bool, tagName string) bool {

	for i := 0; i < typ.NumField(); i++ {

		f := typ.Field(i)

		if f.PkgPath == "" && !checkMapstructureTags { // check for unexported fields

			return true

		}

		if checkMapstructureTags && f.Tag.Get(tagName) != "" { // check for mapstructure tags inside

			return true

		}

	}

	return false

}

func dereferencePtrToStructIfNeeded(v reflect.Value, tagName string) reflect.Value {

	if v.Kind() != reflect.Ptr || v.Elem().Kind() != reflect.Struct {

		return v

	}

	deref := v.Elem()

	derefT := deref.Type()

	if isStructTypeConvertibleToMap(derefT, true, tagName) {

		return deref

	}

	return v

}