123 lines
2.3 KiB
Markdown
123 lines
2.3 KiB
Markdown
# Struct Mapper
|
|
|
|
The structmapper package converts Go structures into other Go structures. It is possible to use automatic conversion or to define your own strategies.
|
|
|
|
## AutoMap
|
|
|
|
AutoMap automatically attempts to convert Struct1 to Struct2. JSON serialisation is used for this purpose.
|
|
|
|
```Go
|
|
package main
|
|
|
|
import "git.apihub24.de/admin/structmapper"
|
|
|
|
type Struct1 struct {
|
|
Id int
|
|
Name string
|
|
}
|
|
|
|
type Struct2 struct {
|
|
Id int
|
|
Name string
|
|
Active bool
|
|
}
|
|
|
|
func main() {
|
|
result, err := structmapper.AutoMap[Struct1, Struct2](Struct1{
|
|
Id: 1,
|
|
Name: "test"
|
|
})
|
|
// prints 1
|
|
println(result.Id)
|
|
// prints test
|
|
println(result.Name)
|
|
// prints false
|
|
println(result.Active)
|
|
}
|
|
```
|
|
|
|
## Strategies
|
|
|
|
Custom mapping logics can be created and used with RegisterStrategy or removed again with UnregisterStrategy. These are then automatically searched for and used by the Map function. If no suitable strategy is found, an AutoMap is attempted.
|
|
|
|
```Go
|
|
type Right1 struct {
|
|
Id int
|
|
Name string
|
|
}
|
|
|
|
type Right2 struct {
|
|
Id int
|
|
Name string
|
|
}
|
|
|
|
structmapper.RegisterStrategy(func(from *Right1) (*Right2, error) {
|
|
return &testRight2{
|
|
Id: from.Id,
|
|
Name: from.Name,
|
|
}, nil
|
|
})
|
|
structmapper.RegisterStrategy(func(from *Right2) (*Right1, error) {
|
|
return &Right1{
|
|
Id: from.Id,
|
|
Name: from.Name,
|
|
}, nil
|
|
})
|
|
|
|
right := Right1 {
|
|
Id: 1,
|
|
Name: "test"
|
|
}
|
|
// now you can use the Map Method
|
|
result, err := structmapper.Map[*Right1, *Right2](right)
|
|
```
|
|
|
|
Strategies can be removed with UnregisterStrategy.
|
|
|
|
```Go
|
|
structmapper.UnregisterStrategy[Right1, Right2]()
|
|
structmapper.UnregisterStrategy[Right2, Right1]()
|
|
```
|
|
|
|
## SliceMap
|
|
|
|
SliceMap is a helper function that makes it easy to map slices in strategies. For complexity reasons, only an empty slice is returned here in the event of an error, not an error!
|
|
|
|
```Go
|
|
type Right1 struct {
|
|
Id int
|
|
Name string
|
|
}
|
|
|
|
type Right2 struct {
|
|
Id int
|
|
Name string
|
|
}
|
|
|
|
structmapper.RegisterStrategy(func(from *Right1) (*Right2, error) {
|
|
return &testRight2{
|
|
Id: from.Id,
|
|
Name: from.Name,
|
|
}, nil
|
|
})
|
|
structmapper.RegisterStrategy(func(from *Right2) (*Right1, error) {
|
|
return &Right1{
|
|
Id: from.Id,
|
|
Name: from.Name,
|
|
}, nil
|
|
})
|
|
|
|
right1 := Right1{
|
|
Id: 1,
|
|
Name: "READ"
|
|
}
|
|
right2 := Right1{
|
|
Id: 2,
|
|
Name: "WRITE"
|
|
}
|
|
|
|
result := structmapper.SliceMap[Right1, Right2]([]Right1{
|
|
right1, right2,
|
|
})
|
|
```
|