omcsnet.h

Go to the documentation of this file.

/*  This file is part of OMCSNetCPP

    OMCSNetCPP is free software; you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation; either version 2.1 of the License, or
    (at your option) any later version.

    OMCSNetCPP is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with OMCSNetCPP; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef _OMCSNET

#define _OMCSNET

#include <string>

#include "textid_map.h"
#include "id_generator.h"
#include "concept_map.h"
#include "link_map.h"
#include "link_list.h"

class CFindAnalogousConfig;
class CAnalogousWeightNode;
class CFindContextConfig;
class CFindPathConfig;


class COMCSNet
{
        public:
                bool Load(const std::string &a_path)
                {
                        FILE *l_fp;

                        l_fp = fopen(a_path.c_str(), "rb");

                        if (l_fp)
                        {
                                if (false ==
                                    m_conceptMap.Load(l_fp, m_textIDMap))
                                {
                                        return false;
                                }

                                if (false == m_linkMap.Load(l_fp, m_conceptMap))
                                {
                                        return false;
                                }

                                // TODO: set latest idfactory value

                                fclose(l_fp);

                                return true;
                        }

                        return false;
                }

                bool Save(const std::string &a_path)
                {
                        FILE *l_fp;

                        l_fp = fopen(a_path.c_str(), "wb");

                        if (l_fp)
                        {
                                if (false == m_conceptMap.Save(l_fp))
                                {
                                        return false;
                                }

                                if (false == m_linkMap.Save(l_fp))
                                {
                                        return false;
                                }

                                fclose(l_fp);

                                return true;
                        }

                        return false;
                }

                bool LoadPredicateFile(const std::string &a_path);

                std::string LookupString(const SemanticID a_id);

                bool FindAnalogous(CFindAnalogousConfig &a_config);

                bool FindContext(const std::string          &a_conceptList,
                                         CFindContextConfig &a_config);

                bool FindPathFromA_To_B(const std::string     &a_src,
                                        const std::string     &a_dst,
                                              CFindPathConfig &a_config);

                CSemanticConcept *LookupConcept(const std::string &a_name)
                {
                        SemanticID l_id;

                        l_id = m_textIDMap.Lookup(a_name);

                        if (SEMANTIC_ID_NONE != l_id)
                        {
                                return m_conceptMap.Lookup(l_id);
                        }

                        return NULL;
                }

                CSemanticConcept *LookupConcept(const SemanticID   a_id)
                {
                        return m_conceptMap.Lookup(a_id);
                }

                COMCSNet() {}

                ~COMCSNet() {}

        private:
                bool p_AnalogousProcessLinkMap(CLinkMap             *a_linkMap,
                                               CFindAnalogousConfig &a_config);

                bool p_AnalogousProcessBackwardLinkMap(CLinkMap   *a_linkMap,
                                             CFindAnalogousConfig &a_config,
                                             const RelationType    a_relation);

                void p_AnalogousProcessLink(CSemanticLink        *a_link,
                                            CFindAnalogousConfig &a_config);

                void p_AnalogousProcessBackwardLink(CSemanticLink *a_link,
                                             CFindAnalogousConfig &a_config,
                                             const RelationType    a_relation);

                void p_AnalogousProcessWeightedNode(
                                                CAnalogousWeightNode *a_node);

                bool p_FindContextProcessLinkMap(
                                             CLinkMap             *a_linkMap,
                                             CFindContextConfig &a_config,
                                             const float           a_oldScore);

                CTextIDMap m_textIDMap;

                CSemanticIDGenerator m_idFactory;

                CConceptMap          m_conceptMap;
        
                CLinkMap             m_linkMap;
};


#endif

---