for (std::uint8_t i = 0;

i < static_cast<std::uint8_t>(http_method::count_); ++i) {

auto m = static_cast<http_method>(i);

if (methods.contains(m)) fn(m);

}

std::random_device rd;

static constexpr char kHex[] = "0123456789abcdef";

std::string out;

out.reserve(32);

for (int i = 0; i < 8; ++i) {

uint32_t sample = static_cast<uint32_t>(rd());

// Pack 4 bytes -> 8 hex chars per std::random_device sample.

for (int b = 0; b < 4; ++b) {

uint32_t octet = (sample >> (b * 8)) & 0xFFu;

out.push_back(kHex[(octet >> 4) & 0xFu]);

out.push_back(kHex[octet & 0xFu]);

}

}

return out;

: parent(parent), daemon_(this, bind_socket_val),

#ifdef HAVE_WEBSOCKET

// Declared with ws_ (before the services block), so it must be

// initialised before errors_ here to satisfy -Wreorder.

ws_upgrader_(ws_),

#endif // HAVE_WEBSOCKET

errors_(parent->config), hooks_dispatch_(hooks_, parent->config),

response_mat_(errors_, hooks_dispatch_, digest_opaque_, parent->config),

upload_(parent->config),

dispatcher_(routes_, hooks_dispatch_, errors_, response_mat_,

#ifdef HAVE_WEBSOCKET

ws_upgrader_,

#endif // HAVE_WEBSOCKET

parent->config),

pipeline_(hooks_dispatch_, dispatcher_, parent->config) {

// Guard against null parent: the dispatch helpers (not_found_page,

// method_not_allowed_page, internal_error_page, etc.) read the const

// config bag on `parent` and will dereference this pointer on every

// request. The only valid call site is webserver::webserver, which

// always passes `this` — a non-null pointer to the owning webserver.

// (daemon_ was already constructed with owner=this above; it stores the

// pointer but never dereferences parent config until start(). The

// config-reading behavior services below -- errors_ and the ones added

// in later DR-014 steps -- DO bind parent->config in this init list, so

// a non-null parent is a hard construction precondition; the sole caller

// webserver::webserver satisfies it by passing `this`.)

if (parent == nullptr) {

throw std::invalid_argument(

"webserver_impl requires a non-null owning webserver pointer");

}

#ifdef HAVE_DAUTH

digest_opaque_ = generate_random_hex_opaque_();

#endif // HAVE_DAUTH

method_set methods) {

const detail::route_entry* existing = routes_.find_v2_entry_by_path_(idx);

if (existing == nullptr) {

return {std::make_shared<detail::lambda_resource>(), /*fresh=*/true};

}

// Existing entry. route_entry::handler is a

// shared_ptr<http_resource>. Dynamic-cast to

// lambda_resource: if the cast misses, a class-based

// register_path/register_prefix owns this path and we must throw.

auto shim = std::dynamic_pointer_cast<detail::lambda_resource>(

existing->handler);

if (!shim) {

throw std::invalid_argument(

"A non-lambda http_resource is already registered at "

"this path; on_*/route cannot share a path with "

"register_path/register_prefix");

}

// Atomicity pre-check: every requested slot must be empty BEFORE

// we mutate any of them.

for_each_requested_method(methods, [&](http_method m) {

if (shim->has_slot(m)) {

throw std::invalid_argument(

"A handler is already registered for one of the "

"requested methods on this path");

}

});

return {shim, /*fresh=*/false};

method_set methods,

std::function<::httpserver::http_response(

const ::httpserver::http_request&)> handler) {

// Collect the set of requested methods in iteration order so the

// loop below can identify the last one. Using a small inline array

// avoids a heap allocation in the common case (N <= 9 methods).

//

// Move-into-last-slot optimisation:

// all but the last slot receive a copy; the last slot is populated

// by moving the handler, avoiding one extra heap allocation when the

// std::function's capture is too large for the SBO buffer.

std::array<http_method, static_cast<std::size_t>(http_method::count_)> buf{};

std::size_t count = 0;

for_each_requested_method(methods, [&](http_method m) {

buf[count++] = m;

});

for (std::size_t i = 0; i < count; ++i) {

if (i + 1 < count) {

shim.set_slot(buf[i], handler); // copy

} else {

shim.set_slot(buf[i], std::move(handler)); // move into last slot

}

}