Support struct wrapped in interface as target for decoding

[andig]

Similar to #186, mapstructure is not handling structs assigned to interfaces:

var cc interface{}
cc = struct{ Foo, Bar string }{}

decoderConfig := &mapstructure.DecoderConfig{Result: &cc, ErrorUnused: true}
decoder, err := mapstructure.NewDecoder(decoderConfig)
if err != nil {
	log.Fatal(err)
}

conf := map[string]string{
	"foo": "bar",
	"bar": "baz",
}

if err := decoder.Decode(conf); err != nil {
	log.Fatal(err)
}

Will give

* '' has invalid keys: bar, foo

Would this be something worthwile to address with a PR or are there constraints that would prevent handling this case?

[GeorgeGkinis]

I could also use this to avoid alot of duplicate code.

[mitchellh]

This can work if the underlying type is a pointer:

var cc interface{}
cc = &struct{ Foo, Bar string }{}

It doesn't work if its not a pointer. If this can be fixed I'd love to fix it, I'm actually not sure if this is fixable.

[mitchellh]

As soon as I said that, I have a fix for it... one sec!

[andig]

@mitchellh

This can work if the underlying type is a pointer:

Out of curiosity: even if it wasn‘t a pointer it should be possible to deep-clone the assigned struct and assign the clone to the interface? Not sure it is needed as this is a perfect workaround, but I feel this would still be doable?

[mitchellh]

That is basically what ended up happening in the linked PR. We didn’t do a “deep” copy though, just a shallow one (which will subsequently copy if necessary). This behavior should be acceptable since the expectation with map structure is the target structure is modified.

But what I ended up doing was: if I couldn’t address the value, then I make a copy (which can be addressed), decode into there, then reassign. The pseudo code would be like this:

Target <- interface.Elem()
If Target not addressable:
  Target <- copy(Target)

DecodeInto(Target)
Interface.Elem = Target

[andig]

We didn’t do a “deep” copy though, just a shallow one (which will subsequently copy if necessary).

One of the use cases for mapstructure is setting default values that won't be overridden by zero values- won't those get overridden if shallow copy is used although they were present in the original struct?