How can I check what embedded type a concrete type is composed of?

Question

I suspect I am trying to shoehorn go into behaving in an OOP way, but I don't know the go idiom to do what I want.

I have a Message struct that I use to pass data around in a client-server application:

type Message struct {
    ID   string      `json:"id,omitempty"`
    Type string      `json:"type"`
    Data interface{} `json:"data"`
}

the Data here can be different things, for example a number of Commands:

type Command struct {
    User *types.UserInfo `json:"user"`
}

type CommandA struct {
    Command
    A *AData `json:"a_data"`
}

type CommandB struct {
    CommandB
    B *BData `json:"b_data"`

}

What I want to do is to check that the message data type is a Command and perform actions that are common to all commands, for example authorisation, all in one place and not having to type assert what type of command, calling the appropriate handler function and then do the auth, as this would result in massive code duplication.

The code below reflects what I would like to happen.

for {
    select {
    case m := <-in:
      // what I would like to do, obviously not working as
      // m.Data is not of type Command but the actual command type
      if c, ok := m.Data.(msg.Command); ok {
        // do auth and other common stuff
      }
      switch t := m.Data.(type) {
      case *msg.CommandA:
        go srv.handleCommandA(m.ID, t)
      case *msg.CommandB:
        go srv.handleCommandB(m.ID, t)
      // etc etc
      default:
        // do something
      }
   }
}

How do I solve this go idiomatically?

Answer 1

You can define common command stuff in interface

type Commander interface{
    DoCommonStuff()
}

implement it for Command struct

func (c Command) DoCommonStuff(){
//do stuff
}

and then assert

if c, ok := m.Data.(Commander); ok {
    c.DoCommonStuff()
}

your other code should work unchanged