typed_mailbox.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "mailbox.hpp"
#include "../messaging/message_registry.hpp"
#include <type_traits>
 
namespace commrat {
 
template<typename Registry, typename... AllowedPayloadTypes>
class TypedMailbox {
private:
    // SendOnlyTypes extracted from template magic if needed
    // For now, this is the base implementation
    // Extract MessageDefinition types for allowed payloads
    template<typename PayloadT>
    struct FindMessageDef {
        // TODO: Extract MessageDefinition from Registry for this PayloadT
        // For now, use MessageDefinition with UserDefined prefix
        using type = MessageDefinition<PayloadT, MessagePrefix::UserDefined, UserSubPrefix::Data>;
    };
    
    // Create underlying mailbox with all MessageDefinitions from registry
    // (We'll add type validation in send/receive methods)
    template<typename... MessageDefs>
    static auto extract_mailbox_type(MessageRegistry<MessageDefs...>*) -> Mailbox<MessageDefs...>;
    
    using UnderlyingMailbox = decltype(extract_mailbox_type(static_cast<Registry*>(nullptr)));
    
    UnderlyingMailbox mailbox_;
    
    // Compile-time validation helpers
    template<typename PayloadT>
    static constexpr bool is_allowed_type = (std::is_same_v<PayloadT, AllowedPayloadTypes> || ...);
    
    // For base TypedMailbox: sendable = allowed (no send-only types)
    template<typename PayloadT>
    static constexpr bool is_sendable_type = is_allowed_type<PayloadT>;
    
    template<typename PayloadT>
    static constexpr bool is_registered_type = Registry::template is_registered<PayloadT>;
    
public:
    // ========================================================================
    // Type Information
    // ========================================================================
    
    static constexpr size_t max_message_size = 
        Registry::template max_size_for_types<AllowedPayloadTypes...>();
    
    static constexpr size_t num_allowed_types = sizeof...(AllowedPayloadTypes);
    
    template<typename PayloadT>
    static constexpr bool is_allowed() {
        return is_allowed_type<PayloadT>;
    }
    
    // ========================================================================
    // Construction and Lifecycle
    // ========================================================================
    
    explicit TypedMailbox(const MailboxConfig& config)
        : mailbox_(config) {
        
        static_assert(sizeof...(AllowedPayloadTypes) > 0,
                      "TypedMailbox requires at least one allowed payload type");
        
        // Validate all allowed types are registered in the registry
        static_assert((is_registered_type<AllowedPayloadTypes> && ...),
                      "All allowed types must be registered in the message registry");
    }
    
    ~TypedMailbox() = default;
    
    // Non-copyable, movable
    TypedMailbox(const TypedMailbox&) = delete;
    TypedMailbox& operator=(const TypedMailbox&) = delete;
    TypedMailbox(TypedMailbox&&) noexcept = default;
    TypedMailbox& operator=(TypedMailbox&&) noexcept = default;
    
    // ========================================================================
    // Lifecycle Management
    // ========================================================================
    
    auto start() -> MailboxResult<void> {
        return mailbox_.start();
    }
    
    void stop() {
        mailbox_.stop();
    }
    
    bool is_running() const {
        return mailbox_.is_running();
    }
    
    uint32_t mailbox_id() const {
        return mailbox_.mailbox_id();
    }
    
    // ========================================================================
    // Type-Safe Send Operations
    // ========================================================================
    
    template<typename PayloadT>
    auto send(PayloadT& message, uint32_t dest_mailbox) 
        -> MailboxResult<void> {
        
        static_assert(is_sendable_type<PayloadT>,
                      "Message type not sendable from this mailbox. "
                      "Check that PayloadT is in AllowedPayloadTypes or SendOnlyTypes.");
        
        static_assert(is_registered_type<PayloadT>,
                      "Message type not registered in the message registry.");
        
        // Create TimsMessage wrapper (const → non-const copy for underlying Mailbox)
        TimsMessage<PayloadT> tims_msg{
            .header = {
                .msg_type = Registry::template get_message_id<PayloadT>(),
                .msg_size = 0,  // Will be set by serialization
                .timestamp = 0, // Will be set by TiMS with current time
                .seq_number = 0, // Will be set by TiMS
                .flags = 0
            },
            .payload = message
        };
        
        return mailbox_.send(tims_msg, dest_mailbox);
    }
    
