ConceptComposedUnit.cpp

Go to the documentation of this file.

// ConceptComposedUnit.cpp: implementation of the ConceptComposedUnit class.
//
 
#include "ConceptComposedUnit.h"
using namespace std;
 
// Construction/Destruction
 
ConceptComposedUnit::ConceptComposedUnit()
{
    this->m_ID_Type = 002;
    this->m_Indefinite_Concept_ID_pt = NULL;
    this->m_label_ID_pt = NULL;
    this->m_CoreID_pt = NULL;
    //002--ConceptComposedUnit
}
 
ConceptComposedUnit::~ConceptComposedUnit()
{
/*  delete this->m_CoreID_pt;
    delete this->m_label_ID_pt;
    delete this->m_Indefinite_Concept_ID_pt;
*/
    this->m_Spec_array.clear();
    this->m_antonym_list.clear();
    this->m_ID_antonym_list.clear();
    this->m_ID_spec_list.clear();
}
 
void ConceptComposedUnit::ReadConceptComposedUnitInfoFromFile(string _ID, ifstream &fin)
{
    
 
}
 
bool ConceptComposedUnit::CheckWetherContainThisBasicConcept(ConceptBasicUnit *_B_pt)
{
    bool Contain = false;
//  ConceptBasicUnit * B_pt;
    ConceptComposedUnit * C_pt;
    vector<IDElement *>::iterator ID_itr;
 
    if(m_CoreID_pt == (IDElement*)_B_pt)
    {
        Contain = true;
        return Contain;
    }
    for(ID_itr = this->m_Spec_array.begin(); ID_itr!= this->m_Spec_array.end() && Contain == false; ID_itr++)
    {
        if((*ID_itr)->m_ID_Type == 001)
        {
            if((*ID_itr) == (IDElement *)_B_pt)
            {Contain = true;}
        }
        else if((*ID_itr)->m_ID_Type == 002)
        {
            C_pt = (ConceptComposedUnit *)(*ID_itr);
            Contain = C_pt->CheckWetherContainThisBasicConcept(_B_pt);
        }
    }
    return Contain;
}
 
bool ConceptComposedUnit::CheckWhetherContainThisConceptDirectly(IDElement * _ID_pt)
{
    bool Contain = false;
    vector<IDElement *>::iterator ID_itr;
    if (this->m_CoreID_pt == _ID_pt)
    {
        Contain = true;
        return Contain;
    }
    for(ID_itr = this->m_Spec_array.begin(); ID_itr != this->m_Spec_array.end() && Contain == false; ID_itr++)
    {
        if((*ID_itr) == _ID_pt)
        {
            Contain = true;
        }
    }
    return Contain;
}
 
bool ConceptComposedUnit::CheckWhetherThisConceptContainASubConceptByPt(IDElement * sub_ID_pt)
{
    vector<IDElement*>::iterator ID_itr;
    ConceptComposedUnit * CC_pt;
    bool include_bl = false;
    
    switch (this->m_CoreID_pt->m_ID_Type )
    {
    case 001:
        if(this->m_CoreID_pt == sub_ID_pt)
        {
            include_bl = true;
            return include_bl;
        }
        break;
    case 002:
        CC_pt = (ConceptComposedUnit*)(this->m_CoreID_pt);
        if(CC_pt->CheckWhetherThisConceptContainASubConceptByPt(sub_ID_pt) == true)
        {
            include_bl = true;
            return include_bl;
        }
        break;
    default:
        break;
    }
    for(ID_itr = this->m_Spec_array.begin(); ID_itr != this->m_Spec_array.end(); ID_itr++)
    {
        switch ((*ID_itr)->m_ID_Type)
        {
        case 001:
            if((*ID_itr) == sub_ID_pt)
            {
                include_bl = true;
                return include_bl;
            }
            break;
        case 002:
            CC_pt = (ConceptComposedUnit*)(*ID_itr);
            if(CC_pt->CheckWhetherThisConceptContainASubConceptByPt(sub_ID_pt) == true)
            {
                include_bl = true;
                return include_bl;
            }
            break;
        }
    }
    return include_bl;
}
 
//DEL void ConceptComposedUnit::Empty()
//DEL {
//DEL 
//DEL }
 
void ConceptComposedUnit::CopyInfoFromAnotherConceptComposedUnit(ConceptComposedUnit *_CC_pt)
{//this function only copies the basic information. The linkage among concept units is not established here
    vector<IDElement *>::iterator ID_itr;
    vector<string >::iterator str_itr;
    string ID;  
    this->m_activation = _CC_pt->m_activation;
    this->m_activation_baseline = _CC_pt->m_activation_baseline;
    this->m_change_ratio = _CC_pt->m_change_ratio;
    this->m_ID = _CC_pt->m_ID;
    this->m_ID_Type = _CC_pt->m_ID_Type;
    // linkage: core concept, specification concept, antonym ID, indefinite_ID, label_ID
    this->m_ID_core = _CC_pt->m_ID_core; // core concept
    
    if(_CC_pt->m_antonym_list.size() > 0)
    {
        for(ID_itr = _CC_pt->m_antonym_list.begin(); ID_itr != _CC_pt->m_antonym_list.end(); ID_itr++)
        {
            ID = (*ID_itr)->m_ID;
            this->m_ID_antonym_list.push_back(ID);
        }
    }
    else
    {
        for(str_itr = _CC_pt->m_ID_antonym_list.begin(); str_itr != _CC_pt->m_ID_antonym_list.end(); str_itr++)
        {//antonym list
            ID = *str_itr;
            this->m_ID_antonym_list.push_back(ID);      
        }
    }
    for(str_itr = _CC_pt->m_ID_spec_list.begin(); str_itr != _CC_pt->m_ID_spec_list.end(); str_itr++)
    {//specification concept
        ID = *str_itr;
        this->m_ID_spec_list.push_back(ID);
    }
    
    //indefinite concept
    this->m_ID_indefinite = _CC_pt->m_ID_indefinite;
    
    //label
    this->m_ID_lable = _CC_pt->m_ID_lable;  
}
 
void ConceptComposedUnit::ConvertPointerConnectionToStringForm()
{
    vector<IDElement *>::iterator ID_itr;
    string ID;
    //Core ID
    this->m_ID_core = this->m_CoreID_pt->m_ID;
    //
    if(this->m_Indefinite_Concept_ID_pt != NULL)
    {
        this->m_ID_indefinite = this->m_Indefinite_Concept_ID_pt->m_ID;
    }
    else
    {
        this->m_ID_indefinite = "";
    }
    //
    if(this->m_label_ID_pt != NULL)
    {
        this->m_ID_lable = this->m_label_ID_pt->m_ID;
    }
    else
    {
        this->m_ID_lable = "";
    }
    //defining concept
    if(this->m_ID_spec_list.size() == 0)
    {
        for(ID_itr = this->m_Spec_array.begin(); ID_itr != this->m_Spec_array.end(); ID_itr++)
        {
            ID = (*ID_itr)->m_ID;
            this->m_ID_spec_list.push_back(ID);
        }
    }
    //antonym concept
    if(this->m_ID_antonym_list.size() == 0)
    {
        for(ID_itr = this->m_antonym_list.begin(); ID_itr != this->m_antonym_list.end(); ID_itr++)
        {
            ID = (*ID_itr)->m_ID;
            this->m_ID_antonym_list.push_back(ID);
        }
    }
}