Statement.cpp

Go to the documentation of this file.

// Statement.cpp: implementation of the Statement class.
//
 
#include <string>
#include <sstream>
#include <iostream>
#include <fstream>
 
#include "Statement.h"
#include "Investigator.h"
#include "../Global/fmodule.h"
#include "ReasonMachine.h"
#include "../Crew/OperatorDM.h"
#include "../Global/SimulationContext.h"
 
using namespace std;
 
 
 
// Construction/Destruction
 
Statement::Statement() {
  //initialize the pointers, set to be NULL
  this->m_investigator_ID_pt = NULL;
  this->m_sent_pt = NULL;
  this->m_diagnose_invest_ID_pt = NULL;
 
  this->m_ID_investigator = "";
  this->m_ID_sentence = "";
  this->m_ID_DI = "";
  //
  this->m_state = true;
  this->m_ID_Type = 101;
  this->m_tbi_bl = true;
  this->m_ongoing_bl = true;
 
  this->m_ID_investigator = "";
  this->m_ID_sentence = "";
  this->m_ID_DI = "";
 
}
 
Statement::~Statement() {
 
  this->m_upperstream_statement_list.clear();
  this->m_downstream_statement_list.clear();
  this->m_ID_upperstream_statement_list.clear();
  this->m_ID_downstream_statement_list.clear();
}
 
 
 
//DEL void Statement::UpdateEndTime(double _endTime, bool _ongoing)
//DEL {
//DEL   Investigator * invest_pt;
//DEL   this->m_time_range.m_end_time = _endTime;
//DEL   this->m_ongoing_bl = _ongoing;
//DEL   if(this->m_investigator_ID_pt != NULL)
//DEL   {
//DEL       invest_pt = (Investigator*)(this->m_investigator_ID_pt);
//DEL   }
//DEL   invest_pt->UpdateEffectiveEndTimeRangeFromStatement(_endTime);
//DEL }
 
void Statement::PropagateFullActivationToSemanticSentence() {
  if (this->m_sent_pt == NULL) { return; }//error message
  this->m_sent_pt->m_change_ratio = 1 / this->m_sent_pt->m_activation;
}
 
void Statement::RefreshStatementEndTimeToCurrentTime(int _type) {
  Investigator *invest_pt;
  string prompt;
  vector<Statement *>::iterator statement_itr;
 
  ReasonMachine *RM_pt;
  if (this->m_operator == sim::Operator::ODM) { RM_pt = g_sim.Decision_Maker.m_RM.get(); }
  else if (this->m_operator == sim::Operator::OAT) { RM_pt = g_sim.Action_Taker.m_RM.get(); }
  else {}//add error message
 
  if (_type == 0) { this->m_time_range.m_time_before = r5pars_.timesno; }
  else if (_type == 1) { this->m_time_range.m_end_time = r5pars_.timesno; }
  //type 3, not change the time
 
 
  this->m_last_activated_time = r5pars_.timesno;
  RM_pt->ActivationUpdateByRefreshAStatement(this);
 
  if (this->m_investigator_ID_pt != NULL) {
    invest_pt = (Investigator *) this->m_investigator_ID_pt;
    if (invest_pt->m_explained == 1)//caution of this
    {
      invest_pt->UpdateEffectiveEndTimeRangeFromStatement(r5pars_.timesno, true);
    }
  }
 
  //print prompt
  prompt = "A Statement is updated: ";
 
  if (this->m_sent_pt == NULL) {
    prompt = "it is NULL!";
    this->ErrorMessage(prompt);
  } else {
    prompt += this->GetThisStatementWords();
  }
  this->PrintMessage(prompt);
 
  for (statement_itr = this->m_downstream_statement_list.begin();
       statement_itr != this->m_downstream_statement_list.end(); statement_itr++) {
    (*statement_itr)->RefreshStatementEndTimeToCurrentTime(_type);
  }
 
}
 
void Statement::PrintThisStatement() {
  string str;
 
  ofstream fout("RMI.txt", ios::app);
  if (this->m_sent_pt == NULL) {
    str = "This statement is NULL, check the program";
    cout << str << '\n';
    fout << str << '\n';
  } else {
    str = this->m_sent_pt->m_ID;
    str += " is ";
    if (this->m_state == true) {
      str += "TRUE; ";
    } else {
      str += "FALSE; ";
    }
    cout << str;
    fout << str;
 
    str = "";
    if (this->m_time_range.m_start_time != 0) {
      cout << "from " << this->m_time_range.m_start_time << " to " << this->m_time_range.m_end_time << '\n';
      fout << "from " << this->m_time_range.m_start_time << " to " << this->m_time_range.m_end_time << '\n';
    } else {
      cout << "time range ( " << this->m_time_range.m_time_after << ", " << this->m_time_range.m_time_before << ")"
           << '\n';
      fout << "time range ( " << this->m_time_range.m_time_after << ", " << this->m_time_range.m_time_before << ")"
           << '\n';
    }
  }
  fout.close();
}
 
