In my code, there's a package called variables which contains an interface Variable, and two structs that implement the methods in the interface - NumericalVariable and TextualVariable. Here is how they are structured...
package variables
type Variable interface {
GetColumnIndex() int
IsActive() bool
StartDataLoad()
AddData(value string) (bool, error)
FinishDataLoad()
VectorLength() int
SetVectorOffset(offset int)
LoadIntoVector(sv string, vector []float64) float64
}
type NumericVariable struct {
Column_idx int
Name string
Vector_offset int
Mean float64
Sum float64
SumSq float64
SD float64
Count float64
Max float64
Min float64
Vector_max float64
Vector_min float64
values []float64
Active bool
}
type Category struct {
Count int
Vector_offset int
Coefficient float64
}
type TextualVariable struct {
Column_idx int
Name string
Vector_offset int
Categories map[string]Category
Categories_k float64
Active bool
Count int
}
Additionally, I have another module named model which defines a type Model containing a slice of Variable interfaces, as shown below...
package model
type Model struct {
Vars []variables.Variable
}
During data processing, I instantiate either a NumericalVariable or TextualVariable based on the data at hand, adding these instances to the Vars slice within a Model object. My goal is to be able to save and load the Model struct from a JSON file.
While saving is straightforward thanks to Golang's json package, reading poses a challenge due to model.Vars being a slice of interfaces without explicit type information during unmarshalling.
To tackle this issue, reflection seemed like a viable solution but has me stumped in implementation. Here's a snippet of what I've tried...
func (_self Model) Read(filename string) {
_model, err := ioutil.ReadFile(filename)
if err != nil {
log.Fatal(err)
return
}
var dat map[string][]interface{}
err = json.Unmarshal([]byte(_model), &dat)
if err != nil {
log.Fatal(err)
return
}
_vars := dat["Vars"]
for _, _vi := range _vars {
k := reflect.ValueOf(_vi)
if k.Kind() == reflect.Map {
if len(k.MapKeys()) == 13 {
// This is a numeric variable
nv := variables.NumericVariable()
// How do I proceed to load values into nv using reflection?
}
if len(k.MapKeys()) == 8 {
// This is a textual variable
tv := variables.TextualVariable()
// Similarly, how can I utilize reflection to populate tv with the reflected values?
}
}
}
I am able to detect the types correctly through reflection, but struggle with loading the values into their respective structs automatically. Any guidance on effectively utilizing reflection for automatic unmarshalling would be greatly appreciated.