price.hpp

Go to the documentation of this file.

#pragma once
 
 
#include <cstdint>
#include <format>
#include <string>
#include <type_traits>
 
namespace itch {
 
template <typename RawType, unsigned int Decimals>
class BasicPrice {
    static_assert(std::is_unsigned_v<RawType>, "Price raw storage must be an unsigned integer");
 
   public:
    using raw_type = RawType;
 
    static constexpr unsigned int decimals = Decimals;
 
    constexpr BasicPrice() noexcept = default;
 
    explicit constexpr BasicPrice(raw_type raw_value) noexcept : m_raw {raw_value} {}
 
    [[nodiscard]] constexpr auto raw() const noexcept -> raw_type { return m_raw; }
 
    [[nodiscard]] static constexpr auto divisor() noexcept -> raw_type {
        raw_type result {1};
        for (unsigned int exponent {0}; exponent < Decimals; ++exponent) {
            result *= 10;
        }
        return result;
    }
 
    [[nodiscard]] constexpr auto to_double() const noexcept -> double {
        return static_cast<double>(m_raw) / static_cast<double>(divisor());
    }
 
    [[nodiscard]] auto to_string() const -> std::string {
        return std::format("{:.{}f}", to_double(), Decimals);
    }
 
    [[nodiscard]] friend constexpr auto operator==(BasicPrice, BasicPrice) noexcept -> bool =
                                                                                           default;
    [[nodiscard]] friend constexpr auto operator<=>(BasicPrice, BasicPrice) noexcept = default;
 
   private:
    raw_type m_raw {0};
};
 
using StandardPrice = BasicPrice<std::uint32_t, 4>;
 
using MwcbPrice = BasicPrice<std::uint64_t, 8>;
 
[[nodiscard]] constexpr auto make_price(std::uint32_t raw_value) noexcept -> StandardPrice {
    return StandardPrice {raw_value};
}
 
[[nodiscard]] constexpr auto make_mwcb_price(std::uint64_t raw_value) noexcept -> MwcbPrice {
    return MwcbPrice {raw_value};
}
 
}  // namespace itch
 
template <typename RawType, unsigned int Decimals>
struct std::formatter<itch::BasicPrice<RawType, Decimals>> : std::formatter<double> {
    auto format(itch::BasicPrice<RawType, Decimals> price, std::format_context& ctx) const {
        return std::formatter<double>::format(price.to_double(), ctx);
    }
};