finda_cfg.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 _FINDA_CFG

#define _FINDA_CFG

#include <string>

#include "semantic_id.h"
#include "link_map.h"
#include "debug.h"


class CAnalogousWeightNode
{
        public:
                void SetConcept(CSemanticConcept *a_concept)
                {
                        m_concept = a_concept;
                }

                CSemanticConcept *GetConcept()
                {
                        return m_concept;
                }

                void AddLink(CSemanticLink *a_link)
                {
                        m_links.Store(a_link);
                }

                CSemanticLinkMap_i GetLinkIterator()
                {
                        return m_links.GetIterator();
                }

                CSemanticLink *GetLink(CSemanticLinkMap_i &a_iter)
                {
                        return m_links.GetNext(a_iter);
                }

                u_int GetWeightValue() const
                {
                        return m_weight;
                }

                void AddWeightValue(const u_int a_value)
                {
                        m_weight += a_value;
                }

                CAnalogousWeightNode()
                {
                        m_concept = NULL;

                        m_weight = 0;
                }

                ~CAnalogousWeightNode()
                {
                        // NOTE: concept and link list not deallocated because
                        // they are deallocated centrally by the main concept
                        // and link maps
                }

        private:
                CSemanticConcept *m_concept;

                CLinkMap          m_links;

                u_int             m_weight;
};


typedef std::map<SemanticID, CAnalogousWeightNode *>
                                CAnalogousWeightNodeMap;
typedef CAnalogousWeightNodeMap::iterator
                                CAnalogousWeightNodeMap_i;
typedef CAnalogousWeightNodeMap::reverse_iterator
                                CAnalogousWeightNodeMap_ri;
typedef CAnalogousWeightNodeMap::const_iterator
                                CAnalogousWeightNodeMap_ci;

typedef std::pair<CAnalogousWeightNode *, float>
                                CAnalogousWeightPair;

typedef std::list<CAnalogousWeightPair> CAnalogousWeightNodeList;
typedef CAnalogousWeightNodeList::iterator CAnalogousWeightNodeList_i;


class CFindAnalogousConfig
{
        public:
                bool AllowVisit()
                {
                        if (m_curNodeVisits >= m_maxNodeVisits)
                        {
                                return false;
                        }

                        return true;
                }

                void VisitNode()
                {
                        m_curNodeVisits++;
                }

                std::string GetNodeName() const
                {
                        return m_nodeName;
                }

                void SetNodeName(const std::string &a_name)
                {
                        m_nodeName = a_name;
                }

                void StoreWeightedLink(CSemanticLink *a_link)
                {
                        CAnalogousWeightNodeMap_i i;

                        i = m_weightedNodeMap.find(a_link->GetSourceID());

                        if (i != m_weightedNodeMap.end())
                        {
                                DPRINT("adding link to existing node.\n");

                                (*i).second->AddLink(a_link);   
                        }
                        else
                        {
                                DPRINT("adding new node.\n");

                                CAnalogousWeightNode *l_node;

                                l_node = new CAnalogousWeightNode;

                                l_node->SetConcept(a_link->GetSource());

                                l_node->AddLink(a_link);

                                m_weightedNodeMap[a_link->GetSourceID()] =
                                                                        l_node;
                        }
                }

                CAnalogousWeightNodeMap_i GetWeightedIterator()
                {
                        DPRINT("get weight iterator size %d\n",
                                m_weightedNodeMap.size());

                        return m_weightedNodeMap.begin();
                }

                CAnalogousWeightNode *GetWeightedNode(
                                            CAnalogousWeightNodeMap_i &a_iter)
                {
                        if (m_weightedNodeMap.end() != a_iter)
                        {
                                CAnalogousWeightNode *l_node = NULL;

                                l_node = (*a_iter).second;

                                ++a_iter;

                                return l_node;
                        }

                        return NULL;
                }

                bool AddNodeToResults(CAnalogousWeightNode *a_node,
                                      const float           a_score)
                {
                        CAnalogousWeightPair l_pair;

                        if (m_resultsList.size() >= m_maxNodeResults)
                        {
                                return false;
                        }

                        l_pair.first  = a_node;
                        l_pair.second = a_score;

                        m_resultsList.push_back(l_pair);

                        return true;
                }

                u_int GetNumResults() const
                {
                        return m_resultsList.size();
                }

                CAnalogousWeightNode *GetResult(const u_int  a_index,
                                                  float *a_score)
                {
                        u_int l_count = 0;

                        CAnalogousWeightNodeList_i i;

                        for (i = m_resultsList.begin();i != m_resultsList.end();
                             ++i)
                        {
                                if (a_index == l_count)
                                {
                                        if (a_score)
                                        {
                                                *a_score = (*i).second;
                                        }

                                        return (*i).first;
                                }

                                l_count++;
                        }

                        return NULL;
                }

                u_int GetNumNodeVisits() const
                {
                        return m_curNodeVisits;
                }

                CFindAnalogousConfig()
                {
                        m_maxNodeVisits  = 1000000;
                        m_maxNodeResults = 200;

                        m_curNodeVisits = 0;
                }

                virtual ~CFindAnalogousConfig() {}

        private:
                std::string m_nodeName;

                CAnalogousWeightNodeMap m_weightedNodeMap;

                u_int m_maxNodeVisits;

                u_int m_maxNodeResults;

                u_int m_curNodeVisits;

                CAnalogousWeightNodeList m_resultsList;
};


#endif

---