/*

This file is part of libhttpserver

Copyright (C) 2011-2026 Sebastiano Merlino

This library is free software; you can redistribute it and/or

modify it under the terms of the GNU Lesser General Public

License as published by the Free Software Foundation; either

version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public

License along with this library; if not, write to the Free Software

Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301

USA

*/

// Dispatch shim used by webserver::on_methods_ to

// slot lambda handlers into the existing v1-shaped route table.

//

// The shim is a sub-class of http_resource that holds one slot per

// http_method enumerator. Its render_* virtuals look up the slot for

// the dispatched method and invoke it. The shim starts with EVERY

// method disallowed (`disallow_all()`); each on_*/route call enables

// exactly the matching bits via `set_allowing(method, true)`. The

// existing finalize_answer dispatch glue therefore returns 405 for

// unregistered methods automatically — no edit to webserver.cpp's

// dispatch path is needed.

//

// `final` is intentional: the conflict check in webserver::on_methods_

// uses dynamic_pointer_cast<lambda_resource>(...) to distinguish

// lambda-owned routes from class-owned routes. A subclass would hide

// in that test and break the invariant.

//

// Internal header — only reachable when compiling libhttpserver. NOT

// included from the public umbrella <httpserver.hpp>.

#if !defined(HTTPSERVER_COMPILATION)

#error "lambda_resource.hpp is internal; only reachable when compiling libhttpserver."

#endif

#ifndef SRC_HTTPSERVER_DETAIL_LAMBDA_RESOURCE_HPP_

#define SRC_HTTPSERVER_DETAIL_LAMBDA_RESOURCE_HPP_

#include <array>

#include <cassert>

#include <cstddef>

#include <cstdint>

#include <functional>

#include <utility>

#include "httpserver/http_method.hpp"

#include "httpserver/http_resource.hpp"

#include "httpserver/http_response.hpp"

#include "httpserver/detail/route_entry.hpp"

namespace httpserver {

class http_request;

} // namespace httpserver

namespace httpserver {

namespace detail {

// The per-method slot signature for lambda_resource. Returns

// http_response by value and takes the request by const

// reference. std::function is the chosen storage so users can pass any

// callable (lambda, function pointer, std::bind result, member-function

// adaptor) without leaking the concrete callable type into the slot

// array.

//

// The typedef lives here, next to its only uses: every on_*/route

// path funnels through lambda_resource — no other writer stores a

// lambda handler directly.

using lambda_handler = std::function<::httpserver::http_response(const ::httpserver::http_request&)>;

// Tiny adapter that wraps a single lambda_handler as an http_resource

// virtual override. We keep one slot per method enum and dispatch in

// each render_* override. Each slot holds a

// std::function<http_response(const http_request&)>

// (the `lambda_handler` typedef defined above). Slots are installed

// via set_slot() and invoked by the render_* overrides below.

class lambda_resource final : public ::httpserver::http_resource {

public:

lambda_resource() {

// Lambda routes are opt-in per method (the default

// http_resource constructor enables every method via

// set_all()). on_* sets the matching bit when populating a slot.

disallow_all();

}

// Install (or replace) the slot for `method`. Caller must have

// already verified that no slot is currently set for `method`

// (webserver::on_methods_ enforces this and throws on conflict).

void set_slot(http_method method, lambda_handler h) {

slots_[static_cast<std::size_t>(method)] = std::move(h);

set_allowing(method, true);

}

bool has_slot(http_method method) const noexcept {

return is_allowed(method);

}

// These seven overrides correspond to the seven on_* entry points exposed

// by webserver (get, post, put, delete, patch, options, head). Each is a

// mechanical delegation to invoke_() and differs only by the http_method

// enum constant forwarded. They cannot be collapsed further without

// changing the http_resource base-class interface.

//

// render_connect and render_trace are intentionally NOT overridden here:

// no on_connect / on_trace API is offered, so those slots are never

// populated. The is_allowed gate in finalize_answer prevents dispatch from

// ever reaching the base-class render_connect / render_trace on a

// lambda_resource shim (disallow_all() in the constructor clears the full

// mask). The claim that "these seven are required by the base-class

// interface" was misleading — the base class has nine render_* overrides;

// seven are wired here by deliberate design choice, not interface mandate.

::httpserver::http_response

render_get(const ::httpserver::http_request& r) override {

return invoke_(http_method::get, r);

}

::httpserver::http_response

render_post(const ::httpserver::http_request& r) override {

return invoke_(http_method::post, r);

}

::httpserver::http_response

render_put(const ::httpserver::http_request& r) override {

return invoke_(http_method::put, r);

}

::httpserver::http_response

render_delete(const ::httpserver::http_request& r) override {

return invoke_(http_method::del, r);

}

::httpserver::http_response

render_patch(const ::httpserver::http_request& r) override {

return invoke_(http_method::patch, r);

}

::httpserver::http_response

render_options(const ::httpserver::http_request& r) override {

return invoke_(http_method::options, r);

}

::httpserver::http_response

render_head(const ::httpserver::http_request& r) override {

return invoke_(http_method::head, r);

}

private:

// Dispatch to the registered slot for method `m`, returning the

// handler's http_response by value. Callers must ensure is_allowed(m)

// is true before calling (the 405 guard in finalize_answer enforces this).

::httpserver::http_response

invoke_(http_method m, const ::httpserver::http_request& r) {

auto& slot = slots_[static_cast<std::size_t>(m)];

// Invariant: set_slot stores the handler AND calls

// set_allowing(method, true); the finalize_answer 405 path fires

// before reaching invoke_ unless has_slot is true. A populated

// slot is therefore guaranteed here.

//

// assert fires in debug builds; the explicit check beneath it is

// the defensive release-build path (CWE-617: assert compiled away

// under NDEBUG). An empty std::function would otherwise throw

// std::bad_function_call, which is undefined behavior inside an

// MHD callback. The check branch is predicted-not-taken and has

// negligible runtime cost.

assert(slot);

if (!slot) {

return ::httpserver::http_response::string(

"Internal Server Error: unregistered method slot invoked")

.with_status(500);

}

// lambda_handler returns http_response by value; the

// dispatch path in webserver_impl::finalize_answer moves the

// returned value into connection_context::response — the single

// anchor that keeps deferred-body producers alive until

// request_completed.

return slot(r);

}

std::array<lambda_handler,

static_cast<std::size_t>(http_method::count_)> slots_{};

};

} // namespace detail

} // namespace httpserver

#endif // SRC_HTTPSERVER_DETAIL_LAMBDA_RESOURCE_HPP_