    template<typename PayloadT>
    auto send(PayloadT& message, uint32_t dest_mailbox, uint64_t timestamp) 
        -> MailboxResult<void> {
        
        static_assert(is_sendable_type<PayloadT>,
                      "Message type not sendable from this mailbox. "
                      "Check that PayloadT is in AllowedPayloadTypes or SendOnlyTypes.");
        
        static_assert(is_registered_type<PayloadT>,
                      "Message type not registered in the message registry.");
        
        // Create TimsMessage wrapper with explicit timestamp
        TimsMessage<PayloadT> tims_msg{
            .header = {
                .msg_type = Registry::template get_message_id<PayloadT>(),
                .msg_size = 0,  // Will be set by serialization
                .timestamp = timestamp, // USER-PROVIDED timestamp
                .seq_number = 0, // Will be set by TiMS
                .flags = 0
            },
            .payload = message
        };
        
        return mailbox_.send(tims_msg, dest_mailbox);
    }
    
    template<typename PayloadT>
    auto send(const TimsMessage<PayloadT>& tims_message, uint32_t dest_mailbox)
        -> MailboxResult<void> {
        
        static_assert(is_sendable_type<PayloadT>,
                      "Message type not sendable from this mailbox.");
        
        static_assert(is_registered_type<PayloadT>,
                      "Message type not registered in the message registry.");
        
        return mailbox_.send(tims_message, dest_mailbox);
    }
    
    // ========================================================================
    // Type-Safe Receive Operations
    // ========================================================================
    
    template<typename PayloadT>
    auto receive() -> MailboxResult<TimsMessage<PayloadT>> {
        static_assert(is_allowed_type<PayloadT>,
                      "Message type not allowed in this typed mailbox. "
                      "Check that PayloadT is in the AllowedPayloadTypes list.");
        static_assert(is_registered_type<PayloadT>,
                      "Message type not registered in the message registry.");
        return mailbox_.template receive<PayloadT>();
    }
    
    template<typename PayloadT>
    auto receive_for(std::chrono::milliseconds timeout) -> MailboxResult<TimsMessage<PayloadT>> {
        static_assert(is_allowed_type<PayloadT>,
                      "Message type not allowed in this typed mailbox.");
        static_assert(is_registered_type<PayloadT>,
                      "Message type not registered in the message registry.");
        return mailbox_.template receive_for<PayloadT>(timeout);
    }
    
    template<typename PayloadT>
    auto try_receive() -> MailboxResult<TimsMessage<PayloadT>> {
        static_assert(is_allowed_type<PayloadT>,
                      "Message type not allowed in this typed mailbox.");
        static_assert(is_registered_type<PayloadT>,
                      "Message type not registered in the message registry.");
        return mailbox_.template try_receive<PayloadT>();
    }
    
    template<typename Visitor>
    auto receive_any(Visitor&& visitor) -> MailboxResult<void> {
        return mailbox_.receive_any(std::forward<Visitor>(visitor));
    }
    
    template<typename Visitor>
    auto receive_any_for(std::chrono::milliseconds timeout, Visitor&& visitor) -> MailboxResult<void> {
        return mailbox_.receive_any_for(timeout, std::forward<Visitor>(visitor));
    }
    
    // ========================================================================
    // Send Operations
    // ========================================================================
    
    // ========================================================================
    // Access to Underlying Mailbox
    // ========================================================================
    
    auto& get_underlying_mailbox() { return mailbox_; }
    const auto& get_underlying_mailbox() const { return mailbox_; }
};
 
// ============================================================================
// Specialization with SendOnlyTypes Support
// ============================================================================
 
template<typename... Ts>
struct ReceiveTypes {
    using Types = std::tuple<Ts...>;
};
 
template<typename... Ts>
struct SendOnlyTypes {
    using Types = std::tuple<Ts...>;
};
 
template<typename Registry, typename... SendOnlyTypesInner>
class TypedMailbox<Registry, SendOnlyTypes<SendOnlyTypesInner...>> {
private:
    template<typename... MessageDefs>
    static auto extract_mailbox_type(MessageRegistry<MessageDefs...>*) -> Mailbox<MessageDefs...>;
    
