rxn

type KeyedEvent = internal.KeyedEvent

type MapCodec[K comparable, T any] = states.MapCodec[K, T]

type MapSpec[K comparable, T any] interface {
	StateFor(subject Subject) MapState[K, T]
}

type MapState[K comparable, V any] interface {
	Get(key K) (V, bool)
	Set(key K, value V)
	Delete(key K)
	All() iter.Seq2[K, V]
	Size() int
}

type OperatorHandler interface {
	// Called when a new event arrives. The subject is a set of APIs scoped to
	// the specific partition key being used. Because of this scoping, think of this
	// as the subject (e.g. a User, a Product) in your domain.
	OnEvent(ctx context.Context, subject Subject, event KeyedEvent) error

	// A previously set timer expires. This is an asynchronous action where the
	// timer fires at the specified time AT THE EARLIEST. That means that events
	// after the timer's timestamp have likely already arrived.
	OnTimerExpired(ctx context.Context, subject Subject, timer time.Time) error
}

type ScalarMapCodec[K comparable, V any] struct{}

type ScalarValueCodec[T states.ProtoScalar] struct{}

type Sink[T any] interface {
	Collect(ctx context.Context, value T)
}

type Subject interface {
	// Timestamp returns the timestamp associated with the current event.
	Timestamp() time.Time
	// Key returns the key associated with the current event.
	Key() []byte
	// SetTimer sets a timer for the current key. After the timer expires, the
	// OnTimerExpired method will be called with this timestamp.
	SetTimer(ts time.Time)
	// Watermark returns the current watermark
	Watermark() time.Time
}

type ValueCodec[T any] interface {
	Encode(value T) ([]byte, error)
	Decode(b []byte) (T, error)
}

type ValueSpec[T any] interface {
	StateFor(subject Subject) ValueState[T]
}

type ValueState[T any] interface {
	Value() T
	Set(value T)
	Drop()
}