irsol::server::handlers::MessageHandler Class Reference

Binds incoming protocol messages to the appropriate per-client logic. More...

#include <message_handler.hpp>

Public Member Functions
handling_function_response_t	handle (const irsol::types::client_id_t &clientId, protocol::InMessage &&message) const
	Dispatches an incoming message to the correct user-defined handler.
template<typename T , std::enable_if_t< irsol::traits::is_type_in_variant< T, irsol::protocol::InMessage >::value, int > = 0>
bool	registerHandler (const std::string &identifier, handler_function_t< T > handler)
	Registers a user-defined handler for a specific message type and identifier.

Private Types
using	handling_function_response_t = std::vector< protocol::OutMessage >
using	handler_identifier_t = std::string
template<typename T >
using	handler_function_t = std::function< handling_function_response_t(const irsol::types::client_id_t &, T &&)>
using	assignment_handler_function_t = handler_function_t< protocol::Assignment && >
using	inquiry_handler_function_t = handler_function_t< protocol::Inquiry && >
using	command_handler_function_t = handler_function_t< protocol::Command && >
template<typename T >
using	message_handler_map_t = std::unordered_map< handler_identifier_t, T >
using	assignment_message_handler_map_t = message_handler_map_t< assignment_handler_function_t >
using	inquiry_message_handler_map_t = message_handler_map_t< inquiry_handler_function_t >
using	command_message_handler_map_t = message_handler_map_t< command_handler_function_t >
using	any_handler_function_t = std::variant< assignment_handler_function_t, inquiry_handler_function_t, command_handler_function_t >

Private Member Functions
std::optional< any_handler_function_t >	findHandlerForMessage (const protocol::InMessage &msg) const
	Locates a registered handler (of any message type) for a given message.
template<typename T , std::enable_if_t< irsol::traits::is_type_in_variant< T, irsol::protocol::InMessage >::value, int > = 0>
std::optional< handler_function_t< T > >	findHandler (const handler_identifier_t &identifier) const
	Locates a handler of a specific message type and identifier.

Private Attributes
assignment_message_handler_map_t	m_assignmentMessageHandlers {}
	Registered handlers for Assignment messages, keyed by identifier.
inquiry_message_handler_map_t	m_inquiryMessageHandlers {}
	Registered handlers for Inquiry messages, keyed by identifier.
command_message_handler_map_t	m_commandMessageHandlers {}
	Registered handlers for Command messages, keyed by identifier.

Detailed Description

Binds incoming protocol messages to the appropriate per-client logic.

This class acts as a central dispatcher used by the application layer irsol::server::App to process structured incoming messages irsol::protocol::InMessage. Each message is handled by a user-registered callback function based on its type and identifier.

Messages are categorized into three types:

• irsol::protocol::Assignment (e.g., parameter changes)
• irsol::protocol::Inquiry (e.g., state queries)
• irsol::protocol::Command (e.g., actions or triggers)

For each type, client-specific logic is registered using registerHandler(). When a message arrives, handle() invokes the matching callback and returns the generated response messages to be sent back to the client.

Definition at line 52 of file message_handler.hpp.

Member Typedef Documentation

any_handler_function_t

using irsol::server::handlers::MessageHandler::any_handler_function_t = std:: variant<assignment_handler_function_t, inquiry_handler_function_t, command_handler_function_t>

private

Definition at line 72 of file message_handler.hpp.

assignment_handler_function_t

using irsol::server::handlers::MessageHandler::assignment_handler_function_t = handler_function_t<protocol::Assignment&&>

private

Definition at line 61 of file message_handler.hpp.

assignment_message_handler_map_t

using irsol::server::handlers::MessageHandler::assignment_message_handler_map_t = message_handler_map_t<assignment_handler_function_t>

private

Definition at line 68 of file message_handler.hpp.

command_handler_function_t

using irsol::server::handlers::MessageHandler::command_handler_function_t = handler_function_t<protocol::Command&&>

private

Definition at line 63 of file message_handler.hpp.

command_message_handler_map_t

using irsol::server::handlers::MessageHandler::command_message_handler_map_t = message_handler_map_t<command_handler_function_t>

private

Definition at line 70 of file message_handler.hpp.

handler_function_t

template<typename T >

using irsol::server::handlers::MessageHandler::handler_function_t = std::function<handling_function_response_t(const irsol::types::client_id_t&, T&&)>

