lifecycle

type CallbackFuture[V any] struct {
	// contains filtered or unexported fields
}

type ChanFuture[V any] chan V

type CloseFunc = func(Lifecycle) error

type DefaultLifecycle struct {
	State
	sync.RWMutex
	// contains filtered or unexported fields
}

type Future[V any] interface {
	Complete(value V)
}

type Futures[V any] []Future[V]

type Group struct {
	Lifecycle
	// contains filtered or unexported fields
}

type GroupLifecycleHolder struct {
	Lifecycle
	// contains filtered or unexported fields
}

type InterruptedError struct {
	Target string
	Action string
}

type InterruptedRunFunc = func(lifecycle Lifecycle, interrupter chan struct{}) error

type InterruptedRunner interface {
	DoStart(lifecycle Lifecycle, interrupter chan struct{}) error

	DoRun(lifecycle Lifecycle, interrupter chan struct{}) error
}

type InterruptedStartFunc = func(lifecycle Lifecycle, interrupter chan struct{}) error

type InterruptedStarter interface {
	DoStart(lifecycle Lifecycle, interrupter chan struct{}) (runFn InterruptedRunFunc, err error)
}

type InterruptedStarterFunc = func(lifecycle Lifecycle, interrupter chan struct{}) (runFn InterruptedRunFunc, err error)

type Lifecycle interface {
	Run() error

	Background() error

	Start() error

	StartedWaiter() <-chan error

	Close(future Future[error]) error

	ClosedWaiter() <-chan error

	Shutdown() error

	AddStartedFuture(future Future[error]) Future[error]

	AddClosedFuture(future Future[error]) Future[error]

	OnStarting(OnStartingFunc) Lifecycle

	OnStarted(OnStartedFunc) Lifecycle

	OnClose(OnCloseFunc) Lifecycle

	OnClosed(OnClosedFunc) Lifecycle

	SetOnStarting(OnStartingFunc) Lifecycle

	SetOnStarted(OnStartedFunc) Lifecycle

	SetOnClose(OnCloseFunc) Lifecycle

	SetOnClosed(OnClosedFunc) Lifecycle

	Field(name string) any

	Fields() map[string]any

	SetField(name string, value any) Lifecycle

	SetDefaultField(name string, defaultValue any) (value any, exist bool)

	DeleteField(name string) Lifecycle

	RemoveField(name string) any

	RangeField(f func(name string, value any) bool) Lifecycle

	Error() error
}

type List struct {
	Lifecycle
	// contains filtered or unexported fields
}

type ListLifecycleHolder struct {
	Lifecycle
	// contains filtered or unexported fields
}

type NopFuture[V any] struct{}

type OnCloseFunc = func(Lifecycle, error)

type OnClosedFunc = func(Lifecycle, error)

type OnStartedFunc = func(Lifecycle, error)

type OnStartingFunc = func(Lifecycle)

type Option interface {
	Apply(lifecycle Lifecycle)
}

type Retryable[LIFECYCLE Lifecycle] struct {
	Lifecycle
	// contains filtered or unexported fields
}

type RunFunc = func(Lifecycle) error

type Runner interface {
	DoStart(Lifecycle) error

	DoRun(Lifecycle) error

	DoClose(Lifecycle) error
}

type StartFunc = func(Lifecycle) error

type Starter interface {
	DoStart(Lifecycle) (runFn RunFunc, closeFn CloseFunc, err error)
}

type StarterFunc func(Lifecycle) (runFn RunFunc, closeFn CloseFunc, err error)

type State int

type StateClosedError struct {
	Target string
}

type StateClosingError struct {
	Target string
}

type StateConflictError struct {
	Target   string
	State    string
	Conflict string
}

type StateDependencyError struct {
	Target string
	State  string
	Depend string
}

type StateInfo struct {
	State     State
	UpperName string
	LowerName string
}

type StateMustSwitchError struct {
	Target string
	Form   string
	To     string
}

type StateNotAllowSwitchError struct {
	Target string
	Form   string
	To     string
}

type StateNotClosedError struct {
	Target string
}

type StateNotRunningError struct {
	Target string
}

type StateRunningError struct {
	Target string
}

type StateStartingError struct {
	Target string
}

type SyncFutures[V any] struct {
	sync.Mutex
	// contains filtered or unexported fields
}

type UnknownStateError struct {
	Target string
	State  State
}

type WaitableFuture[V any] interface {
	Future[V]

	Wait() V
}

type WaiterFuture[V any] struct {
	// contains filtered or unexported fields
}