refactor: rename radix_tree->segment_trie and modded_request::dhr->request

Two mechanical renames (bundled -- they overlap in webserver_request.cpp
and webserver_dispatch.cpp, so they cannot be split cleanly at file
granularity). Both are pure renames; no behavior change. Build green,
full suite 109/109.

1. radix_tree data structure -> segment_trie
   The structure is an uncompressed per-segment trie (one node per '/'-
   delimited path segment, no edge compression), not a radix tree:
     radix_tree     -> segment_trie
     radix_node     -> segment_trie_node
     radix_match    -> segment_trie_match
     radix_tree.hpp -> segment_trie.hpp (+ include guard)
   plus "radix tree"/"radix-tree" prose -> "segment trie". The route
   *tier* keeps its historical name (route_tier_kind::radix, "radix
   tier", upsert_v2_radix_route) -- a separate concept (the
   parameterized-path tier), out of scope here.

2. modded_request::dhr member -> request
   `dhr` was inherited v1 shorthand carried through ~50 dispatch call
   sites as mr->dhr; now mr->request. Unrelated local `dhr` header-map
   variables in http_request_impl.cpp and the v1 baseline benchmark are
   left untouched.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: etr

src/Makefile.am

@@ -29,7 +29,7 @@ libhttpserver_la_SOURCES = string_utilities.cpp webserver.cpp webserver_add_hook
 # noinst_HEADERS: shipped in the tarball but NEVER installed under $prefix/include.
 # Detail headers (httpserver/detail/*.hpp) live here so they cannot leak to
 # downstream consumers — the public surface comes in through <httpserver.hpp>.
-noinst_HEADERS = httpserver/string_utilities.hpp httpserver/detail/modded_request.hpp httpserver/detail/http_endpoint.hpp httpserver/detail/body.hpp httpserver/detail/webserver_impl.hpp httpserver/detail/webserver_impl_dispatch.hpp httpserver/detail/connection_state.hpp httpserver/detail/secure_zero.hpp httpserver/detail/http_request_impl.hpp httpserver/detail/resource_hook_table.hpp httpserver/detail/route_entry.hpp httpserver/detail/lambda_resource.hpp httpserver/detail/radix_tree.hpp httpserver/detail/route_cache.hpp httpserver/detail/route_tier.hpp httpserver/detail/unescape_helpers.hpp gettext.h
+noinst_HEADERS = httpserver/string_utilities.hpp httpserver/detail/modded_request.hpp httpserver/detail/http_endpoint.hpp httpserver/detail/body.hpp httpserver/detail/webserver_impl.hpp httpserver/detail/webserver_impl_dispatch.hpp httpserver/detail/connection_state.hpp httpserver/detail/secure_zero.hpp httpserver/detail/http_request_impl.hpp httpserver/detail/resource_hook_table.hpp httpserver/detail/route_entry.hpp httpserver/detail/lambda_resource.hpp httpserver/detail/segment_trie.hpp httpserver/detail/route_cache.hpp httpserver/detail/route_tier.hpp httpserver/detail/unescape_helpers.hpp gettext.h
 nobase_include_HEADERS = httpserver.hpp httpserver/body_kind.hpp httpserver/cookie.hpp httpserver/constants.hpp httpserver/create_webserver.hpp httpserver/create_webserver_setters.hpp httpserver/create_test_request.hpp httpserver/webserver.hpp httpserver/webserver_routes.hpp httpserver/webserver_runtime.hpp httpserver/webserver_websocket.hpp httpserver/webserver_hooks.hpp httpserver/websocket_handler.hpp httpserver/http_utils.hpp httpserver/http_utils_inet.hpp httpserver/ip_representation.hpp httpserver/file_info.hpp httpserver/http_request.hpp httpserver/http_request_auth.hpp httpserver/http_request_getters.hpp httpserver/http_response.hpp httpserver/http_response_factories.hpp httpserver/http_resource.hpp httpserver/feature_unavailable.hpp httpserver/iovec_entry.hpp httpserver/http_arg_value.hpp httpserver/http_method.hpp httpserver/hook_phase.hpp httpserver/hook_action.hpp httpserver/hook_handle.hpp httpserver/hook_context.hpp
 
 AM_CXXFLAGS += -fPIC -Wall

src/detail/webserver_aliases.cpp

