DecisionAction.cpp

Go to the documentation of this file.

// DecisionAction.cpp: implementation of the DecisionAction class.
//
 
#include <math.h>
#include <boost/serialization/export.hpp>
 
#include "DecisionAction.h"
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
BOOST_CLASS_EXPORT_IMPLEMENT(DecisionAction)
using namespace std;
 
 
// Construction/Destruction
 
DecisionAction::DecisionAction()
{
    action_name = "NONE";
    this->setTypeOfMentalInfo(sim::Action::Action);
}
 
DecisionAction::~DecisionAction()
{
 
}
void DecisionAction::setActionName(string str){action_name = str;}
string DecisionAction::getActionName(){return action_name;}
void DecisionAction::copyDecisionAction(DecisionAction &_dap){
    this->copyMentalControl(_dap);
    this->copyStateOfActivation(_dap);
    action_name = _dap.getActionName();
}
void DecisionAction::readInfoFromFile(ifstream &fin){
    double perceived_control_value;
    fin >> action_name >> perceived_control_value;
    this->setPerceivedControlValue(perceived_control_value);
}
int DecisionAction::checkForMatch(string _action_name, double _action_value){
    int n_return = 0;
    int activated_state;
    double control_value;
    control_value = this->getPerceivedControlValue();
    if(_action_name.compare(action_name) == 0){
        activated_state = this->getStateOfActivation();
        if (fabs(control_value - _action_value) < 0.00001){
            this->setStateOfActivation(sim::State::Succeed);
            if(activated_state == sim::State::Succeed){
                n_return = 0;}
            else if(activated_state == sim::State::Failed){
                n_return = 2;}
            else{
                n_return = 1;
            }
        }
        else{
            this->setStateOfActivation(sim::State::Failed);
            if(activated_state == sim::State::Succeed){
                n_return = -2;}
            else if(activated_state == sim::State::Failed){
                n_return = 0;}
            else{
                n_return = -1;
            }
        }
    }
    else{
        n_return = 0;
    }
    return n_return;
}
void DecisionAction::saveDecisionActionToFile(ofstream &fout){
    fout << action_name << '\n';
    this->saveMentalControlToFile(fout);
    this->saveStateOfActivationToFile(fout);
}
void DecisionAction::retrieveDecisionActionFromFile(ifstream &fin){
    fin >> action_name;
    this->retrieveMentalControlFromFile(fin);
    this->retrieveStateOfActivationFromFile(fin);
}
bool DecisionAction::checkIfIsIdenticalDecisionAction(DecisionAction &_da){
    bool matched = true;
    if(!this->checkIfIsIdenticalMentalControl(_da) || !this->checkIfIsIdenticalStateOfActivation(_da) ||
        action_name != _da.getActionName()){
        matched = false;
    }
    return matched;
}