User Manual, Developers Guide and API Documentation

MultiAccessible.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_CONTAINER_MULTIACCESSIBLE_HPP
#define WNS_CONTAINER_MULTIACCESSIBLE_HPP

#include <WNS/Assure.hpp>

#include <cstddef>
#include <cassert>
#include <algorithm>

namespace wns { namespace container {
    namespace MultiAccessibleDefs
    {
        typedef std::size_t SizeType;
    }

    template<typename T,
         MultiAccessibleDefs::SizeType N,
         typename R = const T&,
         typename I = MultiAccessibleDefs::SizeType
         >
    class MultiReadAccessible
    {
    public:
        typedef T ValueType;

        typedef MultiAccessibleDefs::SizeType SizeType;

        typedef I IndexType;

        typedef R ReturnType;

        typedef const MultiReadAccessible<ValueType, N-1, ReturnType, IndexType>& ConstReference;

        virtual ~MultiReadAccessible() {};

        virtual ConstReference operator[](const IndexType& index) const = 0;

        template<class InputIterator>
        ValueType at(const InputIterator& first, const InputIterator& last) const
        {
            InputIterator temp = first;
            return (*this)[*first].at(++temp, last);
        }

        virtual SizeType dimSize(const SizeType& dim) const = 0;

        virtual SizeType size() const
        {
            SizeType s = 1;
            for (SizeType i = 0; i < N; ++i) s *= dimSize(i);
            return s;
        }
    };

    template<typename T,
         typename ReturnType,
         typename I
         >
    class MultiReadAccessible<T, 1, ReturnType, I>
    {
    public:
        typedef T ValueType;
        typedef MultiAccessibleDefs::SizeType SizeType;
        typedef I IndexType;

        virtual ~MultiReadAccessible() {};

        virtual ReturnType operator[](const IndexType& index) const = 0;

        template<class InputIterator>
#ifndef WNS_NDEBUG
        ValueType at(const InputIterator& first, const InputIterator& last) const
#else
        ValueType at(const InputIterator& first, const InputIterator& /*last*/) const
#endif
        {
            assure(std::distance(first, last) == 1, "range error");
            return (*this)[*first];
        }

        virtual SizeType dimSize(const SizeType& dim) const = 0;

        virtual SizeType size() const
        {
            return dimSize(0);
        }
    };

    template<typename T,
         MultiAccessibleDefs::SizeType N,
         typename I = MultiAccessibleDefs::SizeType>
    class MultiWriteAccessible
    {
    public:
        typedef T ValueType;

        typedef MultiAccessibleDefs::SizeType SizeType;

        typedef I IndexType;

        typedef MultiWriteAccessible<ValueType, N-1, IndexType>& Reference;

        virtual ~MultiWriteAccessible() {};

        virtual Reference operator[](const IndexType& index) = 0;

        template<class InputIterator>
        ValueType& at(const InputIterator& first, const InputIterator& last)
        {
            InputIterator temp = first;
            return (*this)[*first].at(++temp, last);
        }

        virtual SizeType dimSize(const SizeType& dim) const = 0;

        virtual SizeType size() const
        {
            SizeType s = 1;
            for (SizeType i = 0; i < N; ++i) s *= dimSize(i);
            return s;
        }
    };

    template<typename T,
         typename I>
    class MultiWriteAccessible<T, 1, I>
    {
    public:
        typedef T ValueType;
        typedef MultiAccessibleDefs::SizeType SizeType;
        typedef I IndexType;

        typedef ValueType& Reference;

        virtual ~MultiWriteAccessible() {};

        virtual Reference operator[](const IndexType& index) = 0;

        template<class InputIterator>
        Reference at(const InputIterator& first, const InputIterator& last)
        {
            assert(std::distance(first, last) == 1);
            return (*this)[*first];
        }

        virtual SizeType dimSize(const SizeType& dim) const = 0;

        virtual SizeType size() const
        {
            return dimSize(0);
        }
    };

    template<typename T,
         MultiAccessibleDefs::SizeType N,
         typename R = const T&,
         typename I = MultiAccessibleDefs::SizeType>
    class MultiReadWriteAccessible : public MultiReadAccessible<T, N, R, I>,
                     public MultiWriteAccessible<T, N, I>
    {
    public:
        typedef T ValueType;

        typedef MultiAccessibleDefs::SizeType SizeType;

        typedef I IndexType;

        typedef R ReturnType;

        virtual ~MultiReadWriteAccessible() {};

        virtual SizeType dimSize(const SizeType& dim) const = 0;

        virtual SizeType size() const
        {
            SizeType s = 1;
            for (SizeType i = 0; i < N; ++i) s *= dimSize(i);
            return s;
        }
    };
}}

#endif // _MULTIACCESSIBLE_HPP

---