Golang: Unmarshal function that can handle 2 different structs - go

Question

looking for help.
Say I have the following structs..
type phoneStruct struct {
PhoneID string `json:"id"`
Carrier string `json:"carrier"`
}
type carStruct struct {
CarID string `json:"id"`
Model string `json:"model"`
}
Two very different structs.. but predictable.
Now in my code what I'm doing is doing a POST request and then parsing the body of what I get back so that I can do some test assertions on it. But for simplicity lets say I have this JSON
var jsonPhone = `{
"id": "123",
"carrier": "Rogers"
}`
var jsonCar = `{
"id": "foobar-fewf-434-fewf",
"model": "Civic"
}`
And I want to associate that json with my structs, so I have the following calls:
p, err := parsePhone(jsonPhone)
c, err := parseCar(jsonCar)
And the functions looks something like
func parsePhone(body []byte) (*phoneStruct, error) {
var p = new(phoneStruct)
err := json.Unmarshal(body, p)
return p, err
}
func parseCar(body []byte) (*carStruct, error) {
var c = new(carStruct)
err := json.Unmarshal(body, c)
return c, err
}
.. I am wondering if there is a way to just have one struct. I know there is if there is some commonality between two or more structs .. or how to parse unknown structs.. but haven't been able to find a resource on if I know the structures.. how can I have a function that looks something like..
func parseAnything(body []byte (<pointer to the struct>, error)
var c = new(someStruct)
err := json.Unmarshal(body, c)
return c, err
}
Note that I will always know what I am calling so I could do a conditional switch statement in my parse function that says 'if car.. if phone..' but I'm not sure how to define the return.
Thank you!

Answer 1

Write the function to take a pointer to the result:
func parseAnything(body []byte, c interface{}) error {
return json.Unmarshal(body, c)
}
Use it like this:
var p phoneStruct
if err := parseAnything(jsonPhone, &p); err != nil {
// handle error
}
// p has unmarshaled phone
var c carStruct
if err := parseAnything(jsonCar, &c); err != nil {
// handle error
}
// c has unmarshaled car

Answer 2

I don't know exactly what are you trying to build, but will try to give some insight based on what I understood.
If you are trying to use the same parser for both structs, they probably have something in common. Probably they are being used together for some use case of you application.
So, if they are being use together, they should implement some interface that represents the set of features that these structs have in common (with may or maybe not be related with just the parsing of data).
And, as you said, you know beforehand of what type of struct you need, so this should come easy with something like this:
//The interface that represents what the structs have in common.
//I named it "Parser" because it's the info I have. It probably should have another (better) name
type Parser interface {
Parse([]byte) (Parser, error)
}
type Phone struct {
PhoneID string `json:"id"`
Carrier string `json:"carrier"`
}
type Car struct {
CarID string `json:"id"`
Model string `json:"model"`
}
func (p *Phone) Parse (body []byte) (Parser, error) {
err := json.Unmarshal(body, p)
return p, err
}
func (c *Car) Parse (body []byte) (Parser, error) {
err := json.Unmarshal(body, c)
return c, err
}
func main() {
c := Car{}
var jsonCar = `{
"id": "123",
"model": "Civic"
}`
res, _ := c.Parse([]byte(jsonCar))
fmt.Println(res)
p := Phone{}
var jsonPhone = `{
"id": "123",
"carrier": "Rogers"
}`
res, _ = p.Parse([]byte(jsonPhone))
fmt.Println(res)
}