BranchUnit.cpp

Go to the documentation of this file.

// BranchUnit.cpp: implementation of the BranchUnit class.
//
 
#include "BranchUnit.h"
#include <boost/serialization/export.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
BOOST_CLASS_EXPORT_IMPLEMENT(BranchUnit)
using namespace std;
 
// Construction/Destruction
 
BranchUnit::BranchUnit() {
  number_of_combination = 0;
}
 
BranchUnit::~BranchUnit() {
  //unique_ptr handles deletion automatically
}
void BranchUnit::calculateNumberOfCombination() {
  number_of_combination = 1;
  bool zero_branch = true;
  if (goal.size() > 0) {
    number_of_combination *= goal.size();
    zero_branch = false;
  }
  if (strategy.size() > 0) {
    number_of_combination *= strategy.size();
    zero_branch = false;
  }
  if (subgoal.size() > 0) {
    number_of_combination *= subgoal.size();
    zero_branch = false;
  }
  if (diagnosis.size() > 0) {
    number_of_combination *= diagnosis.size();
    zero_branch = false;
  }
  if (action_objective.size() > 0) {
    number_of_combination *= action_objective.size();
    zero_branch = false;
  }
  if (action_pack.size() > 0) {
    number_of_combination *= action_pack.size();
    zero_branch = false;
  }
  if (action.size() > 0) {
    number_of_combination *= action.size();
    zero_branch = false;
  }
  if (alarm_state.size() > 0) {
    number_of_combination *= alarm_state.size();
    zero_branch = false;
  }
  if (component_state.size() > 0) {
    number_of_combination *= component_state.size();
    zero_branch = false;
  }
  if (support_system_state.size() > 0) {
    number_of_combination *= support_system_state.size();
    zero_branch = false;
  }
  if (parameter_trend.size() > 0) {
    number_of_combination *= parameter_trend.size();
    zero_branch = false;
  }
  if (parameter_value.size() > 0) {
    number_of_combination *= parameter_value.size();
    zero_branch = false;
  }
  if (parameter_difference.size() > 0) {
    number_of_combination *= parameter_difference.size();
    zero_branch = false;
  }
  if (scanned_parameter.size() > 0) {
    number_of_combination *= scanned_parameter.size();
    zero_branch = false;
  }
  if (procedure_step.size() > 0) {
    number_of_combination *= procedure_step.size();
    zero_branch = false;
  }
  if (instinctive_response_procedure.size() > 0) {
    number_of_combination *= instinctive_response_procedure.size();
    zero_branch = false;
  }
//
  if (info_gather_mode.size() > 0) {
    number_of_combination *= info_gather_mode.size();
    zero_branch = false;
  }
  if (mental_belief.size() > 0) {
    number_of_combination *= mental_belief.size();
    zero_branch = false;
//
  }
  if (zero_branch) number_of_combination = 0;
}
int BranchUnit::getNumberOfCombination() {
  if (number_of_combination == 0) {
    this->calculateNumberOfCombination();
  }
  return number_of_combination;
}
void BranchUnit::clearBranchUnit() {
  goal.clear();
  strategy.clear();
  subgoal.clear();
  diagnosis.clear();
  action_objective.clear();
  action_pack.clear();
  action.clear();
  alarm_state.clear();
  component_state.clear();
  support_system_state.clear();
  parameter_trend.clear();
  parameter_value.clear();
  parameter_difference.clear();
  procedure_step.clear();
  instinctive_response_procedure.clear();
  info_gather_mode.clear();
  mental_belief.clear();
  scanned_parameter.clear();
}
void BranchUnit::clearBranchUnitAllPointers() {
  // Release ownership without destroying objects (used for non-owning staging vectors)
  goal.clear();
  strategy.clear();
  subgoal.clear();
  diagnosis.clear();
  action_objective.clear();
  action_pack.clear();
  action.clear();
  alarm_state.clear();
  component_state.clear();
  support_system_state.clear();
  parameter_trend.clear();
  parameter_value.clear();
  parameter_difference.clear();
  procedure_step.clear();
  instinctive_response_procedure.clear();
  info_gather_mode.clear();
  mental_belief.clear();
  scanned_parameter.clear();
}
int BranchUnit::getTotalPiecesOfInfo() {
  int n_return;
  n_return = goal.size() + strategy.size() + subgoal.size() + diagnosis.size() +
      action_objective.size() + action_pack.size() + action.size() + alarm_state.size() +
      component_state.size() + support_system_state.size() + parameter_trend.size() + parameter_value.size()
      + parameter_difference.size() + procedure_step.size() + instinctive_response_procedure.size()
      + info_gather_mode.size() + mental_belief.size() + scanned_parameter.size();
  return n_return;
}
void BranchUnit::copyBranchUnit(BranchUnit &_bu) {
  for (auto &src : _bu.goal) {
    auto p = make_shared<BranchGoal>();
    p->copyBranchGoal(*src);
    this->goal.push_back(std::move(p));
  }
  for (auto &src : _bu.strategy) {
    auto p = make_shared<BranchStrategy>();
    p->copyBranchStrategy(*src);
    this->strategy.push_back(std::move(p));
  }
  for (auto &src : _bu.subgoal) {
    auto p = make_shared<BranchSubGoal>();
    p->copyBranchSubGoal(*src);
    this->subgoal.push_back(std::move(p));
  }
  for (auto &src : _bu.diagnosis) {
    auto p = make_shared<BranchDiagnosis>();
    p->copyBranchDiagnosis(*src);
    this->diagnosis.push_back(std::move(p));
  }
  for (auto &src : _bu.action_objective) {
    auto p = make_shared<BranchActionObjective>();
    p->copyBranchActionObjective(*src);
    this->action_objective.push_back(std::move(p));
  }
  for (auto &src : _bu.action_pack) {
    auto p = make_shared<BranchActionPack>();
    p->copyBranchActionPack(*src);
    this->action_pack.push_back(std::move(p));
  }
  for (auto &src : _bu.action) {
    auto p = make_shared<BranchAction>();
    p->copyBranchAction(*src);
    this->action.push_back(std::move(p));
  }
  for (auto &src : _bu.alarm_state) {
    auto p = make_shared<BranchExpectedAlarmState>();
    p->copyBranchExpectedAlarmState(*src);
    this->alarm_state.push_back(std::move(p));
  }
  for (auto &src : _bu.component_state) {
    auto p = make_shared<BranchExpectedComponentState>();
    p->copyBranchExpectedComponentState(*src);
    this->component_state.push_back(std::move(p));
  }
  for (auto &src : _bu.support_system_state) {
    auto p = make_shared<BranchExpectedSupportSystemState>();
    p->copyBranchExpectedSupportSystemState(*src);
    this->support_system_state.push_back(std::move(p));
  }
  for (auto &src : _bu.parameter_trend) {
    auto p = make_shared<BranchExpectedParameterTrend>();
    p->copyBranchExpectedParameterTrend(*src);
    this->parameter_trend.push_back(std::move(p));
  }
  for (auto &src : _bu.parameter_value) {
    auto p = make_shared<BranchExpectedParameterValue>();
    p->copyBranchExpectedParameterValue(*src);
    this->parameter_value.push_back(std::move(p));
  }
  for (auto &src : _bu.parameter_difference) {
    auto p = make_shared<BranchExpectedParameterDifference>();
    p->copyBranchExpectedParameterDifference(*src);
    this->parameter_difference.push_back(std::move(p));
  }
  for (auto &src : _bu.procedure_step) {
    auto p = make_shared<BranchProcedureStep>();
    p->copyBranchProcedureStep(*src);
    this->procedure_step.push_back(std::move(p));
  }
  for (auto &src : _bu.instinctive_response_procedure) {
    auto p = make_shared<BranchProcedureStep>();
    p->copyBranchProcedureStep(*src);
    this->instinctive_response_procedure.push_back(std::move(p));
  }
  for (auto &src : _bu.info_gather_mode) {
    auto p = make_shared<BranchInfoGatherMode>();
    p->copyBranchInfoGatherMode(*src);
    this->info_gather_mode.push_back(std::move(p));
  }
  for (auto &src : _bu.mental_belief) {
    auto p = make_shared<BranchExpectedMentalBelief>();
    p->copyBranchExpectedMentalBelief(*src);
    this->mental_belief.push_back(std::move(p));
  }
  for (auto &src : _bu.scanned_parameter) {
    auto p = make_shared<BranchScannedParameter>();
    p->copyBranchScannedParameter(*src);
    this->scanned_parameter.push_back(std::move(p));
  }
  number_of_combination = _bu.getNumberOfCombination();
}
int BranchUnit::getNumberOfItemInBranchUnit() {
  int n;
  n = goal.size() + strategy.size() + subgoal.size() + diagnosis.size() +
      action_objective.size() + action_pack.size() + action.size() +
      alarm_state.size() + component_state.size() + support_system_state.size() + parameter_trend.size() +
      parameter_value.size() + parameter_difference.size() + procedure_step.size() +
      instinctive_response_procedure.size() + info_gather_mode.size() + mental_belief.size() +
      scanned_parameter.size();
  return n;
}
void BranchUnit::saveBranchUnitToFile(ofstream &fout) {
  fout << number_of_combination << '\n';
 
  fout << this->goal.size() << '\n';
  for (auto &p : goal) { p->saveBranchGoalToFile(fout); }
  fout << this->strategy.size() << '\n';
  for (auto &p : strategy) { p->saveBranchStrategyToFile(fout); }
  fout << this->subgoal.size() << '\n';
  for (auto &p : subgoal) { p->saveBranchSubGoalToFile(fout); }
  fout << this->diagnosis.size() << '\n';
  for (auto &p : diagnosis) { p->saveBranchDiagnosisToFile(fout); }
  fout << this->action_objective.size() << '\n';
  for (auto &p : action_objective) { p->saveBranchActionObjectiveToFile(fout); }
  fout << this->action_pack.size() << '\n';
  for (auto &p : action_pack) { p->saveBranchActionPackToFile(fout); }
  fout << this->action.size() << '\n';
  for (auto &p : action) { p->saveBranchActionToFile(fout); }
  fout << this->alarm_state.size() << '\n';
  for (auto &p : alarm_state) { p->saveBranchExpectedAlarmStateToFile(fout); }
  fout << this->component_state.size() << '\n';
  for (auto &p : component_state) { p->saveBranchExpectedComponentStateToFile(fout); }
  fout << this->support_system_state.size() << '\n';
  for (auto &p : support_system_state) { p->saveBranchExpectedSupportSystemStateToFile(fout); }
  fout << this->parameter_trend.size() << '\n';
  for (auto &p : parameter_trend) { p->saveBranchExpectedParameterTrendToFile(fout); }
  fout << this->parameter_value.size() << '\n';
  for (auto &p : parameter_value) { p->saveBranchExpectedParameterValueToFile(fout); }
  fout << this->parameter_difference.size() << '\n';
  for (auto &p : parameter_difference) { p->saveBranchExpectedParameterDifferenceToFile(fout); }
  fout << this->procedure_step.size() << '\n';
  for (auto &p : procedure_step) { p->saveBranchProcedureStepToFile(fout); }
  fout << this->instinctive_response_procedure.size() << '\n';
  for (auto &p : instinctive_response_procedure) { p->saveBranchProcedureStepToFile(fout); }
  fout << this->info_gather_mode.size() << '\n';
  for (auto &p : info_gather_mode) { p->saveBranchInfoGatherModeToFile(fout); }
  fout << this->mental_belief.size() << '\n';
  for (auto &p : mental_belief) { p->saveBranchExpectedMentalBeliefToFile(fout); }
  fout << this->scanned_parameter.size() << '\n';
  for (auto &p : scanned_parameter) { p->saveBranchScannedParameterToFile(fout); }
}
void BranchUnit::retrieveBranchUnitFromFile(ifstream &fin) {
  int i, num;
//
  fin >> number_of_combination;
  fin >> num;
  for (i = 0; i < num; i++) {
    auto p = make_shared<BranchGoal>();
    p->retrieveBranchGoalFromFile(fin);
    this->goal.push_back(std::move(p));
  }
  fin >> num;
  for (i = 0; i < num; i++) {
    auto p = make_shared<BranchStrategy>();
    p->retrieveBranchStrategyFromFile(fin);
    this->strategy.push_back(std::move(p));
  }
  fin >> num;
  for (i = 0; i < num; i++) {
    auto p = make_shared<BranchSubGoal>();
    p->retrieveBranchSubGoalFromFile(fin);
    this->subgoal.push_back(std::move(p));
  }
  fin >> num;
  for (i = 0; i < num; i++) {
    auto p = make_shared<BranchDiagnosis>();
    p->retrieveBranchDiagnosisFromFile(fin);
    this->diagnosis.push_back(std::move(p));
  }
  fin >> num;
  for (i = 0; i < num; i++) {
    auto p = make_shared<BranchActionObjective>();
    p->retrieveBranchActionObjectiveFromFile(fin);
    this->action_objective.push_back(std::move(p));
  }
  fin >> num;
  for (i = 0; i < num; i++) {
    auto p = make_shared<BranchActionPack>();
    p->retrieveBranchActionPackFromFile(fin);
    this->action_pack.push_back(std::move(p));
  }
  fin >> num;
  for (i = 0; i < num; i++) {
    auto p = make_shared<BranchAction>();
    p->retrieveBranchActionFromFile(fin);
    this->action.push_back(std::move(p));
  }
  fin >> num;
  for (i = 0; i < num; i++) {
    auto p = make_shared<BranchExpectedAlarmState>();
    p->retrieveBranchExpectedAlarmStateFromFile(fin);
    this->alarm_state.push_back(std::move(p));
  }
  fin >> num;
  for (i = 0; i < num; i++) {
    auto p = make_shared<BranchExpectedComponentState>();
    p->retrieveBranchExpectedComponentStateFromFile(fin);
    this->component_state.push_back(std::move(p));
  }
  fin >> num;
  for (i = 0; i < num; i++) {
    auto p = make_shared<BranchExpectedSupportSystemState>();
    p->retrieveBranchExpectedSupportSystemStateFromFile(fin);
    this->support_system_state.push_back(std::move(p));
  }
  fin >> num;
  for (i = 0; i < num; i++) {
    auto p = make_shared<BranchExpectedParameterTrend>();
    p->retrieveBranchExpectedParameterTrendFromFile(fin);
    this->parameter_trend.push_back(std::move(p));
  }
  fin >> num;
  for (i = 0; i < num; i++) {
    auto p = make_shared<BranchExpectedParameterValue>();
    p->retrieveBranchExpectedParameterValueFromFile(fin);
    this->parameter_value.push_back(std::move(p));
  }
  fin >> num;
  for (i = 0; i < num; i++) {
    auto p = make_shared<BranchExpectedParameterDifference>();
    p->retrieveBranchExpectedParameterDifferenceFromFile(fin);
    this->parameter_difference.push_back(std::move(p));
  }
  fin >> num;
  for (i = 0; i < num; i++) {
    auto p = make_shared<BranchProcedureStep>();
    p->retrieveBranchProcedureStepFromFile(fin);
    this->procedure_step.push_back(std::move(p));
  }
  fin >> num;
  for (i = 0; i < num; i++) {
    auto p = make_shared<BranchProcedureStep>();
    p->retrieveBranchProcedureStepFromFile(fin);
    this->instinctive_response_procedure.push_back(std::move(p));
  }
  fin >> num;
  for (i = 0; i < num; i++) {
    auto p = make_shared<BranchInfoGatherMode>();
    p->retrieveBranchInfoGatherModeFromFile(fin);
    this->info_gather_mode.push_back(std::move(p));
  }
  fin >> num;
  for (i = 0; i < num; i++) {
    auto p = make_shared<BranchExpectedMentalBelief>();
    p->retrieveBranchExpectedMentalBeliefFromFile(fin);
    this->mental_belief.push_back(std::move(p));
  }
  fin >> num;
  for (i = 0; i < num; i++) {
    auto p = make_shared<BranchScannedParameter>();
    p->retrieveBranchScannedParameterFromFile(fin);
    this->scanned_parameter.push_back(std::move(p));
  }
}