private

Definition at line 58 of file message_handler.hpp.

handler_identifier_t

using irsol::server::handlers::MessageHandler::handler_identifier_t = std::string

private

Definition at line 55 of file message_handler.hpp.

handling_function_response_t

using irsol::server::handlers::MessageHandler::handling_function_response_t = std::vector<protocol::OutMessage>

private

Definition at line 54 of file message_handler.hpp.

inquiry_handler_function_t

using irsol::server::handlers::MessageHandler::inquiry_handler_function_t = handler_function_t<protocol::Inquiry&&>

private

Definition at line 62 of file message_handler.hpp.

inquiry_message_handler_map_t

using irsol::server::handlers::MessageHandler::inquiry_message_handler_map_t = message_handler_map_t<inquiry_handler_function_t>

private

Definition at line 69 of file message_handler.hpp.

message_handler_map_t

template<typename T >

using irsol::server::handlers::MessageHandler::message_handler_map_t = std::unordered_map<handler_identifier_t, T>

private

Definition at line 66 of file message_handler.hpp.

Member Function Documentation

findHandler()

template<typename T , std::enable_if_t< irsol::traits::is_type_in_variant< T, irsol::protocol::InMessage >::value, int > = 0>

std::optional< handler_function_t< T > > irsol::server::handlers::MessageHandler::findHandler ( const handler_identifier_t &  identifier ) const

inlineprivate

Locates a handler of a specific message type and identifier.

Template Parameters

T	Message type (Assignment, Inquiry, or Command).

Parameters

identifier

Identifier of the message to match.

Returns

A callable if found, or std::nullopt if no handler is registered.

Definition at line 160 of file message_handler.hpp.

  {
    if constexpr(std::is_same_v<T, protocol::Assignment>) {
      auto it = m_assignmentMessageHandlers.find(identifier);
      return it == m_assignmentMessageHandlers.end() ? std::nullopt
                                                     : std::make_optional(it->second);
    } else if constexpr(std::is_same_v<T, protocol::Inquiry>) {
      auto it = m_inquiryMessageHandlers.find(identifier);
      return it == m_inquiryMessageHandlers.end() ? std::nullopt : std::make_optional(it->second);
    } else if constexpr(std::is_same_v<T, protocol::Command>) {
      auto it = m_commandMessageHandlers.find(identifier);
      return it == m_commandMessageHandlers.end() ? std::nullopt : std::make_optional(it->second);
    } else {
      IRSOL_MISSING_TEMPLATE_SPECIALIZATION(T, "findHandler()");
    }
  }

findHandlerForMessage()

std::optional< MessageHandler::any_handler_function_t > irsol::server::handlers::MessageHandler::findHandlerForMessage ( const protocol::InMessage &  msg ) const

private

Locates a registered handler (of any message type) for a given message.

Parameters

msg	The message whose identifier and type are used for lookup.

Returns

A matching handler wrapped in a std::variant, or std::nullopt if not found.

Definition at line 42 of file message_handler.cpp.

{
  return std::visit(
    [this](auto&& value) -> std::optional<any_handler_function_t> {
      using T  = std::decay_t<decltype(value)>;
      auto res = this->findHandler<T>(value.identifier);
      if(!res) {
        return std::nullopt;
      }
      return std::make_optional<any_handler_function_t>(*res);
    },
    msg);
}

handle()

MessageHandler::handling_function_response_t irsol::server::handlers::MessageHandler::handle	(	const irsol::types::client_id_t &	clientId,
		protocol::InMessage &&	message
	)		const

Dispatches an incoming message to the correct user-defined handler.

This method extracts the message type and identifier from the parsed InMessage, then finds the corresponding callback registered via registerHandler(). The appropriate handler is invoked with the clientId and the message payload.

Parameters

clientId	Unique identifier of the client sending the message.
message	The parsed incoming message to handle.

Returns

A list of OutMessage responses to be sent back to the client.

Definition at line 11 of file message_handler.cpp.

