link_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 _LINK_LIST

#define _LINK_LIST

#include <list>

//#include "link.h"
#include "id_map.h"

class CSemanticLink;

typedef std::list<CSemanticLink *>      CLinkList;

typedef CLinkList::iterator             CLinkList_i;
typedef CLinkList::const_iterator       CLinkList_ci;
typedef CLinkList::reverse_iterator     CLinkList_ri;

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

                        CLinkList_i i;

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

                        return l_list;
                }

                bool Lookup(CSemanticLink *a_link)
                {
                        CLinkList_i i;

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

                        return false;
                }

                CLinkList_i GetIterator()
                {
                        return m_links.begin();
                }

                CLinkList_ri GetReverseIterator()
                {
                        return m_links.rbegin();
                }

                CSemanticLink *GetNext(CLinkList_ri &a_iter)
                {
                        if (a_iter == m_links.rend())
                        {
                                return NULL;
                        }

                        return (*a_iter++);
                }       

                CSemanticLink *GetNext(CLinkList_i &a_iter)
                {
                        if (a_iter == m_links.end())
                        {
                                return NULL;
                        }

                        return (*a_iter++);
                }       

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

                void StoreFront(CSemanticLink *a_link)
                {
                        m_links.push_front(a_link);
                }

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

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

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

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

                CSemanticLinkList() {}

                ~CSemanticLinkList() {}

        private:
                CLinkList m_links;
};


#endif

---