iterable.hxx

#pragma once
 
#include <StormByte/exception.hxx>
 
#include <iterator>
#include <utility>
 
namespace StormByte {
    template <typename Container>
    class Iterable {
        protected:
            Container m_data;                                   
        public:
            using value_type                                    = typename Container::value_type;
            using size_type                                     = typename Container::size_type;
            using difference_type                               = typename Container::difference_type;
            using reference                                     = typename Container::reference;
            using const_reference                               = typename Container::const_reference;
            using pointer                                       = typename Container::pointer;
            using const_pointer                                 = typename Container::const_pointer;
 
            class Iterator {
                friend class Iterable;
                public:
                    using iterator_category                     = std::random_access_iterator_tag;
                    using value_type                            = typename Container::value_type;
                    using difference_type                       = typename Container::difference_type;
                    using pointer                               = typename Container::pointer;
                    using reference                             = typename Container::reference;
 
                    reference                                   operator*() { return *m_it; }
 
                    pointer                                     operator->() { return m_it.operator->(); }
 
                    Iterator&                                   operator++() { ++m_it; return *this; }
 
                    Iterator                                    operator++(int) { Iterator tmp = *this; ++m_it; return tmp; }
 
                    Iterator&                                   operator--() { --m_it; return *this; }
 
                    Iterator                                    operator--(int) { Iterator tmp = *this; --m_it; return tmp; }
 
                    Iterator&                                   operator+=(difference_type n) { m_it += n; return *this; }
 
                    Iterator&                                   operator-=(difference_type n) { m_it -= n; return *this; }
 
                    Iterator                                    operator+(difference_type n) const { return Iterator(m_it + n); }
 
                    Iterator                                    operator-(difference_type n) const { return Iterator(m_it - n); }
 
                    difference_type                             operator-(const Iterator& other) const { return m_it - other.m_it; }
 
                    bool                                        operator==(const Iterator& other) const { return m_it == other.m_it; }
 
                    bool                                        operator!=(const Iterator& other) const { return m_it != other.m_it; }
 
                private:
                    typename Container::iterator m_it;          
 
                    Iterator(typename Container::iterator it): m_it(it) {}
            };
 
            class ConstIterator {
                friend class Iterable;
                public:
                    using iterator_category                     = std::random_access_iterator_tag;
                    using value_type                            = typename Container::value_type;
                    using difference_type                       = typename Container::difference_type;
                    using pointer                               = typename Container::const_pointer;
                    using reference                             = typename Container::const_reference;
 
                    reference                                   operator*() const { return *m_it; }
 
                    pointer                                     operator->() const { return m_it.operator->(); }
 
                    ConstIterator&                              operator++() { ++m_it; return *this; }
 
                    ConstIterator                               operator++(int) { ConstIterator tmp = *this; ++m_it; return tmp; }
 
                    ConstIterator&                              operator--() { --m_it; return *this; }
 
                    ConstIterator                               operator--(int) { ConstIterator tmp = *this; --m_it; return tmp; }
 
                    ConstIterator&                              operator+=(difference_type n) { m_it += n; return *this; }
 
                    ConstIterator&                              operator-=(difference_type n) { m_it -= n; return *this; }
 
                    ConstIterator                               operator+(difference_type n) const { return ConstIterator(m_it + n); }
 
                    ConstIterator                               operator-(difference_type n) const { return ConstIterator(m_it - n); }
 
                    difference_type                             operator-(const ConstIterator& other) const { return m_it - other.m_it; }
 
                    bool                                        operator==(const ConstIterator& other) const { return m_it == other.m_it; }
 
                    bool                                        operator!=(const ConstIterator& other) const { return m_it != other.m_it; }
 
                private:
                    typename Container::const_iterator m_it;
 
                    ConstIterator(typename Container::const_iterator it): m_it(it) {}
            };
 
            using iterator                                      = Iterator;
            using const_iterator                                = ConstIterator;
            using reverse_iterator                              = std::reverse_iterator<iterator>;
            using const_reverse_iterator                        = std::reverse_iterator<const_iterator>;
 
            Iterable()                                          = default;
 
            explicit Iterable(const Container& data): m_data(data) {}
 
            explicit Iterable(Container&& data): m_data(std::move(data)) {}
 
            Iterable(const Iterable&)                           = default;
 
            Iterable(Iterable&&)                                = default;
 
            virtual ~Iterable()                                 = default;
 
            Iterable&                                           operator=(const Iterable&) = default;
 
            Iterable&                                           operator=(Iterable&&) = default;
 
            iterator                                            begin() noexcept { return iterator(m_data.begin()); }
 
            iterator                                            end() noexcept { return iterator(m_data.end()); }
 
            const_iterator                                      begin() const noexcept { return const_iterator(m_data.begin()); }
 
            const_iterator                                      end() const noexcept { return const_iterator(m_data.end()); }
 
            const_iterator                                      cbegin() const noexcept { return const_iterator(m_data.cbegin()); }
 
            const_iterator                                      cend() const noexcept { return const_iterator(m_data.cend()); }
 
            reverse_iterator                                    rbegin() noexcept { return reverse_iterator(end()); }
 
            reverse_iterator                                    rend() noexcept { return reverse_iterator(begin()); }
 
            const_reverse_iterator                              rbegin() const noexcept { return const_reverse_iterator(end()); }
 
            const_reverse_iterator                              rend() const noexcept { return const_reverse_iterator(begin()); }
 
            const_reverse_iterator                              crbegin() const noexcept { return const_reverse_iterator(cend()); }
 
            const_reverse_iterator                              crend() const noexcept { return const_reverse_iterator(cbegin()); }
 
            size_type                                           size() const noexcept { return m_data.size(); }
 
            bool                                                empty() const noexcept { return m_data.empty(); }
 
            reference                                           operator[](size_type i) {
                if (i >= m_data.size())
                    throw OutOfBoundsError("Index {} out of bounds in Iterable::operator[]", i);
                return m_data[i];
            }
 
            const_reference                                     operator[](size_type i) const {
                if (i >= m_data.size())
                    throw OutOfBoundsError("Index {} out of bounds in Iterable::operator[]", i);
                return m_data[i];
            }
 
            void                                                add(const value_type& value) { m_data.push_back(value); }
 
            void                                                add(value_type&& value) { m_data.push_back(std::move(value)); }
        };
}