User Manual, Developers Guide and API Documentation

Registry.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_REGISTRY_HPP
#define WNS_CONTAINER_REGISTRY_HPP

#include <WNS/Assure.hpp>
#include <WNS/TypeInfo.hpp>
#include <WNS/Exception.hpp>

#include <map>
#include <list>

namespace wns { namespace container {

    namespace registry {
        class NoneOnErase
        {
        public:

            template <typename ANY>
            void
            operator()(ANY&) const
            {
            }
        };

        class DeleteOnErase
        {
        public:

            template <typename ANY>
            void
            operator()(ANY any) const
            {
                delete any;
            }
        };
    }

    template<
        typename KEY,
        typename ELEMENT,
        typename CLEANUPPOLICY = registry::NoneOnErase,
        typename SORTINGPOLICY = std::less<KEY> >
    class Registry:
        public IOutputStreamable
    {

        typedef std::map<KEY, ELEMENT, SORTINGPOLICY> ElementContainer;
        typedef typename ElementContainer::iterator iterator;

    public:
        typedef KEY KeyType;
        typedef ELEMENT ElementType;
        typedef std::list<KEY> KeyList;

        class DuplicateKeyValue :
            public Exception
        {
        public:
            explicit
            DuplicateKeyValue(const KeyType& key) :
                Exception("Duplicate key in registry detected.\n")
            {
                (*this) << TypeInfo::create<ElementType>()
                        << " with this key already registered.\n"
                        << "Key: " << key;
            }

            virtual
            ~DuplicateKeyValue() throw()
            {
            }
        };

        class UnknownKeyValue :
            public Exception
        {
        public:
            UnknownKeyValue(const KeyType& key, const Registry& reg) :
                Exception()
            {
                (*this) << "No " << TypeInfo::create<ElementType>()
                        << " with this key registered.\n"
                        << "Key: " << key << "\n"
                        << reg;
            }

            virtual
            ~UnknownKeyValue() throw()
            {
            }
        };

        typedef typename ElementContainer::const_iterator const_iterator;

        Registry() :
            elements_()
        {
        }

        virtual
        ~Registry()
            throw()
        {
            this->clear();
        }

        virtual void
        clear()
        {
            CLEANUPPOLICY cleanup;
            while (this->elements_.empty() == false)
            {
                cleanup(this->elements_.begin()->second);
                this->elements_.erase(this->elements_.begin());
            }
        }

        virtual void
        insert(const KeyType& key, ElementType element)
            throw(DuplicateKeyValue)
        {
            // Store size of map before potentially adding
            size_t sizeBeforeInserting = this->size();
            // This should add an element, if not the key was
            // already used
            ElementType& slotInContainer = this->elements_[key];
            // Store size of map after potentially adding
            size_t sizeAfterInserting = this->size();

            if (sizeAfterInserting - sizeBeforeInserting == 0)
            {
                // The key was already in use
                throw DuplicateKeyValue(key);
            }
            slotInContainer = element;
        }


        virtual void
        update(const KeyType& key, ElementType element)
            throw(UnknownKeyValue)
        {
            iterator itr = this->elements_.find(key);
            if (itr == this->elements_.end())
            {
                throw UnknownKeyValue(key, *this);
            }
            CLEANUPPOLICY cleanup;
            cleanup(itr->second);
            itr->second = element;

        }

        virtual void
        erase(const KeyType& key)
            throw(UnknownKeyValue)
        {
            iterator itr = this->elements_.find(key);
            if (itr == this->elements_.end())
            {
                throw UnknownKeyValue(key,*this);
            }

            CLEANUPPOLICY cleanup;
            cleanup(itr->second);
            this->elements_.erase(itr);
        }

        virtual const ElementType&
        find(const KeyType& key) const
            throw(UnknownKeyValue)
        {
            const_iterator itr = this->elements_.find(key);
            if (itr == this->elements_.end())
            {
                throw UnknownKeyValue(key, *this);
            }
            return itr->second;
        }

        virtual ElementType&
        find(const KeyType& key)
            throw(UnknownKeyValue)
        {
            iterator itr = this->elements_.find(key);
            if (itr == this->elements_.end())
            {
                throw UnknownKeyValue(key, *this);
            }
            return itr->second;
        }

        virtual const_iterator
        begin() const
            throw()
        {
            return this->elements_.begin();
        }

        virtual const_iterator
        end() const
            throw()
        {
            return this->elements_.end();
        }

        virtual bool
        knows(const KeyType& key) const
            throw()
        {
            return this->elements_.find(key) != elements_.end();
        }

        virtual bool
        empty() const
            throw()
        {
            return this->elements_.empty();
        }

        virtual size_t
        size() const
            throw()
        {
            return this->elements_.size();
        }

        virtual KeyList
        keys() const
            throw()
        {
            KeyList retVal;
            for (const_iterator iter = begin(); iter != end(); ++iter)
            {
                retVal.push_back(iter->first);
            }
            return retVal;
        }

    private:
        std::string
        doToString() const
        {
            std::stringstream repr;

            repr << "Elements with the following keys are registered:\n";

            for (typename Registry::const_iterator itr = elements_.begin();
                 itr != elements_.end();
                 ++itr)
                {
                    repr << " - " << itr->first << "\n";
                }

            return repr.str();
        }

        ElementContainer elements_;
    }; // Registry
} // container
} // wns

#endif // NOT defined WNS_REGISTRY_HPP

---