    using UnderlyingMailbox = decltype(extract_mailbox_type(static_cast<Registry*>(nullptr)));
    UnderlyingMailbox mailbox_;
    
    // Type checking
    template<typename PayloadT>
    static constexpr bool is_send_only_type = (std::is_same_v<PayloadT, SendOnlyTypesInner> || ...);
    
    template<typename PayloadT>
    static constexpr bool is_registered_type = Registry::template is_registered<PayloadT>;
 
public:
    // Minimal buffer (no receive types)
    static constexpr size_t max_message_size = 64;  // Minimal size for headers only
    
    explicit TypedMailbox(const MailboxConfig& config)
        : mailbox_(MailboxConfig{
            .mailbox_id = config.mailbox_id,
            .message_slots = config.message_slots,
            .max_message_size = max_message_size,
            .send_priority = config.send_priority,
            .realtime = config.realtime,
            .mailbox_name = config.mailbox_name
        }) {}
    
    // Send operations (allow send-only types)
    template<typename PayloadT>
    auto send(PayloadT& message, uint32_t dest_mailbox) -> MailboxResult<void> {
        static_assert(is_send_only_type<PayloadT>,
                      "Message type not in SendOnlyTypes list.");
        static_assert(is_registered_type<PayloadT>,
                      "Message type not registered in registry.");
        
        TimsMessage<PayloadT> tims_msg{
            .header = {
                .msg_type = Registry::template get_message_id<PayloadT>(),
                .msg_size = 0,
                .timestamp = 0,
                .seq_number = 0,
                .flags = 0
            },
            .payload = message
        };
        return mailbox_.send(tims_msg, dest_mailbox);
    }
    
    template<typename PayloadT>
    auto send(PayloadT& message, uint32_t dest_mailbox, uint64_t timestamp) -> MailboxResult<void> {
        static_assert(is_send_only_type<PayloadT>, "Message type not in SendOnlyTypes list.");
        static_assert(is_registered_type<PayloadT>, "Type not registered.");
        
        TimsMessage<PayloadT> tims_msg{
            .header = {
                .msg_type = Registry::template get_message_id<PayloadT>(),
                .msg_size = 0,
                .timestamp = timestamp,
                .seq_number = 0,
                .flags = 0
            },
            .payload = message
        };
        return mailbox_.send(tims_msg, dest_mailbox);
    }
    
    // No receive operations (compile error if attempted)
    template<typename PayloadT>
    auto receive() -> MailboxResult<TimsMessage<PayloadT>> = delete;
    
    template<typename PayloadT>
    auto receive_timed(int64_t timeout_ns) -> MailboxResult<TimsMessage<PayloadT>> = delete;
    
    // receive_any also not allowed (no receive types)
    template<typename Visitor>
    auto receive_any(Visitor&& visitor) -> MailboxResult<void> = delete;
    
    // Lifecycle
    auto create() -> MailboxResult<void> { return mailbox_.create(); }
    auto destroy() -> MailboxResult<void> { return mailbox_.destroy(); }
    auto start() -> MailboxResult<void> { return mailbox_.start(); }
    void stop() { mailbox_.stop(); }
    auto get_id() const -> uint32_t { return mailbox_.get_id(); }
};
 
template<typename Registry, typename... ReceiveTypesInner, typename... SendOnlyTypesInner>
class TypedMailbox<Registry, ReceiveTypes<ReceiveTypesInner...>, SendOnlyTypes<SendOnlyTypesInner...>> {
private:
    template<typename... MessageDefs>
    static auto extract_mailbox_type(MessageRegistry<MessageDefs...>*) -> Mailbox<MessageDefs...>;
    
    using UnderlyingMailbox = decltype(extract_mailbox_type(static_cast<Registry*>(nullptr)));
    UnderlyingMailbox mailbox_;
    
    // Type checking
    template<typename PayloadT>
    static constexpr bool is_receive_type = (std::is_same_v<PayloadT, ReceiveTypesInner> || ...);
    