void Statement::ErrorMessage(string str) {
  cout << r5pars_.timesno << "  " << str << " in Statement.cpp" << '\n';
  ofstream fout("err messages.txt", ios::app);
  fout << r5pars_.timesno << "  " << str << '\n';
  fout.close();
  //r5pars_.terminateall = true;
 
 
}
string Statement::GetThisStatementWords() {
  string str;
  stringstream conv;
  str = this->m_sent_pt->m_ID;
  str += " is ";
  if (this->m_state == true) {
    str += "true";
  } else {
    str += "false";
  }
  str += ". ";
  if (this->m_time_range.m_start_time != 0) {
    str += "started from ";
    conv.str("");
    conv << this->m_time_range.m_start_time;
    str += conv.str();
  } else {
    str += "happened after ";
    conv.str("");
    conv << this->m_time_range.m_time_after;
    str += conv.str();
  }
  str += " , ";
 
  if (this->m_time_range.m_end_time != 0) {
    str += " till ";
    conv.str("");
    conv << this->m_time_range.m_end_time;
    str += conv.str();
  } else {
    str += " before ";
    conv.str("");
    conv << this->m_time_range.m_time_before;
    str += conv.str();
  }
  return str;
}
 
void Statement::PrintMessage(string str) {
  cout << "Time: " << r5pars_.timesno << ": " << str << '\n';
 
  //test
  ofstream fout("RMI.txt", ios::app);
  fout << "Time: " << r5pars_.timesno << ": " << str << '\n';
  fout.close();
}
 
void Statement::CopyAuxInfoFromUpperstreamStatement(Statement *_upper_statement_pt) {
  this->m_confidence = _upper_statement_pt->m_confidence;
  this->m_ongoing_bl = _upper_statement_pt->m_ongoing_bl;
  this->m_time_range.m_end_time = _upper_statement_pt->m_time_range.m_end_time;
  this->m_time_range.m_start_time = _upper_statement_pt->m_time_range.m_start_time;
  this->m_time_range.m_time_after = _upper_statement_pt->m_time_range.m_time_after;
  this->m_time_range.m_time_before = _upper_statement_pt->m_time_range.m_time_before;
}
 
void Statement::CopyStatementInfoFromAnother(Statement *_state_pt) {
/*
int m_operator;
    int m_factual_type; //1, reading from control panel; 2, directly inferred; 3, reasoning result from upperstream; 4, probabilistic reasoning result from downstream
    float m_confidence;
    bool m_state;
    double m_last_activated_time;
    double m_time_generated;
    bool m_ongoing_bl;
    bool m_tbi_bl;
    
*/
  this->CopyIDElementToRestartInfo((IDElement *) _state_pt);
  this->CopyActivationToRestartInfo((Activation *) _state_pt);
 
  this->m_operator = _state_pt->m_operator;
  this->m_factual_type = _state_pt->m_factual_type;
  this->m_confidence = _state_pt->m_confidence;
  this->m_state = _state_pt->m_state;
  this->m_last_activated_time = _state_pt->m_last_activated_time;
  this->m_time_generated = _state_pt->m_time_generated;
  this->m_ongoing_bl = _state_pt->m_ongoing_bl;
  this->m_tbi_bl = _state_pt->m_tbi_bl;
  this->m_time_range.CopyTimeRangeFromAnother(_state_pt->m_time_range);
 
  /*    TimeRange m_time_range;
IDElement * m_investigator_ID_pt;
SentenceUnit * m_sent_pt;
IDElement * m_diagnose_invest_ID_pt;
vector<Statement *> m_upperstream_statement_list;
vector<Statement *> m_downstream_statement_list;
 
 
string m_ID_investigator;
string m_ID_sentence;
string m_ID_DI;
*/
  if (_state_pt->m_investigator_ID_pt != NULL) { this->m_ID_investigator = _state_pt->m_investigator_ID_pt->m_ID; }
  else { this->m_ID_investigator = _state_pt->m_ID_investigator; }
 
  if (_state_pt->m_sent_pt != NULL) { this->m_ID_sentence = _state_pt->m_sent_pt->m_ID; }
  else { this->m_ID_sentence = _state_pt->m_ID_sentence; }
 
  if (_state_pt->m_diagnose_invest_ID_pt != NULL) { this->m_ID_DI = _state_pt->m_diagnose_invest_ID_pt->m_ID; }
  else { this->m_ID_DI = _state_pt->m_ID_DI; }
 
  /*
  vector<string> m_ID_upperstream_statement_list;
  vector<string> m_ID_downstream_statement_list;
  */
 
  vector<string>::iterator str_itr;
  vector<Statement *>::iterator state_itr;
  //Statement * state_pt;
  string ID;
 
  if (this->m_ID_upperstream_statement_list.size() != 0) {
    this->ErrorMessage("this->m_ID_upperstream_statement_list.size() != 0");
    return;
  }
  if (this->m_ID_downstream_statement_list.size() != 0) {
    this->ErrorMessage("this->m_ID_downstream_statement_list.size() != 0");
    return;
  }
 
  if (_state_pt->m_upperstream_statement_list.size() != 0) {//copy from the statement list
    for (state_itr = _state_pt->m_upperstream_statement_list.begin();
         state_itr != _state_pt->m_upperstream_statement_list.end(); state_itr++) {
      ID = (*state_itr)->m_ID;
      this->m_ID_upperstream_statement_list.push_back(ID);
    }
  } else {//copy from the string list;
    for (str_itr = _state_pt->m_ID_upperstream_statement_list.begin();
         str_itr != _state_pt->m_ID_upperstream_statement_list.end(); str_itr++) {
      ID = *str_itr;
      this->m_ID_upperstream_statement_list.push_back(ID);
    }
  }
 
}
 
