ddn.hap

One attached handler record inside HapState, identified by a monotonically increasing id so Registration handles stay stable across splices.

Heap-backed state shared between a hap and its Registration handles, generic over the record type.

State-keyed registration implementation behind the public Registration alias.

Registration-keyed scoped wrapper behind the public ScopedRegistration alias.

One stored detach callback inside RegistrationBag.

Shared state behind a pending registerOneShot registration.

Registration-keyed one-shot handle behind the public OneShotRegistration alias.

Heap-anchored registration so an owner-held container can hold a registration by pointer and keep its detach callback addressable. Works for any handle type exposing attached() and detach().

An owner-held container that detaches multiple heterogeneous registrations in bulk.

RegistrationBag stores registrations from any number of Hap or NothrowHap instances, regardless of their argument types, using internal type erasure. Call clear() or let the bag be destroyed to detach all live registrations.

Multiple private bags are expected in real programs: each component, library, plugin, controller, or test fixture that creates registrations should own its own bag. A global or shared bag is not recommended.

RegistrationBag is non-copyable and move-only.

A multicast hap that invokes all attached handlers synchronously.

Hap is the general-purpose, GC-backed variant for ordinary application code. It accepts @safe handlers, supports throwing handlers, and uses snapshot dispatch semantics: mutations made during emit affect later emits, not the handler slice currently being iterated.

Hap is intentionally not thread-safe. Use it as thread-confined owned state, or provide external synchronization when deliberately sharing an owning object.

A multicast hap restricted to handlers that cannot throw exceptions.

NothrowHap has the same ownership and snapshot semantics as Hap, but its handlers are nothrow, so emit is also nothrow.

A fixed-capacity multicast hap for @nogc nothrow dispatch paths.

StaticHap stores handlers inline, never allocates, and reports attachment failure when the configured capacity is reached.

StaticHap does not provide register because the registration lifetime model requires heap-backed state that would compromise @nogc dispatch. Use attach and detach for StaticHap handler management.

An observable value that emits when assignment changes the stored value.

Property!T is a small subject in observer-pattern terms: it owns one value of type T and emits onChanged with the old and new values whenever a successful assignment occurs. Unchanged assignments (where the new value compares equal to the old value) do not emit.

Equality is `==`, which is what users expect for strings, arrays and structs. The floating-point consequence: NaN == NaN is false, so assigning NaN to a NaN-valued property emits every time, while -0.0 and 0.0 compare equal and do not emit.

Property is non-copyable because the embedded onChanged hap is an owned notification channel. Move semantics are available via core.lifetime.move.

One attached handler record in SharedState, keyed by a monotonically increasing id so SharedRegistration handles stay stable across splices.

Lock-protected handler list shared by all SharedHap handles and threads.

A thread-safe registration handle returned by SharedHap, SharedHap.register.

SharedRegistration represents exactly one attached handler on a SharedHap and provides explicit, idempotent detach. Both attached() and detach() take the internal lock and look the record up by its id, so the handle stays valid across handler-list splices and concurrent emits. It is non-copyable, move-only, and inert when default-initialised or moved-from.

A thread-safe multicast hap that invokes all attached handlers synchronously.

SharedHap provides the same attach/detach/emit semantics as Hap but with internal synchronization for safe use across threads. Every public method is a this This template, so the hap is usable both as a plain local (SharedHap!T) and as a field of a shared object (shared SharedHap!T) with no casts at call sites.

Handlers are invoked outside the internal lock to prevent deadlocks during re-entrant calls. The internal state is published with an atomic compare-and-swap on first use and every access reads it with acquire semantics, so concurrent first use from multiple threads is safe: no handler is ever lost to an initialization race.

Snapshot semantics: emit captures a snapshot of current handlers under the lock, then releases the lock before invoking handlers. Mutations during emit affect future snapshots, not the current one. A handler already captured in an in-flight snapshot may still run after detach or detachAll returns.

Handler model: handlers are void delegate(Args) @safe, not shared delegates. Handlers run on the emitting thread and must be thread-safe by construction; SharedHap protects only its own handler list, nothing the handlers themselves touch.

SharedHap is non-copyable and move-only. It uses reference-backed shared state so in-flight snapshots remain valid even if the public SharedHap value is moved or destroyed after snapshot capture. Moving the struct value while another thread holds a reference to it is the caller's race; only the heap state is protected.

A multicast hap that dispatches handlers in priority order.

PriorityHap associates each handler with an integer priority. Handlers with lower priority values run first. Handlers with equal priority run in stable attachment order. This is a separate type from Hap to keep normal attachment-order dispatch simple and fast.

PriorityHap supports attach, detach, detachAll, emit, and hasHandlers/handlerCount. It is non-copyable and move-only.

Cancellation state passed to handlers during a CancellableHap emit.

A handler calls cancel() to stop later handlers in the same emit from running. Cancellation is one-way: once cancelled, it cannot be undone.

A multicast hap that supports propagation-stopping workflows.

CancellableHap passes a CancelToken as the first argument to each handler. When a handler calls token.cancel(), subsequent handlers in that emit are skipped. Handlers before cancellation run in attachment order.

This is a separate type from Hap to keep normal dispatch simple and to make cancellation explicit at the handler signature level.

A multicast hap whose handlers return a value that is collected.

QueryHap is an observer container where every handler answers the query: emit invokes all attached handlers in attachment order and returns their results as a Result[]. Use it to fan a request out to several responders and gather every answer, such as validation votes, plugin lookups, or metric samples.

Snapshot semantics: emit captures the handler list at dispatch start, so attaching or detaching during dispatch affects only future emissions.

A hap that replays the last emitted value to newly attached handlers.

ReplayHap stores the most recent arguments from the last emit call. When a handler is attached, it immediately receives the stored value if one exists. Subsequent emit calls update the stored value and invoke all handlers as usual.

Two semantics distinguish ReplayHap from the core haps:

• attach invokes the new handler synchronously with the stored value, even while an emit on the same hap is in flight. This is a deliberate exception to the core rule that a handler attached during emit runs only on a later emit: a late observer must not miss the current value.
• emit stores the new value before dispatching. If a handler throws, the stored value is already updated and later attaches replay it.

This is useful for state-like values such as settings, selection state, or configuration values where new observers need the current value immediately.

Shared implementation core of the dynamic hap family.

HapCore provides the storage, attach/detach/register surface, count queries and dispatch bookkeeping common to Hap, NothrowHap and the specialised variants. It is a mixin template so each hap struct keeps its value semantics; attributes beyond the explicit @safe (nothrow, @nogc) are inferred per instantiation exactly as they were before the mixin existed.