Template Class SignalProcessor

• Defined in File signal_processor.hpp

Class Documentation

template<typename S>
class SignalProcessor

Simple signal processor.

Simple signal processor for integrator callbacks.

Lightweight signal processor using standard C++ only.

This replaces the complex event bus system with a simple, type-safe signal handling mechanism.

This provides a lightweight way to process signals and update integration parameters without heavy communication dependencies.

Public Types

using state_type = S

template<typename T>
using SignalHandler = std::function<void(const Signal<T>&)>

using state_type = S

using time_type = typename S::value_type

template<typename T>
using SignalHandler = std::function<void(const Signal<T>&)>

using state_type = S

template<typename T>
using SignalHandler = std::function<void(const Signal<T>&)>

using state_type = S

using time_type = T

using value_type = typename S::value_type

using integrator_type = AsyncIntegrator<S, T>

using parameter_signal = Signal<std::unordered_map<std::string, double>>

using control_signal = Signal<std::vector<double>>

using market_signal = Signal<std::unordered_map<std::string, double>>

using state_type = S

using time_type = typename S::value_type

template<typename T>
using SignalHandler = std::function<void(const Signal<T>&)>

Public Functions

SignalProcessor() = default

template<typename T>
inline void emit_signal(std::string_view signal_type, T &&data, double priority = 1.0)

Emit a signal with arbitrary data.

template<typename T, typename Handler>
inline void register_handler(std::string_view signal_type, Handler &&handler)

Register a typed signal handler.

SignalProcessor() = default

template<typename T>
inline void emit_signal(std::string_view signal_type, T &&data, double priority = 1.0)

Emit a signal with arbitrary data.

template<typename T, typename Handler>
inline void register_handler(std::string_view signal_type, Handler &&handler)

Register a typed signal handler.

inline void update_parameter(const std::string &param_name, double value)

Update integration parameters.

SignalProcessor() = default

template<typename T>
inline void emit_signal(std::string_view signal_type, T &&data, double priority = 1.0)

Emit a signal with arbitrary data.

template<typename T, typename Handler>
inline void register_handler(std::string_view signal_type, Handler &&handler)

Register a typed signal handler.

inline explicit SignalProcessor(std::shared_ptr<integrator_type> integrator)

inline void process_parameter_signal(const parameter_signal &signal)

Process parameter update signal.

inline void process_control_signal(const control_signal &signal)

Process control signal (for robotics)

inline void process_market_signal(const market_signal &signal)

Process market signal (for finance)

inline const std::vector<double> &get_control_targets() const

Get current control targets.

inline double get_market_data(const std::string &symbol) const

Get market data for symbol.

inline void update_parameter(const std::string &name, double value)

Update integration parameter.

inline double get_parameter(const std::string &name) const

Get parameter value.

template<typename SignalType, SignalHandler<SignalType> Handler>
inline void register_handler(const std::string &signal_type, Handler &&handler)

Register custom signal handler.

template<typename SignalType>
inline void process_signal(const SignalType &signal)

Process generic signal.

SignalProcessor() = default

template<typename T>
inline void emit_signal(std::string_view signal_type, T &&data, double priority = 1.0)

Emit a signal with arbitrary data.

template<typename T, typename Handler>
inline void register_handler(std::string_view signal_type, Handler &&handler)

Register a typed signal handler.

inline void update_parameter(const std::string &param_name, double value)

Update integration parameters.