transition.hpp

 
// File: transition.hpp                                                       //
// Project: respond                                                           //
// Created Date: 2026-02-02                                                   //
// Author: Matthew Carroll                                                    //
// -----                                                                      //
// Last Modified: 2026-09-24                                                  //
// Modified By: Matthew Carroll                                               //
// -----                                                                      //
// Copyright (c) 2026 Syndemics Lab at Boston Medical Center                  //
 
#ifndef RESPOND_TRANSITION_HPP_
#define RESPOND_TRANSITION_HPP_
 
#include <map>
#include <memory>
#include <string>
#include <vector>
 
#include <Eigen/Dense>
 
#include <respond/constants.hpp>
#include <respond/history.hpp>
#include <respond/logging_config.hpp>
 
namespace respond {
 
class Transition {
public:
    virtual ~Transition() = default;
 
    virtual Eigen::VectorXd
    Execute(const Eigen::Ref<const Eigen::VectorXd> &s,
            std::map<std::string, History> &h) const = 0;
 
    virtual void AddMatrix(Eigen::Ref<const Eigen::MatrixXd> m) = 0;
 
    virtual std::vector<Eigen::MatrixXd> GetMatrices() const = 0;
 
    virtual std::string GetName() const = 0;
 
    virtual void ClearMatrices() = 0;
 
    Transition(const Transition &) = delete;
    Transition &operator=(const Transition &) = delete;
 
    virtual std::unique_ptr<Transition> clone() const = 0;
 
    [[deprecated("Use Transition::Create(type, name, LoggingConfig) instead")]]
    static std::unique_ptr<Transition>
    Create(const std::string &type,
           const std::string &name = RESPOND_DEFAULT_TRANSITION_NAME,
           const std::string &log_name = RESPOND_DEFAULT_LOG,
           const std::string &log_file = RESPOND_DEFAULT_LOG_FILE);
 
    static std::unique_ptr<Transition>
    Create(const std::string &type, const std::string &name,
           const LoggingConfig &logging_config);
 
    virtual void Serialize(std::ostream &os) const = 0;
 
protected:
    Transition() = default;
};
 
inline std::ostream &operator<<(std::ostream &os,
                                const Transition &transition) {
    transition.Serialize(os);
    return os;
}
 
} // namespace respond
 
#endif