func Locate() depth level

[Ganitzsh]

Hi!
I'm trying to recover a slice of a byte array (encoded msgpack) .
The msgpacked string looks good and I'm able to recover a slice from the root depth, but not more.
Here is the structure:

type MyStructA {
 Field1 interface{}
}

type MyStructB {
 Field2 interface{}
}

type MyStructC {
 Field3 string
}

data := MyStructA {
       Field1: &MyStructB {
         Field2: &MyStructC {
           Field3: "String",
           },
          },
      }

I want to isolate Field2 to decode it into a MyStructC variable to avoid dealing with a map[string]interface{} object since my fields are of type interface{}.
Using the raw content (the entire msgpack from data) I can access Field1 and decode it to a proper structure but not Field2 because msgp.Locate("Field2", raw) returns an empty byte array.

[philhofer]

Keep in mind that each struct is its own map, so a struct containing other structs is turned into a map-of-maps. Consequently, the encoded msgpack looks like

{ "Field1" : { "Field2" : { "Field3" : "String" } } }

You need to locate Field1, and then within that locate Field2. So:

msgp.Locate("Field2", msgp.Locate("Field1", raw))

[philhofer]

If you wanted to be fancy, you could wrap Locate in a function that took an input like "Field1.Field2" and split the input on each . and then applied each search recursively.

[Ganitzsh]

Ok! It works... My bad, I made a mistake in my structure and I was looking for the wrong key.
Thanks for the tip about the wrap, I thought of it and was wondering why you did not implement it?

[philhofer]

Mostly because the string-processing (allocation) is more expensive than the actual de-serialization, and so the performance benefit of incremental/partial processing goes out the window.