mirror of
https://github.com/XRPLF/rippled.git
synced 2025-11-05 03:35:51 +00:00
3cbdf818a7
- Added a new Invariant: `ValidPseudoAccounts` which checks that all pseudo-accounts behave consistently through creation and updates, and that no "real" accounts look like pseudo-accounts (which means they don't have a 0 sequence).
- `to_short_string(base_uint)`. Like `to_string`, but only returns the first 8 characters. (Similar to how a git commit ID can be abbreviated.) Used as a wrapped sink to prefix most transaction-related messages. More can be added later.
- `XRPL_ASSERT_PARTS`. Convenience wrapper for `XRPL_ASSERT`, which takes the `function` and `description` as separate parameters.
- `SField::sMD_PseudoAccount`. Metadata option for `SField` definitions to indicate that the field, if set in an `AccountRoot` indicates that account is a pseudo-account. Removes the need for hard-coded field lists all over the place. Added the flag to `AMMID` and `VaultID`.
- Added functionality to `SField` ctor to detect both code and name collisions using asserts. And require all SFields to have a name
- Convenience type aliases `STLedgerEntry::const_pointer` and `STLedgerEntry::const_ref`. (`SLE` is an alias to `STLedgerEntry`.)
- Generalized `feeunit.h` (`TaggedFee`) into `unit.h` (`ValueUnit`) and added new "BIPS"-related tags for future use. Also refactored the type restrictions to use Concepts.
- Restructured `transactions.macro` to do two big things
1. Include the `#include` directives for transactor header files directly in the macro file. Removes the need to update `applySteps.cpp` and the resulting conflicts.
2. Added a `privileges` parameter to the `TRANSACTION` macro, which specifies some of the operations a transaction is allowed to do. These `privileges` are enforced by invariant checks. Again, removed the need to update scattered lists of transaction types in various checks.
- Unit tests:
1. Moved more helper functions into `TestHelpers.h` and `.cpp`.
2. Cleaned up the namespaces to prevent / mitigate random collisions and ambiguous symbols, particularly in unity builds.
3. Generalized `Env::balance` to add support for `MPTIssue` and `Asset`.
4. Added a set of helper classes to simplify `Env` transaction parameter classes: `JTxField`, `JTxFieldWrapper`, and a bunch of classes derived or aliased from it. For an example of how awesome it is, check the changes `src/test/jtx/escrow.h` for how much simpler the definitions are for `finish_time`, `cancel_time`, `condition`, and `fulfillment`.
5. Generalized several of the amount-related helper classes to understand `Asset`s.
6. `env.balance` for an MPT issuer will return a negative number (or 0) for consistency with IOUs.
105 lines
3.7 KiB
C++
105 lines
3.7 KiB
C++
//------------------------------------------------------------------------------
|
|
/*
|
|
This file is part of rippled: https://github.com/ripple/rippled
|
|
Copyright (c) 2018 Ripple Labs Inc.
|
|
|
|
Permission to use, copy, modify, and/or distribute this software for any
|
|
purpose with or without fee is hereby granted, provided that the above
|
|
copyright notice and this permission notice appear in all copies.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
|
ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
|
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
*/
|
|
//==============================================================================
|
|
|
|
#ifndef RIPPLE_BASICS_SAFE_CAST_H_INCLUDED
|
|
#define RIPPLE_BASICS_SAFE_CAST_H_INCLUDED
|
|
|
|
#include <type_traits>
|
|
|
|
namespace ripple {
|
|
|
|
// safe_cast adds compile-time checks to a static_cast to ensure that
|
|
// the destination can hold all values of the source. This is particularly
|
|
// handy when the source or destination is an enumeration type.
|
|
|
|
template <class Src, class Dest>
|
|
concept SafeToCast = (std::is_integral_v<Src> && std::is_integral_v<Dest>) &&
|
|
(std::is_signed<Src>::value || std::is_unsigned<Dest>::value) &&
|
|
(std::is_signed<Src>::value != std::is_signed<Dest>::value
|
|
? sizeof(Dest) > sizeof(Src)
|
|
: sizeof(Dest) >= sizeof(Src));
|
|
|
|
template <class Dest, class Src>
|
|
inline constexpr std::
|
|
enable_if_t<std::is_integral_v<Dest> && std::is_integral_v<Src>, Dest>
|
|
safe_cast(Src s) noexcept
|
|
{
|
|
static_assert(
|
|
std::is_signed_v<Dest> || std::is_unsigned_v<Src>,
|
|
"Cannot cast signed to unsigned");
|
|
constexpr unsigned not_same =
|
|
std::is_signed_v<Dest> != std::is_signed_v<Src>;
|
|
static_assert(
|
|
sizeof(Dest) >= sizeof(Src) + not_same,
|
|
"Destination is too small to hold all values of source");
|
|
return static_cast<Dest>(s);
|
|
}
|
|
|
|
template <class Dest, class Src>
|
|
inline constexpr std::
|
|
enable_if_t<std::is_enum_v<Dest> && std::is_integral_v<Src>, Dest>
|
|
safe_cast(Src s) noexcept
|
|
{
|
|
return static_cast<Dest>(safe_cast<std::underlying_type_t<Dest>>(s));
|
|
}
|
|
|
|
template <class Dest, class Src>
|
|
inline constexpr std::
|
|
enable_if_t<std::is_integral_v<Dest> && std::is_enum_v<Src>, Dest>
|
|
safe_cast(Src s) noexcept
|
|
{
|
|
return safe_cast<Dest>(static_cast<std::underlying_type_t<Src>>(s));
|
|
}
|
|
|
|
// unsafe_cast explicitly flags a static_cast as not necessarily able to hold
|
|
// all values of the source. It includes a compile-time check so that if
|
|
// underlying types become safe, it can be converted to a safe_cast.
|
|
|
|
template <class Dest, class Src>
|
|
inline constexpr std::
|
|
enable_if_t<std::is_integral_v<Dest> && std::is_integral_v<Src>, Dest>
|
|
unsafe_cast(Src s) noexcept
|
|
{
|
|
static_assert(
|
|
!SafeToCast<Src, Dest>,
|
|
"Only unsafe if casting signed to unsigned or "
|
|
"destination is too small");
|
|
return static_cast<Dest>(s);
|
|
}
|
|
|
|
template <class Dest, class Src>
|
|
inline constexpr std::
|
|
enable_if_t<std::is_enum_v<Dest> && std::is_integral_v<Src>, Dest>
|
|
unsafe_cast(Src s) noexcept
|
|
{
|
|
return static_cast<Dest>(unsafe_cast<std::underlying_type_t<Dest>>(s));
|
|
}
|
|
|
|
template <class Dest, class Src>
|
|
inline constexpr std::
|
|
enable_if_t<std::is_integral_v<Dest> && std::is_enum_v<Src>, Dest>
|
|
unsafe_cast(Src s) noexcept
|
|
{
|
|
return unsafe_cast<Dest>(static_cast<std::underlying_type_t<Src>>(s));
|
|
}
|
|
|
|
} // namespace ripple
|
|
|
|
#endif
|