concept_list.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 _CONCEPT_LIST

#define _CONCEPT_LIST

#include <list>

#include "id_map.h"

class CSemanticConcept;

typedef std::list<CSemanticConcept *>           CConceptList;
typedef CSemanticConceptList::iterator          CConceptList_i;
typedef CSemanticConceptList::const_iterator    CConceptList_ci;
typedef CSemanticConceptList::reverse_iterator  CConceptList_ri;

class CSemanticConceptList
{
        public:
                CSemanticConceptList *Clone()
                {
                        CSemanticConceptList *l_list = new CSemanticConceptList;

                        CConceptList_i i;

                        for (i = m_concepts.begin();i != m_concepts.end();++i)
                        {
                                l_list->Store((*i));
                        }

                        return l_list;
                }

                bool Lookup(CSemanticConcept *a_concept)
                {
                        CConceptList_i i;

                        for (i = m_concepts.begin();i != m_concepts.end();++i)
                        {
                                if ((*i) == a_link)
                                {
                                        return true;
                                }
                        }

                        return false;
                }

                CSemanticConceptList_i GetIterator()
                {
                        return m_concepts.begin();
                }

                CSemanticConceptList_ri GetReverseIterator()
                {
                        return m_concepts.rbegin();
                }

                CSemanticConcept *GetNext(CSemanticConceptList_ri &a_iter)
                {
                        if (a_iter == m_concepts.rend())
                        {
                                return NULL;
                        }

                        return (*a_iter++);
                }       

                CSemanticConcept *GetNext(CSemanticConceptList_i &a_iter)
                {
                        if (a_iter == m_concepts.end())
                        {
                                return NULL;
                        }

                        return (*a_iter++);
                }       

                void Store(CSemanticConcept *a_link)
                {
                        m_concepts.push_back(a_link);
                }

                void StoreFront(CSemanticConcept *a_link)
                {
                        m_concepts.push_front(a_link);
                }

                void Remove()
                {
                        m_concepts.pop_back();
                }

                void RemoveFront()
                {
                        m_concepts.pop_front();
                }

                void Clear()
                {
                        m_concepts.clear();
                }

                u_int GetSize() const
                {
                        return m_concepts.size();
                }

                CSemanticConceptList() {}

                ~CSemanticConceptList() {}

        private:
                CConceptList m_concepts;
};


#endif

---