User Manual, Developers Guide and API Documentation

Pool.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_POOL_HPP
#define WNS_CONTAINER_POOL_HPP

#include <WNS/Assure.hpp>

#include <WNS/simulator/ISimulator.hpp>
#include <WNS/events/scheduler/Interface.hpp>

#include <set>

#include <iostream>

namespace wns { namespace container {

    template<typename ID>
    class Pool
    {
        typedef std::set<ID> PoolContainer;
    public:
        explicit
        Pool(simTimeType _unbindDelay, ID _lowestId, ID _highestId)
            {
                unbindDelay = _unbindDelay;
                highestId = _highestId;
                lowestId = _lowestId;

                maximumCapacity = 0;
                ID tmp = lowestId;
                while(tmp < highestId)
                {
                    ++tmp;
                    ++maximumCapacity;
                }
            }

        virtual
        ~Pool() {}

        void
        bind(ID id)
            {
                assure(id <= highestId, "Please choose a lower ID (<" << highestId);
                assure(id >= lowestId, "Please choose a higher ID (>" << lowestId);
                assure(isAvailable(id), "ID is already bound");
                boundIds.insert(id);

            }

        void
        unbind(ID id)
            {
                assure(id <= highestId, "Please choose a lower ID (<" << highestId);
                assure(id >= lowestId, "Please choose a higher ID (>" << lowestId);
                assure(!isAvailable(id), "ID is not bound");

                wns::simulator::getEventScheduler()->scheduleDelay(Unbind(this, id), unbindDelay);
            }

        ID
        suggestPort() const
        {
            ID id = lowestId;

            // This searches for a free port beginning at lowerBorder.
            while(
                // go on as long as no free port found
                boundIds.find(id) != boundIds.end() &&
                // go on as long as not highest port number reached
                id <= highestId)
            {
                ++id;
            }

            assure(id <= highestId, "No free ID available");
            return id;
        }

        bool
        isAvailable(ID id) const
        {
            assure(id <= highestId, "Please choose a lower ID (<" << highestId);
            assure(id >= lowestId, "Please choose a higher ID (>" << lowestId);
            return boundIds.find(id) == boundIds.end();
        }

        int
        getCapacity() const
        {
            int capacity = maximumCapacity - boundIds.size();
            assure(capacity >= 0, "Pool allocated more elements than were allowed! " << maximumCapacity << "/" << boundIds.size());
            return capacity;
        }
        simTimeType
        getUnbindDelay() const
            {
                return unbindDelay;
            }

    private:
        class Unbind
        {
        public:
            Unbind(Pool<ID>* pp,  ID unbindId)
                {
                    assure(pp, "No valid instance of Pool given!");
                    portPoolInstance = pp;
                    id = unbindId;
                }
            void
            operator()()
                {
                    portPoolInstance->boundIds.erase(id);
                }

        private:
            Pool<ID>* portPoolInstance;

            ID id;
        };

        simTimeType unbindDelay;
        PoolContainer boundIds;

        ID highestId;

        ID lowestId;

        int maximumCapacity;
    };
} // container
} // wns

#endif // NOT defined WNS_CONTAINER_POOL_HPP


/*
  Local Variables:
  mode: c++
  fill-column: 80
  c-basic-offset: 8
  c-tab-always-indent: t
  indent-tabs-mode: t
  tab-width: 8
  End:
*/

---