leikari

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

type ActorContext interface {
	ActorExecutor
	Name() string
	Log() Logger
	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, ...Option) (Ref, error)
}

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

	Root() ActorHandler
	Parent() (ActorHandler, bool)
	System() System
	Log() Logger

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

	CreateRef() Ref

	Cache() Cache
}

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

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 HandlerSettings struct {
	Name         string
	WorkerPool   int
	MessageQueue int
	Log          Logger
	Async        bool
}

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 NamedActor interface {
	ActorName() string
}

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, ...Option) (ActorHandler, error)
}

type Startable interface {
	PreStart(ActorContext) error
}

type Stopable interface {
	PostStop(ActorContext) error
}

type System interface {
	ActorExecutor
	ServiceExecutor
	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 struct {
	NoSignature bool
}