SignalRouter.hpp

Go to the documentation of this file.

#pragma once

 
#include <icarus/core/Error.hpp>
#include <icarus/signal/Backplane.hpp>
 
#include <cstdint>
#include <set>
#include <string>
#include <unordered_set>
#include <vector>
 
namespace icarus {
namespace signal {

struct SignalRoute {
    std::string input_path;  
    std::string output_path; 
 
    // Optional transformations
    double gain = 1.0;   
    double offset = 0.0; 
    double delay = 0.0;  

    std::set<int32_t> active_phases;
 
    SignalRoute() = default;
    SignalRoute(std::string input, std::string output, double g = 1.0, double o = 0.0,
                double d = 0.0)
        : input_path(std::move(input)), output_path(std::move(output)), gain(g), offset(o),
          delay(d) {}

    [[nodiscard]] double EffectiveGain(int32_t current_phase) const {
        if (active_phases.empty()) {
            return gain; // No phase restriction - always active
        }
        if (active_phases.contains(current_phase)) {
            return gain; // Active in this phase
        }
        return 0.0; // Inactive: zero the output
    }

    [[nodiscard]] bool IsActiveInPhase(int32_t current_phase) const {
        return active_phases.empty() || active_phases.contains(current_phase);
    }

    [[nodiscard]] std::vector<std::string> Validate() const {
        std::vector<std::string> errors;
        if (input_path.empty()) {
            errors.push_back("SignalRoute: input_path is empty");
        }
        if (output_path.empty()) {
            errors.push_back("SignalRoute: output_path is empty");
        }
        if (delay < 0.0) {
            errors.push_back("SignalRoute: delay cannot be negative");
        }
        return errors;
    }
};

template <typename Scalar> class SignalRouter {
  public:
    void AddRoute(const SignalRoute &route) { routes_.push_back(route); }

    void AddRoute(const std::string &input_path, const std::string &output_path,
                  double gain = 1.0) {
        routes_.emplace_back(input_path, output_path, gain);
    }

    void ApplyRoutes(Backplane<Scalar> &bp) {
        // First pass: validate all signals exist
        auto errors = ValidateRoutes(bp);
        if (!errors.empty()) {
            std::string msg = "Signal routing validation failed:\n";
            for (const auto &err : errors) {
                msg += "  - " + err + "\n";
            }
            throw RoutingError(msg);
        }
 
        // Second pass: wire with gains
        for (const auto &route : routes_) {
            bp.WireWithGain(route.input_path, route.output_path, route.gain);
        }
    }

    [[nodiscard]] std::vector<std::string> ValidateRoutes(const Backplane<Scalar> &bp) const {
        std::vector<std::string> errors;
 
        for (const auto &route : routes_) {
            if (!bp.HasOutput(route.output_path)) {
                errors.push_back("Output not found: '" + route.output_path + "'");
            }
            if (!bp.HasInput(route.input_path)) {
                errors.push_back("Input not found: '" + route.input_path + "'");
            }
        }
 
        return errors;
    }

    [[nodiscard]] std::vector<std::string> GetUnwiredInputs(const Backplane<Scalar> &bp) const {
        // Get all declared inputs from backplane
        auto all_inputs = bp.GetDeclaredInputs();
 
        // Build set of wired inputs
        std::unordered_set<std::string> wired;
        for (const auto &route : routes_) {
            wired.insert(route.input_path);
        }
 
        // Find unwired
        std::vector<std::string> unwired;
        for (const auto &input : all_inputs) {
            if (wired.find(input) == wired.end()) {
                unwired.push_back(input);
            }
        }
 
        return unwired;
    }

    [[nodiscard]] const std::vector<SignalRoute> &GetRoutes() const { return routes_; }

    void Clear() { routes_.clear(); }

    [[nodiscard]] std::size_t Size() const { return routes_.size(); }
 
  private:
    std::vector<SignalRoute> routes_;
};
 
} // namespace signal
} // namespace icarus