ContiguousRange.hpp

Go to the documentation of this file.

#ifndef ESTD_CONTIGUOUSRANGE_HPP_
#define ESTD_CONTIGUOUSRANGE_HPP_

#include <array>

namespace estd
{

template<typename T>
class ContiguousRange
{
public:

    using value_type = T;

    using pointer = value_type*;

    using const_pointer = const value_type*;

    using reference = value_type&;

    using const_reference = const value_type&;

    using iterator = value_type*;

    using const_iterator = const value_type*;

    using size_type = std::size_t;

    using difference_type = std::ptrdiff_t;

    using reverse_iterator = std::reverse_iterator<iterator>;

    using const_reverse_iterator = std::reverse_iterator<const_iterator>;

    constexpr ContiguousRange(const iterator beginn, const iterator endd) noexcept :
            begin_{beginn},
            end_{endd}
    {

    }

    constexpr ContiguousRange() noexcept :
            ContiguousRange{nullptr, nullptr}
    {

    }

    constexpr ContiguousRange(const iterator beginn, size_t sizee) noexcept :
            begin_{beginn},
            end_{beginn + sizee}
    {

    }

    template<size_t N>
    constexpr explicit ContiguousRange(T (& array)[N]) noexcept :
            ContiguousRange{array, array + N}
    {

    }

    template<size_t N>
    constexpr explicit ContiguousRange(std::array<T, N>& array) noexcept :
            ContiguousRange{array.begin(), array.end()}
    {

    }

    template<size_t N>
    constexpr explicit ContiguousRange(const std::array<typename std::remove_const<T>::type, N>& array) noexcept :
            ContiguousRange{array.begin(), array.end()}
    {

    }

    template<size_t N, typename TT = T, typename = typename std::enable_if<std::is_const<TT>::value == true>::type>
    constexpr explicit ContiguousRange(const std::array<T, N>& array) noexcept :
            ContiguousRange{array.begin(), array.end()}
    {

    }

    constexpr explicit ContiguousRange(T& value) noexcept :
            ContiguousRange{&value, &value + 1}
    {

    }

    template<typename TT = T, typename = typename std::enable_if<std::is_const<TT>::value == true>::type>
    constexpr explicit ContiguousRange(const ContiguousRange<typename std::remove_const<TT>::type>& other) noexcept :
            ContiguousRange{other.begin(), other.end()}
    {

    }

    reference operator[](const size_type i) const noexcept
    {
        return begin_[i];
    }

    constexpr iterator begin() const noexcept
    {
        return begin_;
    }

    constexpr const_iterator cbegin() const noexcept
    {
        return begin();
    }

    constexpr const_iterator cend() const noexcept
    {
        return end();
    }

    constexpr const_reverse_iterator crbegin() const noexcept
    {
        return rbegin();
    }

    constexpr const_reverse_iterator crend() const noexcept
    {
        return rend();
    }

    constexpr iterator end() const noexcept
    {
        return end_;
    }

    constexpr reverse_iterator rbegin() const noexcept
    {
        return reverse_iterator{end()};
    }

    constexpr reverse_iterator rend() const noexcept
    {
        return reverse_iterator{begin()};
    }

    constexpr size_type size() const noexcept
    {
        return end_ - begin_;
    }

private:

    iterator begin_;

    iterator end_;
};

}   // namespace estd

#endif  // ESTD_CONTIGUOUSRANGE_HPP_