ConvertToString.cpp

Go to the documentation of this file.

// ConvertToString.cpp: implementation of the ConvertToString class.
//
 
#include <boost/serialization/export.hpp>
 
#include "ConvertToString.h"
#include "TermConversions.h"
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
BOOST_CLASS_EXPORT_IMPLEMENT(ConvertToString)
using namespace std;
 
 
// Construction/Destruction
 
ConvertToString::ConvertToString() {
 
}
 
ConvertToString::~ConvertToString() {
  this->clearConvertToString();
}
void ConvertToString::clearConvertToString() {
  term_names_.clear();
}
 
void ConvertToString::initiationForSimulation() {
  term_names_ = {
    {sim::Bool::False,            "FALSE"},
    {sim::Bool::True,             "TRUE"},
    {sim::Bool::Yes,              "YES"},
    {sim::Bool::No,               "NO"},
    {sim::Bool::Checked,          "CHECKED"},
    {sim::Bool::Unchecked,       "UN_CHECKED"},
    {sim::Compare::GT,               ">"},
    {sim::Compare::GE,               ">="},
    {sim::Compare::EQ,               "="},
    {sim::Compare::LE,               "<="},
    {sim::Compare::LT,               "<"},
    {sim::Trend::Decreasing,       "DECREASING"},
    {sim::Trend::Increasing,       "INCREASING"},
    {sim::Trend::Stable,           "STABLE"},
    {sim::Source::Bypass,           "BYPASS"},
    {sim::Source::AgOperator,      "AG_OPERATOR"},
    {sim::Source::PrPanel,         "PR_PANEL"},
    {sim::Source::PrOperator,      "PR_OPERATOR"},
    {sim::Source::PrPlant,         "PR_PLANT"},
    {sim::State::Normal,           "NORMAL"},
    {sim::State::Failed,           "FAILED"},
    {sim::State::Succeed,          "SUCCEED"},
    {sim::State::On,               "ON"},
    {sim::State::Off,              "OFF"},
    {sim::Source::Reliability,      "NO_CHECKED"},
    {sim::Source::Panel,            "PANEL"},
    {sim::Source::Plant,            "PLANT"},
    {sim::State::Activated,        "ACTIVATED"},
    {sim::State::Skip,             "VSKIP"},
    {sim::State::Standby,          "STANDBY"},
    {sim::State::Operate,          "OPERATE"},
    {sim::State::Control,          "CONTROL"},
    {sim::Compare::Between,          "BETWEEN"},
    {sim::State::Auto,             "AUTO"},
    {sim::State::Reset,            "RESET"},
    {sim::State::New,              "NEW"},
    {sim::State::FailedP,         "FAILED_P"},
    {sim::Operator::OdmAsk,          "ODM_ASK"},
    {sim::Operator::OdmCom,          "ODM_COM"},
    {sim::Operator::OdmAdv,          "ODM_ADV"},
    {sim::Operator::OatSend,         "OAT_SEND"},
    {sim::Operator::OctAdv,          "OCT_ADV"},
    {sim::Operator::OAT,              "OAT"},
    {sim::Operator::ODM,              "ODM"},
    {sim::Operator::OCT,              "OCT"},
    {sim::None,             "NONE"},
    {sim::Goal::NormalOp,             "GNOP"},
    {sim::Goal::TroubleShoot,              "GTS"},
    {sim::Goal::MaintainGlobalSafetyMargin,            "GMGSM"},
    {sim::Goal::MonitorAbnormal,             "GMON"},
    {sim::Goal::MaintainEquipSafetyMargin,            "GMESM"},
    {sim::SubGoal::FindRootCause,            "SGFRC"},
    {sim::SubGoal::DecideActionPack,            "SGDAP"},
    {sim::SubGoal::PerformAction,             "SGPA"},
    {sim::Strategy::WaitMonitor,              "SWM"},
    {sim::Strategy::DirectMatch,              "SDM"},
    {sim::Strategy::LimitedReasoning,              "SLR"},
    {sim::Strategy::InstinctiveResponse,              "SPR"},
    {sim::Strategy::InductiveDeductive,             "SIDR"},
    {sim::Strategy::FollowProcedure,              "SFP"},
    {sim::Strategy::TrialAndError,              "STE"},
    {sim::Strategy::AskAdvise,              "SAA"},
    {sim::Strategy::FollowInstruction,              "SFI"},
    {sim::Strategy::ReportTakenAction,             "SRTA"},
    {sim::Strategy::ReportPerceivedInfo,             "SRPI"},
    {sim::Strategy::GiveAdvise,              "SGA"},
    {sim::Strategy::GiveCommand,              "SGC"},
    {sim::Strategy::AskInfo,              "SAI"},
    {sim::Decision::Goal,             "GOAL"},
    {sim::Decision::SubGoal,          "SUBGOAL"},
    {sim::Decision::Strategy,         "STRATEGY"},
    {sim::Decision::Diagnosis,        "DIAGNOSIS"},
    {sim::Action::Objective,  "ACTIONOBJECTIVE"},
    {sim::Action::Pack,       "ACTIONPACK"},
    {sim::Action::Action,           "ACTION"},
    {sim::Action::Check,          "ACTIONC"},
    {sim::Action::ActionCommand,         "ACTIONAC"},
    {sim::Action::Direct,          "ACTIONA"},
    {sim::Action::Confirm,         "CONFIRMC"},
    {sim::Action::SendInfo,          "ACTIONI"},
    {sim::Action::GiveAdvise,         "ACTIONIA"},
    {sim::State::Processing,       "PROCESSING"},
    {sim::State::ProcessingA,     "PROCESSING_A"},
    {sim::Problem::Local,           "LOCALE"},
    {sim::Problem::LocalParam,           "LOCALP"},
    {sim::Problem::Global,           "GLOBAL"},
    {sim::Merge::Replace,          "REPLACE"},
    {sim::Merge::Combine,          "COMBINE"},
    {sim::Merge::NoChange,         "NOCHANGE"},
    {sim::State::Interrupted,      "INTERRUPTED"},
    {sim::State::Waiting,          "WAITING"},
    {sim::State::OldInfo,          "OLDINFO"},
    {sim::Branch::ProcedureXfr,    "FORGOT"},
    {sim::Source::Self,             "SELF"},
    {sim::Branch::Transient,        "TRANSIENT"},
    {sim::Branch::Branch,           "BRANCH"},
    {sim::Branch::EndState,               "END_STATE"},
    {sim::State::Done,             "DONE"},
    {sim::State::Open,             "OPEN"},
    {sim::State::Close,            "CLOSE"},
    {sim::Branch::ExpectControl,   "EXPECT_CONTROL"},
    {sim::Diagnosis::Alarm,         "DIAALARM"},
    {sim::Diagnosis::Component,          "DIACOMP"},
    {sim::Diagnosis::Parameter,           "DIAPAR"},
    {sim::Diagnosis::Combined,       "DIACOMBINE"},
    {sim::Failure::ToStart,    "FAIL_TO_START"},
    {sim::Failure::ToRun,      "FAIL_TO_RUN"},
    {sim::Failure::ToOpen,     "FAIL_TO_OPEN"},
    {sim::Failure::ToClose,    "FAIL_TO_CLOSE"},
    {sim::Branch::Verify,           "VERIFY"},
    {sim::Branch::Procedure,        "PROCEDURE"},
    {sim::ControlAction::Proportional,     "PROPORTIONAL"},
    {sim::ControlAction::Additive,         "ADDITIVE"},
    {sim::Strategy::Advise,           "SLEADV"},
    {sim::ControlAction::Special,          "SPECIAL"},
    {sim::ControlAction::Trip,             "TRIP"},
    {sim::ControlAction::Stop,             "STOP"},
    {sim::ControlAction::TripValve,           "TRPVLV"},
    {sim::ControlAction::ServoValve,           "SRVVLV"},
    {sim::ControlAction::TerminateIMA,    "TERMINATE_IMA"},
    {sim::ControlAction::GreaterThenOn,  "GREATER_THEN_ON"},
    {sim::ControlAction::SmallerThenOn,  "SMALLER_THEN_ON"},
    {sim::ControlAction::GreaterThenOpen,"GREATER_THEN_OPEN"},
    {sim::ControlAction::SmallerThenOpen,"SMALLER_THEN_OPEN"},
    {sim::State::Unknown,          "UNKNOWN"},
    {sim::State::Mental,           "MENTAL"},
    {sim::State::Active,           "ACTIVE"},
    {sim::State::Pause,            "PAUSE"},
    {sim::Branch::ProcedureTransfer,"PROCEDURE_TRANSFER"},
    {sim::Branch::InfoGatherMode, "INFO_GATHER_MODE"},
    {sim::Branch::MentalBelief,    "MENTAL_BELIEF"},
    {sim::State::Recovery,         "RECOVERY"},
    {sim::ControlAction::GreaterThenOff, "GREATER_THEN_OFF"},
    {sim::ControlAction::SmallerThenOff, "SMALLER_THEN_OFF"},
    {sim::ControlAction::GreaterThenClose,"GREATER_THEN_CLOSE"},
    {sim::ControlAction::SmallerThenClose,"SMALLER_THEN_CLOSE"},
    {sim::Operator::OatScan,         "OAT_SCAN_PARAMETER"},
    {sim::Operator::OdmScan,         "ODM_SCAN_PARAMETER"},
    {sim::Operator::OctScan,         "OCT_SCAN_PARAMETER"},
    {sim::ControlAction::ParameterControl,"PARAMETER_CONTROL"},
    {sim::ControlAction::ParameterScan,   "PARAMETER_SCAN"},
    {sim::Branch::FtPlant,          "FT_PLANT"},
    // Gap values 3142-3150 are unused
    // Procedure types (3151-3165)
    {sim::Proc::NOP,              "NOP"},
    {sim::Proc::AOP,              "AOP"},
    {sim::Proc::EOP,              "EOP"},
    {sim::Proc::FRG,              "FRG"},
    {sim::Proc::ECA,              "ECA"},
    {sim::Proc::MentalProcedure, "MENTAL_PROCEDURE"},
    {sim::Proc::ObjectiveRelated,"OBJECTIVE_RELATED"},
    {sim::Proc::PrerequisiteAction,"PREREQUISITE_ACTION"},
    {sim::Proc::MonitoringStep,  "MONITORING_STEP"},
    {sim::Proc::VerificationStep,"VERIFICATION_STEP"},
    {sim::Proc::DiagnosisStep,   "DIAGNOSIS_STEP"},
  };
}
 
string ConvertToString::getString(int n) const {
  auto it = term_names_.find(n);
  if (it != term_names_.end()) {
    return it->second;
  }
  return "Warning: " + to_string(n);
}
 
string ConvertToString::removeQuotationAndSpace(string _str) {
  string str1;
  string::iterator str_itr;
  str1 = _str;
  str_itr = str1.begin();
  while (str_itr != str1.end()) {
    if (*str_itr == '"') {
      str_itr = str1.erase(str_itr);
    } else if (*str_itr == ' ') {
      *str_itr = '_';
      str_itr++;
    } else {
      str_itr++;
    }
  }
  return str1;
}
 
void ConvertToString::copyConvertToString(const ConvertToString &_cs) {
  term_names_ = _cs.term_names_;
}