KBActionPackUnit.cpp

Go to the documentation of this file.

// KBActionPackUnit.cpp: implementation of the KBActionPackUnit class.
//
 
#include "KBActionPackUnit.h"
using namespace std;
 
// Construction/Destruction
 
KBActionPackUnit::KBActionPackUnit()
{
 
}
 
KBActionPackUnit::~KBActionPackUnit()
{
    action.clear();
    expected_alarm_state.clear();
    expected_component_state.clear();
    expected_parameter_value.clear();
    expected_parameter_trend.clear();
}
void KBActionPackUnit::readInfoFromFile(ifstream &fin){
    string str;
    int i, n;
    KBElement::readInfoFromFile(fin);
    fin >> str >> n;
    for(i = 0; i < n; i ++){
        auto action_pt = make_unique<DecisionAction>();
        action_pt->readInfoFromFile(fin);
        action.push_back(std::move(action_pt));
    }
    fin >> str >> n;
    for(i = 0; i < n; i ++){
        auto expected_alarm_state_pt = make_unique<KBExpectedAlarmStateUnit>();
        expected_alarm_state_pt->readInfoFromFile(fin);
        expected_alarm_state.push_back(std::move(expected_alarm_state_pt));
    }
    fin >> str >> n;
    for(i = 0; i < n; i ++){
        auto expected_component_state_pt = make_unique<KBExpectedComponentStateUnit>();
        expected_component_state_pt->readInfoFromFile(fin);
        expected_component_state.push_back(std::move(expected_component_state_pt));
    }
    fin >> str >> n;
    for(i = 0; i < n; i ++){
        auto expected_parameter_value_pt = make_unique<KBExpectedParameterValueUnit>();
        expected_parameter_value_pt->readInfoFromFile(fin);
        expected_parameter_value.push_back(std::move(expected_parameter_value_pt));
    }
/*  fin >> str >> n;
    for(i = 0; i < n; i ++){
        auto expected_parameter_trend_pt = make_unique<KBExpectedParameterTrendUnit>();
        expected_parameter_trend_pt->readInfoFromFile(fin);
        expected_parameter_trend.push_back(std::move(expected_parameter_trend_pt));
    }*/
}
void KBActionPackUnit::checkForAction(string _action_name, double _action_value){
    int n_return;
    for(auto& a : action){
        n_return = a->checkForMatch(_action_name, _action_value);
    }
}
void KBActionPackUnit::checkForAlarmState(string _alarm_name, int _alarm_state){
    int n_return;
    for(auto& ea : expected_alarm_state){
        n_return = ea->checkForMatch(_alarm_name, _alarm_state);
    }
}
void KBActionPackUnit::checkForComponentState(string _comp_name, int _comp_state){
    int n_return;
    for(auto& ec : expected_component_state){
        n_return = ec->checkForMatch(_comp_name, _comp_state);
    }
}
void KBActionPackUnit::checkForParameterValue(string _par_name, double _par_value, int _operator){
    int n_return;
    for(auto& ep : expected_parameter_value){
        n_return = ep->checkForMatch(_par_name, _par_value, _operator);
    }
};
void KBActionPackUnit::checkForParameterTrend(string _par_name, int _par_trend){
    int n_return;
    for(auto& et : expected_parameter_trend){
        n_return = et->checkForMatch(_par_name, _par_trend);
    }
};
void KBActionPackUnit::copyKBActionPackUnit(KBActionPackUnit &_ap){
    this->copyKBElement(_ap);
    this->copyStateOfActivation(_ap);
    for(auto& src : _ap.action){
        auto action_pt = make_unique<DecisionAction>();
        action_pt->copyDecisionAction(*src);
        action.push_back(std::move(action_pt));
    }
    for(auto& src : _ap.expected_alarm_state){
        auto expected_alarm_state_pt = make_unique<KBExpectedAlarmStateUnit>();
        expected_alarm_state_pt->copyKBExpectedAlarmStateUnit(*src);
        expected_alarm_state.push_back(std::move(expected_alarm_state_pt));
    }
    for(auto& src : _ap.expected_component_state){
        auto expected_component_state_pt = make_unique<KBExpectedComponentStateUnit>();
        expected_component_state_pt->copyKBExpectedComponentStateUnit(*src);
        expected_component_state.push_back(std::move(expected_component_state_pt));
    }
    for(auto& src : _ap.expected_parameter_value){
        auto expected_parameter_value_pt = make_unique<KBExpectedParameterValueUnit>();
        expected_parameter_value_pt->copyKBExpectedParameterValueUnit(*src);
        expected_parameter_value.push_back(std::move(expected_parameter_value_pt));
    }
    for(auto& src : _ap.expected_parameter_trend){
        auto expected_parameter_trend_pt = make_unique<KBExpectedParameterTrendUnit>();
        expected_parameter_trend_pt->copyKBExpectedParameterTrendUnit(*src);
        expected_parameter_trend.push_back(std::move(expected_parameter_trend_pt));
    }
};
bool KBActionPackUnit::updateActionPackUnitState(){
    bool activated = true;
    if(this->getStateOfActivation() == sim::State::Succeed){
        activated = false;
    }
    else if(this->getStateOfActivation() == sim::State::Active){
    }
    else{
        auto action_itr = action.begin();
        while(action_itr != action.end() && activated){
            if((*action_itr)->getStateOfActivation() != sim::State::Succeed) activated = false;
            action_itr++;
        }
        auto expected_alarm_state_itr = expected_alarm_state.begin();
        while(expected_alarm_state_itr != expected_alarm_state.end() && activated){
            if((*expected_alarm_state_itr)->getStateOfExpectation() != sim::State::Succeed) activated = false;
            expected_alarm_state_itr ++;
        }
        auto expected_component_state_itr = expected_component_state.begin();
        while(expected_component_state_itr != expected_component_state.end() && activated){
            if((*expected_component_state_itr)->getStateOfExpectation() != sim::State::Succeed) activated = false;
            expected_component_state_itr++;
        }
        auto expected_parameter_value_itr = expected_parameter_value.begin();
        while(expected_parameter_value_itr != expected_parameter_value.end() && activated){
            if((*expected_parameter_value_itr)->getStateOfExpectation() != sim::State::Succeed) activated = false;
            expected_parameter_value_itr++;
        }
        if(activated) this->setStateOfActivation(sim::State::Active);
    }
    return activated;
};