row.hxx

#pragma once
 
#include <StormByte/database/value.hxx>
 
#include <iterator>
#include <utility>
#include <vector>
 
namespace StormByte::Database {
    class STORMBYTE_DATABASE_PUBLIC Row {
        public:
            class STORMBYTE_DATABASE_PUBLIC Iterator {
                public:
                    using iterator_category                         = std::random_access_iterator_tag;
                    using value_type                                = Value;
                    using difference_type                           = std::ptrdiff_t;
                    using pointer                                   = Value*;
                    using reference                                 = Value&;
 
                    inline reference                                operator*() {
                        return (*m_row)[m_index];
                    }
 
                    inline pointer                                  operator->() {
                        return &(*m_row)[m_index];
                    }
 
                    inline Iterator&                                operator++() {
                        ++m_index;
                        return *this;
                    }
 
                    inline Iterator                                 operator++(int) {
                        Iterator tmp = *this;
                        ++(*this);
                        return tmp;
                    }
 
                    inline Iterator&                                operator--() noexcept {
                        --m_index;
                        return *this;
                    }
 
                    inline Iterator                                 operator--(int) noexcept {
                        Iterator tmp = *this;
                        --(*this);
                        return tmp;
                    }
 
                    inline Iterator&                                operator+=(difference_type n) noexcept {
                        m_index = static_cast<std::size_t>(static_cast<difference_type>(m_index) + n);
                        return *this;
                    }
 
                    inline  Iterator&                               operator-=(difference_type n) noexcept {
                        m_index = static_cast<std::size_t>(static_cast<difference_type>(m_index) - n);
                        return *this;
                    }
 
                    inline Iterator                                 operator+(difference_type n) const noexcept {
                        Iterator tmp = *this;
                        tmp += n;
                        return tmp;
                    }
 
                    inline Iterator                                 operator-(difference_type n) const noexcept {
                        Iterator tmp = *this;
                        tmp -= n;
                        return tmp;
                    }
 
                    inline difference_type                          operator-(const Iterator& other) const noexcept {
                        return static_cast<difference_type>(m_index) - static_cast<difference_type>(other.m_index);
                    }
 
                    inline bool                                     operator==(const Iterator& other) const noexcept {
                        return m_row == other.m_row && m_index == other.m_index;
                    }
 
                    inline bool                                     operator!=(const Iterator& other) const noexcept {
                        return !(*this == other);
                    }
 
                private:
                    friend class Row;
 
                    Iterator(Row* row, std::size_t index) noexcept:
                    m_row(row), m_index(index) {}
 
                    Row* m_row;                                     
                    std::size_t m_index;                            
            };
 
            class STORMBYTE_DATABASE_PUBLIC ConstIterator {
                public:
                    using iterator_category                         = std::random_access_iterator_tag;
                    using value_type                                = const Value;
                    using difference_type                           = std::ptrdiff_t;
                    using pointer                                   = const Value*;
                    using reference                                 = const Value&;
 
                    inline reference                                operator*() const {
                        return (*m_row)[m_index];
                    }
 
                    inline pointer                                  operator->() const {
                        return &(*m_row)[m_index];
                    }
 
                    inline ConstIterator&                           operator++() {
                        ++m_index;
                        return *this;
                    }
 
                    inline ConstIterator                            operator++(int) {
                        ConstIterator tmp = *this;
                        ++(*this);
                        return tmp;
                    }
 
                    inline ConstIterator&                           operator--() noexcept {
                        --m_index;
                        return *this;
                    }
 
                    inline ConstIterator                            operator--(int) noexcept {
                        ConstIterator tmp = *this;
                        --(*this);
                        return tmp;
                    }
 
                    inline ConstIterator&                           operator+=(difference_type n) noexcept {
                        m_index = static_cast<std::size_t>(static_cast<difference_type>(m_index) + n);
                        return *this;
                    }
 
                    inline ConstIterator&                           operator-=(difference_type n) noexcept {
                        m_index = static_cast<std::size_t>(static_cast<difference_type>(m_index) - n);
                        return *this;
                    }
 
                    inline ConstIterator                            operator+(difference_type n) const noexcept {
                        ConstIterator tmp = *this;
                        tmp += n;
                        return tmp;
                    }
 
                    inline ConstIterator                            operator-(difference_type n) const noexcept {
                        ConstIterator tmp = *this;
                        tmp -= n;
                        return tmp;
                    }
 
                    inline difference_type                          operator-(const ConstIterator& other) const noexcept {
                        return static_cast<difference_type>(m_index) - static_cast<difference_type>(other.m_index);
                    }
 
                    inline reference                                operator[](difference_type n) const {
                        return (*m_row)[m_index + static_cast<std::size_t>(n)];
                    }
 
                    inline bool                                     operator==(const ConstIterator& other) const noexcept {
                        return m_row == other.m_row && m_index == other.m_index;
                    }
 
                    inline bool                                     operator!=(const ConstIterator& other) const noexcept {
                        return !(*this == other);
                    }
 
                private:
                    friend class Row;
 
                    ConstIterator(const Row* row, std::size_t index) noexcept:
                    m_row(row), m_index(index) {}
 
                    const Row* m_row;                               
                    std::size_t m_index;                            
            };
 
            using iterator = Iterator;
            using const_iterator = ConstIterator;
            using reverse_iterator = std::reverse_iterator<iterator>;
            using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
            Row() noexcept                                          = default;
 
            Row(const Row& other)                                   = default;
 
            Row(Row&& other) noexcept                               = default;
 
            ~Row() noexcept                                         = default;
 
            Row& operator=(const Row& other)                        = default;
 
            Row& operator=(Row&& other) noexcept                    = default;
 
            const Value&                                            operator[](std::size_t index) const &;
 
            Value&                                                  operator[](std::size_t index) &;
 
            Value                                                   operator[](std::size_t index) &&;
 
            const Value&                                            operator[](const std::string& columnName) const &;
 
            Value&                                                  operator[](const std::string& columnName) &;
 
            Value                                                   operator[](const std::string& columnName) &&;
 
            inline void                                             Add(std::string&& columnName, Value&& value) {
                m_values.emplace_back(std::move(columnName), std::move(value));
            }
 
            inline iterator                                         begin() noexcept {
                return Iterator(this, 0);
            }
 
            inline iterator                                         end() noexcept {
                return Iterator(this, m_values.size());
            }
 
            inline const_iterator                                   begin() const noexcept {
                return ConstIterator(this, 0);
            }
 
            inline const_iterator                                   end() const noexcept {
                return ConstIterator(this, m_values.size());
            }
 
            inline const_iterator                                   cbegin() const noexcept {
                return ConstIterator(this, 0);
            }
 
            inline const_iterator                                   cend() const noexcept {
                return ConstIterator(this, m_values.size());
            }
 
            inline reverse_iterator                                 rbegin() noexcept {
                return reverse_iterator(end());
            }
 
            inline reverse_iterator                                 rend() noexcept {
                return reverse_iterator(begin());
            }
 
            inline const_reverse_iterator                           rbegin() const noexcept {
                return const_reverse_iterator(end());
            }
 
            inline const_reverse_iterator                           rend() const noexcept {
                return const_reverse_iterator(begin());
            }
 
            inline std::size_t                                      Count() const noexcept {
                return m_values.size();
            }
 
        private:
            std::vector<std::pair<std::string, Value>> m_values;    
    };
}