无法反序列化结构（“类型的值不可分配给类型”）

Question

I'm running into an issue when trying to deserialize a struct.

I've tried using JSON and YAML, rewriting the struct to use a slice instead of a map (thinking it was an issue with my use of a map), all to no avail.

The struct below contains the issue, specifically the Deserialize function. I've replaced irrelevant code with ... :

type Collection struct {
    Objects []Object `yaml:"objects,omitempty"`
}

...

func (c *Collection) Serialize() ([]byte, error) {
    return yaml.Marshal(c)
}

func (c *Collection) Deserialize(raw []byte) error {
    return yaml.Unmarshal(raw, c)
}

My test serializes a Collection, then attempts to deserialize the raw data from the first collection, into the second. It will then compare the two collections, but the issue presents itself during the deserialization:

func TestDeserialize(t *testing.T) {
    c := NewCollection()

    // NewRect creates a Rect (inherits from Object)
    c.AddObject(NewRect(10,10,NewPos(0,0))

    c2 := NewCollection()

    v raw, err := c.Serialize()
    if err != nil {
        t.Fatalf("collection 1 failed to serialize: %v", err)
    }

    // deserialize raw 1 into 2
    // this is the call that fails
    err = c2.Deserialize(raw)
    if err != nil {
        t.Fatalf("collection 2 failed to deserialize: %v", err)
    }
}

This is the error I keep running into:

panic: reflect.Set: value of type map[interface {}]interface {} is not assignable to type bw.Object [recovered]
    panic: reflect.Set: value of type map[interface {}]interface {} is not assignable to type bw.Object [recovered]
    panic: reflect.Set: value of type map[interface {}]interface {} is not assignable to type bw.Object

Edit: I forgot to include the definition of Object . Object is a very basic interface:

type Object interface {
    Update()
    Draw()
    Serialize()
    Deserialize()
}

Answer 1

This will work when you serialize because during serialization each element of the Objects array are structs. It will not work when you deserialize, because during deserialization, Objects is an empty array of interfaces. You cannot unmarshal to an interface, only to a struct, or value.

To fix this, you have to figure out the type of each individual array element in Objects during deserialization, and then deserialized based on the struct. There are multiple ways this can be done.

One way to do is to use a fat interface , a temporary struct containing all possible items:

type unmarshalObject struct {
   Type string `yaml:"type"`
   // All possible fields of all possible implementations
}

type unmarshalCollection struct {
    Objects []unmarshalObject `yaml:"objects,omitempty"`
}

func (c *Collection) Deserialize(raw []byte) error {
    var intermediate unmarshalCollection
    yaml.Unmarshal(raw, &intermediate)
    c.Objects=make([]Object,0)
    for _,object:=range intermediate.Objects {
        switch object.Type {
          case "rect":
             c.Objects=append(c.Objects,Rectangle{X1:object.X1,...})
          case "...":
           ...
        }
    }
    return nil
}

Error checking is omitted.

Same approach can be used with a map[string]interface{} instead of unmarshalObject , but that would require lots of type assertions.