accept_decision,

request_received,

route_resolved,

before_handler,

handler_exception,

after_handler,

response_sent,

request_completed,

count_, // sentinel; must remain last

http::status status; // invalid -> the engine's default synthesis

http::fields fields;

std::vector<std::byte> body;

public:

hook_action() noexcept = default;

hook_action(const hook_action&) = delete;

hook_action& operator=(const hook_action&) = delete;

hook_action(hook_action&&) noexcept = default;

hook_action& operator=(hook_action&&) noexcept = default;

~hook_action() = default;

[[nodiscard]] static hook_action pass() noexcept {

return hook_action{};

}

[[nodiscard]] static hook_action respond_with(hook_response r) noexcept {

hook_action a;

a.response_.emplace(std::move(r));

return a;

}

[[nodiscard]] bool is_pass() const noexcept {

return !response_.has_value();

}

// Consumes the wrapped response. Precondition: !is_pass().

[[nodiscard]] hook_response&& take_response() && noexcept {

assert(response_.has_value()

&& "take_response() called on a pass-action");

return std::move(*response_);

}

private:

std::optional<hook_response> response_{};

std::string_view pattern; // views the registry's stored pattern

http::method_set methods;

bool is_prefix = false;

net::peer_address peer;

bool accepted = true;

peer_refusal reason = peer_refusal::none;

const http::request_head& request;

bool matched = false; // fires on a hit AND a miss alike

route_descriptor route; // empty pattern on a miss

const http::request_head& request;

http::status status;

http::fields fields;

const http::request_head& request;

bool succeeded = true;

http::outcome end; // ok on success; typed end reason

public:

hook_handle() noexcept = default;

hook_handle(const hook_handle&) = delete;

hook_handle& operator=(const hook_handle&) = delete;

hook_handle(hook_handle&&) noexcept = default;

hook_handle& operator=(hook_handle&&) noexcept = default;

~hook_handle();

// Erases the registration. Idempotent; a no-op when disarmed or

// when the bus is gone.

void remove() noexcept;

// Disarms the destructor, making the registration permanent.

void detach() noexcept;

// False after remove(), detach(), or a move-out.

bool armed() const noexcept { return key_ != 0; }

private:

friend class hook_bus;

hook_handle(std::uint64_t key, std::uint8_t phase,

std::weak_ptr<detail::hook_bus_impl> owner) noexcept;

std::uint64_t key_ = 0; // 0 = disarmed

std::uint8_t phase_ = 0;

std::weak_ptr<detail::hook_bus_impl> owner_;

public:

hook_bus();

~hook_bus();

hook_bus(const hook_bus&) = delete;

hook_bus& operator=(const hook_bus&) = delete;

hook_bus(hook_bus&&) noexcept;

hook_bus& operator=(hook_bus&&) noexcept;

// Registers @p hook for phase P. The callable's sole `Ctx&`

// parameter must be the phase's context type (statically

// enforced). Registration order within the phase is the firing

// order.

template <hook_phase P, typename F>

hook_handle add(F&& hook) {

using ctx = typename detail::hook_arg<std::decay_t<F>>::type;

static_assert(

std::is_same_v<ctx, detail::phase_ctx_t<P>>,

"hook context type does not match the registered phase");

const std::uint64_t key = detail::hook_bus_add(

impl_, static_cast<std::uint8_t>(P),

concurrency::unique_function<hook_action(void*)>(

[call = std::forward<F>(hook)](void* erased) -> hook_action {

return call(*static_cast<ctx*>(erased));

}));

return hook_handle(key, static_cast<std::uint8_t>(P), impl_);

}

// True once the phase holds at least one live registration.

bool any_hooks(hook_phase p) const noexcept {

return detail::hook_bus_any(impl_, static_cast<std::uint8_t>(p));

}

// The engine-facing firing seam: invokes the phase's hooks in

// registration order over a snapshot; the first respond_with wins

// and later hooks of the phase do not run. A throwing hook is

// contained and treated as pass() (the v2 rule).

template <hook_phase P>

hook_action fire(typename detail::phase_ctx_t<P>& ctx) const {

std::exception_ptr ignored;

return fire<P>(ctx, ignored);

}

// The D4-recording form of the seam: @p contained receives the

// FIRST exception a hook of the phase threw (cleared first), so

// the dispatcher can surface it through the handler_exception

// chain; a clean fire leaves it null.

template <hook_phase P>

hook_action fire(typename detail::phase_ctx_t<P>& ctx,

std::exception_ptr& contained) const {

return detail::hook_bus_fire(impl_, static_cast<std::uint8_t>(P),

&ctx, &contained);

}

private:

std::shared_ptr<detail::hook_bus_impl> impl_;