actorlayer

type Actor[M any] interface {
	Receive(ctx Context, env TypedEnvelope[M]) error
}

type ActorFunc[M any] func(ctx Context, env TypedEnvelope[M]) error

type ActorID string

type ActorRef[M any] struct {
	// contains filtered or unexported fields
}

type AskOption interface {
	// contains filtered or unexported methods
}

type Behavior interface {
	Receive(ctx Context, env Envelope) error
}

type BoundedMailboxConfig struct {
	Capacity   int
	FullPolicy MailboxFullPolicy
}

type Clock interface {
	Now() time.Time
}

type Config struct {
	NodeID                 string
	DefaultMailbox         MailboxFactory
	DeadLetters            DeadLetterSink
	Observer               Observer
	Tracer                 Tracer
	Supervision            SupervisorStrategy
	Clock                  Clock
	MaxActors              int
	MaxTotalQueued         int
	DefaultAskLimit        time.Duration
	TellRateLimitPerSecond int
	ShutdownPolicy         ShutdownPolicy
	ShutdownPollInterval   time.Duration
}

type Context interface {
	context.Context

	Self() Ref
	Parent() *Ref
	Sender() *Ref

	Tell(ctx context.Context, to Ref, payload any, opts ...TellOption) error
	TellAfter(ctx context.Context, delay time.Duration, to Ref, payload any, opts ...TellOption) (Scheduled, error)
	Ask(ctx context.Context, to Ref, payload any, opts ...AskOption) (Envelope, error)

	Spawn(ctx context.Context, name string, props Props, opts ...SpawnOption) (Ref, error)
	Stop(ctx context.Context, ref Ref) error
	Watch(ctx context.Context, ref Ref) error

	State() State
	Publish(ctx context.Context, topic string, payload any) error
}

type CorrelationID string

type DeadLetter struct {
	Envelope Envelope
	Reason   string
	Err      error
}

type DeadLetterSink interface {
	HandleDeadLetter(ctx context.Context, letter DeadLetter)
}

type DefaultSupervisor struct{}

type Directive int

type Envelope struct {
	ID            MessageID
	CorrelationID CorrelationID

	To      Ref
	From    Ref
	ReplyTo *Ref

	Headers map[string]string
	Payload any

	Deadline time.Time
	SentAt   time.Time
}

type EnvelopeMeta struct {
	ID            MessageID
	CorrelationID CorrelationID

	To      Ref
	From    Ref
	ReplyTo *Ref

	Headers  map[string]string
	Deadline time.Time
	SentAt   time.Time
}

type EventActor[M any] interface {
	OnEvent(ctx Context, env TypedEnvelope[M]) error
}

type EventActorFunc[M any] func(ctx Context, env TypedEnvelope[M]) error

type Failure struct {
	Actor   Ref
	Message Envelope
	Err     error
	Panic   any
	At      time.Time
}

type Mailbox interface {
	Enqueue(ctx context.Context, env Envelope) error
	Dequeue(ctx context.Context) (Envelope, error)
	Len() int
	Close() error
}

type MailboxFactory interface {
	NewMailbox(actorID ActorID) (Mailbox, error)
}

type MailboxFullPolicy int

type MessageID string

type NopDeadLetterSink struct{}

type NopObserver struct{}

type NopTracer struct{}

type Observer interface {
	OnActorSpawn(actorID ActorID)
	OnActorStop(actorID ActorID)
	OnTellEnqueue(actorID ActorID)
	OnAskStart(actorID ActorID)
	OnAskDone(actorID ActorID, err error)
	OnReceive(actorID ActorID, duration time.Duration, err error, panicValue any)
	OnRestart(actorID ActorID)
	OnDeadLetter(letter DeadLetter)
}

type Props struct {
	Kind        string
	NewBehavior func(ctx SpawnContext) (Behavior, error)

	Mailbox    MailboxFactory
	Supervisor SupervisorStrategy
}

type PublishedMessage struct {
	Topic   string
	Payload any
}

type ReceiveFunc func(ctx Context, env Envelope) error

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

type RequestActor[Req any, Resp any] interface {
	Handle(ctx Context, env TypedEnvelope[Req]) (Resp, error)
}

type RequestActorFunc[Req any, Resp any] func(ctx Context, env TypedEnvelope[Req]) (Resp, error)

type Scheduled interface {
	// Cancel stops the scheduled delivery if it has not fired yet.
	Cancel() bool
	// Done is closed when scheduling completes, returning the final send result.
	Done() <-chan error
}

type ShutdownPolicy int

type Span interface {
	AddEvent(name string, attrs TraceAttrs)
	End(err error)
}

type SpawnContext struct {
	Self   Ref
	Parent *Ref
}

type SpawnOption interface {
	// contains filtered or unexported methods
}

type Started struct {
	Actor Ref
}

type State interface {
	Get(key string) (any, bool)
	Set(key string, value any)
	Delete(key string)
}

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

type StatsSnapshot struct {
	ActorSpawns     int64
	ActorStops      int64
	TellEnqueues    int64
	AskStarts       int64
	AskFailures     int64
	Receives        int64
	ReceiveFailures int64
	ReceivePanics   int64
	Restarts        int64
	DeadLetters     int64
	ReceiveDurTotal time.Duration
}

type Stopped struct {
	Actor Ref
}

type SupervisionContext struct {
	System *System
}

type SupervisorStrategy interface {
	Decide(ctx SupervisionContext, failure Failure) Directive
}

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

type TellOption interface {
	// contains filtered or unexported methods
}

type Terminated struct {
	ActorID ActorID
}

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

type ThresholdSupervisorConfig struct {
	Base        SupervisorStrategy
	MaxRestarts int
	Window      time.Duration
	OnExceeded  Directive
}

type TraceAttrs map[string]string

type Tracer interface {
	Start(ctx context.Context, name string, attrs TraceAttrs) (context.Context, Span)
}

type TypedEnvelope[M any] struct {
	Meta    EnvelopeMeta
	Message M
}

type TypedProps[M any] struct {
	Kind     string
	NewActor func(ctx SpawnContext) (Actor[M], error)

	Mailbox    MailboxFactory
	Supervisor SupervisorStrategy
}