value.hxx

Go to the documentation of this file.

/*
 * Copyright (C) 2024-2026 David C. Manuelda (StormBytePP)
 *
 * This file is part of StormByte-Database.
 *
 * StormByte-Database 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-Database source in this
 * repository. They do not cover other StormByte modules or any third-party
 * material shipped with this repository (including everything under
 * thirdparty/, and in particular the bundled StormByte-Logger tree and
 * the PostgreSQL, MariaDB and SQLite trees), which remain under their own
 * licenses.
 *
 * 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-Database 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-Database. 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/database/exception.hxx>
#include <StormByte/database/typedefs.hxx>
#include <StormByte/database/visibility.h>
#include <StormByte/type_traits.hxx>
 
#include <cmath>
#include <limits>
#include <string_view>
#include <type_traits>
 
namespace StormByte {
    namespace 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(static_cast<long long int>(value)), m_type(Type::LongInteger) {}
 
                Value(unsigned long int value) noexcept : m_value(static_cast<unsigned long long int>(value)), m_type(Type::UnsignedLongInteger) {}
 
                Value(long long int value) noexcept : m_value(value), m_type(Type::LongInteger) {}
 
                Value(unsigned long long int value) noexcept : m_value(value), m_type(Type::UnsignedLongInteger) {}
 
                Value(double value) noexcept : m_value(value), m_type(Type::Double) {}
 
                Value(std::string_view value) noexcept;
 
                Value(const StormByte::BinaryData &value);
 
                Value(StormByte::BinaryData &&value) noexcept;
 
                template <typename T>
                    requires StormByte::Type::SameAs<std::remove_cvref_t<T>, bool>
                Value(T &&value) noexcept : m_value(value), m_type(Type::Boolean) {}
                Value(const Value &other);
 
                Value(Value &&other) noexcept;
 
                Value &operator=(const Value &other);
 
                Value &operator=(Value &&other) noexcept;
 
                inline bool operator==(const Value &other) const noexcept {
                    return m_value == other.m_value;
                }
 
                inline bool operator!=(const Value &other) const noexcept {
                    return !(*this == other);
                }
 
                virtual ~Value() noexcept;
 
                template <typename T>
                    requires StormByte::Type::VariantHasType<ValuesVariant, std::decay_t<T>>
                std::decay_t<T> Get() const {
                    using To = std::decay_t<T>;
                    return std::visit([](auto &&val) -> To {
                        using From = std::decay_t<decltype(val)>;
                        if constexpr (StormByte::Type::SameAs<From, std::monostate>) {
                            throw WrongValueType("Requested type does not match stored type (null).");
                        } else if constexpr (StormByte::Type::SameAs<From, To>) {
                            return val;
                        } else if constexpr (StormByte::Type::Arithmetic<From> && StormByte::Type::Arithmetic<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:
                template <typename To, typename From>
                    requires(StormByte::Type::Arithmetic<To> && StormByte::Type::Arithmetic<From>)
                static To convert_numeric(const From &val) {
                    if constexpr (StormByte::Type::Integral<From> && StormByte::Type::Integral<To>) {
                        if constexpr (StormByte::Type::Signed<From>) {
                            std::intmax_t from = static_cast<std::intmax_t>(val);
                            if constexpr (StormByte::Type::Signed<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 {
                                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 {
                            std::uintmax_t from = static_cast<std::uintmax_t>(val);
                            if constexpr (StormByte::Type::Signed<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 {
                                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 (StormByte::Type::Integral<From> && StormByte::Type::FloatingPoint<To>) {
                        return static_cast<To>(val);
                    } else if constexpr (StormByte::Type::FloatingPoint<From> && StormByte::Type::Integral<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.");
                        const long double upper_bound = std::ldexp(1.0L, std::numeric_limits<To>::digits);
                        if constexpr (StormByte::Type::Signed<To>) {
                            if (d < -upper_bound || d >= upper_bound)
                                throw WrongValueType("Floating to integer conversion would overflow/narrow.");
                        } else {
                            if (d < 0)
                                throw WrongValueType("Negative value cannot be converted to unsigned.");
                            if (d >= upper_bound)
                                throw WrongValueType("Floating to integer conversion would overflow/narrow.");
                        }
                        return static_cast<To>(d);
                    } else if constexpr (StormByte::Type::FloatingPoint<From> && StormByte::Type::FloatingPoint<To>) {
                        return static_cast<To>(val);
                    } else {
                        throw WrongValueType("Unsupported numeric conversion.");
                    }
                }
 
                ValuesVariant m_value; 
                enum Type m_type;      
        };
    }
}