107 lines
2.0 KiB
Go
107 lines
2.0 KiB
Go
package testpb
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"sort"
|
|
|
|
"cosmossdk.io/core/appmodule"
|
|
"cosmossdk.io/depinject"
|
|
)
|
|
|
|
func init() {
|
|
appmodule.Register(&TestRuntimeModule{},
|
|
appmodule.Provide(provideRuntimeState, provideStoreKey, provideApp),
|
|
)
|
|
|
|
appmodule.Register(&TestModuleA{},
|
|
appmodule.Provide(provideModuleA),
|
|
)
|
|
|
|
appmodule.Register(&TestModuleB{},
|
|
appmodule.Provide(provideModuleB),
|
|
)
|
|
}
|
|
|
|
func provideRuntimeState() *runtimeState {
|
|
return &runtimeState{}
|
|
}
|
|
|
|
func provideStoreKey(key depinject.ModuleKey, state *runtimeState) StoreKey {
|
|
sk := StoreKey{name: key.Name()}
|
|
state.storeKeys = append(state.storeKeys, sk)
|
|
return sk
|
|
}
|
|
|
|
func provideApp(state *runtimeState, handlers map[string]Handler) App {
|
|
return func(w io.Writer) {
|
|
sort.Slice(state.storeKeys, func(i, j int) bool {
|
|
return state.storeKeys[i].name < state.storeKeys[j].name
|
|
})
|
|
|
|
for _, key := range state.storeKeys {
|
|
_, _ = fmt.Fprintf(w, "got store key %s\n", key.name)
|
|
}
|
|
|
|
var modNames []string
|
|
for modName := range handlers {
|
|
modNames = append(modNames, modName)
|
|
}
|
|
|
|
sort.Strings(modNames)
|
|
for _, name := range modNames {
|
|
_, _ = fmt.Fprintf(w, "running module handler %s\n", name)
|
|
_, _ = fmt.Fprintf(w, "result: %s\n", handlers[name].DoSomething())
|
|
}
|
|
}
|
|
}
|
|
|
|
type App func(writer io.Writer)
|
|
|
|
type runtimeState struct {
|
|
storeKeys []StoreKey
|
|
}
|
|
|
|
type StoreKey struct{ name string }
|
|
|
|
type Handler struct {
|
|
DoSomething func() string
|
|
}
|
|
|
|
func (h Handler) IsOnePerModuleType() {}
|
|
|
|
func provideModuleA(key StoreKey) (KeeperA, Handler) {
|
|
return keeperA{key: key}, Handler{DoSomething: func() string {
|
|
return "hello"
|
|
}}
|
|
}
|
|
|
|
type keeperA struct {
|
|
key StoreKey
|
|
}
|
|
|
|
type KeeperA interface {
|
|
Foo()
|
|
}
|
|
|
|
func (k keeperA) Foo() {}
|
|
|
|
func provideModuleB(key StoreKey, a KeeperA) (KeeperB, Handler) {
|
|
return keeperB{key: key, a: a}, Handler{
|
|
DoSomething: func() string {
|
|
return "goodbye"
|
|
},
|
|
}
|
|
}
|
|
|
|
type keeperB struct {
|
|
key StoreKey
|
|
a KeeperA
|
|
}
|
|
|
|
type KeeperB interface {
|
|
isKeeperB()
|
|
}
|
|
|
|
func (k keeperB) isKeeperB() {}
|