    template<typename PayloadT>
    static constexpr bool is_send_only_type = (std::is_same_v<PayloadT, SendOnlyTypesInner> || ...);
    
    template<typename PayloadT>
    static constexpr bool is_sendable_type = is_receive_type<PayloadT> || is_send_only_type<PayloadT>;
    
    template<typename PayloadT>
    static constexpr bool is_registered_type = Registry::template is_registered<PayloadT>;
 
public:
    // Buffer sized for receive types only!
    static constexpr size_t max_message_size = 
        Registry::template max_size_for_types<ReceiveTypesInner...>();
    
    explicit TypedMailbox(const MailboxConfig& config)
        : mailbox_(MailboxConfig{
            .mailbox_id = config.mailbox_id,
            .message_slots = config.message_slots,
            .max_message_size = max_message_size,  // Optimized!
            .send_priority = config.send_priority,
            .realtime = config.realtime,
            .mailbox_name = config.mailbox_name
        }) {}
    
    // Send operations (allow receive + send-only types)
    template<typename PayloadT>
    auto send(PayloadT& message, uint32_t dest_mailbox) -> MailboxResult<void> {
        static_assert(is_sendable_type<PayloadT>,
                      "Message type not sendable from this mailbox.");
        static_assert(is_registered_type<PayloadT>,
                      "Message type not registered in registry.");
        
        TimsMessage<PayloadT> tims_msg{
            .header = {
                .msg_type = Registry::template get_message_id<PayloadT>(),
                .msg_size = 0,
                .timestamp = 0,
                .seq_number = 0,
                .flags = 0
            },
            .payload = message
        };
        return mailbox_.send(tims_msg, dest_mailbox);
    }
    
    template<typename PayloadT>
    auto send(PayloadT& message, uint32_t dest_mailbox, uint64_t timestamp) -> MailboxResult<void> {
        static_assert(is_sendable_type<PayloadT>, "Message type not sendable.");
        static_assert(is_registered_type<PayloadT>, "Type not registered.");
        
        TimsMessage<PayloadT> tims_msg{
            .header = {
                .msg_type = Registry::template get_message_id<PayloadT>(),
                .msg_size = 0,
                .timestamp = timestamp,
                .seq_number = 0,
                .flags = 0
            },
            .payload = message
        };
        return mailbox_.send(tims_msg, dest_mailbox);
    }
    
    // Receive operations (only receive types allowed)
    template<typename PayloadT>
    auto receive() -> MailboxResult<TimsMessage<PayloadT>> {
        static_assert(is_receive_type<PayloadT>,
                      "Message type not receivable. Only ReceiveTypes can be received.");
        static_assert(is_registered_type<PayloadT>, "Type not registered.");
        return mailbox_.template receive<PayloadT>();
    }
    
    template<typename PayloadT>
    auto receive_timed(int64_t timeout_ns) -> MailboxResult<TimsMessage<PayloadT>> {
        static_assert(is_receive_type<PayloadT>, "Only ReceiveTypes can be received.");
        static_assert(is_registered_type<PayloadT>, "Type not registered.");
        return mailbox_.template receive_timed<PayloadT>(timeout_ns);
    }
    
    // receive_any for ReceiveTypes
    template<typename Visitor>
    auto receive_any(Visitor&& visitor) -> MailboxResult<void> {
        return mailbox_.receive_any(std::forward<Visitor>(visitor));
    }
    
    // Lifecycle
    auto start() -> MailboxResult<void> { return mailbox_.start(); }
    void stop() { mailbox_.stop(); }
    auto& get_underlying_mailbox() { return mailbox_; }
    const auto& get_underlying_mailbox() const { return mailbox_; }
};
 
// ============================================================================
// Convenience Type Aliases
// ============================================================================
 
template<typename Registry, typename PayloadT>
using SingleTypeMailbox = TypedMailbox<Registry, PayloadT>;
 
template<typename Registry, typename... CommandTypes>
using CommandMailbox = TypedMailbox<Registry, CommandTypes...>;
 
template<typename Registry, typename... DataTypes>
using DataMailbox = TypedMailbox<Registry, DataTypes...>;
 
} // namespace commrat