findc_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 _FINDC_CFG

#define _FINDC_CFG

#include "concept_map.h"
#include "link_list.h"
#include "debug.h"

class CSemanticConcept;

typedef std::pair<CSemanticConcept *, float>
                                CSemanticConceptPair;

typedef std::list<CSemanticConceptPair>      CResultsList;
typedef CResultsList::iterator               CResultsList_i;
typedef CResultsList::const_iterator         CResultsList_ci;

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

                        return true;
                }

                void VisitNode()
                {
                        m_curNodeVisits++;
                }

                float GetDiscountFactor() const
                {
                        return 0.5;
                }

                bool AddNodeToResults(CSemanticConcept *a_concept,
                                      const float       a_score)
                {
                        CSemanticConceptPair l_pair;

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

                        l_pair.first  = a_concept;
                        l_pair.second = a_score;

                        m_resultsList.push_back(l_pair);

                        return true;
                }

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

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

                        CResultsList_ci 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;
                }

                CResultsList_i GetScoreIterator()
                {
                        DPRINT("get score iterator size %d\n",
                                m_scoreQueue.size());

                        return m_scoreQueue.begin();
                }

                CSemanticConcept *GetScoreQueue(CResultsList_i &a_iter,
                                                float          *a_score)
                {
                        if (m_scoreQueue.end() != a_iter)
                        {
                                CSemanticConcept *l_concept;

                                l_concept = (*a_iter).first;

                                if (a_score)
                                {
                                        *a_score = (*a_iter).second;
                                }

                                a_iter++;

                                return l_concept;
                        }

                        return NULL;
                }

                CSemanticConcept *GetScoreQueue(float *a_score)
                {
                        CResultsList_i i;

                        i = m_scoreQueue.begin();

                        if (m_scoreQueue.end() != i)
                        {
                                CSemanticConcept *l_concept;

                                l_concept = (*i).first;

                                if (a_score)
                                {
                                        *a_score = (*i).second;
                                }

                                m_scoreQueue.pop_front();

                                return l_concept;
                        }

                        return NULL;
                }

                void QueueScore(      CSemanticConcept *a_concept,
                                const float             a_score)
                {
                        CSemanticConceptPair l_pair;

                        l_pair.first  = a_concept;
                        l_pair.second = a_score;

                        m_scoreQueue.push_back(l_pair);
                }

                CFindContextConfig()
                {
                        m_maxNodeVisits  = 1000;
                        m_maxNodeResults = 200;

                        m_curNodeVisits = 0;
                }

                virtual ~CFindContextConfig() {}

        private:
                u_int m_maxNodeVisits;
                u_int m_maxNodeResults;

                u_int m_curNodeVisits;

                CResultsList m_resultsList;

                CResultsList m_scoreQueue;
};

#endif

---