Transform struct to slice struct

I'm trying to select a struct by string input and then depending on the return JSON Object or Array, unmarshall the JSON. Is it correct to think of a way to reflect the struct to slice struct? if so how to do that with reflection? Regards, Peter

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "log"
)

type NameStruct struct {
    Name string
}

func main() {

    jsonData := []byte(`[{"name":"james"},{"name":"steven"}]`)
    returnModel := InitializeModel("NameStruct", jsonData)
    fmt.Println(returnModel)

    jsonData = []byte(`{"name":"james"}`)
    returnModel = InitializeModel("NameStruct", jsonData)
    fmt.Println(returnModel)

}

func getModelByName(modelType string) interface{} {
    modelMap := make(map[string]interface{})
    modelMap["NameStruct"] = new(NameStruct)

    //don't want to do this
    modelMap["arrNameStruct"] = new([]NameStruct)
    return modelMap[modelType]
}

func InitializeModel(modelName string, jsonData []byte) interface{} {
    switch IsArray(jsonData) {
    case true:
        // some conversion here, how?
        returnModel := getModelByName("NameStruct")
        if err := json.Unmarshal(jsonData, &returnModel); err != nil {
            log.Println(err)
        }
        return returnModel
    case false:
        returnModel := getModelByName("NameStruct")
        if err := json.Unmarshal(jsonData, &returnModel); err != nil {
            log.Println(err)
        }
        return returnModel
    }
    return nil
}

func IsArray(jsonData []byte) bool {
    return (bytes.HasPrefix(jsonData, []byte("["))) && (bytes.HasSuffix(jsonData, []byte("]")))
}

Expanding on my comment, you can create a Factory where pre-defined types are registered:

type Factory struct {
    m map[string]reflect.Type
}

func (f *Factory) Register(v interface{}) {
    vt := reflect.TypeOf(v)
    n := vt.Name()
    f.m[n] = vt
    f.m["[]"+n] = reflect.SliceOf(vt) // implicitly register a slice of type too
}

these types can be looked up by name at runtime and initialized with JSON data:

func (f *Factory) Make(k string, bs []byte) (interface{}, error) {
    vt, ok := f.m[k]
    if !ok {
        return nil, fmt.Errorf("type %q not registered", k)
    }

    pv := reflect.New(vt).Interface()

    err := json.Unmarshal(bs, pv)
    if err != nil {
        return nil, err
    }

    return pv, nil
}

To use:

type Place struct {
    City string `json:"city"`
}

factory.Register(Place{})

p, err := factory.Make("Place", []byte(`{"city":"NYC"}`))

fmt.Printf("%#v\n", p) // &main.Place{City:"NYC"}

Slices also work:

ps, err := factory.Make("[]Place", []byte(`[{"city":"NYC"},{"city":"Dublin"}]`))

fmt.Printf("%#v\n", p, p) // &[]main.Place{main.Place{City:"NYC"}, main.Place{City:"Dublin"}}

Playground: https://play.golang.org/p/qWEdwk-YUug