Procedures.h

Go to the documentation of this file.

#pragma once
 
 
#include <boost/serialization/vector.hpp>
#include <boost/serialization/unique_ptr.hpp>
#include <boost/serialization/map.hpp>
#include <boost/serialization/string.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <memory>
#include "ProcedureStep.h"
#include "ProcedureStepInfo.h"
#include <map>
#include <vector>
#include <cstdint>
#include <stdexcept>
#include <boost/serialization/export.hpp>
#include <boost/serialization/split_member.hpp>
#include "../Global/SharedConfig.h"
 
class Procedures  
{
public:
    Procedures();
    virtual ~Procedures();
    void initiationForSimulation();
    void readInfoFromFile();
    void copyProcedures(Procedures &);
    void copyProceduresFromRestartInfoForRestart(Procedures &);
    void copyProceduresToRestartInfoForRestart(Procedures &);
    void clearProceduresForRestart();
    double getNormalProcedureMultiplier();
    double getMentalProcedureMultiplier();
    double getAbnormalProcedureMultiplier();
    double getOptimalRecoveryProcedureMultiplier();
    double getFunctionalRecoveryProcedureMultipler();
    double getAlarmResponseProcedureMultiplier();
    double getObjectiveStepMultiplier();
    double getPrerequisiteStepMultiplier();
    double getMonitoringStepMultiplier();
    double getVerificationStepMultiplier();
    double getDiagnosisStepMultiplier();
    void setNormalProcedureMultiplier(double);
    void setMentalProcedureMultiplier(double);
    void setAbnormalProcedureMultiplier(double);
    void setOptimalRecoveryProcedureMultiplier(double);
    void setFunctionalRecoveryProcedureMultipler(double);
    void setAlarmResponseProcedureMultiplier(double);
    void setObjectiveStepMultiplier(double);
    void setPrerequisiteStepMultiplier(double);
    void setMonitoringStepMultiplier(double);
    void setVerificationStepMultiplier(double);
    void setDiagnosisStepMultiplier(double);
    std::string getEntryProcedureName();
    std::string getEntryStepName();
    void setStepTransferTime(double);
    double getStepTransferTime();
    void setProcedureTransferTime(double);
    double getProcedureTransferTime();
    void clearProcedures();
    void saveProceduresToFile(std::ofstream &);
    void retrieveProceduresFromFile(std::ifstream &);
    std::vector<std::unique_ptr<ProcedureStep>> procedure_step;
    std::map<std::string, ProcedureStep *> procedure_map;
    std::vector<std::unique_ptr<ProcedureStepInfo>> list_of_procedural_step;
 
private:
    double step_transfer_time, procedure_transfer_time;
    double normal_procedure_multiplier;
    double mental_procedure_multiplier;
    double abnormal_procedure_multiplier;
    double optimal_recovery_procedure_multiplier;
    double functional_recovery_procedure_multiplier;
    double alarm_response_procedure_multiplier;
    double objective_step_multiplier;
    double prerequisite_step_multiplier;
    double monitoring_step_multiplier;
    double verification_step_multiplier;
    double diagnosis_step_multiplier;
 
    // State overlay: the archive carries EXECUTION STATE only. Definitions
    // (multipliers, step names/descriptions, the entry-point list) live in
    // the process-local master registered with adsidac::set_shared_procedures
    // and are re-seeded at load; procedure_map is rebuilt from the seeded
    // steps, never serialized (it holds raw pointers into procedure_step).
    // save() writes the step count as a structure guard; load() refuses a
    // count mismatch, because state applied to the wrong book must die loudly.
    friend class boost::serialization::access;
    BOOST_SERIALIZATION_SPLIT_MEMBER()
    template<class Archive>
    void save(Archive &ar, const unsigned int) const {
        const uint32_t n_steps = static_cast<uint32_t>(procedure_step.size());
        ar & n_steps;
        for (const auto& sp : procedure_step)
            ar & *sp;
    }
    template<class Archive>
    void load(Archive &ar, const unsigned int) {
        if (const Procedures* master = adsidac::shared_procedures();
            master != nullptr && master != this)
            seedFromMaster(*master);
        uint32_t n_steps = 0;
        ar & n_steps;
        if (n_steps != procedure_step.size())
            throw std::runtime_error(
                "Procedures state overlay: archive has " + std::to_string(n_steps)
                + " steps but the loaded procedure book has "
                + std::to_string(procedure_step.size())
                + " — configuration inputs do not match the snapshot");
        for (auto& sp : procedure_step)
            ar & *sp;
    }
    void seedFromMaster(const Procedures& master);
};
 
 
BOOST_CLASS_EXPORT_KEY(Procedures)