Given a struct:
type MyStruct struct {
A int
B int
}
and a string with the struct's name
a := "MyStruct"
or
a := "mypkg.MyStruct"
How do I create an instance of my struct from the string name rather than the struct? The idea is that I would create an application with all of the structures linked into the binary but create the runtime instances from the strings. (sort of a meta-meta)
There is no central registry of types in Go, so what you ask is impossible in the general case.
You could build up your own registry by hand to support such a feature using a map from strings to reflect.Type values corresponding to each type. For instance:
var typeRegistry = make(map[string]reflect.Type)
func init() {
myTypes := []interface{}{MyString{}}
for _, v := range myTypes {
// typeRegistry["MyString"] = reflect.TypeOf(MyString{})
typeRegistry[fmt.Sprintf("%T", v)] = reflect.TypeOf(v)
}
}
You can then create instances of the types like so:
func makeInstance(name string) interface{} {
v := reflect.New(typeRegistry[name]).Elem()
// Maybe fill in fields here if necessary
return v.Interface()
}
reflect.TypeOf(foo).Name() instead of typing out each string manually.
reflect.TypeOf(foo).String() see small example here.
The Go runtime doesn't exposes a list of types built in the program. And there is a reason: you never have to be able to build all types availables but instead just a subset.
You can build yourself this subset using a map. And you can use the reflect package to create an instance from a reflect.Type.
My solution (see on Go Playground) uses typed nil pointers (instead of empty values) to reduce size of allocations when building the map (compared to @james-henstridge solution).
package main
import (
"fmt"
"reflect"
)
var typeRegistry = make(map[string]reflect.Type)
func registerType(typedNil interface{}) {
t := reflect.TypeOf(typedNil).Elem()
typeRegistry[t.PkgPath() + "." + t.Name()] = t
}
type MyString string
type myString string
func init() {
registerType((*MyString)(nil))
registerType((*myString)(nil))
// ...
}
func makeInstance(name string) interface{} {
return reflect.New(typeRegistry[name]).Elem().Interface()
}
func main() {
for k := range typeRegistry {
fmt.Println(k)
}
fmt.Printf("%T\n", makeInstance("main.MyString"))
fmt.Printf("%T\n", makeInstance("main.myString"))
}
You can create a map of name -> struct "template"
When grabbing a value from a map, you get a copy of the value, the map effectively acts as a factory for your values.
Notice that the values from the map are unique. In order to actually do something with the struct, you'll need to either assert its type or use some reflections based processor (ie: get struct from map, then json decode in to the struct)
Here's a simple Example with one struct in raw form and one pre-filled in. Notice the type assertion on foowv1, that's so I can actually set the value.
package main
import "fmt"
type foo struct {
a int
}
var factory map[string]interface{} = map[string]interface{}{
"foo": foo{},
"foo.with.val": foo{2},
}
func main() {
foo1 := factory["foo"]
foo2 := factory["foo"]
fmt.Println("foo1", &foo1, foo1)
fmt.Println("foo2", &foo2, foo2)
foowv1 := factory["foo.with.val"].(foo)
foowv1.a = 123
foowv2 := factory["foo.with.val"]
fmt.Println("foowv1", &foowv1, foowv1)
fmt.Println("foowv2", &foowv2, foowv2)
}
type bar struct {..}. How do you type assert unless you know ahead of time which type to use?
unsafepackage and I haven't seen anything super promising...