value.hxx

#pragma once
 
#include <StormByte/database/exception.hxx>
#include <StormByte/database/typedefs.hxx>
#include <StormByte/database/visibility.h>
#include <StormByte/type_traits.hxx>
#include <cmath>
#include <limits>
#include <type_traits>
 
namespace StormByte::Database {
    class STORMBYTE_DATABASE_PUBLIC Value {
        public:
            enum class Type: unsigned short {
                Null        = 0,                                
                Integer,                                        
                UnsignedInteger,                                
                LongInteger,                                    
                UnsignedLongInteger,                            
                Double,                                         
                Text,                                           
                Blob,                                           
                Boolean                                         
            };
 
            Value() noexcept:
            m_value(std::monostate{}), m_type(Type::Null) {}
 
            Value(int value) noexcept:
            m_value(value), m_type(Type::Integer) {}
 
            Value(unsigned int value) noexcept:
            m_value(value), m_type(Type::UnsignedInteger) {}
 
            Value(long int value) noexcept:
            m_value(value), m_type(Type::LongInteger) {}
 
            Value(unsigned long int value) noexcept:
            m_value(value), m_type(Type::UnsignedLongInteger) {}
 
            Value(double value) noexcept:
            m_value(value), m_type(Type::Double) {}
 
            Value(const std::string& value) noexcept:
            m_value(value), m_type(Type::Text) {}
 
            Value(std::string&& value) noexcept:
            m_value(std::move(value)), m_type(Type::Text) {}
 
            Value(const char* value) noexcept:
            Value(std::string(value)) {}
 
            Value(const std::vector<std::byte>& value) noexcept:
            m_value(value), m_type(Type::Blob) {}
 
            Value(std::vector<std::byte>&& value) noexcept:
            m_value(std::move(value)), m_type(Type::Blob) {}
 
            Value(bool value) noexcept:
            m_value(value), m_type(Type::Boolean) {}
            Value(const Value&)                                 = default;
 
            Value(Value&&) noexcept                             = default;
 
            Value& operator=(const Value&)                      = default;
 
            Value& operator=(Value&&) noexcept                  = default;
 
            ~Value() noexcept                                   = default;
 
            template<typename T>
            requires StormByte::Type::VariantHasType<ValuesVariant, std::decay_t<T>>
            std::decay_t<T>                                     Get() const {
                using To = std::decay_t<T>;
                // visitor handles all stored alternatives and performs safe numeric conversions
                return std::visit([](auto&& val) -> To {
                    using From = std::decay_t<decltype(val)>;
                    if constexpr (std::is_same_v<From, std::monostate>) {
                        throw WrongValueType("Requested type does not match stored type (null).");
                    } else if constexpr (std::is_same_v<From, To>) {
                        return val;
                    } else if constexpr (std::is_arithmetic_v<From> && std::is_arithmetic_v<To>) {
                        return convert_numeric<To, From>(val);
                    } else {
                        throw WrongValueType("Requested type does not match stored type.");
                    }
                }, m_value);
            }
 
            inline Type                                         Type() const noexcept {
                return m_type;
            }
 
            inline bool                                         IsNull() const noexcept {
                return m_type == Type::Null;
            }
 
        private:
            // Helper: safe numeric conversion; only instantiated for arithmetic To and From
            template<typename To, typename From>
            requires (std::is_arithmetic_v<To> && std::is_arithmetic_v<From>)
            static To convert_numeric(const From& val) {
                if constexpr (std::is_integral_v<From> && std::is_integral_v<To>) {
                    if constexpr (std::is_signed_v<From>) {
                        std::intmax_t from = static_cast<std::intmax_t>(val);
                        if constexpr (std::is_signed_v<To>) {
                            if (from < static_cast<std::intmax_t>(std::numeric_limits<To>::lowest()) || from > static_cast<std::intmax_t>(std::numeric_limits<To>::max()))
                                throw WrongValueType("Integer conversion would overflow/narrow.");
                            return static_cast<To>(from);
                        } else {
                            // From signed, To unsigned
                            if (from < 0) throw WrongValueType("Negative value cannot be converted to unsigned.");
                            if (static_cast<std::uintmax_t>(from) > static_cast<std::uintmax_t>(std::numeric_limits<To>::max()))
                                throw WrongValueType("Integer conversion would overflow/narrow.");
                            return static_cast<To>(from);
                        }
                    } else {
                        // From unsigned
                        std::uintmax_t from = static_cast<std::uintmax_t>(val);
                        if constexpr (std::is_signed_v<To>) {
                            if (from > static_cast<std::uintmax_t>(std::numeric_limits<To>::max()))
                                throw WrongValueType("Integer conversion would overflow/narrow.");
                            return static_cast<To>(from);
                        } else {
                            // both unsigned
                            if (from > static_cast<std::uintmax_t>(std::numeric_limits<To>::max()))
                                throw WrongValueType("Integer conversion would overflow/narrow.");
                            return static_cast<To>(from);
                        }
                    }
                } else if constexpr (std::is_integral_v<From> && std::is_floating_point_v<To>) {
                    return static_cast<To>(val);
                } else if constexpr (std::is_floating_point_v<From> && std::is_integral_v<To>) {
                    long double d = static_cast<long double>(val);
                    if (!std::isfinite(d)) throw WrongValueType("Non-finite floating conversion to integer.");
                    if (std::trunc(d) != d) throw WrongValueType("Floating value has fractional part; would lose data.");
                    std::intmax_t tmp = static_cast<std::intmax_t>(d);
                    if constexpr (std::is_signed_v<To>) {
                        if (tmp < static_cast<std::intmax_t>(std::numeric_limits<To>::lowest()) || tmp > static_cast<std::intmax_t>(std::numeric_limits<To>::max()))
                            throw WrongValueType("Floating to integer conversion would overflow/narrow.");
                        return static_cast<To>(tmp);
                    } else {
                        // To unsigned
                        if (tmp < 0) throw WrongValueType("Negative value cannot be converted to unsigned.");
                        if (static_cast<std::uintmax_t>(tmp) > static_cast<std::uintmax_t>(std::numeric_limits<To>::max()))
                            throw WrongValueType("Floating to integer conversion would overflow/narrow.");
                        return static_cast<To>(tmp);
                    }
                } else if constexpr (std::is_floating_point_v<From> && std::is_floating_point_v<To>) {
                    return static_cast<To>(val);
                } else {
                    throw WrongValueType("Unsupported numeric conversion.");
                }
            }
            ValuesVariant m_value;                              
            enum Type m_type;                                   
    };
}