@@ -101,7 +101,7 @@ void install_internal_error_alias(
     impl->handler_exception_alias_ =
         [user_handler = std::move(user_handler)](
                 const handler_exception_ctx& ctx) -> hook_action {
-            // mr->dhr is always non-null at the call site in
+            // mr->request is always non-null at the call site in
             // handle_dispatch_exception; this guard is purely defensive for
             // any future call site that relaxes that invariant. If that
             // invariant is violated in debug builds, assert fires first.

src/detail/webserver_body_pipeline.cpp

@@ -99,7 +99,7 @@ bool fire_and_maybe_short_circuit_body_chunk(webserver_impl* impl,
     // upload callback (the *upload_data_size == 0 call that routes to
     // complete_request), which never reaches this fire site.
     ::httpserver::body_chunk_ctx ctx{
-        mr->dhr.get(),
+        mr->request.get(),
         std::as_bytes(std::span<const char>(upload_data, upload_data_size)),
         mr->body_bytes_seen,
         /*is_final=*/false};
@@ -199,11 +199,11 @@ MHD_Result webserver_impl::requests_answer_first_step(MHD_Connection* connection
     // MHD_CONNECTION_INFO_SOCKET_CONTEXT, then allocates the http_request_impl
     // from that arena. The arena plumbing is therefore implicit at this call
     // site but explicit within the constructor.
-    mr->dhr.reset(new http_request(connection, parent->unescaper));
-    mr->dhr->set_file_cleanup_callback(parent->file_cleanup_callback);
+    mr->request.reset(new http_request(connection, parent->unescaper));
+    mr->request->set_file_cleanup_callback(parent->file_cleanup_callback);
     // Propagate the redaction-bypass bit so operator<< honours
     // the builder opt-in for every request the webserver dispatches.
-    mr->dhr->set_expose_credentials_in_logs(parent->expose_credentials_in_logs);
+    mr->request->set_expose_credentials_in_logs(parent->expose_credentials_in_logs);
 
     // request_received hook. Fires after the http_request is
     // populated but before any body bytes are read (and before any
@@ -216,7 +216,7 @@ MHD_Result webserver_impl::requests_answer_first_step(MHD_Connection* connection
     // No post-processor exists at this point, so no teardown is needed.
     if (has_hooks_for(::httpserver::hook_phase::request_received)) {
         ::httpserver::request_received_ctx ctx{
-            mr->dhr.get(),
+            mr->request.get(),
             std::chrono::steady_clock::now()};
         if (auto sc = fire_request_received(ctx)) {
             mr->response.emplace(std::move(*sc));
@@ -229,7 +229,7 @@ MHD_Result webserver_impl::requests_answer_first_step(MHD_Connection* connection
         return MHD_YES;
     }
 
-    mr->dhr->set_content_size_limit(parent->content_size_limit);
+    mr->request->set_content_size_limit(parent->content_size_limit);
     const char *encoding = MHD_lookup_connection_value(connection, MHD_HEADER_KIND, http_utils::http_header_content_type);
 
     if (parent->post_process_enabled &&
@@ -265,7 +265,7 @@ MHD_Result webserver_impl::requests_answer_second_step(MHD_Connection* connectio
     }
 
     // body_chunk hook fires per chunk BEFORE the bytes are
-    // appended to mr->dhr / fed to MHD_post_process.
+    // appended to mr->request / fed to MHD_post_process.
     if (has_hooks_for(::httpserver::hook_phase::body_chunk)) {
         if (fire_and_maybe_short_circuit_body_chunk(
                 this, mr, upload_data, *upload_data_size)) {
@@ -294,7 +294,7 @@ MHD_Result webserver_impl::requests_answer_second_step(MHD_Connection* connectio
     // all other content (which is indicated by mr-pp == nullptr)
     // has to be put to the content even if put_processed_data_to_content is set to false
     if (mr->pp == nullptr || parent->put_processed_data_to_content) {
-        mr->dhr->grow_content(upload_data, *upload_data_size);
+        mr->request->grow_content(upload_data, *upload_data_size);
     }
     run_post_processor_if_attached(mr, parent, upload_data, *upload_data_size);
 

src/detail/webserver_callbacks.cpp

@@ -99,7 +99,7 @@ void webserver_impl::request_completed(void *cls, struct MHD_Connection *connect
     // Fire request_completed BEFORE the modded_request is
     // destroyed so the ctx pointers remain backed by live storage. The
     // gate-and-fire helper reads any_hooks_[request_completed] and
-    // builds the ctx from mr->dhr, mr->response, and the MHD
+    // builds the ctx from mr->request, mr->response, and the MHD
     // termination code. The fire site is the very first thing this
     // callback does, while mr is still untouched.
     auto* mr = static_cast<detail::modded_request*>(*con_cls);
@@ -380,9 +380,9 @@ MHD_Result webserver_impl::handle_post_form_arg(detail::modded_request* mr,
     // means MHD is feeding us a continuation chunk of a previously-
     // started value, so append rather than replace.
     if (off > 0) {
-        mr->dhr->grow_last_arg(key, std::string(data, size));
+        mr->request->grow_last_arg(key, std::string(data, size));
     } else {
-        mr->dhr->set_arg(key, std::string(data, size));
+        mr->request->set_arg(key, std::string(data, size));
     }
     return MHD_YES;
 }
@@ -435,7 +435,7 @@ void webserver_impl::manage_upload_stream(detail::modded_request* mr,
 MHD_Result webserver_impl::process_file_upload(detail::modded_request* mr,
         const char* key, const char* filename, const char* content_type,
         const char* transfer_encoding, const char* data, size_t size) const {
-    http::file_info& file = mr->dhr->get_or_create_file_info(key, filename);
+    http::file_info& file = mr->request->get_or_create_file_info(key, filename);
     if (file.get_file_system_file_name().empty()) {
         if (!setup_new_upload_file_info(file, filename, content_type, transfer_encoding)) {
             return MHD_NO;
@@ -463,8 +463,8 @@ MHD_Result webserver_impl::post_iterator(void *cls, enum MHD_ValueKind kind,
 
     try {
         if (mr->ws->file_upload_target != FILE_UPLOAD_DISK_ONLY) {
-            mr->dhr->set_arg_flat(key,
-                std::string(mr->dhr->get_arg(key)) + std::string(data, size));
+            mr->request->set_arg_flat(key,
+                std::string(mr->request->get_arg(key)) + std::string(data, size));
         }
         if (*filename != '\0' && mr->ws->file_upload_target != FILE_UPLOAD_MEMORY_ONLY) {
             MHD_Result r = mr->ws->impl_->process_file_upload(

src/detail/webserver_dispatch.cpp

@@ -226,7 +226,7 @@ webserver_impl::lookup_v2(http_method method, const std::string& path) {
         std::shared_lock table_lock(route_table_mutex_);
 
         // Radix tier — segment-trie walk.
-        radix_match<route_entry> rm;
+        segment_trie_match<route_entry> rm;
         if (param_and_prefix_routes_.find(key.path, rm) && rm.entry) {
             result.found = true;
             result.tier = tier_hit::radix;
@@ -314,9 +314,9 @@ bool webserver_impl::resolve_resource_for_request(detail::modded_request* mr,
     // Replay captured URL parameters into the request. Per-name
     // set_arg matches v1 behaviour exactly — duplicates with later
     // wins, etc.
-    if (mr->dhr != nullptr) {
+    if (mr->request != nullptr) {
         for (const auto& [name, value] : result.captured_params) {
-            mr->dhr->set_arg(name, value);
+            mr->request->set_arg(name, value);
         }
     }
 
@@ -369,7 +369,7 @@ void handle_dispatch_exception(
         // (Naming the capture makes clear we are taking a reference to
         // the in-flight exception object.)
         auto current_exc = std::current_exception();
-        handler_exception_ctx ctx{mr->dhr.get(), current_exc, message};
+        handler_exception_ctx ctx{mr->request.get(), current_exc, message};
         if (server_chain) {
             if (auto sc = impl->fire_handler_exception(ctx)) {
                 mr->response.emplace(std::move(*sc));
@@ -427,7 +427,7 @@ void webserver_impl::dispatch_resource_handler(detail::modded_request* mr,
             // by value; the prvalue is moved into the
             // per-connection optional anchor. shared_ptr has no
             // operator->*, so call as ((*ptr).*pmf)(...).
-            mr->response.emplace(((*hrm).*(mr->callback))(*mr->dhr));
+            mr->response.emplace(((*hrm).*(mr->callback))(*mr->request));
             if (mr->response->get_status() == -1) {
                 // No exception was thrown, but the handler
                 // returned the default-sentinel response. Route through

src/detail/webserver_error_pages.cpp

@@ -28,7 +28,7 @@
 // double-fault-safe wrapper around the user internal_error_handler
 // (run_internal_error_handler_safely). They are pure const helpers off
 // webserver_impl and share no state with the rest of the dispatch TU
-// beyond `parent->*` user handlers and `mr->dhr`.
+// beyond `parent->*` user handlers and `mr->request`.
 
 #include "httpserver/webserver.hpp"
 #include "httpserver/detail/webserver_impl.hpp"
@@ -51,15 +51,15 @@ namespace detail {
 
 http_response webserver_impl::not_found_page(detail::modded_request* mr) const {
     if (parent->not_found_handler != nullptr) {
-        return parent->not_found_handler(*mr->dhr);
+        return parent->not_found_handler(*mr->request);
     }
     return http_response::string(std::string{constants::NOT_FOUND_ERROR})
         .with_status(http_utils::http_not_found);
 }
 
 http_response webserver_impl::method_not_allowed_page(detail::modded_request* mr) const {
     if (parent->method_not_allowed_handler != nullptr) {
-        return parent->method_not_allowed_handler(*mr->dhr);
+        return parent->method_not_allowed_handler(*mr->request);
     }
     return http_response::string(std::string{constants::METHOD_ERROR})
         .with_status(http_utils::http_method_not_allowed);
@@ -80,7 +80,7 @@ http_response webserver_impl::internal_error_page(
     }
     // Invoke the user handler with the originating message.
     if (parent->internal_error_handler != nullptr) {
-        return parent->internal_error_handler(*mr->dhr, msg);
+        return parent->internal_error_handler(*mr->request, msg);
     }
     // The default body is the fixed string
     // "Internal Server Error" to avoid CWE-209 information disclosure of

src/detail/webserver_finalize.cpp

@@ -102,7 +102,7 @@ bool webserver_impl::fire_before_handler_gated(
             /*is_prefix=*/mr->matched_is_prefix};
     }
     before_handler_ctx ctx{
-        /*request=*/mr->dhr.get(),
+        /*request=*/mr->request.get(),
         /*matched=*/std::move(desc),
         /*method=*/mr->method_enum,
         /*resource=*/hrm.get()};
@@ -148,7 +148,7 @@ void webserver_impl::fire_after_handler_gated(detail::modded_request* mr,
     if (!server_gate && !route_gate) return;
     if (!mr->response) return;  // defensive: never fire without a response
 
-    after_handler_ctx ctx{mr->dhr.get(), &*mr->response};
+    after_handler_ctx ctx{mr->request.get(), &*mr->response};
     if (server_gate) {
         if (auto sc = fire_after_handler(ctx)) {
             // Short-circuit: REPLACE mr->response (emplace
@@ -207,7 +207,7 @@ void webserver_impl::fire_response_sent_gated(detail::modded_request* mr,
         ? std::chrono::duration_cast<std::chrono::nanoseconds>(
               std::chrono::steady_clock::now() - mr->start_time)
         : std::chrono::nanoseconds::zero();
-    response_sent_ctx ctx{mr->dhr.get(), &*mr->response,
+    response_sent_ctx ctx{mr->request.get(), &*mr->response,
         mr->response->get_status(), bytes_queued, elapsed};
     fire_response_sent(ctx);
     // Per-route chain AFTER server-wide + its alias slot.
@@ -273,7 +273,7 @@ void webserver_impl::fire_request_completed_gated(
             : std::chrono::duration_cast<std::chrono::nanoseconds>(
                   raw_duration);
     request_completed_ctx ctx{
-        /*request=*/mr->dhr.get(),
+        /*request=*/mr->request.get(),
         /*resp=*/resp_ptr,
         /*succeeded=*/(toe == MHD_REQUEST_TERMINATED_COMPLETED_OK),
         /*duration=*/duration,

src/detail/webserver_register.cpp

@@ -199,8 +199,8 @@ void webserver_impl::register_v2_route(const detail::http_endpoint& idx,
     // Place a register_path / register_prefix registration into the
     // v2 3-tier route table. Tier placement via classify_route_tier()
     // (single source-of-truth):
-    //   - family=true  -> radix tree (prefix terminus).
-    //   - radix tier   -> radix tree (exact terminus, wildcard nodes).
+    //   - family=true  -> segment trie (prefix terminus).
+    //   - radix tier   -> segment trie (exact terminus, wildcard nodes).
     //   - regex tier   -> regex_routes_ (pre-compiled at registration time).
     //   - exact tier   -> exact_routes_ hash map.
     std::unique_lock table_lock(route_table_mutex_);

src/detail/webserver_request.cpp

@@ -275,7 +275,7 @@ static void fire_route_resolved_gated(webserver_impl* impl,
             /*is_prefix=*/mr->matched_is_prefix};
     }
     route_resolved_ctx ctx{
-        /*request=*/mr->dhr.get(),
+        /*request=*/mr->request.get(),
         /*matched=*/std::move(desc),
         /*resource=*/hrm ? hrm.get() : nullptr};
     impl->fire_route_resolved(ctx);
@@ -381,9 +381,9 @@ MHD_Result webserver_impl::finalize_answer(MHD_Connection* connection,
 MHD_Result webserver_impl::complete_request(MHD_Connection* connection, struct detail::modded_request* mr, const char* version, const char* method) {
     // mr->ws is pre-populated in answer_to_connection (hoisted there for
     // early-path request_completed coverage); no need to set it again here.
-    mr->dhr->set_path(mr->standardized_url);
-    mr->dhr->set_method(method);
-    mr->dhr->set_version(version);
+    mr->request->set_path(mr->standardized_url);
+    mr->request->set_method(method);
+    mr->request->set_version(version);
 
     return finalize_answer(connection, mr);
 }
@@ -438,7 +438,7 @@ MHD_Result webserver_impl::answer_to_connection(void* cls, MHD_Connection* conne
     auto* mr = static_cast<detail::modded_request*>(*con_cls);
     auto* impl = static_cast<webserver_impl*>(cls);
 
-    if (mr->dhr) {
+    if (mr->request) {
         return impl->requests_answer_second_step(connection, method, version,
                                                   upload_data, upload_data_size, mr);
     }
@@ -468,7 +468,7 @@ MHD_Result webserver_impl::answer_to_connection(void* cls, MHD_Connection* conne
     base_unescaper(&t_url, impl->parent->unescaper);
     // SECURITY: collapse dot-segments ("." / "..") into the canonical
     // path here, at the single point where the routing/auth path is
-    // derived. Both the route matcher (radix_tree::find via
+    // derived. Both the route matcher (segment_trie::find via
     // mr->standardized_url) and should_skip_auth() must interpret the
     // path identically; should_skip_auth() runs the path through
     // normalize_path() (which pops ".."), but standardize_url() only

src/detail/webserver_routes_upsert.cpp

@@ -128,9 +128,9 @@ const detail::route_entry* webserver_impl::find_v2_entry_by_path_(
         // it as the wildcard child) and descends that unconstrained
         // wildcard child. A constrained "{id|[0-9]+}" segment, however,
         // fails the constraint regex_match in step_to_child_
-        // (radix_tree.hpp) and is NOT found -- the literal pattern text
+        // (segment_trie.hpp) and is NOT found -- the literal pattern text
         // does not satisfy its own constraint.
-        detail::radix_match<detail::route_entry> rm;
+        detail::segment_trie_match<detail::route_entry> rm;
         if (param_and_prefix_routes_.find(key, rm)
                 && rm.entry != nullptr && !rm.is_prefix_match) {
             return rm.entry;
@@ -265,9 +265,9 @@ void webserver_impl::upsert_v2_radix_route(const std::string& key,
     // symmetric guard in register_v2_route). Must run BEFORE the
     // read-merge below so a thrown exception leaves the table intact.
     reject_terminus_collision(key, /*want_is_prefix=*/false);
-    // Read-merge-reinsert: radix_tree::insert always overwrites the
+    // Read-merge-reinsert: segment_trie::insert always overwrites the
     // terminus, so we must fold any existing entry's methods in first.
-    detail::radix_match<detail::route_entry> existing;
+    detail::segment_trie_match<detail::route_entry> existing;
     detail::route_entry merged;
     if (param_and_prefix_routes_.find(key, existing)
             && existing.entry && !existing.is_prefix_match) {