107 lines
3.1 KiB
Go
107 lines
3.1 KiB
Go
package container
|
|
|
|
import (
|
|
"fmt"
|
|
"reflect"
|
|
|
|
"github.com/goccy/go-graphviz/cgraph"
|
|
|
|
"github.com/pkg/errors"
|
|
)
|
|
|
|
// OnePerScopeType marks a type which
|
|
// can have up to one value per scope. All of the values for a one-per-scope type T
|
|
// and their respective scopes, can be retrieved by declaring an input parameter map[string]T.
|
|
type OnePerScopeType interface {
|
|
// IsOnePerScopeType is a marker function just indicates that this is a one-per-scope type.
|
|
IsOnePerScopeType()
|
|
}
|
|
|
|
var onePerScopeTypeType = reflect.TypeOf((*OnePerScopeType)(nil)).Elem()
|
|
|
|
func isOnePerScopeType(t reflect.Type) bool {
|
|
return t.Implements(onePerScopeTypeType)
|
|
}
|
|
|
|
func isOnePerScopeMapType(typ reflect.Type) bool {
|
|
return typ.Kind() == reflect.Map && isOnePerScopeType(typ.Elem()) && typ.Key().Kind() == reflect.String
|
|
}
|
|
|
|
type onePerScopeResolver struct {
|
|
typ reflect.Type
|
|
mapType reflect.Type
|
|
providers map[Scope]*simpleProvider
|
|
idxMap map[Scope]int
|
|
resolved bool
|
|
values reflect.Value
|
|
graphNode *cgraph.Node
|
|
}
|
|
|
|
type mapOfOnePerScopeResolver struct {
|
|
*onePerScopeResolver
|
|
}
|
|
|
|
func (o *onePerScopeResolver) resolve(_ *container, _ Scope, _ Location) (reflect.Value, error) {
|
|
return reflect.Value{}, errors.Errorf("%v is a one-per-scope type and thus can't be used as an input parameter, instead use %v", o.typ, o.mapType)
|
|
}
|
|
|
|
func (o *onePerScopeResolver) describeLocation() string {
|
|
return fmt.Sprintf("one-per-scope type %v", o.typ)
|
|
}
|
|
|
|
func (o *mapOfOnePerScopeResolver) resolve(c *container, _ Scope, caller Location) (reflect.Value, error) {
|
|
// Log
|
|
c.logf("Providing one-per-scope type map %v to %s from:", o.mapType, caller.Name())
|
|
c.indentLogger()
|
|
for scope, node := range o.providers {
|
|
c.logf("%s: %s", scope.Name(), node.provider.Location)
|
|
}
|
|
c.dedentLogger()
|
|
|
|
// Resolve
|
|
if !o.resolved {
|
|
res := reflect.MakeMap(o.mapType)
|
|
for scope, node := range o.providers {
|
|
values, err := node.resolveValues(c)
|
|
if err != nil {
|
|
return reflect.Value{}, err
|
|
}
|
|
idx := o.idxMap[scope]
|
|
if len(values) < idx {
|
|
return reflect.Value{}, errors.Errorf("expected value of type %T at index %d", o.typ, idx)
|
|
}
|
|
value := values[idx]
|
|
res.SetMapIndex(reflect.ValueOf(scope.Name()), value)
|
|
}
|
|
|
|
o.values = res
|
|
o.resolved = true
|
|
}
|
|
|
|
return o.values, nil
|
|
}
|
|
|
|
func (o *onePerScopeResolver) addNode(n *simpleProvider, i int) error {
|
|
if n.scope == nil {
|
|
return errors.Errorf("cannot define a constructor with one-per-scope dependency %v which isn't provided in a scope", o.typ)
|
|
}
|
|
|
|
if existing, ok := o.providers[n.scope]; ok {
|
|
return errors.Errorf("duplicate provision for one-per-scope type %v in scope %s: %s\n\talready provided by %s",
|
|
o.typ, n.scope.Name(), n.provider.Location, existing.provider.Location)
|
|
}
|
|
|
|
o.providers[n.scope] = n
|
|
o.idxMap[n.scope] = i
|
|
|
|
return nil
|
|
}
|
|
|
|
func (o *mapOfOnePerScopeResolver) addNode(s *simpleProvider, _ int) error {
|
|
return errors.Errorf("%v is a one-per-scope type and thus %v can't be used as an output parameter in %s", o.typ, o.mapType, s.provider.Location)
|
|
}
|
|
|
|
func (o onePerScopeResolver) typeGraphNode() *cgraph.Node {
|
|
return o.graphNode
|
|
}
|