row.hxx

#pragma once
 
#include <StormByte/database/exception.hxx>
#include <StormByte/variadic_value.hxx>
 
#include <algorithm>
#include <memory>
#include <vector>
#include <span>
 
namespace StormByte::Database {
    template<class Value> class STORMBYTE_DATABASE_PUBLIC Row {
        public:
            using NamedValue        = std::pair<std::string, std::shared_ptr<Value>>;   
            using Storage           = std::vector<NamedValue>;                          
            using iterator          = typename Storage::iterator;                       
            using const_iterator    = typename Storage::const_iterator;                 
 
            Row() noexcept                                      = default;
 
            Row(const Row&)                                     = default;
 
            Row(Row&&) noexcept                                 = default;
 
            Row& operator=(const Row&)                          = default;
 
            Row& operator=(Row&&) noexcept                      = default;
 
            virtual ~Row() noexcept                             = default;
 
            Value&                                              operator[](const std::string& columnName) {
                return const_cast<Value&>(static_cast<const Row*>(this)->operator[](columnName));
            }
 
            const Value&                                        operator[](const std::string& columnName) const {
                auto it = std::find_if(m_values.begin(), m_values.end(), [&columnName](const NamedValue& item ) { return item.first == columnName; });
                if (it == m_values.end())
                    throw ColumnNotFound(columnName);
                return *(it->second);
            }
 
            Value&                                              operator[](const size_t& columnIndex) {
                return const_cast<Value&>(static_cast<const Row*>(this)->operator[](columnIndex));
            }
 
            const Value&                                        operator[](const size_t& columnIndex) const {
                if (columnIndex >= m_values.size())
                    throw OutOfBounds(columnIndex);
                return *m_values[columnIndex].second;
            }
 
            constexpr                                           operator bool() const noexcept {
                return m_values.size() > 0;
            }
 
            iterator                                            begin() noexcept {
                return m_values.begin();
            }
 
            const_iterator                                      begin() const noexcept {
                return m_values.begin();
            }
 
            iterator                                            end() noexcept {
                return m_values.end();
            }
 
            const_iterator                                      end() const noexcept {
                return m_values.end();
            }
 
            std::span<NamedValue>                               Values() noexcept {
                return m_values;
            }
 
            std::span<const NamedValue>                         Values() const noexcept {
                return m_values;
            }
 
            void                                                Add(const std::string& columnName, std::unique_ptr<Value>&& value) {
                m_values.push_back({columnName, std::move(value)});
            }
 
            constexpr size_t                                    Count() const noexcept {
                return m_values.size();
            }
 
        protected:
            Storage m_values; //< Internal storage
    };
}