executors

type CRONRule struct {
	// Expr cron expr
	Expr string `json:"expr,omitempty"`

	// Timezone default UTC
	Timezone string `json:"timezone,omitempty"`
}

type Callable[T any] interface {
	Call(ctx context.Context) (T, error)
}

type CallableFunc[T any] func(ctx context.Context) (T, error)

type CallerRunsRejectionPolicy struct {
}

type CancelFunc = func()

type CatchFunction func(err error)

type DiscardErrorHandler struct {
}

type DiscardRejectionPolicy struct {
}

type ErrInvalidState struct {
	// contains filtered or unexported fields
}

type ErrPanic struct {
	Cause interface{}
}

type ErrorHandler interface {
	CatchError(runnable Runnable, e error)
}

type ErrorHandlerFunc func(runnable Runnable, e error)

type Executor interface {
	// Execute execute a task in background
	// Will return ErrShutdown if shutdown already
	// Will return ErrRejectedExecution if task out of cap
	Execute(Runnable) error

	// Shutdown shutdown the executor
	// Will wait the queued task to be finish
	Shutdown(ctx context.Context) error
}

type ExecutorService[T any] interface {
	Executor

	// Submit execute a task with result async, and can get the task result via get
	Submit(callable Callable[T]) (Future[T], error)
}

type Future[T any] interface {
	Get(ctx context.Context) (T, error)
	Then(thenFunc ThenFunction[T]) Future[T]
	Catch(catchFunc CatchFunction) Future[T]
	Cancel() bool
	Canceled() bool
	Completed() bool
	CompletedError() bool
}

type FutureTask[T any] struct {
	// contains filtered or unexported fields
}

type LogErrorHandler struct {
}

type NoopErrorHandler struct {
}

type NoopRejectionPolicy struct {
}

type PoolExecutor[T any] struct {
	// contains filtered or unexported fields
}

type PoolScheduleExecutor struct {
	*PoolExecutor[any]
	// contains filtered or unexported fields
}

type RejectionHandler interface {
	RejectExecution(runnable Runnable, e Executor) error
}

type Runnable interface {
	Run(ctx context.Context)
}

type RunnableFunc func(ctx context.Context)

type ScheduledExecutor interface {
	Executor
	// Schedule run a one time task after delay duration
	Schedule(r Runnable, delay time.Duration) (CancelFunc, error)

	// ScheduleAtFixRate schedule a periodic task in fixed rate
	ScheduleAtFixRate(r Runnable, period time.Duration) (CancelFunc, error)

	// ScheduleAtCronRate schedule at periodic cron task
	ScheduleAtCronRate(r Runnable, rule CRONRule) (CancelFunc, error)
}

type ThenFunction[T any] func(val T)