types.h

/*
 * MIT License
 *
 * Copyright (c) 2025 Adriano dos Santos Fernandes
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
 
#ifndef FBCPP_TYPES_H
#define FBCPP_TYPES_H
 
#include "fb-api.h"
#include "config.h"
#include <chrono>
#include <cstdint>
#include <format>
#include <iostream>
#include <string>
#include <type_traits>
 
#if FB_CPP_USE_BOOST_MULTIPRECISION != 0
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
#endif
 
#if FB_CPP_USE_BOOST_DECIMAL != 0
#include <boost/decimal.hpp>
#endif
 
 
namespace fbcpp
{
    template <typename T>
    struct ScaledNumber final
    {
        bool operator==(const ScaledNumber& o) const noexcept
        {
            if constexpr (std::is_same_v<T, FB_I128>)
            {
                return value.fb_data[0] == o.value.fb_data[0] && value.fb_data[1] == o.value.fb_data[1] &&
                    scale == o.scale;
            }
            else
                return value == o.value && scale == o.scale;
        }
 
        T value{};
 
        int scale = 0;
    };
 
    using ScaledInt16 = ScaledNumber<std::int16_t>;
 
    using ScaledInt32 = ScaledNumber<std::int32_t>;
 
    using ScaledInt64 = ScaledNumber<std::int64_t>;
 
#if FB_CPP_USE_BOOST_MULTIPRECISION != 0
    using BoostInt128 = boost::multiprecision::int128_t;
 
    using ScaledBoostInt128 = ScaledNumber<BoostInt128>;
#endif
 
#if FB_CPP_USE_BOOST_MULTIPRECISION != 0
    using BoostDecFloat16 = boost::multiprecision::number<boost::multiprecision::cpp_dec_float<16>>;
 
    using BoostDecFloat34 = boost::multiprecision::number<boost::multiprecision::cpp_dec_float<34>>;
#endif
 
#if FB_CPP_USE_BOOST_DECIMAL != 0
    using BoostDecimal32 = boost::decimal::decimal32_t;
 
    using BoostDecimal64 = boost::decimal::decimal64_t;
 
    using BoostDecimal128 = boost::decimal::decimal128_t;
#endif
 
    using Date = std::chrono::year_month_day;
 
    using Time = std::chrono::hh_mm_ss<std::chrono::microseconds>;
 
    struct Timestamp final
    {
        bool operator==(const Timestamp& o) const noexcept
        {
            return date == o.date && time.to_duration() == o.time.to_duration();
        }
 
        std::chrono::local_time<std::chrono::microseconds> toLocalTime() const noexcept
        {
            return std::chrono::local_days{date} + time.to_duration();
        }
 
        static Timestamp fromLocalTime(std::chrono::local_time<std::chrono::microseconds> value) noexcept
        {
            const auto days = std::chrono::floor<std::chrono::days>(value);
            const Date dateValue{days};
            const auto timeOfDay = std::chrono::duration_cast<std::chrono::microseconds>(value - days);
 
            return Timestamp{dateValue, Time{timeOfDay}};
        }
 
        Date date{};
 
        Time time{std::chrono::microseconds::zero()};
    };
 
    struct TimeTz final
    {
        bool operator==(const TimeTz& o) const noexcept
        {
            return utcTime.to_duration() == o.utcTime.to_duration() && zone == o.zone;
        }
 
        Time utcTime;
 
        std::string zone;
    };
 
    struct TimestampTz final
    {
        bool operator==(const TimestampTz&) const noexcept = default;
 
        Timestamp utcTimestamp;
 
        std::string zone;
    };
 
    using OpaqueInt128 = FB_I128;
 
    using OpaqueDecFloat16 = FB_DEC16;
 
    using OpaqueDecFloat34 = FB_DEC34;
 
    using ScaledOpaqueInt128 = ScaledNumber<OpaqueInt128>;
 
    struct alignas(alignof(ISC_DATE)) OpaqueDate final
    {
        bool operator==(const OpaqueDate&) const noexcept = default;
 
        ISC_DATE value;
    };
 
    struct alignas(alignof(ISC_TIME)) OpaqueTime final
    {
        bool operator==(const OpaqueTime&) const noexcept = default;
 
        ISC_TIME value;
    };
 
    struct alignas(alignof(ISC_TIMESTAMP)) OpaqueTimestamp final
    {
        bool operator==(const OpaqueTimestamp& o) const noexcept
        {
            return value.timestamp_date == o.value.timestamp_date && value.timestamp_time == o.value.timestamp_time;
        }
 
        ISC_TIMESTAMP value;
    };
 
    struct alignas(alignof(ISC_TIME_TZ)) OpaqueTimeTz final
    {
        bool operator==(const OpaqueTimeTz& o) const noexcept
        {
            return value.utc_time == o.value.utc_time && value.time_zone == o.value.time_zone;
        }
 
        ISC_TIME_TZ value;
    };
 
    struct alignas(alignof(ISC_TIMESTAMP_TZ)) OpaqueTimestampTz final
    {
        bool operator==(const OpaqueTimestampTz& o) const noexcept
        {
            return value.utc_timestamp.timestamp_date == o.value.utc_timestamp.timestamp_date &&
                value.utc_timestamp.timestamp_time == o.value.utc_timestamp.timestamp_time &&
                value.time_zone == o.value.time_zone;
        }
 
        ISC_TIMESTAMP_TZ value;
    };
 
    // FIXME: test
    template <typename T>
    std::ostream& operator<<(std::ostream& os, const fbcpp::ScaledNumber<T>& scaledNumber)
    {
        os << scaledNumber.value << "e" << scaledNumber.scale;
        return os;
    }
}  // namespace fbcpp
 
 
// FIXME: test
template <typename T>
struct std::formatter<fbcpp::ScaledNumber<T>> : std::formatter<T>
{
    constexpr auto parse(format_parse_context& ctx)
    {
        return std::formatter<T>::parse(ctx);
    }
 
    template <typename FormatContext>
    auto format(const fbcpp::ScaledNumber<T>& scaledNumber, FormatContext& ctx) const
    {
        const auto valueEnd = std::formatter<T>::format(scaledNumber.value, ctx);
        return std::format_to(valueEnd, "e{}", scaledNumber.scale);
    }
};
 
 
#endif  // FBCPP_TYPES_H