InstantiationBase.cpp

Go to the documentation of this file.

// InstantiationBase.cpp: implementation of the InstantiationBase class.
//
 
#include "InstantiationBase.h"
#include "../Crew/OperatorDM.h"
#include "../Crew/OperatorAT.h"
#include "ReasonMachine.h"
#include "../Global/SimulationContext.h"
using namespace std;
 
 
// Construction/Destruction
 
InstantiationBase::InstantiationBase()
{
 
}
 
InstantiationBase::~InstantiationBase()
{
    
    this->m_label_list.clear();
    this->m_instantiation_list.clear();
 
}
 
void InstantiationBase::ReadInstantiationBaseFromInputFile()
{
    ReasonMachine * RM_pt;
    if (this->m_operator == sim::Operator::ODM)
    {RM_pt = g_sim.Decision_Maker.m_RM.get();}
    else if (this->m_operator == sim::Operator::OAT)
    {RM_pt = g_sim.Action_Taker.m_RM.get();}
    else
    {}//add error message 
 
    string file_name, name;
    string err_mes;
    string str, str1, str2;
    int n_Unit, i, j, n_member;
    bool found_file;
    ifstream fin;
    ConceptComposedUnit * CC_pt;
    Label * label_pt;
    Instantiation * Inst_pt;
    IDElement * ID_pt;
    vector<IDElement*>::iterator ID_itr;
 
    if (this->m_operator == sim::Operator::ODM)
    {file_name = g_sim.SScheduler.getODMDirectory();
    file_name += "RM//";
    file_name += "KB_ODM_Instantiation_Base.txt";}
    else if (this->m_operator == sim::Operator::OAT)
    {file_name = g_sim.SScheduler.getOATDirectory();
    file_name += "RM//";
    file_name += "KB_OAT_Instantiation_Base.txt";}
    fin.open(file_name.c_str(), ios::in);
    if(!fin.is_open()){
        err_mes = "can not find file: " + file_name;
        this->ErrorMessage(err_mes);
        found_file = false;
        return; //has to return and close this program if there is an error
    }
    else{
        fin >> str >> n_Unit; 
        if(str.compare("Number_of_Instantiation_Label_Groups:") != 0)
        {
            err_mes = str + " is incorrectly in the position of Number_of_Instantiation_Label_Groups:";
            this->ErrorMessage(err_mes);
            return;
        }
        for (i = 0; i < n_Unit; i++)
        {
            auto label_owned = std::make_unique<Label>();
            label_pt = label_owned.get();
            this->m_label_list.push_back(std::move(label_owned));
            fin >> str >> name;
            if(str.compare("Group_Name:") != 0)
            {
                err_mes = str + " is incorrectly in the position of Group_Name:";
                this->ErrorMessage(err_mes);
                return;
            }
            label_pt->m_lable_name = name;
 
            fin >> str >> n_member;
            if(str.compare("Number_of_Members:") != 0)
            {
                err_mes = str + " is incorrectly in the position of Number_of_Members:";
                this->ErrorMessage(err_mes);
                return;
            }
            fin >> str;
            if(str.compare("Member_list:") != 0)
            {
                err_mes = str + " is incorrectly in the position of Member_list:";
                this->ErrorMessage(err_mes);
                return;
            }
            for(j = 0; j < n_member; j++)
            {
                fin >> name;
                ID_pt = NULL;
                ID_pt = RM_pt->m_Concept_Base->CheckExistanceOfConcept(name);
                if(ID_pt == NULL)
                {
                    err_mes = "could not find " + name + " in the concept base";
                    this->ErrorMessage(err_mes);
                    return;
                }
                label_pt->m_label_option_list.push_back(ID_pt);             
            }
        }
        fin >> str >> n_Unit; 
        if(str.compare("Number_of_Instantiation_Groups:") != 0)
        {
            err_mes = str + " is incorrectly in the position of Number_of_Instantiation_Label_Groups:";
            this->ErrorMessage(err_mes);
            return;
        }
        for(i = 0; i < n_Unit; i++)
        {
            auto inst_owned = std::make_unique<Instantiation>();
            Inst_pt = inst_owned.get();
            fin >> str >> name;
            if(str.compare("Indefinite_Concept:") != 0)
            {
                err_mes = str + " is incorrectly in the position of Indefinite_Concept:";
                this->ErrorMessage(err_mes);
                return;
            }
            if(this->CheckExistanceOfInstantiationGroupByIndefiniteConceptName(name) != NULL)
            {
                err_mes = name + " already existed in the list";
                this->ErrorMessage(err_mes);
                return;
            }
            this->m_instantiation_list.push_back(std::move(inst_owned));
            Inst_pt->m_indefinite_instance_pt = RM_pt->m_Concept_Base->checkExistanceOfConceptComposedUnit(name);
            if(Inst_pt->m_indefinite_instance_pt == NULL)
            {
                err_mes = "could not find " + name + " in the Concept Base";
                this->ErrorMessage(err_mes);
                return;
            }
            fin >> str >> name;
            if(str.compare("Corresponding_Basic_Group:") != 0)
            {
                err_mes = str + " is incorrectly in the position of Corresponding_Basic_Group:";
                this->ErrorMessage(err_mes);
                return;
            }
            Inst_pt->m_ID_lable_group_name = name;
            Inst_pt->m_label_pt = this->CheckExistanceOfLabelGroupByName(name);
            if(Inst_pt->m_label_pt  == NULL)
            {
                err_mes = "could not find " + name + " in the Label list";
                this->ErrorMessage(err_mes);
                return;
            }
            fin >> str >> n_member;
            if(str.compare("Number_of_Member:") != 0)
            {
                err_mes = str + " is incorrectly in the position of Number_of_Member:";
                this->ErrorMessage(err_mes);
                return;
            }
            fin >> str;
            if(str.compare("Member_list:") != 0)
            {
                err_mes = str + " is incorrectly in the position of Member_list:";
                this->ErrorMessage(err_mes);
                return;
            }
            for(j=0; j<n_member; j++)
            {
                fin >> name;
                CC_pt = NULL;
                CC_pt = RM_pt->m_Concept_Base->checkExistanceOfConceptComposedUnit(name);
                if(ID_pt == NULL)
                {
                    err_mes = "could not find " + name + " in the concept base";
                    this->ErrorMessage(err_mes);
                    return;
                }               
                Inst_pt->m_instance_list.push_back(CC_pt);
                CC_pt->m_Indefinite_Concept_ID_pt = Inst_pt->m_indefinite_instance_pt;
                for(ID_itr = Inst_pt->m_label_pt->m_label_option_list.begin(); ID_itr != Inst_pt->m_label_pt->m_label_option_list.end(); ID_itr ++)
                {
                    if(CC_pt->CheckWhetherThisConceptContainASubConceptByPt(*ID_itr) == true)
                    {
                        CC_pt->m_label_ID_pt = *ID_itr;
                        break;
                    }
                }
                if(CC_pt->m_label_ID_pt == NULL)
                {
                    err_mes = "could not find a label option for " + CC_pt->m_ID;
                    this->ErrorMessage(err_mes);
                    return;
                }
            }
        }
    }
 
}
 
