tb_typed_range.hpp

 
#ifndef TurtleBrains_TypedRange_hpp
#define TurtleBrains_TypedRange_hpp
 
#include <turtle_brains/core/tb_types.hpp>
 
#include <functional>
#include <type_traits>
 
namespace TurtleBrains::Core
{
 
    template<typename IndexType, typename ValueType, size_t kMaximumIndex, ValueType& (*AccessFunction)(const IndexType index)> struct TypedRange
    {
        class Iterator
        {
        public:
            explicit Iterator(const IndexType index) :
                mIndex(index)
            {
            }
 
            Iterator operator++(void) { ++mIndex; return *this; }
            Iterator operator++(int) { Iterator value = *this; ++mIndex; return value; }
            bool operator==(const Iterator& other) const { return mIndex == other.mIndex; }
            bool operator!=(const Iterator& other) const { return mIndex != other.mIndex; }
            ValueType& operator*(void) const { return AccessFunction(mIndex); }
 
        private:
            IndexType mIndex;
        };
 
        Iterator begin(void) const { return Iterator{ 0 }; }
        Iterator end(void) const { return Iterator{ kMaximumIndex }; }
    };
 
 
    template<typename IndexType, typename ValueType, IndexType (*SizeFunction)(void), ValueType& (*AccessFunction)(const IndexType index)> struct DynamicTypedRange
    {
        class Iterator
        {
        public:
            explicit Iterator(const IndexType index) :
                mIndex(index)
            {
            }
 
            Iterator operator++(void) { ++mIndex; return *this; }
            Iterator operator++(int) { Iterator value = *this; ++mIndex; return value; }
            bool operator==(const Iterator& other) const { return mIndex == other.mIndex; }
            bool operator!=(const Iterator& other) const { return mIndex != other.mIndex; }
            ValueType& operator*(void) const { return AccessFunction(mIndex); }
 
        private:
            IndexType mIndex;
        };
 
        Iterator begin(void) const { return Iterator{ 0 }; }
        Iterator end(void) const { return Iterator{ SizeFunction() }; }
    };
 
 
    template<typename IndexType, typename ValueType> struct OtherTypedRange
    {
        OtherTypedRange(std::function<IndexType()> sizeFunction, std::function<ValueType(IndexType)> accessFunction) :
            mSizeFunction(sizeFunction),
            mAccessFunction(accessFunction)
        {
        }
 
        class Iterator
        {
        public:
            explicit Iterator(const IndexType index, std::function<ValueType(IndexType)> accessFunction) :
                mIndex(index),
                mAccessFunction(accessFunction)
            {
            }
 
            Iterator operator++(void) { ++mIndex; return *this; }
            Iterator operator++(int) { Iterator value = *this; ++mIndex; return value; }
            bool operator==(const Iterator& other) const { return mIndex == other.mIndex; }
            bool operator!=(const Iterator& other) const { return mIndex != other.mIndex; }
            ValueType operator*(void) const { return mAccessFunction(mIndex); }
 
        private:
            IndexType mIndex;
            std::function<ValueType(IndexType)> mAccessFunction;
        };
 
        Iterator begin(void) const { return Iterator{ 0, mAccessFunction }; }
        Iterator end(void) const { return Iterator{ mSizeFunction(), mAccessFunction }; }
 
        std::function<IndexType()> mSizeFunction;
        std::function<ValueType(IndexType)> mAccessFunction;
    };
 
 
    namespace Internals
    {
        template<typename MapContainerType> struct ValuesOfAccessor
        {
            MapContainerType& mContainer;
 
            ValuesOfAccessor(MapContainerType& container) :
                mContainer(container)
            {
            }
 
            using BaseIterator = typename std::conditional<std::is_const<MapContainerType>::value,
                typename MapContainerType::const_iterator,
                typename MapContainerType::iterator>::type;
 
            using ValueType = typename std::conditional<std::is_const<MapContainerType>::value,
                const typename MapContainerType::mapped_type, typename MapContainerType::mapped_type>::type;
 
            class Iterator : public BaseIterator
            {
            public:
                explicit Iterator(BaseIterator iterator) :
                    BaseIterator(iterator) { }
 
                ValueType& operator*(void) const { return (*this)->second; }
            };
 
            Iterator begin(void) const { return Iterator(mContainer.begin()); }
            Iterator end(void) const { return Iterator(mContainer.end()); }
            Iterator begin(void) { return Iterator(mContainer.begin()); }
            Iterator end(void) { return Iterator(mContainer.end()); }
        };
    };
 
    template<typename MapContainerType> Internals::ValuesOfAccessor<MapContainerType> ValuesOf(MapContainerType& container)
    {
        return Internals::ValuesOfAccessor<MapContainerType>(container);
    }
 
};  //namespace TurtleBrains::Core
 
namespace tbCore = TurtleBrains::Core;
 
#endif /* TurtleBrains_TypedRange_hpp */