mirror of
https://github.com/XRPLF/rippled.git
synced 2026-04-29 15:37:57 +00:00
33f4c92b61
- Refactor Number internals away from int64 to uint64 & a sign flag
- ctors and accessors use `rep`. Very few things expose
`internalrep`.
- An exception is "unchecked" and the new "normalized", which explicitly
take an internalrep. But with those special control flags, it's easier
to distinguish and control when they are used.
- For now, skip the larger mantissas in AMM transactions and tests
- Remove trailing zeros from scientific notation Number strings
- Update tests. This has the happy side effect of making some of the string
representations _more_ consistent between the small and large
mantissa ranges.
- Add semi-automatic rounding of STNumbers based on Asset types
- Create a new SField metadata enum, sMD_NeedsAsset, which indicates
the field should be associated with an Asset so it can be rounded.
- Add a new STTakesAsset intermediate class to handle the Asset
association to a derived ST class. Currently only used in STNumber,
but could be used by other types in the future.
- Add "associateAsset" which takes an SLE and an Asset, finds the
sMD_NeedsAsset fields, and associates the Asset to them. In the case
of STNumber, that both stores the Asset, and rounds the value
immediately.
- Transactors only need to add a call to associateAsset _after_ all of
the STNumbers have been set. Unfortunately, the inner workings of
STObject do not do the association correctly with uninitialized
fields.
- When serializing an STNumber that has an Asset, round it before
serializing.
- Add an override of roundToAsset, which rounds a Number value in place
to an Asset, but without any additional scale.
- Update and fix a bunch of Loan-related tests to accommodate the
expanded Number class.
---------
Co-authored-by: Vito <5780819+Tapanito@users.noreply.github.com>
201 lines
4.8 KiB
C++
201 lines
4.8 KiB
C++
#ifndef XRPL_PROTOCOL_AMOUNTCONVERSION_H_INCLUDED
|
|
#define XRPL_PROTOCOL_AMOUNTCONVERSION_H_INCLUDED
|
|
|
|
#include <xrpl/protocol/IOUAmount.h>
|
|
#include <xrpl/protocol/STAmount.h>
|
|
#include <xrpl/protocol/XRPAmount.h>
|
|
|
|
#include <type_traits>
|
|
|
|
namespace xrpl {
|
|
|
|
inline STAmount
|
|
toSTAmount(IOUAmount const& iou, Issue const& iss)
|
|
{
|
|
bool const isNeg = iou.signum() < 0;
|
|
std::uint64_t const umant = isNeg ? -iou.mantissa() : iou.mantissa();
|
|
return STAmount(iss, umant, iou.exponent(), isNeg, STAmount::unchecked());
|
|
}
|
|
|
|
inline STAmount
|
|
toSTAmount(IOUAmount const& iou)
|
|
{
|
|
return toSTAmount(iou, noIssue());
|
|
}
|
|
|
|
inline STAmount
|
|
toSTAmount(XRPAmount const& xrp)
|
|
{
|
|
bool const isNeg = xrp.signum() < 0;
|
|
std::uint64_t const umant = isNeg ? -xrp.drops() : xrp.drops();
|
|
return STAmount(umant, isNeg);
|
|
}
|
|
|
|
inline STAmount
|
|
toSTAmount(XRPAmount const& xrp, Issue const& iss)
|
|
{
|
|
XRPL_ASSERT(
|
|
isXRP(iss.account) && isXRP(iss.currency), "xrpl::toSTAmount : is XRP");
|
|
return toSTAmount(xrp);
|
|
}
|
|
|
|
template <class T>
|
|
T
|
|
toAmount(STAmount const& amt) = delete;
|
|
|
|
template <>
|
|
inline STAmount
|
|
toAmount<STAmount>(STAmount const& amt)
|
|
{
|
|
return amt;
|
|
}
|
|
|
|
template <>
|
|
inline IOUAmount
|
|
toAmount<IOUAmount>(STAmount const& amt)
|
|
{
|
|
XRPL_ASSERT(
|
|
amt.mantissa() < std::numeric_limits<std::int64_t>::max(),
|
|
"xrpl::toAmount<IOUAmount> : maximum mantissa");
|
|
bool const isNeg = amt.negative();
|
|
std::int64_t const sMant =
|
|
isNeg ? -std::int64_t(amt.mantissa()) : amt.mantissa();
|
|
|
|
XRPL_ASSERT(!isXRP(amt), "xrpl::toAmount<IOUAmount> : is not XRP");
|
|
return IOUAmount(sMant, amt.exponent());
|
|
}
|
|
|
|
template <>
|
|
inline XRPAmount
|
|
toAmount<XRPAmount>(STAmount const& amt)
|
|
{
|
|
XRPL_ASSERT(
|
|
amt.mantissa() < std::numeric_limits<std::int64_t>::max(),
|
|
"xrpl::toAmount<XRPAmount> : maximum mantissa");
|
|
bool const isNeg = amt.negative();
|
|
std::int64_t const sMant =
|
|
isNeg ? -std::int64_t(amt.mantissa()) : amt.mantissa();
|
|
|
|
XRPL_ASSERT(isXRP(amt), "xrpl::toAmount<XRPAmount> : is XRP");
|
|
return XRPAmount(sMant);
|
|
}
|
|
|
|
template <class T>
|
|
T
|
|
toAmount(IOUAmount const& amt) = delete;
|
|
|
|
template <>
|
|
inline IOUAmount
|
|
toAmount<IOUAmount>(IOUAmount const& amt)
|
|
{
|
|
return amt;
|
|
}
|
|
|
|
template <class T>
|
|
T
|
|
toAmount(XRPAmount const& amt) = delete;
|
|
|
|
template <>
|
|
inline XRPAmount
|
|
toAmount<XRPAmount>(XRPAmount const& amt)
|
|
{
|
|
return amt;
|
|
}
|
|
|
|
template <typename T>
|
|
T
|
|
toAmount(
|
|
Issue const& issue,
|
|
Number const& n,
|
|
Number::rounding_mode mode = Number::getround())
|
|
{
|
|
saveNumberRoundMode rm(Number::getround());
|
|
if (isXRP(issue))
|
|
Number::setround(mode);
|
|
|
|
if constexpr (std::is_same_v<IOUAmount, T>)
|
|
return IOUAmount(n);
|
|
else if constexpr (std::is_same_v<XRPAmount, T>)
|
|
return XRPAmount(static_cast<std::int64_t>(n));
|
|
else if constexpr (std::is_same_v<STAmount, T>)
|
|
{
|
|
if (isXRP(issue))
|
|
return STAmount(issue, static_cast<std::int64_t>(n));
|
|
return STAmount(issue, n);
|
|
}
|
|
else
|
|
{
|
|
constexpr bool alwaysFalse = !std::is_same_v<T, T>;
|
|
static_assert(alwaysFalse, "Unsupported type for toAmount");
|
|
}
|
|
}
|
|
|
|
template <typename T>
|
|
T
|
|
toMaxAmount(Issue const& issue)
|
|
{
|
|
if constexpr (std::is_same_v<IOUAmount, T>)
|
|
return IOUAmount(STAmount::cMaxValue, STAmount::cMaxOffset);
|
|
else if constexpr (std::is_same_v<XRPAmount, T>)
|
|
return XRPAmount(static_cast<std::int64_t>(STAmount::cMaxNativeN));
|
|
else if constexpr (std::is_same_v<STAmount, T>)
|
|
{
|
|
if (isXRP(issue))
|
|
return STAmount(
|
|
issue, static_cast<std::int64_t>(STAmount::cMaxNativeN));
|
|
return STAmount(issue, STAmount::cMaxValue, STAmount::cMaxOffset);
|
|
}
|
|
else
|
|
{
|
|
constexpr bool alwaysFalse = !std::is_same_v<T, T>;
|
|
static_assert(alwaysFalse, "Unsupported type for toMaxAmount");
|
|
}
|
|
}
|
|
|
|
inline STAmount
|
|
toSTAmount(
|
|
Issue const& issue,
|
|
Number const& n,
|
|
Number::rounding_mode mode = Number::getround())
|
|
{
|
|
return toAmount<STAmount>(issue, n, mode);
|
|
}
|
|
|
|
template <typename T>
|
|
Issue
|
|
getIssue(T const& amt)
|
|
{
|
|
if constexpr (std::is_same_v<IOUAmount, T>)
|
|
return noIssue();
|
|
else if constexpr (std::is_same_v<XRPAmount, T>)
|
|
return xrpIssue();
|
|
else if constexpr (std::is_same_v<STAmount, T>)
|
|
return amt.issue();
|
|
else
|
|
{
|
|
constexpr bool alwaysFalse = !std::is_same_v<T, T>;
|
|
static_assert(alwaysFalse, "Unsupported type for getIssue");
|
|
}
|
|
}
|
|
|
|
template <typename T>
|
|
constexpr T
|
|
get(STAmount const& a)
|
|
{
|
|
if constexpr (std::is_same_v<IOUAmount, T>)
|
|
return a.iou();
|
|
else if constexpr (std::is_same_v<XRPAmount, T>)
|
|
return a.xrp();
|
|
else if constexpr (std::is_same_v<STAmount, T>)
|
|
return a;
|
|
else
|
|
{
|
|
constexpr bool alwaysFalse = !std::is_same_v<T, T>;
|
|
static_assert(alwaysFalse, "Unsupported type for get");
|
|
}
|
|
}
|
|
|
|
} // namespace xrpl
|
|
|
|
#endif
|