void Statement::BuildConnectionsToThisStatement(void *_pt) {
  ReasonMachine *RM_pt;
  RM_pt = (ReasonMachine *) _pt;
 
  //SentenceUnit * m_sent_pt;
  this->m_sent_pt = RM_pt->SearchSentenceByID(this->m_ID_sentence);
  if (this->m_sent_pt == NULL) {
    this->ErrorMessage("could not find the sentence for this statement " + this->m_ID_sentence);
    return;
  }
 
  //IDElement * m_investigator_ID_pt;
  if (this->m_ID_investigator.compare("") != 0) {
    this->m_investigator_ID_pt = (IDElement *) (RM_pt->FindInvestigatorByID(this->m_ID_investigator));
    if (this->m_investigator_ID_pt == NULL) {
      this->ErrorMessage("could not find the Investigator for this statement" + this->m_ID_investigator);
      return;
    }
  }
  //IDElement * m_diagnose_invest_ID_pt;
  if (this->m_ID_DI.compare("") != 0) {
    this->m_diagnose_invest_ID_pt =
        (IDElement *) (RM_pt->m_event_schema_base->FindDiagnoseInvestigatorByID(this->m_ID_DI));
    if (this->m_diagnose_invest_ID_pt == NULL) {
      this->ErrorMessage("could not find the Investigator " + this->m_ID_DI);
      return;
    }
  }
 
  Statement *state_pt;
  vector<string>::iterator str_itr;
 
  if (this->m_upperstream_statement_list.size() != 0) {
    this->ErrorMessage("this->m_upperstream_statement_list.size() != 0 before rebuild the connection");
    return;
  }
  if (this->m_downstream_statement_list.size() != 0) {
    this->ErrorMessage("this->m_downstream_statement_list.size() != 0 before rebuild the connection");
    return;
  }
 
  //vector<Statement *> m_upperstream_statement_list;
  for (str_itr = this->m_ID_upperstream_statement_list.begin(); str_itr != this->m_ID_upperstream_statement_list.end();
       str_itr++) {
    state_pt = RM_pt->FindStatementByID(*str_itr);
    if (state_pt == NULL) {
      this->ErrorMessage("could not find the upperstream statement " + *str_itr);
      return;
    }
    this->m_upperstream_statement_list.push_back(state_pt);
  }
  //vector<Statement *> m_downstream_statement_list;
  for (str_itr = this->m_ID_downstream_statement_list.begin(); str_itr != this->m_ID_downstream_statement_list.end();
       str_itr++) {
    state_pt = RM_pt->FindStatementByID(*str_itr);
    if (state_pt == NULL) {
      this->ErrorMessage("could not find the downstream statement " + *str_itr);
      return;
    }
    this->m_downstream_statement_list.push_back(state_pt);
  }
}
 
//DEL void Statement::ActivateRelatedInvestigatorIfNeeded()
//DEL {
//DEL   Investigator * invest_pt;
//DEL   if(this->m_)
//DEL 
//DEL }