void InstantiationBase::ErrorMessage(string str)
{
    cout << r5pars_.timesno << "  " << str << " in InstantiationBase.cpp" << '\n';
    ofstream fout("err messages.txt", ios::app);
    fout << r5pars_.timesno << "  " << str << '\n';
    fout.close();
    //r5pars_.terminateall = true;
}
 
Label * InstantiationBase::CheckExistanceOfLabelGroupByName(string name)
{
    Label * label_pt = NULL;
    for(auto &e : this->m_label_list)
    {
        if(e->m_lable_name == name)
        {
            label_pt = e.get();
        }
    }
    return label_pt;
}
 
Instantiation * InstantiationBase::CheckExistanceOfInstantiationGroupByIndefiniteConceptName(string name)
{
    Instantiation * Inst_pt = NULL;
    for(auto &e : this->m_instantiation_list)
    {
        if(e->m_indefinite_instance_pt->m_ID == name)
        {
            Inst_pt = e.get();
        }
    }
    return Inst_pt;
}
 
Label * InstantiationBase::CheckWhetherASentenceContainIndefiniteItem(SentenceUnit * _sent_pt)
{
    Label * lb_pt = NULL;
    ConceptComposedUnit * CC_pt = NULL;
    if(_sent_pt->m_subject_pt->m_ID_Type == 002)
    {
        CC_pt = (ConceptComposedUnit *)(_sent_pt->m_subject_pt);
        for(auto &e : this->m_instantiation_list)
        {
            if(e->m_indefinite_instance_pt == CC_pt)
            {
                if(lb_pt == NULL)
                {
                    lb_pt = e->m_label_pt;
                }
                else if(lb_pt != e->m_label_pt )
                {
                    this->ErrorMessage("Error: " + _sent_pt->m_ID + " contains more than one indefinite items!");
                    return NULL;
                }
            }
        }
    }
 
    if(_sent_pt->m_object_pt == NULL)
    {
        return lb_pt;
    }
    if(_sent_pt->m_object_pt->m_ID_Type == 002)
    {
        CC_pt = (ConceptComposedUnit *)(_sent_pt->m_object_pt);
        for(auto &e : this->m_instantiation_list)
        {
            if(e->m_indefinite_instance_pt == CC_pt)
            {
                if(lb_pt == NULL)
                {
                    lb_pt = e->m_label_pt;
                }
                else if(lb_pt != e->m_label_pt )
                {
                    this->ErrorMessage("Error: " + _sent_pt->m_ID + " contains more than one indefinite items!");
                    return NULL;
                }
            }
        }
    }
 
    return lb_pt;
 
}
 
