iterable.hxx

#pragma once
 
#include <StormByte/exception.hxx>
#include <StormByte/type_traits.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;
 
            bool                                                operator==(const Iterable& other) const { return m_data == other.m_data; }
 
            bool                                                operator!=(const Iterable& other) const { return m_data != other.m_data; }
 
            iterator                                            begin() noexcept { return iterator(m_data.begin()); }
 
            const_iterator                                      begin() const noexcept { return const_iterator(m_data.begin()); }
 
            iterator                                            end() noexcept { return iterator(m_data.end()); }
 
            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)
            requires Type::HasSubscript<Container, size_type> {
                if (i >= m_data.size())
                    throw OutOfBoundsError("Index {} out of bounds in Iterable::operator[]", i);
                return m_data[i];
            }
 
            reference                                           operator[](size_type i)
            requires (!Type::HasSubscript<Container, size_type>) {
                if (i >= m_data.size())
                    throw OutOfBoundsError("Index {} out of bounds in Iterable::operator[]", i);
                auto it = m_data.begin();
                std::advance(it, i);
                return *it;
            }
 
            auto                                                operator[](size_type i) -> decltype(auto)
            requires (!Type::HasSubscript<Container, size_type> && !Type::HasMappedType<Container>) {
                if (i >= m_data.size())
                    throw OutOfBoundsError("Index {} out of bounds in Iterable::operator[]", i);
                auto it = m_data.begin();
                std::advance(it, i);
                return *it;
            }
 
 
            /*
            * @brief Key-based access for associative containers (non-const)
            * @param key The key to access in the underlying container
            * @return Reference to the mapped value (forward to container's operator[])
            */
            template<typename K>
            auto                                                operator[](K const &key) -> decltype(auto)
            requires (Type::HasMappedType<Container>) {
                return m_data[static_cast<typename Container::key_type>(key)];
            }
 
            /*
            * @brief Key-based access for associative containers (const)
            * @param key The key to access in the underlying container
            * @return Const reference to the mapped value (searches and throws if not found)
            */
            template<typename K>
            auto                                                operator[](K const &key) const -> decltype(auto)
            requires (Type::HasMappedType<const Container>) {
                auto k = static_cast<typename Container::key_type>(key);
                auto it = m_data.find(k);
                if (it == m_data.cend())
                    throw OutOfBoundsError("Key not found in Iterable::operator[]");
                return it->second;
            }
 
            const_reference                                     operator[](size_type i) const
            requires Type::HasSubscript<const Container, size_type> {
                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
            requires (!Type::HasSubscript<const Container, size_type>) {
                if (i >= m_data.size())
                    throw OutOfBoundsError("Index {} out of bounds in Iterable::operator[]", i);
                auto it = m_data.cbegin();
                std::advance(it, i);
                return *it;
            }
 
            auto                                                operator[](size_type i) const -> decltype(auto)
            requires (!Type::HasSubscript<const Container, size_type> && !Type::HasMappedType<const Container>) {
                if (i >= m_data.size())
                    throw OutOfBoundsError("Index {} out of bounds in Iterable::operator[]", i);
                auto it = m_data.cbegin();
                std::advance(it, i);
                return *it;
            }
 
            void                                                add(const value_type& value) requires Type::HasPushBack<decltype(m_data)> {
                m_data.push_back(value);
            }
 
            void                                                add(const value_type& value) requires (!Type::HasPushBack<decltype(m_data)> and Type::HasPushFront<decltype(m_data)>) {
                m_data.push_front(value);
            }
 
            void                                                add(const value_type& value) requires (!Type::HasPushBack<decltype(m_data)> and !Type::HasPushFront<decltype(m_data)> and Type::HasInsert<decltype(m_data)>) {
                m_data.insert(value);
            }
 
            void                                                add(value_type&& value) requires Type::HasPushBack<decltype(m_data)> {
                m_data.push_back(std::move(value));
            }
 
            void                                                add(value_type&& value) requires (!Type::HasPushBack<decltype(m_data)> and Type::HasPushFront<decltype(m_data)>) {
                m_data.push_front(std::move(value));
            }
 
            void                                                add(value_type&& value) requires (!Type::HasPushBack<decltype(m_data)> and !Type::HasPushFront<decltype(m_data)> and Type::HasInsert<decltype(m_data)>) {
                m_data.insert(std::move(value));
            }
 
            bool                                                has_item(const value_type& value) const {
                for (const auto& item : m_data) {
                    if (item == value) {
                        return true;
                    }
                }
                return false;
            }
 
            template<typename M>
            bool has_item(M const &value) const
            requires Type::HasMappedType<const Container> && std::convertible_to<M, typename Container::mapped_type> {
                for (const auto &item : m_data) {
                    if (item.second == value) return true;
                }
                return false;
            }
 
            template<typename K>
            bool                                                has_key(const K& key) const
            requires Type::HasMappedType<const Container> {
                auto k = static_cast<typename Container::key_type>(key);
                return m_data.find(k) != m_data.cend();
 
            }
    };
}