InfoChunk.h

Go to the documentation of this file.

#include <iostream>
#include <typeinfo>
// InfoChunk.h: interface for the InfoChunk class.
#pragma once
#include <list>
#include <boost/serialization/export.hpp>
 
#include "DecisionGoal.h"
#include "DecisionStrategy.h"
#include "DecisionSubGoal.h"
#include "DecisionDiagnosis.h"
#include "DecisionActionObjective.h"
#include "DecisionActionPack.h"
#include "DecisionActionPack.h"
#include "DecisionProcedureStep.h"
#include "MentalAlarm.h"
#include "MentalControl.h"
#include "MentalComponentState.h"
#include "MentalParameterValue.h"
#include "MentalParameterTrend.h"
#include "../Scheduler/CommunicationPlace.h"
#include "../Procedure/ExpectedMentalBelief.h"
 
#include <vector>
#include <memory>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/shared_ptr.hpp>
#include <boost/serialization/serialization.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
 
class InfoChunk {
 public:
  int ReturnPositionOfOneMentalAlarmInTheVector(MentalAlarm *);
  int ReturnPositionOfOneMentalParameterValue(MentalParameterValue *);
  int ReturnPositionOfOneMentalComponentStateInTheVector(MentalComponentState *);
  int ReturnPositionOfOneMentalSupportSystemStateInTheVector(MentalSupportSystemState *);
  InfoChunk();
  virtual ~InfoChunk();
  void clearInfoChunk();
  void clearInfoChunkPointers();
  int getTotalPieceOfInfoPerceived();
  double getTotalWeightOfAlarmPerceived();
  int getTotalNumberOfAlarmPerceived();
  int getTotalNumberOfFailedDiagnosis();
  int getCurrentGoal();
  int getCurrentStrategy();
  int getCurrentSubGoal();
  int getStateOfAProcedureStep(std::string, std::string);
  int getMentalPriorityOfAProcedureStep(std::string, std::string);
  std::string getCurrentDiagnosis();
  void addANewGoal(int, int);
  void addANewStrategy(int, int);
  void addANewDiagnosis(std::string, int);
  void addANewSubGoal(int, int);
  void addNewProcedureStep(std::string, std::string, int);
  void addNewInstinctiveResponseProcedure(std::string, std::string, int, int, double);
  void pointToAvtiveGoalAndStrategy(InfoChunk &);
  std::string getCurrentProcedureName();
  std::string getCurrentProceduralStepName();
  std::string getCurrentInstinctiveResponseProcedureName();
  std::string getCurrentInstinctiveResponseProceduralStepName();
  int doneWithCurrentGoalAndGoForPreviouslyPausedOne();
  int doneWithCurrentStrategyAndGoForPreviouslyPausedOne();
  std::string doneWithCurrentDiagnosisAndGoForPreviouslyPausedOne();
  int doneWithCurrentSubGoalAndGoForPreviouslyPausedOne();
  bool isThereMentalProcedureWaitingForExecution(std::string, std::string);
  DecisionProcedureStep *identifyTheMentalProcedureToBePerformed(std::string, std::string);
  void pauseCurrenGoalAndAddANewOne(int);
  void pauseCurrenStrategyAndAddANewOne(int);
  void pauseCurrenSubGoalAndAddANewOne(int);
  void pauseCurrenDiagnosisAndAddANewOne(std::string);
  void pointToTheNewGoal(DecisionGoal *);
  void pointToTheNewStrategy(DecisionStrategy *);
  void pointToTheNewSubGoal(DecisionSubGoal *);
  void pointToTheNewDiagnosis(DecisionDiagnosis *);
  void pointToTheNewActionObjective(DecisionActionObjective *);
  void pointToTheNewActionPack(DecisionActionPack *);
  void pointToTheNewAction(DecisionAction *);
  void pointToTheNewProcedureStep(DecisionProcedureStep *);
  void pointToTheNewInstinctiveResponseProcedureStep(DecisionProcedureStep *);
  void updateActionState(std::string, int);
  void generateErrorMessage(std::string);
  DecisionAction *checkExistanceOfAction(std::string);
  MentalAlarm *checkExistanceOfPerceivedAlarms(std::string);
  MentalComponentState *checkExistanceOfPerceivedComponentState(std::string);
  MentalSupportSystemState *checkExistanceOfPerceivedSupportSystemState(std::string);
  MentalParameterValue *checkExistanceOfPerceivedParameterValue(std::string);
  MentalParameterTrend *checkExistanceOfPerceivedParameterTrend(std::string);
  ExpectedMentalBelief *checkExistanceOfMentalBelief(std::string);
  DecisionProcedureStep *checkExistanceOfAnInstinctiveResponseProcedure(std::string, std::string);
  DecisionProcedureStep *checkExistanceOfAProcedure(std::string, std::string);
  void interruptCurrentGoal();
  void interruptCurrentStrategy();
  void interruptCurrentSubGoal();
  void interruptCurrentDiagnosis();
  void interruptCurrentActionObjective();
  void interruptCurrentActionPack();
  void interruptCurrentAction();
  void interruptCurrentProcedureStep();
  int checkWhetherExpectedAlarmMatchObservation(KBExpectedAlarmStateUnit *);
  int checkWhetherExpectedComponentStateMatchObservation(KBExpectedComponentStateUnit *);
  int checkWhetherExpectedSupportSystemStateMatchObservation(KBExpectedSupportSystemStateUnit *);
  int checkWhetherExpectedParameterValueMatchObservation(KBExpectedParameterValueUnit *);
  int checkWhetherExpectedParameterDifferenceMatchObservation(KBExpectedParameterDifferenceUnit *);
  int checkWhetherExpectedParameterTrendMatchObservation(KBExpectedParameterTrendUnit *);
  DecisionProcedureStep *getCurrentProcedureStepPtr(int);
  DecisionProcedureStep *getCurrentInstinctiveResponseProcedurePtr();
  void copyInfoChunk(InfoChunk &);
  bool diagnosisIsIncluded(std::string);
  bool activateTheDiagnosis(std::string);
  bool includeActiveDiagnosis();
  void setStateOfAProcedureStep(std::string, std::string, int);
  void saveInfoChunkToFile(std::ofstream &);
  void retrieveInfoChunkFromFile(std::ifstream &);
  void replaceObjecByPointerForGroupedInfoAll(InfoChunk &);
  void replaceObjecByPointerForGroupedInfoGoal(InfoChunk &);
  void replaceObjecByPointerForGroupedInfoStrategy(InfoChunk &);
  void replaceObjecByPointerForGroupedInfoSubGoal(InfoChunk &);
  void replaceObjecByPointerForGroupedInfoDiagnosis(InfoChunk &);
  void replaceObjecByPointerForGroupedInfoActionObjective(InfoChunk &);
  void replaceObjecByPointerForGroupedInfoActionPack(InfoChunk &);
  void replaceObjecByPointerForGroupedInfoAction(InfoChunk &);
  void replaceObjecByPointerForGroupedInfoProcedureStep(InfoChunk &);
  void replaceObjecByPointerForGroupedInfoInstinctiveResponseProcedure(InfoChunk &);
  void replaceObjecByPointerForGroupedInfoAlarm(InfoChunk &);
  void replaceObjecByPointerForGroupedInfoComponentState(InfoChunk &);
  void replaceObjecByPointerForGroupedInfoSupportSystemState(InfoChunk &);
  void replaceObjecByPointerForGroupedInfoParameterValue(InfoChunk &);
  void replaceObjecByPointerForGroupedInfoParameterTrend(InfoChunk &);
  void replaceObjecByPointerForGroupedInfoMentalBelief(InfoChunk &);
  DecisionGoal *getActiveGoalPt();
  DecisionStrategy *getActiveStrategyPt();
  DecisionSubGoal *getActiveSubGoalPt();
    std::vector<std::shared_ptr<DecisionGoal>> goal;
    std::vector<std::shared_ptr<DecisionStrategy>> strategy;
    std::vector<std::shared_ptr<DecisionSubGoal>> subgoal;
    std::vector<std::shared_ptr<DecisionDiagnosis>> diagnosis;
    std::vector<std::shared_ptr<DecisionActionObjective>> action_objective;
    std::vector<std::shared_ptr<DecisionActionPack>> action_pack;
    std::vector<std::shared_ptr<DecisionAction>> action;
    std::vector<std::shared_ptr<DecisionProcedureStep>> procedure_step;
    std::vector<std::shared_ptr<DecisionProcedureStep>> instinctive_response_procedure;
    std::vector<std::shared_ptr<MentalAlarm>> perceived_alarms;
    std::vector<std::shared_ptr<MentalComponentState>> perceived_component_state;
    std::vector<std::shared_ptr<MentalSupportSystemState>> perceived_support_system_state;
    std::vector<std::shared_ptr<MentalParameterValue>> perceived_parameter_value;
    std::vector<std::shared_ptr<MentalParameterTrend>> perceived_parameter_trend;
    std::vector<std::shared_ptr<ExpectedMentalBelief>> mental_belief;
    // Serialization function
    template<class Archive>
    void serialize(Archive & ar, const unsigned int version) {
//     std::cout << "Serializing class: " << typeid(*this).name() << std::endl;
        ar & goal;
        ar & strategy;
        ar & subgoal;
        ar & diagnosis;
        ar & action_objective;
        ar & action_pack;
        ar & action;
        ar & procedure_step;
        ar & instinctive_response_procedure;
        ar & perceived_alarms;
        ar & perceived_component_state;
        ar & perceived_support_system_state;
        ar & perceived_parameter_value;
        ar & perceived_parameter_trend;
        ar & mental_belief;
    }
};