Label * InstantiationBase::FindLabelGroupByLabelID(IDElement * _ID_pt)
{
    Label * found_label_group_pt = NULL;
 
    for(auto &label_e : this->m_label_list)
    {
        if(found_label_group_pt != NULL) break;
        for(auto *ID_e : label_e->m_label_option_list)
        {
            if(ID_e == _ID_pt)
            {
                found_label_group_pt = label_e.get();
                break;
            }
        }
    }
    return found_label_group_pt;
}
 
void InstantiationBase::CopyInstantiationBaseFromAnotherIB(InstantiationBase *_IB_pt)
{//this function does not establish the pointer connections
    Label * label_pt;
    Instantiation * inst_pt;
 
    this->m_operator = _IB_pt->m_operator;
 
    if(this->m_label_list.size() != 0)
    {
        this->ErrorMessage("this->m_label_list.size() != 0");
    }
    for(auto &e : _IB_pt->m_label_list)
    {
        auto label_owned = std::make_unique<Label>();
        label_owned->CopyLabelInfoFromAnotherLabel(e.get());
        this->m_label_list.push_back(std::move(label_owned));
    }
 
    if(this->m_instantiation_list.size() != 0)
    {
        this->ErrorMessage("this->m_instantiation_list.size() != 0");
    }
    for(auto &e : _IB_pt->m_instantiation_list)
    {
        auto inst_owned = std::make_unique<Instantiation>();
        inst_owned->CopyInfoFromAnotherInstantiationGroup(e.get());
        this->m_instantiation_list.push_back(std::move(inst_owned));
    }
 
}
 
void InstantiationBase::ConvertIBInfoToStringForm()
{
    for(auto &e : this->m_label_list)
    {
        e->ConvertLabelInfoToStringForm();
    }
    for(auto &e : this->m_instantiation_list)
    {
        e->ConvertInstantiationInfoToString();
    }
}
 
void InstantiationBase::BuildConnectionsForTheInstantiationBase(void * _pt)
{
    ReasonMachine * RM_pt;
    RM_pt = (ReasonMachine *)_pt;
 
    //vector<unique_ptr<Label>> m_label_list;
    for(auto &e : this->m_label_list)
    {e->BuildConnectionsForThisLabel(_pt);}
 
    //vector<unique_ptr<Instantiation>> m_instantiation_list;
    for(auto &e : this->m_instantiation_list)
    {e->BuildConnectionsForThisInstantiation(_pt);}
}