IOUAmount.h

#ifndef XRPL_BASICS_IOUAMOUNT_H_INCLUDED
#define XRPL_BASICS_IOUAMOUNT_H_INCLUDED
 
#include <xrpl/basics/LocalValue.h>
#include <xrpl/basics/Number.h>
#include <xrpl/beast/utility/Zero.h>
 
#include <boost/operators.hpp>
 
#include <cstdint>
#include <string>
 
namespace ripple {
 
class IOUAmount : private boost::totally_ordered<IOUAmount>,
                  private boost::additive<IOUAmount>
{
private:
    std::int64_t mantissa_;
    int exponent_;
 
    void
    normalize();
 
public:
    IOUAmount() = default;
    explicit IOUAmount(Number const& other);
    IOUAmount(beast::Zero);
    IOUAmount(std::int64_t mantissa, int exponent);
 
    IOUAmount& operator=(beast::Zero);
 
    operator Number() const;
 
    IOUAmount&
    operator+=(IOUAmount const& other);
 
    IOUAmount&
    operator-=(IOUAmount const& other);
 
    IOUAmount
    operator-() const;
 
    bool
    operator==(IOUAmount const& other) const;
 
    bool
    operator<(IOUAmount const& other) const;
 
    explicit
    operator bool() const noexcept;
 
    int
    signum() const noexcept;
 
    int
    exponent() const noexcept;
 
    std::int64_t
    mantissa() const noexcept;
 
    static IOUAmount
    minPositiveAmount();
 
    friend std::ostream&
    operator<<(std::ostream& os, IOUAmount const& x)
    {
        return os << to_string(x);
    }
};
 
inline IOUAmount::IOUAmount(beast::Zero)
{
    *this = beast::zero;
}
 
inline IOUAmount::IOUAmount(std::int64_t mantissa, int exponent)
    : mantissa_(mantissa), exponent_(exponent)
{
    normalize();
}
 
inline IOUAmount&
IOUAmount::operator=(beast::Zero)
{
    // The -100 is used to allow 0 to sort less than small positive values
    // which will have a large negative exponent.
    mantissa_ = 0;
    exponent_ = -100;
    return *this;
}
 
inline IOUAmount::operator Number() const
{
    return Number{mantissa_, exponent_};
}
 
inline IOUAmount&
IOUAmount::operator-=(IOUAmount const& other)
{
    *this += -other;
    return *this;
}
 
inline IOUAmount
IOUAmount::operator-() const
{
    return {-mantissa_, exponent_};
}
 
inline bool
IOUAmount::operator==(IOUAmount const& other) const
{
    return exponent_ == other.exponent_ && mantissa_ == other.mantissa_;
}
 
inline bool
IOUAmount::operator<(IOUAmount const& other) const
{
    return Number{*this} < Number{other};
}
 
inline IOUAmount::operator bool() const noexcept
{
    return mantissa_ != 0;
}
 
inline int
IOUAmount::signum() const noexcept
{
    return (mantissa_ < 0) ? -1 : (mantissa_ ? 1 : 0);
}
 
inline int
IOUAmount::exponent() const noexcept
{
    return exponent_;
}
 
inline std::int64_t
IOUAmount::mantissa() const noexcept
{
    return mantissa_;
}
 
std::string
to_string(IOUAmount const& amount);
 
/* Return num*amt/den
   This function keeps more precision than computing
   num*amt, storing the result in an IOUAmount, then
   dividing by den.
*/
IOUAmount
mulRatio(
    IOUAmount const& amt,
    std::uint32_t num,
    std::uint32_t den,
    bool roundUp);
 
// Since many uses of the number class do not have access to a ledger,
// getSTNumberSwitchover needs to be globally accessible.
 
bool
getSTNumberSwitchover();
 
void
setSTNumberSwitchover(bool v);
 
class NumberSO
{
    bool saved_;
 
public:
    ~NumberSO()
    {
        setSTNumberSwitchover(saved_);
    }
 
    NumberSO(NumberSO const&) = delete;
    NumberSO&
    operator=(NumberSO const&) = delete;
 
    explicit NumberSO(bool v) : saved_(getSTNumberSwitchover())
    {
        setSTNumberSwitchover(v);
    }
};
 
}  // namespace ripple
 
#endif