ProcedureStepUnit.h

Go to the documentation of this file.

#pragma once
 
// ProcedureStepUnit.h: interface for the ProcedureStepUnit class.
//
 
#include <cmath>
#include <string>
#include <vector>
#include <fstream>
#include <stdexcept>
#include <type_traits>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <boost/serialization/split_member.hpp>
 
#include "ProcedureActionUnit.h"
#include "ExpectationElement.h"
#include "ExpectationORUnit.h"
#include "../ControlPanel/StateOfActivation.h"
#include "ProcedureStepInfo.h"
#include "../Crew/ShortTermMemory.h"
#include "ProcedureScannedParameterUnit.h"
#include "../Scheduler/AnalysisInfoContainer.h"
#include "../Scheduler/AnalysisProcedureDataContainerUnit.h"
 
// Include Boost.Serialization headers
#include <boost/serialization/access.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/unique_ptr.hpp>
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/export.hpp>
#include <memory>
 
class Operator;
 
 
 
class ProcedureStepUnit : public StateOfActivation
{
public:
    ProcedureStepUnit();
    virtual ~ProcedureStepUnit();
    // Existing member functions
    void setTypeOfAction(int);
    int getTypeOfAction();
    void setTypeOfNonResponseAction(int);
    int getTypeOfNonResponseAction();
    void setActionPtr(ProcedureActionUnit *);
    ProcedureActionUnit *getActionPtr();
    ProcedureStepInfo *getMentalProcedurePtr();
    ProcedureScannedParameterUnit *getScannedParameterUnitPtr();
    bool hasNonResponseAction() const;
    double calculateDynamicHEPMultiplier(int, std::string, AnalysisProcedureDataContainerUnit &);
    double calculateAdjustedSkipProbability(double, double);
    bool readInfofromFile(std::ifstream &);
    int readInfofromFileAction(std::ifstream &);
    void readInfofromFileExpectation(std::ifstream &, int);
    bool readInfoFromFileNonResponseExit(std::ifstream &);
    bool checkIfIsChangeSystemAction(std::string );
    int checkForTypeOfExpectation(std::string );
    void setStateOfAction(int);
    void setStateOfNonResponseAction(int);
    int getStateOfAction();
    int getStateOfNonResponseAction();
    void copyProcedureStepUnit(ProcedureStepUnit &);
    bool executeAction(Operator &, ShortTermMemory &, int, std::string, std::string, std::string, double, double);
    bool executeExpectation(Operator &, ShortTermMemory &, int);
    bool executeNonResponseAction(Operator &, ShortTermMemory &, int, std::string, std::string, double, double);
    void setStateOfExpectation(int);
    int getStateOfExpectation();
    int getNumberOfANDExpectation();
    void saveProcedureStepUnitToFile(std::ofstream &);
    void saveProcedureStepUnitActionToFile(std::ofstream &);
    void saveProcedureStepUnitNonResponseActionToFile(std::ofstream &);
    void saveProcedureStepUnitMentalProcedureToFile(std::ofstream &);
    void saveProcedureStepUnitScannedParameterToFile(std::ofstream &);
    void saveProcedureStepUnitExpectationToFile(std::ofstream &);
    void retrieveProcedureStepUnitFromFile(std::ifstream &);
    void retrieveProcedureStepUnitActionFromFile(std::ifstream &);
    void retrieveProcedureStepUnitMentalProcedureFromFile(std::ifstream &);
    void retrieveProcedureStepUnitScannedParameterFromFile(std::ifstream &);
    void retrieveProcedureStepUnitNonResponseActionFromFile(std::ifstream &);
    void retrieveProcedureStepUnitExpectationFromFile(std::ifstream &);
 
    // Member variables
    std::unique_ptr<ProcedureActionUnit> action;
    std::unique_ptr<ProcedureStepInfo> mental_procedure;
    std::unique_ptr<ProcedureScannedParameterUnit> scanned_parameter;
    std::vector<std::unique_ptr<ExpectationORUnit>> expectation;
    std::unique_ptr<ProcedureActionUnit> non_response_action_unit;
    std::unique_ptr<ProcedureStepInfo> non_response_procedure;
    std::unique_ptr<ProcedureScannedParameterUnit> non_response_scan;
 
private:
    int type_of_action;
    int type_of_non_response_action;
    int state_of_action, state_of_non_response_action;
    int state_of_expectation;
 
    int serialized_expectation_count = -1;  // -1 = not std::set (use expectation.size())
 
    // State overlay: state only. type_of_* and the mental/non-response
    // procedure references are definitions re-seeded from the master.
    // action / non_response_action_unit / scan units carry Timer execution
    // state and are (de)serialized IN PLACE through presence flags so their
    // seeded definitions survive the load. The polymorphic expectation tree
    // is walked in place as well: state only on binary archives, whole
    // elements on text archives (see save/load below).
    friend class boost::serialization::access;
    BOOST_SERIALIZATION_SPLIT_MEMBER()
    template<class Archive>
    void save(Archive & ar, const unsigned int) const
    {
        ar & boost::serialization::base_object<StateOfActivation>(*this);
        ar & state_of_action;
        ar & state_of_non_response_action;
        ar & state_of_expectation;
        save_inplace(ar, action);
        save_inplace(ar, scanned_parameter);
        // Expectation trees walk state-only through the virtual hooks; their
        // class serializers carry every member for dynamic crew users. The
        // hooks are concrete-binary virtuals (virtual templates don't exist);
        // text archives keep full elements.
        if constexpr (std::is_same_v<Archive, boost::archive::binary_oarchive>) {
            const uint32_t n_or = static_cast<uint32_t>(expectation.size());
            ar & n_or;
            for (const auto& oru : expectation)
                oru->state_save(ar);
        } else {
            ar & expectation;
        }
        save_inplace(ar, non_response_action_unit);
        save_inplace(ar, non_response_scan);
    }
    template<class Archive>
    void load(Archive & ar, const unsigned int)
    {
        ar & boost::serialization::base_object<StateOfActivation>(*this);
        ar & state_of_action;
        ar & state_of_non_response_action;
        ar & state_of_expectation;
        load_inplace(ar, action);
        load_inplace(ar, scanned_parameter);
        if constexpr (std::is_same_v<Archive, boost::archive::binary_iarchive>) {
            uint32_t n_or = 0;
            ar & n_or;
            if (n_or != expectation.size())
                throw std::runtime_error(
                    "ProcedureStepUnit state overlay: expectation count mismatch "
                    "against the seeded book");
            for (auto& oru : expectation)
                oru->state_load(ar);
        } else {
            ar & expectation;
        }
        load_inplace(ar, non_response_action_unit);
        load_inplace(ar, non_response_scan);
    }
    template<class Archive, class T>
    static void save_inplace(Archive& ar, const std::unique_ptr<T>& p)
    {
        const bool present = (p != nullptr);
        ar & present;
        if (!present) return;
        if constexpr (std::is_same_v<Archive, boost::archive::binary_oarchive>)
            p->state_save(ar);   // Timer progress only; definitions are seeded
        else
            ar & *p;
    }
    template<class Archive, class T>
    static void load_inplace(Archive& ar, std::unique_ptr<T>& p)
    {
        bool present = false;
        ar & present;
        if (present != (p != nullptr))
            throw std::runtime_error(
                "ProcedureStepUnit state overlay: sub-unit presence mismatch "
                "against the seeded book");
        if (!present) return;
        if constexpr (std::is_same_v<Archive, boost::archive::binary_iarchive>)
            p->state_load(ar);
        else
            ar & *p;
    }
};
 
BOOST_CLASS_EXPORT_KEY(ProcedureStepUnit)