iterable.hxx

Go to the documentation of this file.

/*
 * Copyright (C) 2024-2026 David C. Manuelda (StormBytePP)
 *
 * This file is part of StormByte.
 *
 * StormByte original source is dual-licensed:
 *
 * 1. GNU Lesser General Public License v3.0 (or later)
 *    You may redistribute and/or modify this file under the terms of the
 *    GNU Lesser General Public License as published by the Free Software
 *    Foundation, either version 3 of the License, or (at your option)
 *    any later version.
 *
 * 2. Commercial license
 *    Alternatively, this file may be used under the terms of a commercial
 *    license agreement with the copyright holder
 *    (David C. Manuelda <StormByte@gmail.com>).
 *
 * Both licenses apply only to original StormByte source in this repository.
 * They do not cover other StormByte modules or any third-party material
 * shipped with this repository (including everything under thirdparty/),
 * which remains under its own license.
 *
 * Neither license grants any patent rights. Any patent licenses required
 * to use this software or third-party components must be obtained separately
 * from the patent holders.
 *
 * StormByte 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
 * version 3 along with StormByte. If not, see
 * <https://www.gnu.org/licenses/lgpl-3.0.html>.
 *
 * SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-StormByte-Commercial
 */
 
#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 = typename std::iterator_traits<typename Container::iterator>::iterator_category;   
                    using value_type = typename std::iterator_traits<typename Container::iterator>::value_type;
                    using difference_type = typename std::iterator_traits<typename Container::iterator>::difference_type;
                    using pointer = typename std::iterator_traits<typename Container::iterator>::pointer;
                    using reference = typename std::iterator_traits<typename Container::iterator>::reference;
 
                    reference operator*();
 
                    pointer operator->();
 
                    Iterator& operator++();
 
                    Iterator operator++(int);
 
                    Iterator& operator--();
 
                    Iterator operator--(int);
 
                    Iterator& operator+=(difference_type n);
 
                    Iterator& operator-=(difference_type n);
 
                    Iterator operator+(difference_type n) const;
 
                    Iterator operator-(difference_type n) const;
 
                    difference_type operator-(const Iterator& other) const;
 
                    bool operator==(const Iterator& other) const;
 
                    bool operator!=(const Iterator& other) const;
 
                private:
                    typename Container::iterator m_it; 
 
                    Iterator(typename Container::iterator it);
            };
 
            class ConstIterator {
                friend class Iterable;
                public:
                    using iterator_category = typename std::iterator_traits<typename Container::const_iterator>::iterator_category; 
                    using value_type = typename std::iterator_traits<typename Container::const_iterator>::value_type;
                    using difference_type = typename std::iterator_traits<typename Container::const_iterator>::difference_type;
                    using pointer = typename std::iterator_traits<typename Container::const_iterator>::pointer;
                    using reference = typename std::iterator_traits<typename Container::const_iterator>::reference;
 
                    reference operator*() const;
 
                    pointer operator->() const;
 
                    ConstIterator& operator++();
 
                    ConstIterator operator++(int);
 
                    ConstIterator& operator--();
 
                    ConstIterator operator--(int);
 
                    ConstIterator& operator+=(difference_type n);
 
                    ConstIterator& operator-=(difference_type n);
 
                    ConstIterator operator+(difference_type n) const;
 
                    ConstIterator operator-(difference_type n) const;
 
                    difference_type operator-(const ConstIterator& other) const;
 
                    bool operator==(const ConstIterator& other) const;
 
                    bool operator!=(const ConstIterator& other) const;
 
                private:
                    typename Container::const_iterator m_it; 
 
                    ConstIterator(typename Container::const_iterator 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;
 
            template<typename C>
            explicit Iterable(C&& data)
            requires Type::SameAs<C, Container> && (
                (Type::LvalueReference<C> && Type::CopyConstructible<value_type>) ||
                (!Type::LvalueReference<C> && Type::MoveConstructible<value_type>)
            );
 
            Iterable(const Iterable& other);
 
            Iterable(Iterable&&) requires Type::MoveConstructible<Container> = default;
 
            virtual ~Iterable() = default;
 
            Iterable& operator=(const Iterable& other);
 
            Iterable& operator=(Iterable&&) requires Type::MoveAssignable<Container> = default;
 
            bool operator==(const Iterable& other) const;
 
            bool operator!=(const Iterable& other) const;
 
            iterator begin() noexcept;
 
            const_iterator begin() const noexcept;
 
            iterator end() noexcept;
 
            const_iterator end() const noexcept;
 
            const_iterator cbegin() const noexcept;
 
            const_iterator cend() const noexcept;
 
            reverse_iterator rbegin() noexcept;
 
            reverse_iterator rend() noexcept;
 
            const_reverse_iterator rbegin() const noexcept;
 
            const_reverse_iterator rend() const noexcept;
 
            const_reverse_iterator crbegin() const noexcept;
 
            const_reverse_iterator crend() const noexcept;
 
            size_type size() const noexcept;
 
            bool empty() const noexcept;
 
            reference operator[](size_type i);
 
            template<typename K>
            auto operator[](K const& key) -> decltype(auto)
            requires (Type::HasMappedType<Container>);
 
            template<typename K>
            auto operator[](K const& key) const -> decltype(auto)
            requires (Type::HasMappedType<const Container>);
 
            const_reference operator[](size_type i) const;
 
            template<typename T>
            void add(T&& value)
            requires (
                (Type::LvalueReference<T> && Type::CopyConstructible<value_type>) ||
                (!Type::LvalueReference<T> && Type::MoveConstructible<value_type>)
            );
 
            void add(value_type value)
            requires Type::MoveConstructible<value_type>;
 
            bool has_item(const value_type& value) const;
 
            template<typename M>
            bool has_item(M const& value) const
            requires Type::HasMappedType<const Container> && std::convertible_to<M, typename Container::mapped_type>;
 
            template<typename K>
            bool has_key(const K& key) const
            requires Type::HasMappedType<const Container>;
    };
}
 
#include <StormByte/iterable.txx>