ProcedureStep.h

Go to the documentation of this file.

#pragma once
 
#include <iostream>
#include <typeinfo>
 
#include <boost/serialization/vector.hpp>
#include <boost/serialization/unique_ptr.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 <boost/serialization/split_member.hpp>
#include <cstdint>
#include <stdexcept>
#include <memory>
#include "ProcedureStepUnit.h"
#include "../ControlPanel/StateOfActivation.h"
#include "../Crew/ShortTermMemory.h"
#include "../Scheduler/AnalysisInfoContainer.h"
#include "../Scheduler/CommandControlCenter.h"
#include <vector>
#include <string>
#include <boost/serialization/export.hpp>
 
class Operator; // Assuming Operator is serializable if needed
 
 
class ProcedureStep : public StateOfActivation {
public:
    ProcedureStep();
    virtual ~ProcedureStep();
    void clear();
    void setCurrentProcedureName(std::string name);
    void setCurrentStepName(std::string name);
    void setNextProcedureName(std::string name);
    void setNextStepName(std::string name);
    void setProcedureStepCharacteristics(int characteristics);
    void setProcedureStepComplexity(double complexity);
    void setProcedureType(int type);
    std::string getCurrentProcedureName();
    std::string getCurrentStepName();
    std::string getNextProcedureName();
    std::string getNextStepName();
    int getProcedureStepCharacteristics();
    double getProcedureStepComplexity();
    int getProcedureType();
    void setDescription(std::string desc);
    std::string getDescription();
    void readDescriptionFromFile(std::ifstream &);
    bool readInfoFromFile(std::string, std::string);
    void copyProcedureStep(ProcedureStep &);
    bool oneThroughProcessForProcedureStep(Operator &, double, double, bool, ShortTermMemory &);
    bool oneThroughProcessForInstinctiveResponseProcedure(Operator &, double, double, bool, ShortTermMemory &);
    bool executeInstinctiveResponseProcedureTransfer(Operator &, ShortTermMemory &);
    void resetStateOfActivation();
    bool checkWhetherThisIsAMentalProcedure(std::string);
    double calculateProcedureStepStaticHEPMultiplier();
    void setBranchControlFlag(int flag);
    int getBranchControlFlag();
    void saveProcedureStepToFile(std::ofstream &);
    void retrieveProcedureStepFromFile(std::ifstream &);
    std::vector<std::unique_ptr<ProcedureStepUnit>> procedure_step_unit;
 
private:
    std::string current_procedure_name, current_step_name;
    std::string next_procedure_name, next_step_name;
    std::string description;
    int procedure_step_characteristics;
    double procedure_step_complexity;
    int procedure_type;
    int branch_control_flag;
 
    // State overlay: state only. Names, description, and characteristics are
    // definitions re-seeded from the shared master. Units are written by
    // count + in-place element state so load never lets Boost reconstruct
    // the container (reconstruction would default-construct units and wipe
    // the seeded definitions).
    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);
        const uint32_t n_units = static_cast<uint32_t>(procedure_step_unit.size());
        ar & n_units;
        for (const auto& up : procedure_step_unit)
            ar & *up;
    }
    template<class Archive>
    void load(Archive &ar, const unsigned int) {
        ar & boost::serialization::base_object<StateOfActivation>(*this);
        uint32_t n_units = 0;
        ar & n_units;
        if (n_units != procedure_step_unit.size())
            throw std::runtime_error(
                "ProcedureStep state overlay: unit count mismatch against the seeded book");
        for (auto& up : procedure_step_unit)
            ar & *up;
    }
};
 
 
BOOST_CLASS_EXPORT_KEY(ProcedureStep)