User Manual, Developers Guide and API Documentation

RoundRobin.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. 5, 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_ROUNDROBIN_HPP
#define WNS_ROUNDROBIN_HPP

#include <WNS/Assure.hpp>

#include <vector>
#include <algorithm>

namespace wns {

    template <typename T>
    class RoundRobin
    {
        typedef T Element;
        typedef std::vector<Element> Container;
    public:
        explicit
        RoundRobin() :
            elements(),
            first(0),
            inRound(false),
            cursor(0)
        {
        }

        void
        startRound() const
        {
            assure(!inRound, "May only be called after endRound or after constructor");
            inRound = true;
            countdown = size();
            cursor = first;
        }

        void
        endRound()
        {
            assure(inRound, "May only be called after startRound");
            inRound = false;
            first = cursor;
        }

        void
        cancelRound() const
        {
            assure(inRound, "May only be called after startRound");
            inRound = false;
            cursor = first;
        }

        bool
        isInRound() const
        {
            return(inRound);
        }

        const Element
        current() const
        {
            assure(cursor < size(), "Cursor beyond bounds");
            return elements[cursor];
        }


        const Element
        next() const
        {
            assure(inRound, "May only be called after startRound");
            assure(countdown > 0, "No more Elements");
            assure(cursor < size(), "Cursor beyond bounds");
            --countdown;
            int current = cursor;
            advanceCursor();
            return elements[current];
        }

        bool
        hasNext() const
        {
            assure(inRound, "May only be called after startRound");
            return countdown > 0;
        }

        long int
        size() const
        {
            return elements.size();
        }

        bool
        empty() const
        {
            return elements.empty();
        }

        void
        add(Element e)
        {
            assure(std::find(elements.begin(),
                     elements.end(),
                     e) == elements.end(),
                   "element to be added must be unique");

            assure(!inRound, "May only be called when not in round");
            if(first==0) {
                elements.push_back(e);
            } else {
                elements.insert(elements.begin()+first-1, e);
            }
        }

        void
        remove(Element e)
        {
            assure(!inRound, "May only be called when not in round");
            assure(std::find(elements.begin(),
                     elements.end(),
                     e) != elements.end(),
                   "element to be removed not contained");

            for(size_t ii = 0;
                ii < elements.size();
                ++ii)
            {
                if(elements[ii] == e)
                {
                    elements.erase(elements.begin()+ii);
                    if(ii < static_cast<size_t>(first))
                    {
                        --first;
                    }
                }
            }
        }

        void
        clear()
        {
            assure(!inRound, "May only be called when not in round");
            elements.clear();
        }

        Container
        getAllElements() const
        {
            return elements;
        }

    private:
        void advanceCursor() const
        {
            ++cursor %= size();
        }
        Container elements;
        long int first;
        mutable bool inRound;
        mutable long int cursor;
        mutable long int countdown;
    };
} // wns

#endif // not defined WNS_ROUNDROBIN_HPP

---