InputHandle.hpp

Go to the documentation of this file.

#pragma once

 
#include <icarus/core/CoreTypes.hpp>
#include <icarus/core/Error.hpp>
#include <string>
#include <type_traits>
 
namespace icarus {
 
// Forward declarations
template <typename Scalar> class Backplane;
template <typename Scalar> class SignalRegistry;

template <typename T> class InputHandle {
  public:
    InputHandle() : default_value_{} {}

    [[nodiscard]] T get() const {
        if (!source_) {
            // Unwired: return the pokeable default value
            return default_value_;
        }
        // Wired: read from source (with gain for scalars)
        if constexpr (std::is_arithmetic_v<T>) {
            return static_cast<T>(*source_ * gain_);
        } else {
            return *source_;
        }
    }

    void set(const T &value) { default_value_ = value; }

    [[nodiscard]] T operator*() const { return get(); }

    [[nodiscard]] T *data_ptr() { return &default_value_; }

    [[nodiscard]] bool is_wired() const { return source_ != nullptr; }

    [[nodiscard]] const std::string &name() const { return name_; }

    [[nodiscard]] const std::string &full_name() const { return full_name_; }

    [[nodiscard]] const std::string &wired_to() const { return wired_to_; }

    [[nodiscard]] const std::string &units() const { return units_; }

    [[nodiscard]] const std::string &description() const { return description_; }
 
  private:
    // Backplane needs access to wire inputs
    template <typename S> friend class Backplane;
    template <typename S> friend class SignalRegistry;
 
    // Internal setters for Backplane/Registry
    void set_name(const std::string &name) { name_ = name; }
    void set_full_name(const std::string &full_name) { full_name_ = full_name; }
    void set_units(const std::string &units) { units_ = units; }
    void set_description(const std::string &desc) { description_ = desc; }
 
    void wire(const T *source, const std::string &source_name) {
        source_ = source;
        wired_to_ = source_name;
        gain_ = 1.0; // Default gain
    }

    void wire_with_gain(const T *source, const std::string &source_name, double gain) {
        source_ = source;
        wired_to_ = source_name;
        gain_ = gain;
    }
 
    std::string name_;          // Local name (e.g., "throttle")
    std::string full_name_;     // Full name (e.g., "X15.Engine.throttle")
    std::string wired_to_;      // Source signal name
    const T *source_ = nullptr; // Pointer to source value
    double gain_ = 1.0;         // Scale factor (Phase 4.0)
    T default_value_{};         // Default/poke buffer (used when unwired)
 
    // Metadata
    std::string units_;
    std::string description_;
};
 
// =============================================================================
// Convenience Aliases
// =============================================================================

template <typename Scalar> using ScalarInput = InputHandle<Scalar>;

template <typename Scalar> using Vec3Input = InputHandle<Vec3<Scalar>>;

template <typename Scalar> using QuatInput = InputHandle<Vec4<Scalar>>;
 
} // namespace icarus