historical_mailbox.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "registry_mailbox.hpp"
#include "timestamped_ring_buffer.hpp"
#include "../platform/threading.hpp"
#include <optional>
#include <memory>
 
namespace commrat {
 
template<typename UserRegistry, std::size_t HistorySize = 100>
class HistoricalMailbox {
public:
    using Registry = UserRegistry;
    using MailboxType = RegistryMailbox<UserRegistry>;
    
    // Define history buffer tuple type here (where TimestampedRingBuffer is known)
    template<std::size_t... Is>
    static auto make_history_tuple_type(std::index_sequence<Is...>) {
        return std::tuple<
            std::unique_ptr<TimestampedRingBuffer<TimsMessage<typename Registry::template type_at<Is>>, HistorySize>>...
        >{};
    }
    
    using HistoryBufferTuple = decltype(make_history_tuple_type(
        std::make_index_sequence<Registry::num_types>{}
    ));
    
    // ========================================================================
    // Construction and Configuration
    // ========================================================================
    
    explicit HistoricalMailbox(
        const MailboxConfig& config,
        Milliseconds default_tolerance = Milliseconds(50)
    ) : mailbox_(config), default_tolerance_(default_tolerance) {
        // Initialize history buffers for all registered types
        init_history_buffers();
    }
    
    auto start() -> MailboxResult<void> {
        auto result = mailbox_.start();
        if (!result) {
            std::cerr << "[HistoricalMailbox] Start failed for mailbox " 
                      << mailbox_.mailbox_id() << " - error " 
                      << static_cast<int>(result.get_error()) << "\n";
        } else {
            std::cout << "[HistoricalMailbox] Started mailbox " 
                      << mailbox_.mailbox_id() << " successfully\n";
        }
        return result;
    }
    
    void stop() {
        mailbox_.stop();
    }
    
    // ========================================================================
    // Primary Input API (Blocking Receive)
    // ========================================================================
    
    template<typename T>
    auto receive() -> MailboxResult<TimsMessage<T>> {
        
        // Receive from underlying mailbox
        auto result = mailbox_.template receive<T>();
        
        if (result) {
            // Store in history for future getData queries
            store_in_history(result.value());
        }
        
        return result;
    }
    
    // ========================================================================
    // Secondary Input API (Non-Blocking getData)
    // ========================================================================
    
    template<typename T>
    std::optional<TimsMessage<T>> getData(
        uint64_t timestamp,
        Milliseconds tolerance = Milliseconds(-1),
        InterpolationMode mode = InterpolationMode::NEAREST
    ) const {
        auto& buffer = get_history_buffer<T>();
        return buffer.getData(timestamp, tolerance, mode);
    }
    
    template<typename T>
    std::pair<uint64_t, uint64_t> getTimestampRange() const {
        const auto& buffer = get_history_buffer<T>();
        return buffer.getTimestampRange();
    }
    
    template<typename T>
    void clearHistory() {
        auto& buffer = get_history_buffer<T>();
        buffer.clear();
    }
    
    void clearAllHistory() {
        clear_all_buffers();
    }
    
    // ========================================================================
    // Pass-Through API to Underlying Mailbox
    // ========================================================================
    
    template<typename T>
    auto send(T& message, uint32_t dest_mailbox) -> MailboxResult<void> {
        return mailbox_.template send(message, dest_mailbox);
    }
    
    uint32_t get_mailbox_id() const {
        return mailbox_.mailbox_id();
    }
    
    bool is_initialized() const {
        return mailbox_.is_initialized();
    }
    
private:
    // ========================================================================
    // Internal Implementation
    // ========================================================================
    
    template<typename T>
    void store_in_history(const TimsMessage<T>& tims_msg) {
        auto& buffer = get_history_buffer<T>();
        
        // Store TimsMessage directly - no conversion needed!
        // Phase 6.10: Timestamp is in header (tims_msg.header.timestamp)
        buffer.push(tims_msg);
    }
    
    template<typename T>
    const TimestampedRingBuffer<TimsMessage<T>, HistorySize>& get_history_buffer() const {
        constexpr auto type_index = Registry::template get_type_index<T>();
        return *std::get<type_index>(history_buffers_);
    }
    
    template<typename T>
    TimestampedRingBuffer<TimsMessage<T>, HistorySize>& get_history_buffer() {
        constexpr auto type_index = Registry::template get_type_index<T>();
        return *std::get<type_index>(history_buffers_);
    }
    
    void init_history_buffers() {
        init_buffers_impl(std::make_index_sequence<Registry::num_types>{});
    }
    
    template<std::size_t... Is>
    void init_buffers_impl(std::index_sequence<Is...>) {
        ((init_buffer<Is>()), ...);
    }
    
    template<std::size_t I>
    void init_buffer() {
        using PayloadType = typename Registry::template type_at<I>;
        std::get<I>(history_buffers_) = 
            std::make_unique<TimestampedRingBuffer<TimsMessage<PayloadType>, HistorySize>>(
                default_tolerance_
            );
    }
    
    void clear_all_buffers() {
        clear_all_impl(std::make_index_sequence<Registry::num_types>{});
    }
    
    template<std::size_t... Is>
    void clear_all_impl(std::index_sequence<Is...>) {
        ((std::get<Is>(history_buffers_)->clear()), ...);
    }
    
    // ========================================================================
    // Member Variables
    // ========================================================================
    
    MailboxType mailbox_;  
    
    Milliseconds default_tolerance_;  
    
    HistoryBufferTuple history_buffers_;
};
 
} // namespace commrat