User Manual, Developers Guide and API Documentation

FastList.hpp

Go to the documentation of this file.

/*******************************************************************************
 * This file is part of openWNS (open Wireless Network Simulator)
 * _____________________________________________________________________________
 *
 * Copyright (C) 2004-2007
 * Chair of Communication Networks (ComNets)
 * Kopernikusstr. 16, D-52074 Aachen, Germany
 * phone: ++49-241-80-27910,
 * fax: ++49-241-80-22242
 * email: info@openwns.org
 * www: http://www.openwns.org
 * _____________________________________________________________________________
 *
 * openWNS is free software; you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License version 2 as published by the
 * Free Software Foundation;
 *
 * openWNS 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 this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 ******************************************************************************/

#ifndef WNS_CONTAINER_FASTLIST_HPP
#define WNS_CONTAINER_FASTLIST_HPP

#include <WNS/Assure.hpp>
#include <WNS/container/FastListNode.hpp>
#include <WNS/NonCopyable.hpp>
#include <memory>

namespace wns { namespace container {

    template <typename T>
    class FastList
    {
    public:
        class iterator {
            friend class FastList;
        public:
            iterator()
                : fln(0)
            {}

            explicit iterator(FastListNode<T>* f)
                : fln(f)
            {}

            bool operator==(const iterator& i) const
            {
                return fln==i.fln;
            }

            bool operator!=(const iterator& i) const
            {
                return fln!=i.fln;
            }

            T& operator*()
            {
                return fln->getData();
            }

            T& operator->()
            {
                return fln->getData();
            }

            iterator& operator++()
            {
                assure(fln, "Nothing to iterate on");
                fln = fln->getNext();
                return *this;
            };

            iterator operator++(int)
            {
                assure(fln, "Nothing to iterate on");
                iterator i = *this;
                fln = fln->getNext();
                return i;
            }

            iterator& operator--() {
                assure(fln, "Nothing to iterate on");
                fln = fln->getPrevious();
                return *this;
            }

            iterator operator--(int) {
                assure(fln, "Nothing to iterate on");
                iterator i = *this;
                fln = fln->getPrevious();
                return i;
            }

        private:
            FastListNode<T>* fln;
        };

        FastList()
            : b(FastListNode<T>()),
              s(0)
        {}

        ~FastList()
        {
            clear();
        }

        FastList(const FastList& f)
            : b(FastListNode<T>()),
              s(0)
        {
            copy(f);
        }

        void operator=(const FastList& f)
        {
            clear();
            copy(f);
        }

        iterator begin() const
        {
            return iterator(b.getNext());
        }

        iterator end() const
        {
            return iterator(&b);
        }

        T& front() const
        {
            return b.getNext()->getData();
        }

        bool empty() const
        {
            return s==0;
        }

        int size() const
        {
            return s;
        }

        void clear()
        {
            iterator itr, itrEnd;
            itr = begin();
            itrEnd = end();
            while(itr!=itrEnd) {
                erase(itr);
                itr = begin();
                itrEnd = end();
            };
        }

        void erase(const iterator& i)
        {
            assure(i!=end(), "Can't erase this->end()");
            assure(s>0, "No elements in list");
            --s;
            FastListNode<T>* fln = i.fln;
            fln->removeFromList();
            fln->getData()->removeFastListNode(this);
            delete fln;
        }

        void remove(const T& x)
        {
            assure(s>0, "No elements in list");
            --s;
            FastListNode<T>* fln = x->getFastListNode(this);
            fln->removeFromList();
            x->removeFastListNode(this);
            delete fln;
        }

        void remove(T* x)
        {
            assure(s>0, "No elements in list");
            --s;
            FastListNode<T>* fln = x->getFastListNode(this);
            fln->removeFromList();
            x->removeFastListNode(this);
            delete fln;
        }

        void push_front(const T& x)
        {
            std::auto_ptr< FastListNode<T> > fln(new FastListNode<T>(x));
            x->setFastListNode(this, fln.get());
            fln->addToList(b);
            ++s;
            // everything ok, release the poiner, now handled by FastList
            fln.release();
        }

        void push_front(T* x)
        {
            push_front(&x);
        };

        void push_back(const T& x)
        {
            std::auto_ptr< FastListNode<T> > fln(new FastListNode<T>(x));
            x->setFastListNode(this, fln.get());
            fln->addToList(*b.getPrevious());
            ++s;
            // everything ok, release the poiner, now handled by FastList
            fln.release();
        }

        void push_back(T* x)
        {
            push_back(&x);
        };

        void pop_front()
        {
            remove(front());
        }

        bool contains(const T& x)
        {
            return x->isInList(this);
        }

    private:
        void copy(const FastList& f)
        {
            iterator itr;
            for(itr=f.begin(); itr!=f.end(); ++itr)
            {
                push_front(*itr);
            }
        }

        mutable FastListNode<T> b;

        int s;
    };
}}
#endif

---