input_metadata_accessors.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "commrat/module/metadata/input_metadata.hpp"
#include <cstddef>
#include <tuple>
#include <type_traits>
 
namespace commrat {
 
template<typename ModuleType>
class InputMetadataAccessors {
protected:
    // CRTP accessor to get derived module instance
    ModuleType& module() { return static_cast<ModuleType&>(*this); }
    const ModuleType& module() const { return static_cast<const ModuleType&>(*this); }
    
public:
    template<typename T>
    struct InputMetadata {
        uint64_t timestamp;          
        uint32_t sequence_number;    
        uint32_t message_id;         
        bool is_new_data;            
        bool is_valid;               
        
        // Helper to get input type (for debugging/logging)
        static constexpr const char* type_name() { return typeid(T).name(); }
    };
    
    template<std::size_t Index>
    auto get_input_metadata() const {
        constexpr std::size_t num_inputs = ModuleType::num_inputs;
        static_assert(Index < num_inputs, "Input index out of bounds");
        
        using InputType = std::conditional_t<
            (num_inputs == 1),
            typename ModuleType::InputData,  // Single input: use InputData directly
            std::tuple_element_t<Index, typename ModuleType::InputTypesTuple>  // Multi-input: extract from tuple
        >;
        
        const auto& storage = module().input_metadata_[Index];
        return InputMetadata<InputType>{
            .timestamp = storage.timestamp,
            .sequence_number = storage.sequence_number,
            .message_id = storage.message_id,
            .is_new_data = storage.is_new_data,
            .is_valid = storage.is_valid
        };
    }
    
    template<std::size_t Index>
    uint64_t get_input_timestamp() const {
        constexpr std::size_t num_inputs = ModuleType::num_inputs;
        static_assert(Index < num_inputs, "Input index out of bounds");
        return module().input_metadata_[Index].timestamp;
    }
    
    template<std::size_t Index>
    bool has_new_data() const {
        constexpr std::size_t num_inputs = ModuleType::num_inputs;
        static_assert(Index < num_inputs, "Input index out of bounds");
        return module().input_metadata_[Index].is_new_data;
    }
    
    template<std::size_t Index>
    bool is_input_valid() const {
        constexpr std::size_t num_inputs = ModuleType::num_inputs;
        static_assert(Index < num_inputs, "Input index out of bounds");
        return module().input_metadata_[Index].is_valid;
    }
    
    // ========================================================================
    // Phase 6.10: Type-Based Metadata Accessors
    // ========================================================================
    
    template<typename T>
    auto get_input_metadata() const
        requires (ModuleType::num_inputs > 1)  // Only for multi-input
    {
        constexpr std::size_t index = find_type_index<T, 
            typename std::tuple_element<0, typename ModuleType::InputTypesTuple>::type,
            typename std::tuple_element<1, typename ModuleType::InputTypesTuple>::type
            // TODO: Need to unpack full tuple, not just first 2 elements
        >();
        return get_input_metadata<index>();
    }
    
    template<typename T>
    uint64_t get_input_timestamp() const
        requires (ModuleType::num_inputs > 1)
    {
        constexpr std::size_t index = find_type_index<T,
            typename std::tuple_element<0, typename ModuleType::InputTypesTuple>::type,
            typename std::tuple_element<1, typename ModuleType::InputTypesTuple>::type
            // TODO: Need to unpack full tuple
        >();
        return get_input_timestamp<index>();
    }
    
    template<typename T>
    bool has_new_data() const
        requires (ModuleType::num_inputs > 1)
    {
        constexpr std::size_t index = find_type_index<T,
            typename std::tuple_element<0, typename ModuleType::InputTypesTuple>::type,
            typename std::tuple_element<1, typename ModuleType::InputTypesTuple>::type
        >();
        return has_new_data<index>();
    }
    
    template<typename T>
    bool is_input_valid() const
        requires (ModuleType::num_inputs > 1)
    {
        constexpr std::size_t index = find_type_index<T,
            typename std::tuple_element<0, typename ModuleType::InputTypesTuple>::type,
            typename std::tuple_element<1, typename ModuleType::InputTypesTuple>::type
        >();
        return is_input_valid<index>();
    }
};
 
} // namespace commrat