io_spec.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cstddef>
#include <tuple>
#include <type_traits>
#include <concepts>
 
namespace commrat {
 
// ============================================================================
// Forward Declarations
// ============================================================================
 
struct PeriodicInput;
struct LoopInput;
 
// ============================================================================
// Output Specifications
// ============================================================================
 
template<typename T>
struct Output {
    using PayloadType = T;
    static constexpr size_t count = 1;
};
 
template<typename... Ts>
struct Outputs {
    using PayloadTypes = std::tuple<Ts...>;
    static constexpr size_t count = sizeof...(Ts);
    
    static_assert(count > 0, "Outputs<> requires at least one type");
};
 
struct NoOutput {
    static constexpr size_t count = 0;
};
 
// ============================================================================
// Input Specifications
// ============================================================================
 
template<typename T>
struct Input {
    using PayloadType = T;
    static constexpr size_t count = 1;
};
 
template<typename... Ts>
struct Inputs {
    using PayloadTypes = std::tuple<Ts...>;
    static constexpr size_t count = sizeof...(Ts);
    
    static_assert(count > 0, "Inputs<> requires at least one type");
};
 
template<typename T>
struct PrimaryInput {
    using PayloadType = T;
};
 
// ============================================================================
// Type Traits and Concepts
// ============================================================================
 
// --- Output Type Detection ---
 
template<typename T>
struct is_single_output : std::false_type {};
 
template<typename T>
struct is_single_output<Output<T>> : std::true_type {};
 
template<typename T>
inline constexpr bool is_single_output_v = is_single_output<T>::value;
 
template<typename T>
struct is_multi_output : std::false_type {};
 
template<typename... Ts>
struct is_multi_output<Outputs<Ts...>> : std::true_type {};
 
template<typename T>
inline constexpr bool is_multi_output_v = is_multi_output<T>::value;
 
template<typename T>
struct is_no_output : std::false_type {};
 
template<>
struct is_no_output<NoOutput> : std::true_type {};
 
template<typename T>
inline constexpr bool is_no_output_v = is_no_output<T>::value;
 
template<typename T>
concept ValidOutputSpec = is_single_output_v<T> || 
                          is_multi_output_v<T> || 
                          is_no_output_v<T>;
 
// --- Input Type Detection ---
 
template<typename T>
struct is_periodic_input : std::false_type {};
 
template<>
struct is_periodic_input<PeriodicInput> : std::true_type {};
 
template<typename T>
inline constexpr bool is_periodic_input_v = is_periodic_input<T>::value;
 
template<typename T>
struct is_loop_input : std::false_type {};
 
template<>
struct is_loop_input<LoopInput> : std::true_type {};
 
template<typename T>
inline constexpr bool is_loop_input_v = is_loop_input<T>::value;
 
template<typename T>
struct is_single_input : std::false_type {};
 
template<typename T>
struct is_single_input<Input<T>> : std::true_type {};
 
template<typename T>
inline constexpr bool is_single_input_v = is_single_input<T>::value;
 
template<typename T>
struct is_multi_input : std::false_type {};
 
template<typename... Ts>
struct is_multi_input<Inputs<Ts...>> : std::true_type {};
 
template<typename T>
inline constexpr bool is_multi_input_v = is_multi_input<T>::value;
 
template<typename T>
struct is_primary_input : std::false_type {};
 
template<typename T>
struct is_primary_input<PrimaryInput<T>> : std::true_type {};
 
template<typename T>
inline constexpr bool is_primary_input_v = is_primary_input<T>::value;
 
template<typename T>
concept ValidInputSpec = is_periodic_input_v<T> || 
                         is_loop_input_v<T> || 
                         is_single_input_v<T> || 
                         is_multi_input_v<T>;
 
// --- Combined Concepts ---
 
template<typename T>
concept PeriodicOrLoop = is_periodic_input_v<T> || is_loop_input_v<T>;
 
template<typename T>
concept HasContinuousInput = is_single_input_v<T> || 
                             is_multi_input_v<T>;
 
// --- Count Helpers ---
 
template<typename T>
struct OutputCount {
    static constexpr size_t value = 1;  // Raw type = single output
};
 
template<typename T>
struct OutputCount<Output<T>> {
    static constexpr size_t value = 1;
};
 
template<typename... Ts>
struct OutputCount<Outputs<Ts...>> {
    static constexpr size_t value = sizeof...(Ts);
};
 
template<>
struct OutputCount<NoOutput> {
    static constexpr size_t value = 0;
};
 
template<typename T>
inline constexpr size_t OutputCount_v = OutputCount<T>::value;
 
template<typename T>
struct InputCount {
    static constexpr size_t value = 0;  // PeriodicInput, LoopInput = no input
};
 
template<typename T>
struct InputCount<Input<T>> {
    static constexpr size_t value = 1;
};
 
template<typename... Ts>
struct InputCount<Inputs<Ts...>> {
    static constexpr size_t value = sizeof...(Ts);
};
 
template<typename T>
inline constexpr size_t InputCount_v = InputCount<T>::value;
 
// ============================================================================
// Input/Output Normalization
// ============================================================================
 
template<typename T>
struct NormalizeInput {
    using Type = T;  // Default: pass through
};
 
template<typename T>
using NormalizeInput_t = typename NormalizeInput<T>::Type;
 
template<typename T>
struct NormalizeOutput {
    // If T is already an output spec, use it as-is
    // Otherwise, wrap it in Output<T>
    using Type = std::conditional_t<
        ValidOutputSpec<T>,
        T,
        Output<T>
    >;
};
 
template<typename T>
using NormalizeOutput_t = typename NormalizeOutput<T>::Type;
 
// ============================================================================
// Parameter Pack Expansion Helpers
// ============================================================================
 
template<typename InputSpec>
struct InputPayloadTypes {
    using Type = std::tuple<>;  // Default: no inputs
};
 
template<typename T>
struct InputPayloadTypes<Input<T>> {
    using Type = std::tuple<T>;
};
 
template<typename... Ts>
struct InputPayloadTypes<Inputs<Ts...>> {
    using Type = std::tuple<Ts...>;
};
 
template<typename InputSpec>
using InputPayloadTypes_t = typename InputPayloadTypes<InputSpec>::Type;
 
template<typename OutputSpec>
struct OutputPayloadTypes {
    using Type = std::tuple<>;  // Default: no outputs
};
 
template<typename T>
struct OutputPayloadTypes<Output<T>> {
    using Type = std::tuple<T>;
};
 
template<typename... Ts>
struct OutputPayloadTypes<Outputs<Ts...>> {
    using Type = std::tuple<Ts...>;
};
 
template<typename OutputSpec>
using OutputPayloadTypes_t = typename OutputPayloadTypes<OutputSpec>::Type;
 
template<typename OutputSpec>
struct SingleOutputType {
    using Type = OutputSpec;  // Legacy: raw type is the output
};
 
template<typename T>
struct SingleOutputType<Output<T>> {
    using Type = T;
};
 
template<typename OutputSpec>
using SingleOutputType_t = typename SingleOutputType<OutputSpec>::Type;
 
template<typename InputSpec>
struct SingleInputType {
    using Type = void;  // No input type for PeriodicInput/LoopInput
};
 
template<typename T>
struct SingleInputType<Input<T>> {
    using Type = T;
};
 
template<typename InputSpec>
using SingleInputType_t = typename SingleInputType<InputSpec>::Type;
 
// ============================================================================
// Primary Input Index Extraction (Phase 6)
// ============================================================================
 
template<typename PrimaryT, typename InputsTuple>
struct PrimaryInputIndex;
 
// Base case: Primary type not found - compile error
template<typename PrimaryT>
struct PrimaryInputIndex<PrimaryT, std::tuple<>> {
    static_assert(sizeof(PrimaryT) == 0, 
                  "PrimaryInput type not found in Inputs<...> list. "
                  "Ensure PrimaryInput<T> specifies a type T that exists in Inputs<Ts...>.");
};
 
// Recursive case: Primary type matches first type in tuple
template<typename PrimaryT, typename... Rest>
struct PrimaryInputIndex<PrimaryT, std::tuple<PrimaryT, Rest...>> {
    static constexpr size_t value = 0;
};
 
// Recursive case: Primary type doesn't match, continue searching
template<typename PrimaryT, typename First, typename... Rest>
struct PrimaryInputIndex<PrimaryT, std::tuple<First, Rest...>> {
    static constexpr size_t value = 1 + PrimaryInputIndex<PrimaryT, std::tuple<Rest...>>::value;
};
 
template<typename PrimaryT, typename InputsTuple>
inline constexpr size_t PrimaryInputIndex_v = PrimaryInputIndex<PrimaryT, InputsTuple>::value;
 
template<typename PrimaryInputSpec, typename InputSpec>
struct ValidatePrimaryInput {
    static_assert(is_primary_input_v<PrimaryInputSpec>,
                  "PrimaryInputSpec must be PrimaryInput<T>");
    
    static_assert(is_multi_input_v<InputSpec>,
                  "InputSpec must be Inputs<Ts...> when using PrimaryInput<T>");
    
    using PrimaryPayload = typename PrimaryInputSpec::PayloadType;
    using InputsPayloadTypes = typename InputSpec::PayloadTypes;
    
    // This will trigger compile error if PrimaryPayload not in InputsPayloadTypes
    static constexpr size_t primary_index = 
        PrimaryInputIndex_v<PrimaryPayload, InputsPayloadTypes>;
    
    static constexpr bool value = true;
};
 
template<typename PrimaryInputSpec, typename InputSpec>
inline constexpr bool ValidatePrimaryInput_v = 
    ValidatePrimaryInput<PrimaryInputSpec, InputSpec>::value;
 
} // namespace commrat