CommandControlUnit.cpp

Go to the documentation of this file.

// CommandControlUnit.cpp: implementation of the CommandControlUnit class.
//
 
#include "CommandControlUnit.h"
using namespace std;
// Construction/Destruction
 
CommandControlUnit::CommandControlUnit() {
  associated_branch_ID = -1;
}
 
CommandControlUnit::~CommandControlUnit() {
  //memory is controlled in program; do nothing here
}
void CommandControlUnit::copyCommandControlUnit(CommandControlUnit &_cu) {
  this->copyTimer(_cu);
  this->copyStateOfActivation(_cu);
  associated_branch_ID = _cu.getAssociatedBranchID();
  if (_cu.goal) {
    goal = make_shared<BranchGoal>();
    goal->copyBranchGoal(*(_cu.goal));
    return;
  }
  if (_cu.strategy) {
    strategy = make_shared<BranchStrategy>();
    strategy->copyBranchStrategy(*(_cu.strategy));
    return;
  }
  if (_cu.subgoal) {
    subgoal = make_shared<BranchSubGoal>();
    subgoal->copyBranchSubGoal(*(_cu.subgoal));
    return;
  }
  if (_cu.diagnosis) {
    diagnosis = make_shared<BranchDiagnosis>();
    diagnosis->copyBranchDiagnosis(*(_cu.diagnosis));
    return;
  }
  if (_cu.action_objective) {
    action_objective = make_shared<BranchActionObjective>();
    action_objective->copyBranchActionObjective(*(_cu.action_objective));
    return;
  }
  if (_cu.action_pack) {
    action_pack = make_shared<BranchActionPack>();
    action_pack->copyBranchActionPack(*(_cu.action_pack));
    return;
  }
  if (_cu.action) {
    action = make_shared<BranchAction>();
    action->copyBranchAction(*(_cu.action));
    return;
  }
  if (_cu.alarm_state) {
    alarm_state = make_shared<BranchExpectedAlarmState>();
    alarm_state->copyBranchExpectedAlarmState(*(_cu.alarm_state));
    return;
  }
  if (_cu.component_state) {
    component_state = make_shared<BranchExpectedComponentState>();
    component_state->copyBranchExpectedComponentState(*(_cu.component_state));
    return;
  }
  if (_cu.support_system_state) {
    support_system_state = make_shared<BranchExpectedSupportSystemState>();
    support_system_state->copyBranchExpectedSupportSystemState(*(_cu.support_system_state));
    return;
  }
  if (_cu.parameter_trend) {
    parameter_trend = make_shared<BranchExpectedParameterTrend>();
    parameter_trend->copyBranchExpectedParameterTrend(*(_cu.parameter_trend));
    return;
  }
  if (_cu.parameter_value) {
    parameter_value = make_shared<BranchExpectedParameterValue>();
    parameter_value->copyBranchExpectedParameterValue(*(_cu.parameter_value));
    return;
  }
  if (_cu.parameter_difference) {
    parameter_difference = make_shared<BranchExpectedParameterDifference>();
    parameter_difference->copyBranchExpectedParameterDifference(*(_cu.parameter_difference));
    return;
  }
  if (_cu.procedure_step) {
    procedure_step = make_shared<BranchProcedureStep>();
    procedure_step->copyBranchProcedureStep(*(_cu.procedure_step));
    return;
  }
  if (_cu.instinctive_response_procedure) {
    instinctive_response_procedure = make_shared<BranchProcedureStep>();
    instinctive_response_procedure->copyBranchProcedureStep(*(_cu.instinctive_response_procedure));
    return;
  }
  if (_cu.info_gather_mode) {
    info_gather_mode = make_shared<BranchInfoGatherMode>();
    info_gather_mode->copyBranchInfoGatherMode(*(_cu.info_gather_mode));
    return;
  }
  if (_cu.HW_reliability) {
    HW_reliability = make_shared<BranchSystemAction>();
    HW_reliability->copyBranchSystemAction(*(_cu.HW_reliability));
    return;
  }
  if (_cu.SS_reliability) {
    SS_reliability = make_shared<BranchSupportSystemAction>();
    SS_reliability->copyBranchSupportSystemAction(*(_cu.SS_reliability));
    return;
  }
  if (_cu.new_alarm) {
    new_alarm = make_shared<BranchSystemAlarmState>();
    new_alarm->copyBranchSystemAlarmState(*(_cu.new_alarm));
    return;
  }
  if (_cu.mental_belief) {
    mental_belief = make_shared<BranchExpectedMentalBelief>();
    mental_belief->copyBranchExpectedMentalBelief(*(_cu.mental_belief));
    return;
  }
  if (_cu.scanned_parameter) {
    scanned_parameter = make_shared<BranchScannedParameter>();
    scanned_parameter->copyBranchScannedParameter(*_cu.scanned_parameter);
    return;
  }
}
void CommandControlUnit::clearCommandControlUnit() {
  goal.reset();
  strategy.reset();
  subgoal.reset();
  diagnosis.reset();
  action_objective.reset();
  action_pack.reset();
  action.reset();
  alarm_state.reset();
  component_state.reset();
  support_system_state.reset();
  parameter_trend.reset();
  parameter_value.reset();
  parameter_difference.reset();
  procedure_step.reset();
  instinctive_response_procedure.reset();
  info_gather_mode.reset();
  HW_reliability.reset();
  SS_reliability.reset();
  new_alarm.reset();
  mental_belief.reset();
  scanned_parameter.reset();
}
void CommandControlUnit::setAssociatedBranchID(int n) { associated_branch_ID = n; }
int CommandControlUnit::getAssociatedBranchID() { return associated_branch_ID; }
void CommandControlUnit::releaseAllMembers() {
  goal.reset(); strategy.reset(); subgoal.reset(); diagnosis.reset();
  action_objective.reset(); action_pack.reset(); action.reset();
  alarm_state.reset(); component_state.reset(); support_system_state.reset();
  parameter_trend.reset(); parameter_value.reset(); parameter_difference.reset();
  procedure_step.reset(); instinctive_response_procedure.reset();
  info_gather_mode.reset(); HW_reliability.reset(); SS_reliability.reset();
  new_alarm.reset(); mental_belief.reset(); scanned_parameter.reset();
}
void CommandControlUnit::saveCommandControlUnitToFile(ofstream &fout) {
  fout << "CommandControlUnit\n";
  this->saveTimerToFile(fout);
  this->saveStateOfActivationToFile(fout);
  fout << '\n' << associated_branch_ID << ' ';
  if (goal != 0) {
    fout << "1 ";
    goal->saveBranchGoalToFile(fout);
  } else {
    fout << "0 ";
  }
  if (strategy != 0) {
    fout << "1 ";
    strategy->saveBranchStrategyToFile(fout);
  } else {
    fout << "0 ";
  }
  if (subgoal != 0) {
    fout << "1 ";
    subgoal->saveBranchSubGoalToFile(fout);
  } else {
    fout << "0 ";
  }
  if (diagnosis != 0) {
    fout << "1 ";
    diagnosis->saveBranchDiagnosisToFile(fout);
  } else {
    fout << "0 ";
  }
  if (action_objective != 0) {
    fout << "1 ";
    action_objective->saveBranchActionObjectiveToFile(fout);
  } else {
    fout << "0 ";
  }
  if (action_pack != 0) {
    fout << "1 ";
    action_pack->saveBranchActionPackToFile(fout);
  } else {
    fout << "0 ";
  }
  if (action != 0) {
    fout << "1 ";
    action->saveBranchActionToFile(fout);
  } else {
    fout << "0 ";
  }
  if (alarm_state != 0) {
    fout << "1 ";
    alarm_state->saveBranchExpectedAlarmStateToFile(fout);
  } else {
    fout << "0 ";
  }
  if (component_state != 0) {
    fout << "1 ";
    component_state->saveBranchExpectedComponentStateToFile(fout);
  } else {
    fout << "0 ";
  }
  if (support_system_state != 0) {
    fout << "1 ";
    support_system_state->saveBranchExpectedSupportSystemStateToFile(fout);
  } else {
    fout << "0 ";
  }
  if (parameter_trend != 0) {
    fout << "1 ";
    parameter_trend->saveBranchExpectedParameterTrendToFile(fout);
  } else {
    fout << "0 ";
  }
  if (parameter_value != 0) {
    fout << "1 ";
    parameter_value->saveBranchExpectedParameterValueToFile(fout);
  } else {
    fout << "0 ";
  }
  if (parameter_difference != 0) {
    fout << "1 ";
    parameter_difference->saveBranchExpectedParameterDifferenceToFile(fout);
  } else {
    fout << "0 ";
  }
  if (procedure_step != 0) {
    fout << "1 ";
    procedure_step->saveBranchProcedureStepToFile(fout);
  } else {
    fout << "0 ";
  }
  if (instinctive_response_procedure != 0) {
    fout << "1 ";
    instinctive_response_procedure->saveBranchProcedureStepToFile(fout);
  } else {
    fout << "0 ";
  }
  if (info_gather_mode != 0) {
    fout << "1 ";
    info_gather_mode->saveBranchInfoGatherModeToFile(fout);
  } else {
    fout << "0 ";
  }
  if (HW_reliability != 0) {
    fout << "1 ";
    HW_reliability->saveBranchSystemActionToFile(fout);
  } else {
    fout << "0 ";
  }
  if (SS_reliability != 0) {
    fout << "1 ";
    SS_reliability->saveBranchSupportSystemActionToFile(fout);
  } else {
    fout << "0 ";
  }
  if (new_alarm != 0) {
    fout << "1 ";
    new_alarm->saveBranchSystemAlarmStateToFile(fout);
  } else {
    fout << "0 ";
  }
  if (mental_belief != 0) {
    fout << "1 ";
    mental_belief->saveBranchExpectedMentalBeliefToFile(fout);
  } else {
    fout << "0 ";
  }
  if (scanned_parameter != 0) {
    fout << "1 ";
    scanned_parameter->saveBranchScannedParameterToFile(fout);
  } else {
    fout << "0 ";
  }
}
void CommandControlUnit::retrieveCommandControlUnitFromFile(ifstream &fin) {
  int num;
  string str;
//
  fin >> str;
  this->retrieveTimerFromFile(fin);
  this->retrieveStateOfActivationFromFile(fin);
 
  fin >> associated_branch_ID;
  fin >> num;
  if (num == 1) {
    goal = make_shared<BranchGoal>();
    goal->retrieveBranchGoalFromFile(fin);
  }
  fin >> num;
  if (num == 1) {
    strategy = make_shared<BranchStrategy>();
    strategy->retrieveBranchStrategyFromFile(fin);
  }
  fin >> num;
  if (num == 1) {
    subgoal = make_shared<BranchSubGoal>();
    subgoal->retrieveBranchSubGoalFromFile(fin);
  }
  fin >> num;
  if (num == 1) {
    diagnosis = make_shared<BranchDiagnosis>();
    diagnosis->retrieveBranchDiagnosisFromFile(fin);
  }
  fin >> num;
  if (num == 1) {
    action_objective = make_shared<BranchActionObjective>();
    action_objective->retrieveBranchActionObjectiveFromFile(fin);
  }
  fin >> num;
  if (num == 1) {
    action_pack = make_shared<BranchActionPack>();
    action_pack->retrieveBranchActionPackFromFile(fin);
  }
  fin >> num;
  if (num == 1) {
    action = make_shared<BranchAction>();
    action->retrieveBranchActionFromFile(fin);
  }
  fin >> num;
  if (num == 1) {
    alarm_state = make_shared<BranchExpectedAlarmState>();
    alarm_state->retrieveBranchExpectedAlarmStateFromFile(fin);;
  }
  fin >> num;
  if (num == 1) {
    component_state = make_shared<BranchExpectedComponentState>();
    component_state->retrieveBranchExpectedComponentStateFromFile(fin);
  }
  fin >> num;
  if (num == 1) {
    support_system_state = make_shared<BranchExpectedSupportSystemState>();
    support_system_state->retrieveBranchExpectedSupportSystemStateFromFile(fin);
  }
  fin >> num;
  if (num == 1) {
    parameter_trend = make_shared<BranchExpectedParameterTrend>();
    parameter_trend->retrieveBranchExpectedParameterTrendFromFile(fin);
  }
  fin >> num;
  if (num == 1) {
    parameter_value = make_shared<BranchExpectedParameterValue>();
    parameter_value->retrieveBranchExpectedParameterValueFromFile(fin);
  }
  fin >> num;
  if (num == 1) {
    parameter_difference = make_shared<BranchExpectedParameterDifference>();
    parameter_difference->retrieveBranchExpectedParameterDifferenceFromFile(fin);
  }
  fin >> num;
  if (num == 1) {
    procedure_step = make_shared<BranchProcedureStep>();
    procedure_step->retrieveBranchProcedureStepFromFile(fin);
  }
  fin >> num;
  if (num == 1) {
    instinctive_response_procedure = make_shared<BranchProcedureStep>();
    instinctive_response_procedure->retrieveBranchProcedureStepFromFile(fin);
  }
  fin >> num;
  if (num == 1) {
    info_gather_mode = make_shared<BranchInfoGatherMode>();
    info_gather_mode->retrieveBranchInfoGatherModeFromFile(fin);
  }
  fin >> num;
  if (num == 1) {
    HW_reliability = make_shared<BranchSystemAction>();
    HW_reliability->retrieveBranchSystemActionFromFile(fin);
  }
  fin >> num;
  if (num == 1) {
    SS_reliability = make_shared<BranchSupportSystemAction>();
    SS_reliability->retrieveBranchSupportSystemActionFromFile(fin);
  }
  fin >> num;
  if (num == 1) {
    new_alarm = make_shared<BranchSystemAlarmState>();
    new_alarm->retrieveBranchSystemAlarmStateFromFile(fin);
  }
  fin >> num;
  if (num == 1) {
    mental_belief = make_shared<BranchExpectedMentalBelief>();
    mental_belief->retrieveBranchExpectedMentalBeliefFromFile(fin);
  }
  fin >> num;
  if (num == 1) {
    scanned_parameter = make_shared<BranchScannedParameter>();
    scanned_parameter->retrieveBranchScannedParameterFromFile(fin);
  }
}