MPTAmount.h

#pragma once
 
#include <xrpl/basics/Number.h>
#include <xrpl/basics/contract.h>
#include <xrpl/beast/utility/Zero.h>
 
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/operators.hpp>
 
#include <cstdint>
#include <limits>
#include <optional>
#include <ostream>
#include <stdexcept>
#include <string>
 
namespace xrpl {
 
class MPTAmount : private boost::totally_ordered<MPTAmount>,
                  private boost::additive<MPTAmount>,
                  private boost::equality_comparable<MPTAmount, std::int64_t>,
                  private boost::additive<MPTAmount, std::int64_t>
{
public:
    using value_type = std::int64_t;
 
protected:
    value_type value_{};
 
public:
    MPTAmount() = default;
    constexpr MPTAmount(MPTAmount const& other) = default;
    constexpr MPTAmount(beast::Zero);
    constexpr MPTAmount&
    operator=(MPTAmount const& other) = default;
 
    // Round to nearest, even on tie.
    explicit MPTAmount(Number const& x) : MPTAmount(static_cast<value_type>(x))
    {
    }
 
    constexpr explicit MPTAmount(value_type value);
 
    constexpr MPTAmount& operator=(beast::Zero);
 
    MPTAmount&
    operator+=(MPTAmount const& other);
 
    MPTAmount&
    operator-=(MPTAmount const& other);
 
    MPTAmount
    operator-() const;
 
    bool
    operator==(MPTAmount const& other) const;
 
    bool
    operator==(value_type other) const;
 
    bool
    operator<(MPTAmount const& other) const;

    explicit constexpr
    operator bool() const noexcept;
 
    operator Number() const noexcept
    {
        return value();
    }

    [[nodiscard]] constexpr int
    signum() const noexcept;

    [[nodiscard]] constexpr value_type
    value() const;
 
    static MPTAmount
    minPositiveAmount();
};
 
constexpr MPTAmount::MPTAmount(value_type value) : value_(value)
{
}
 
constexpr MPTAmount::MPTAmount(beast::Zero)
{
    *this = beast::kZero;
}
 
constexpr MPTAmount&
MPTAmount::operator=(beast::Zero)
{
    value_ = 0;
    return *this;
}

constexpr MPTAmount::
operator bool() const noexcept
{
    return value_ != 0;
}

constexpr int
MPTAmount::signum() const noexcept
{
    if (value_ < 0)
        return -1;
    return (value_ != 0) ? 1 : 0;
}

constexpr MPTAmount::value_type
MPTAmount::value() const
{
    return value_;
}
 
// Output MPTAmount as just the value.
template <class Char, class Traits>
std::basic_ostream<Char, Traits>&
operator<<(std::basic_ostream<Char, Traits>& os, MPTAmount const& q)
{
    return os << q.value();
}
 
inline std::string
to_string(MPTAmount const& amount)
{
    return std::to_string(amount.value());
}
 
inline MPTAmount
mulRatio(MPTAmount const& amt, std::uint32_t num, std::uint32_t den, bool roundUp)
{
    using namespace boost::multiprecision;
 
    if (den == 0u)
        Throw<std::runtime_error>("division by zero");
 
    int128_t const amt128(amt.value());
    auto const neg = amt.value() < 0;
    auto const m = amt128 * num;
    auto r = m / den;
    if (m % den)
    {
        if (!neg && roundUp)
            r += 1;
        if (neg && !roundUp)
            r -= 1;
    }
    if (r > std::numeric_limits<MPTAmount::value_type>::max())
        Throw<std::overflow_error>("MPT mulRatio overflow");
    return MPTAmount(r.convert_to<MPTAmount::value_type>());
}
 
inline std::optional<MPTAmount>
tryMulRatio(MPTAmount const& amt, std::uint32_t num, std::uint32_t den, bool roundUp)
{
    try
    {
        return mulRatio(amt, num, den, roundUp);
    }
    catch (std::overflow_error const&)
    {
        return std::nullopt;
    }
}
 
}  // namespace xrpl