find_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 _FIND_CFG

#define _FIND_CFG

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

class CSemanticConcept;


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

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

                        return true;
                }

                void VisitNode()
                {
                        m_curNodeVisits++;
                }

                void VisitLink(CSemanticLink *a_link)
                {
                        m_currentPath->Store(a_link);
                }

                bool CheckCurrentPath(CSemanticLink *a_link)
                {
                        return m_currentPath->Lookup(a_link);
                }

                void SetCurrentPath(CSemanticLinkList *a_list)
                {
                        if (a_list)
                        {
                                delete m_currentPath;

                                m_currentPath = a_list->Clone();
                        }
                }

                void LeaveNode()
                {
                }

                void LeaveLink()
                {
                        m_currentPath->Remove();
                }

                void AddPathToResults()
                {
                        CSemanticLinkList *a_list = m_currentPath->Clone();

                        DPRINT("adding result path of size %d\n",
                                a_list->GetSize());

                        m_resultsList.push_back(a_list);
                }

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

                CSemanticLinkList *GetResult(const u_int a_index)
                {
                        u_int l_count = 0;

                        CResultsList_ci i;

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

                                l_count++;
                        }

                        return NULL;
                }

                u_int GetNumNodeVisits() const
                {
                        return m_curNodeVisits;
                }

                CSemanticLinkList *GetQueuePath()
                {
                        CResultsList_i i;

                        i = m_pathQueue.begin();

                        if (m_pathQueue.end() != i)
                        {
                                CSemanticLinkList *l_list = (*i);

                                m_pathQueue.pop_front();

                                return l_list;
                        }

                        return NULL;
                }

                void QueuePath()
                {
                        CSemanticLinkList *l_list = m_currentPath->Clone();

                        m_pathQueue.push_back(l_list);
                }

                CFindPathConfig()
                {
                        m_maxNodeVisits  = 50000;
                        m_maxNodeResults = 200;

                        m_curNodeVisits = 0;
                        m_curNodeDepth  = 0;

                        m_currentPath = new CSemanticLinkList;
                }

                ~CFindPathConfig() {}

        private:
                u_int m_maxNodeVisits;
                u_int m_maxNodeResults;

                u_int m_curNodeVisits;
                u_int m_curNodeDepth;

                CSemanticLinkList *m_currentPath;

                typedef std::list<CSemanticLinkList *>  CResultsList;

                typedef CResultsList::iterator          CResultsList_i;
                typedef CResultsList::const_iterator    CResultsList_ci;

                CResultsList m_resultsList;

                CResultsList m_pathQueue;
};

#endif

---