leikari

type Actor struct {
	OnReceive func(ActorContext, Message)
	OnStart   func(ActorContext) error
	OnStop    func(ActorContext) error
	Async     bool
}

type ActorContext interface {
	ActorExecutor
	Name() string
	Log() Logger
	Settings() Settings
	Done() <-chan struct{}

	Self() Ref

	Handler() ActorHandler

	Set(string, interface{})
	Add(string, interface{}) error
	Replace(string, interface{}) error
	Get(string) (interface{}, bool)
}

type ActorExecutor interface {
	Execute(Receiver, string, ...Option) (Ref, error)
}

type ActorHandler interface {
	Pusher
	ActorHandlerExecutor
	Name() string
	Close()

	Root() ActorHandler
	Parent() (ActorHandler, bool)
	Path() string
	System() System
	Log() Logger
	Settings() Settings

	Child(string) (ActorHandler, bool)
	Children() []ActorHandler

	CreateRef() Ref

	Cache() Cache
}

type ActorHandlerExecutor interface {
	ExecuteHandler(Receiver, string, ...Option) (ActorHandler, error)
}

type ActorSettings interface {
	Settings

	WorkerPoolSize() int
	MessageQueueSize() int
	Async() bool
}

type AsyncActor interface {
	AsyncActor() bool
}

type Cache interface {
	Set(key string, value interface{})
	Add(key string, value interface{}) error
	Replace(key string, value interface{}) error
	Get(key string) (interface{}, bool)
}

type DoneEvent struct{}

type Error struct {
	Code        string `json:"code,omitempty"`
	Message     string `json:"error"`
	Description string `json:"description,omitempty"`
	Status      int    `json:"-"`
}

type LogLevel int

type Logger interface {
	ForName(string) Logger

	Debug(...interface{})
	Info(...interface{})
	Warn(...interface{})
	Error(...interface{})
	Fatal(...interface{})
	Panic(...interface{})

	Debugf(string, ...interface{})
	Infof(string, ...interface{})
	Warnf(string, ...interface{})
	Errorf(string, ...interface{})
	Fatalf(string, ...interface{})
	Panicf(string, ...interface{})
}

type Message interface {
	Value() interface{}
	Reply(interface{})
}

type Option struct {
	Name  string
	Value interface{}
}

type Pusher interface {
	Push(Message) error
}

type Receiver interface {
	Receive(ActorContext, Message)
}

type ReceiverFunc func(ActorContext, Message)

type Ref interface {
	Send(interface{}) error

	RequestChan(interface{}) <-chan interface{}
	Request(interface{}) (interface{}, error)
	RequestContext(context.Context, interface{}) (interface{}, error)
}

type ServiceExecutor interface {
	ExecuteService(Receiver, string, ...Option) (ActorHandler, error)
}

type Settings interface {
	Get(string) interface{}
	GetBool(string) bool
	GetFloat64(string) float64
	GetInt(string) int
	GetIntSlice(string) []int
	GetString(string) string
	GetStringSlice(string) []string
	GetTime(string) time.Time
	GetDuration(string) time.Duration
	IsSet(string) bool

	GetDefault(string, interface{}) interface{}
	GetDefaultBool(string, bool) bool
	GetDefaultFloat64(string, float64) float64
	GetDefaultInt(string, int) int
	GetDefaultIntSlice(string, ...int) []int
	GetDefaultString(string, string) string
	GetDefaultStringSlice(string, ...string) []string
	GetDefaultTime(string, time.Time) time.Time
	GetDefaultDuration(string, time.Duration) time.Duration

	GetSub(string) Settings
}

type Startable interface {
	PreStart(ActorContext) error
}

type Stopable interface {
	PostStop(ActorContext) error
}

type System interface {
	ActorExecutor
	ServiceExecutor
	Settings() SystemSettings
	Log() Logger
	Terminate()
	Terminated() <-chan int
	Run()

	Timer(time.Duration, func(time.Time)) *time.Timer
	Ticker(time.Duration, func(time.Time)) *time.Ticker
}

type SystemSettings interface {
	Settings

	NoSignature() bool
	GetActorSettings(string, ...Option) ActorSettings
}