{
  IRSOL_LOG_TRACE("Handling message: '{}' for client '{}'", protocol::toString(message), clientId);
  auto handler = findHandlerForMessage(message);
  if(!handler) {
    IRSOL_LOG_ERROR("No handler found for message: '{}'", irsol::protocol::toString(message));
    std::vector<protocol::OutMessage> result;
    result.emplace_back(
      protocol::Error::from(std::move(message), "No handler registered for this message."));
    return result;
  }
  // Dispatch the message to the appropriate handler and return the response
  const std::string messageString = protocol::toString(message);
 
  try {
    return std::visit(
      [&handler, &clientId](auto&& msg) -> MessageHandler::handling_function_response_t {
        using T                  = std::decay_t<decltype(msg)>;
        using handler_function_t = MessageHandler::handler_function_t<T>;
        return std::get<handler_function_t>(*handler)(clientId, std::move(msg));
      },
      std::move(message));
 
  } catch(const std::exception& e) {
    IRSOL_LOG_ERROR("Error handling message: '{}': {}", messageString, e.what());
    return {};
  }
}

registerHandler()

template<typename T , std::enable_if_t< irsol::traits::is_type_in_variant< T, irsol::protocol::InMessage >::value, int > = 0>

bool irsol::server::handlers::MessageHandler::registerHandler ( const std::string &  identifier, handler_function_t< T >  handler  )

inline

Registers a user-defined handler for a specific message type and identifier.

Handlers must be registered per message identifier (e.g., "start_stream", "set_param"), and per message kind (Assignment, Inquiry, Command). Duplicate registrations are rejected.

Template Parameters

T	One of protocol::Assignment, protocol::Inquiry, or protocol::Command.

Parameters

identifier	The string identifier of the message (e.g., the name field).
handler	A callable accepting (client_id_t, T&&) and returning response messages.

Returns

true if the handler was successfully registered, false if a duplicate exists.

Definition at line 106 of file message_handler.hpp.

  {
    // Make sure there's no duplicate handlers for the same message kind and identifier
    if(auto existingHandler = findHandler<T>(identifier); existingHandler) {
      if constexpr(std::is_same_v<T, protocol::Assignment>) {
        IRSOL_LOG_ERROR(
          "Duplicate handler registered for identifier '{}' and Assignment type", identifier);
      } else if constexpr(std::is_same_v<T, protocol::Inquiry>) {
        IRSOL_LOG_ERROR(
          "Duplicate handler registered for identifier '{}' and Inquiry type", identifier);
      } else if constexpr(std::is_same_v<T, protocol::Command>) {
        IRSOL_LOG_ERROR(
          "Duplicate handler registered for identifier '{}' and Command type", identifier);
      } else {
        IRSOL_MISSING_TEMPLATE_SPECIALIZATION(T, "registerHandler()");
      }
 
      return false;
    }
 
    if constexpr(std::is_same_v<T, protocol::Assignment>) {
      IRSOL_LOG_INFO("Registering handler for 'Assignment(\"{}\")'", identifier);
      m_assignmentMessageHandlers[identifier] = handler;
    } else if constexpr(std::is_same_v<T, protocol::Inquiry>) {
      IRSOL_LOG_INFO("Registering handler for 'Inquiry(\"{}\")'", identifier);
      m_inquiryMessageHandlers[identifier] = handler;
    } else if constexpr(std::is_same_v<T, protocol::Command>) {
      IRSOL_LOG_INFO("Registering handler for 'Command(\"{}\")'", identifier);
      m_commandMessageHandlers[identifier] = handler;
    } else {
      IRSOL_MISSING_TEMPLATE_SPECIALIZATION(T, "registerHandler()");
    }
    return true;
  }

Member Data Documentation

m_assignmentMessageHandlers

assignment_message_handler_map_t irsol::server::handlers::MessageHandler::m_assignmentMessageHandlers {}

private

Registered handlers for Assignment messages, keyed by identifier.

Definition at line 178 of file message_handler.hpp.

{};

m_commandMessageHandlers

command_message_handler_map_t irsol::server::handlers::MessageHandler::m_commandMessageHandlers {}

private

Registered handlers for Command messages, keyed by identifier.

Definition at line 184 of file message_handler.hpp.

{};

m_inquiryMessageHandlers

inquiry_message_handler_map_t irsol::server::handlers::MessageHandler::m_inquiryMessageHandlers {}

private

Registered handlers for Inquiry messages, keyed by identifier.

Definition at line 181 of file message_handler.hpp.

{};

---

The documentation for this class was generated from the following files:

• src/irsol/include/irsol/server/message_handler.hpp
• src/irsol/lib/irsol/server/message_handler.cpp