qt-migration-legatus/qt6-after/qt6-migrated-legatus/include/rti/apputils/http/server/detail/CivetWebHandler.hpp

/*
 * (c) Copyright, Real-Time Innovations, 2015.
 * All rights reserved.
 *
 * No duplications, whole or partial, manual or electronic, may be made
 * without express written permission.  Any such copies, or
 * revisions thereof, must display this notice unaltered.
 * This code contains trade secrets of Real-Time Innovations, Inc.
 */

#ifndef CIVETWEB_HANDLER_HPP
#define CIVETWEB_HANDLER_HPP

#include <atomic>

#include <CivetServer.h>
#include <civetweb.h>

#include "rti/apputils/http/server/ServerProperty.hpp"
#include "rti/apputils/http/server/Connection.hpp"
#include "rti/apputils/http/server/RequestHandler.hpp"

namespace rti { namespace apputils { namespace http { namespace server {

// Forward declaration
class Server;

/**
 * @brief WebHandler implements the handler functions of CivetWeb's API,
 * wrapping the calls to the generic RequestHandler. The Request is specialized
 * to an specific kind of request handler (e.g., PublisherHandler) whose type is
 * specified via template.
 */
class CivetWebHandler : public CivetHandler {
public:
    /**
     * @brief Constructor of the CivetWebHandler class. It calls the constructor
     * of the specific RequestHandler it implements (i.e., handler)
     *
     * @param web_server_property Reference to the ServerProperty that will
     * be used by the RequestHandler.
     * @param server Web's server.
     */
    explicit CivetWebHandler(
            const ServerProperty& web_server_property,
            Server& server,
            RequestHandler *handler)
            : web_server_property_(web_server_property),
              server_(server),
              handler_(handler),
              callbacks_counter_(0)
    { }

    /**
     * @brief Destructor of the CivetWebHandler class.
     */
    virtual ~CivetWebHandler() = default;

    /**
     * @brief This method handles the POST operation.
     *
     * @param server CivetWeb's server.
     * @param conn CiveWeb's connection.
     * @return Always returns true given the fact that the operation is always
     * processed by the underlying interfaces.
     */
    virtual bool handlePost(CivetServer *, struct mg_connection *conn) final
    {
        CounterGuard guard { callbacks_counter_ };
        Connection connection(conn);
        handler_->handle_post(server_, connection, web_server_property_);

        return true;
    }

    /**
     * @brief This method handles the PUT operation.
     *
     * @param server CivetWeb's server.
     * @param conn CiveWeb's connection.
     * @return Always returns true given the fact that the operation is always
     * processed by the underlying interfaces.
     */
    virtual bool handlePut(CivetServer *, struct mg_connection *conn) final
    {
        CounterGuard guard { callbacks_counter_ };
        Connection connection(conn);
        handler_->handle_put(server_, connection, web_server_property_);

        return true;
    }

    /**
     * @brief This method handles the GET operation.
     *
     * @param server CivetWeb's server.
     * @param conn CiveWeb's connection.
     * @return Always returns true given the fact that the operation is always
     * processed by the underlying interfaces.
     */
    virtual bool handleGet(CivetServer *, struct mg_connection *conn) final
    {
        CounterGuard guard { callbacks_counter_ };
        Connection connection(conn);
        handler_->handle_get(server_, connection, web_server_property_);

        return true;
    }

    /**
     * @brief This method handles the DELETE operation.
     *
     * @param server CivetWeb's server.
     * @param conn CiveWeb's connection.
     * @return Always returns true given the fact that the operation is always
     * processed by the underlying interfaces.
     */
    virtual bool handleDelete(CivetServer *, struct mg_connection *conn) final
    {
        CounterGuard guard { callbacks_counter_ };
        Connection connection(conn);
        handler_->handle_delete(server_, connection, web_server_property_);

        return true;
    }

    /**
     * @brief This method handles the OPTIONS operation.
     *
     * @param server CivetWeb's server.
     * @param conn CiveWeb's connection.
     * @return true if the request was processed by the custom handler,
     * otherwise false.
     */
    virtual bool handleOptions(CivetServer *, struct mg_connection *conn) final
    {
        CounterGuard guard { callbacks_counter_ };
        if (web_server_property_.handle_options_request()) {
            Connection connection(conn);
            handler_->handle_options(server_, connection, web_server_property_);
            return true;
        }

        return false;
    }

    /**
     * @brief This method handles the HEAD operation.
     *
     * @param server CivetWeb's server.
     * @param conn CiveWeb's connection.
     * @return Always returns true given the fact that the operation is always
     * processed by the underlying interfaces.
     */
    virtual bool handleHead(CivetServer *, struct mg_connection *conn) final
    {
        CounterGuard guard { callbacks_counter_ };
        Connection connection(conn);
        handler_->handle_head(server_, connection, web_server_property_);

        return true;
    }

    /**
     * @brief This method handles the PATCH operation.
     *
     * @param server CivetWeb's server.
     * @param conn CiveWeb's connection.
     * @return Always returns true given the fact that the operation is always
     * processed by the underlying interfaces.
     */
    virtual bool handlePatch(CivetServer *, struct mg_connection *conn) final
    {
        CounterGuard guard { callbacks_counter_ };
        Connection connection(conn);
        handler_->handle_patch(server_, connection, web_server_property_);

        return true;
    }

    bool callbacks_running() const
    {
        return callbacks_counter_ != 0;
    }

private:
    struct CounterGuard {
        CounterGuard(std::atomic_short& counter) : counter_(counter)
        {
            ++counter_;
        }

        ~CounterGuard()
        {
            --counter_;
        }

        std::atomic_short& counter_;
    };

    const ServerProperty& web_server_property_;
    Server& server_;
    std::unique_ptr<RequestHandler> handler_;
    std::atomic_short callbacks_counter_;
};

}}}}  // namespace rti::apputils::http::server

#endif  // CIVETWEB_HANDLER_HPP