From dd9e6053a03dcb7cdabbac03ce80850216211c8f Mon Sep 17 00:00:00 2001 From: Fomo <508629+shortthefomo@users.noreply.github.com> Date: Wed, 29 Apr 2026 13:28:00 +0900 Subject: [PATCH 1/6] =?UTF-8?q?fix:=20Expand=20the=20pathing=20tables=20an?= =?UTF-8?q?d=20lower=20weight=20on=20sabbxd,=20also=20return=20up=20?= =?UTF-8?q?=E2=80=A6=20(#723)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/test/app/Path_test.cpp | 162 +++++++++++++++++++++++++++++ src/xrpld/app/paths/PathRequest.h | 2 +- src/xrpld/app/paths/Pathfinder.cpp | 8 +- 3 files changed, 168 insertions(+), 4 deletions(-) diff --git a/src/test/app/Path_test.cpp b/src/test/app/Path_test.cpp index 1db15388f..ae7018947 100644 --- a/src/test/app/Path_test.cpp +++ b/src/test/app/Path_test.cpp @@ -20,6 +20,8 @@ #include #include #include +#include +#include #include #include #include @@ -573,6 +575,164 @@ public: BEAST_EXPECT(equal(sa, Account("alice")["USD"](5))); } + Json::Value + six_path_append_request_result() + { + using namespace jtx; + Env env = pathTestEnv(); + + Account A1{"A1"}; + Account A2{"A2"}; + Account G1{"G1"}; + Account G2{"G2"}; + Account M1{"M1"}; + Account M2{"M2"}; + Account M3{"M3"}; + Account M4{"M4"}; + Account M5{"M5"}; + Account M6{"M6"}; + Account MM{"MM"}; + + env.fund(XRP(1000), A1, A2, G1, G2, M1, M2, M3, M4, M5, M6, MM); + env.close(); + + env.trust(G1["HKD"](2000), A1); + env.trust(G2["HKD"](2000), A2); + + env.trust(G1["HKD"](100000), M1, M2, M3, M4, M5, M6, MM); + env.trust(G2["HKD"](100000), M1, M2, M3, M4, M5, M6, MM); + env.close(); + + env(pay(G1, A1, G1["HKD"](1000))); + + env(pay(G1, M1, G1["HKD"](10))); + env(pay(G1, M2, G1["HKD"](10))); + env(pay(G1, M3, G1["HKD"](10))); + env(pay(G1, M4, G1["HKD"](10))); + env(pay(G1, M5, G1["HKD"](10))); + env(pay(G1, M6, G1["HKD"](10))); + env(pay(G1, MM, G1["HKD"](1000))); + + env(pay(G2, M1, G2["HKD"](10))); + env(pay(G2, M2, G2["HKD"](10))); + env(pay(G2, M3, G2["HKD"](10))); + env(pay(G2, M4, G2["HKD"](10))); + env(pay(G2, M5, G2["HKD"](10))); + env(pay(G2, M6, G2["HKD"](10))); + env(pay(G2, MM, G2["HKD"](1000))); + env.close(); + + env(offer(MM, G1["HKD"](1000), G2["HKD"](100))); + env.close(); + + return find_paths_request( + env, A1, A2, A2["HKD"](60), std::nullopt, G1["HKD"].currency); + } + + void + pathfind_paths_computed_never_exceeds_six() + { + testcase("pathfind paths_computed never exceeds six"); + + auto const result = six_path_append_request_result(); + BEAST_EXPECT(result.isMember(jss::alternatives)); + if (!result.isMember(jss::alternatives)) + return; + + BEAST_EXPECT(result[jss::alternatives].isArray()); + if (!result[jss::alternatives].isArray()) + return; + + bool sawPathsComputed = false; + for (auto const& alt : result[jss::alternatives]) + { + if (!alt.isMember(jss::paths_computed)) + continue; + sawPathsComputed = true; + BEAST_EXPECT(alt[jss::paths_computed].isArray()); + if (alt[jss::paths_computed].isArray()) + BEAST_EXPECT(alt[jss::paths_computed].size() <= 6); + } + BEAST_EXPECT(sawPathsComputed); + } + + void + pathfind_can_return_six_paths_with_append() + { + testcase("pathfind can return six paths with append"); + using namespace jtx; + Env env = pathTestEnv(); + + Account A1{"A1"}; + Account A2{"A2"}; + Account G1{"G1"}; + Account G2{"G2"}; + Account M1{"M1"}; + Account M2{"M2"}; + Account M3{"M3"}; + Account M4{"M4"}; + Account M5{"M5"}; + Account M6{"M6"}; + Account MM{"MM"}; + + env.fund(XRP(1000), A1, A2, G1, G2, M1, M2, M3, M4, M5, M6, MM); + env.close(); + + env.trust(G1["HKD"](2000), A1); + env.trust(G2["HKD"](2000), A2); + + env.trust(G1["HKD"](100000), M1, M2, M3, M4, M5, M6, MM); + env.trust(G2["HKD"](100000), M1, M2, M3, M4, M5, M6, MM); + env.close(); + + env(pay(G1, A1, G1["HKD"](1000))); + + env(pay(G1, M1, G1["HKD"](10))); + env(pay(G1, M2, G1["HKD"](10))); + env(pay(G1, M3, G1["HKD"](10))); + env(pay(G1, M4, G1["HKD"](10))); + env(pay(G1, M5, G1["HKD"](10))); + env(pay(G1, M6, G1["HKD"](10))); + env(pay(G1, MM, G1["HKD"](1000))); + + env(pay(G2, M1, G2["HKD"](10))); + env(pay(G2, M2, G2["HKD"](10))); + env(pay(G2, M3, G2["HKD"](10))); + env(pay(G2, M4, G2["HKD"](10))); + env(pay(G2, M5, G2["HKD"](10))); + env(pay(G2, M6, G2["HKD"](10))); + env(pay(G2, MM, G2["HKD"](1000))); + env.close(); + + env(offer(MM, G1["HKD"](1000), G2["HKD"](100))); + env.close(); + + auto cache = std::make_shared( + env.current(), env.app().journal("RippleLineCache")); + Pathfinder pf( + cache, + A1.id(), + A2.id(), + G1["HKD"].currency, + std::nullopt, + A2["HKD"](60), + std::nullopt, + env.app()); + + BEAST_EXPECT(pf.findPaths(7)); + pf.computePathRanks(5); + + STPath fullLiquidityPath; + auto bestPaths = + pf.getBestPaths(5, fullLiquidityPath, STPathSet{}, A1.id()); + BEAST_EXPECT(bestPaths.size() == 5); + BEAST_EXPECT(!fullLiquidityPath.empty()); + + if (!fullLiquidityPath.empty()) + bestPaths.push_back(fullLiquidityPath); + BEAST_EXPECT(bestPaths.size() == 6); + } + void issues_path_negative_issue() { @@ -1381,6 +1541,8 @@ public: path_find_04(); path_find_05(); path_find_06(); + pathfind_paths_computed_never_exceeds_six(); + pathfind_can_return_six_paths_with_append(); } }; diff --git a/src/xrpld/app/paths/PathRequest.h b/src/xrpld/app/paths/PathRequest.h index 21f10d066..dc32c6a4d 100644 --- a/src/xrpld/app/paths/PathRequest.h +++ b/src/xrpld/app/paths/PathRequest.h @@ -170,7 +170,7 @@ private: std::chrono::steady_clock::time_point quick_reply_; std::chrono::steady_clock::time_point full_reply_; - static unsigned int const max_paths_ = 4; + static unsigned int const max_paths_ = 5; }; } // namespace ripple diff --git a/src/xrpld/app/paths/Pathfinder.cpp b/src/xrpld/app/paths/Pathfinder.cpp index 3732ee34e..aa9f8e3d9 100644 --- a/src/xrpld/app/paths/Pathfinder.cpp +++ b/src/xrpld/app/paths/Pathfinder.cpp @@ -1324,11 +1324,13 @@ Pathfinder::initPathTable() fillPaths( pt_nonXRP_to_XRP, - {{1, "sxd"}, // gateway buys XRP - {2, "saxd"}, // source -> gateway -> book(XRP) -> dest + {{1, "sxd"}, // gateway buys XRP + {2, "saxd"}, // source -> gateway -> book(XRP) -> dest + {5, "sabxd"}, // source -> gateway -> book -> book(XRP) -> dest {6, "saaxd"}, {7, "sbxd"}, - {8, "sabxd"}, + {8, + "sabbxd"}, // source -> gateway -> book -> book -> book(XRP) -> dest {9, "sabaxd"}}); // non-XRP to non-XRP (same currency) From 8dd17973d06529f2fd7199eb903acda7413bf382 Mon Sep 17 00:00:00 2001 From: tequ Date: Wed, 29 Apr 2026 15:41:52 +0900 Subject: [PATCH 2/6] Add hook header `ls_flags.h` and `tx_flags.h` (#717) --- .../workflows/verify-generated-headers.yml | 4 + hook/generate_lsflags.sh | 82 ++++++++++++ hook/generate_txflags.sh | 25 ++++ hook/hookapi.h | 3 + hook/ls_flags.h | 75 +++++++++++ hook/tx_flags.h | 117 ++++++++++++++++++ include/xrpl/protocol/TxFlags.h | 2 +- 7 files changed, 307 insertions(+), 1 deletion(-) create mode 100755 hook/generate_lsflags.sh create mode 100755 hook/generate_txflags.sh create mode 100644 hook/ls_flags.h create mode 100644 hook/tx_flags.h diff --git a/.github/workflows/verify-generated-headers.yml b/.github/workflows/verify-generated-headers.yml index 861d1d2a1..2d682fb58 100644 --- a/.github/workflows/verify-generated-headers.yml +++ b/.github/workflows/verify-generated-headers.yml @@ -18,6 +18,10 @@ jobs: generator: bash ./hook/generate_sfcodes.sh - target: hook/tts.h generator: ./hook/generate_tts.sh + - target: hook/ls_flags.h + generator: ./hook/generate_lsflags.sh + - target: hook/tx_flags.h + generator: ./hook/generate_txflags.sh runs-on: ubuntu-24.04 env: CLANG_VERSION: 18 diff --git a/hook/generate_lsflags.sh b/hook/generate_lsflags.sh new file mode 100755 index 000000000..50a69e8b8 --- /dev/null +++ b/hook/generate_lsflags.sh @@ -0,0 +1,82 @@ +#!/bin/bash +set -eu + +SCRIPT_DIR=$(dirname "$0") +SCRIPT_DIR=$(cd "$SCRIPT_DIR" && pwd) + +RIPPLED_ROOT="$SCRIPT_DIR/../include/xrpl" +LEDGER_FORMATS="$RIPPLED_ROOT/protocol/LedgerFormats.h" + +echo '// Generated using generate_lsflags.sh' +echo '' +echo '#ifndef HOOKLSFLAGS_INCLUDED' +echo '#define HOOKLSFLAGS_INCLUDED 1' +echo '' +awk ' + function ltrim(s) { sub(/^[[:space:]]+/, "", s); return s } + function rtrim(s) { sub(/[[:space:]]+$/, "", s); return s } + function trim(s) { return rtrim(ltrim(s)) } + + function flush_group() { + if (entry_count > 0 && group != "") { + printf "enum %s {\n", group + for (i = 1; i <= entry_count; i++) { + printf " %s,\n", entries[i] + } + printf "};\n" + } + delete entries + entry_count = 0 + } + + /enum LedgerSpecificFlags \{/ { inside = 1; next } + inside && /^\};/ { inside = 0; flush_group(); next } + !inside { next } + + # Group header comments: // ltFOO or // remarks + /^[[:space:]]*\/\/[[:space:]]*(lt[A-Z_]+|remarks)[[:space:]]*$/ { + flush_group() + line = $0 + sub(/.*\/\/[[:space:]]*/, "", line) + group = trim(line) + next + } + + # Skip pure comment lines (not group headers) + /^[[:space:]]*\/\// { next } + + # Skip blank lines + /^[[:space:]]*$/ { next } + + # Accumulate flag lines (handle multi-line values) + { + line = $0 + # Strip inline comments + sub(/\/\/.*/, "", line) + line = trim(line) + if (line == "") next + + if (pending != "") { + pending = pending " " line + } else { + pending = line + } + + # If line ends with comma, the entry is complete + if (pending ~ /,$/) { + # Remove trailing comma + sub(/,$/, "", pending) + entries[++entry_count] = pending + pending = "" + } + } + + BEGIN { + inside = 0 + group = "" + pending = "" + entry_count = 0 + } +' "$LEDGER_FORMATS" +echo '' +echo '#endif // HOOKLSFLAGS_INCLUDED' diff --git a/hook/generate_txflags.sh b/hook/generate_txflags.sh new file mode 100755 index 000000000..f20fcac66 --- /dev/null +++ b/hook/generate_txflags.sh @@ -0,0 +1,25 @@ +#!/bin/bash +set -eu + +SCRIPT_DIR=$(dirname "$0") +SCRIPT_DIR=$(cd "$SCRIPT_DIR" && pwd) + +RIPPLED_ROOT="$SCRIPT_DIR/../include/xrpl" +TX_FLAGS="$RIPPLED_ROOT/protocol/TxFlags.h" + +echo '// Generated using generate_txflags.sh' +echo '#include "ls_flags.h"' +echo '#include ' +echo '' +cat "$TX_FLAGS" | + awk ' + /^[[:space:]]*enum / { + if (count > 0) print "" + inside = 1 + count++ + } + inside { + print + if (/};/) inside = 0 + } + ' diff --git a/hook/hookapi.h b/hook/hookapi.h index eb9751f14..69890544b 100644 --- a/hook/hookapi.h +++ b/hook/hookapi.h @@ -49,4 +49,7 @@ #include "macro.h" #include "tts.h" +#include "ls_flags.h" +#include "tx_flags.h" + #endif diff --git a/hook/ls_flags.h b/hook/ls_flags.h new file mode 100644 index 000000000..2ce87f081 --- /dev/null +++ b/hook/ls_flags.h @@ -0,0 +1,75 @@ +// Generated using generate_lsflags.sh + +#ifndef HOOKLSFLAGS_INCLUDED +#define HOOKLSFLAGS_INCLUDED 1 + +enum ltACCOUNT_ROOT { + lsfPasswordSpent = 0x00010000, + lsfRequireDestTag = 0x00020000, + lsfRequireAuth = 0x00040000, + lsfDisallowXRP = 0x00080000, + lsfDisableMaster = 0x00100000, + lsfNoFreeze = 0x00200000, + lsfGlobalFreeze = 0x00400000, + lsfDefaultRipple = 0x00800000, + lsfDepositAuth = 0x01000000, + lsfTshCollect = 0x02000000, + lsfDisallowIncomingNFTokenOffer = 0x04000000, + lsfDisallowIncomingCheck = 0x08000000, + lsfDisallowIncomingPayChan = 0x10000000, + lsfDisallowIncomingTrustline = 0x20000000, + lsfURITokenIssuer = 0x40000000, + lsfDisallowIncomingRemit = 0x80000000, + lsfAllowTrustLineClawback = 0x00001000, +}; +enum ltOFFER { + lsfPassive = 0x00010000, + lsfSell = 0x00020000, +}; +enum ltRIPPLE_STATE { + lsfLowReserve = 0x00010000, + lsfHighReserve = 0x00020000, + lsfLowAuth = 0x00040000, + lsfHighAuth = 0x00080000, + lsfLowNoRipple = 0x00100000, + lsfHighNoRipple = 0x00200000, + lsfLowFreeze = 0x00400000, + lsfHighFreeze = 0x00800000, + lsfLowDeepFreeze = 0x02000000, + lsfHighDeepFreeze = 0x04000000, + lsfAMMNode = 0x01000000, +}; +enum ltSIGNER_LIST { + lsfOneOwnerCount = 0x00010000, +}; +enum ltDIR_NODE { + lsfNFTokenBuyOffers = 0x00000001, + lsfNFTokenSellOffers = 0x00000002, + lsfEmittedDir = 0x00000004, +}; +enum ltNFTOKEN_OFFER { + lsfSellNFToken = 0x00000001, +}; +enum ltURI_TOKEN { + lsfBurnable = 0x00000001, +}; +enum remarks { + lsfImmutable = 1, +}; +enum ltMPTOKEN_ISSUANCE { + lsfMPTLocked = 0x00000001, + lsfMPTCanLock = 0x00000002, + lsfMPTRequireAuth = 0x00000004, + lsfMPTCanEscrow = 0x00000008, + lsfMPTCanTrade = 0x00000010, + lsfMPTCanTransfer = 0x00000020, + lsfMPTCanClawback = 0x00000040, +}; +enum ltMPTOKEN { + lsfMPTAuthorized = 0x00000002, +}; +enum ltCREDENTIAL { + lsfAccepted = 0x00010000, +}; + +#endif // HOOKLSFLAGS_INCLUDED diff --git a/hook/tx_flags.h b/hook/tx_flags.h new file mode 100644 index 000000000..79ecd9be8 --- /dev/null +++ b/hook/tx_flags.h @@ -0,0 +1,117 @@ +// Generated using generate_txflags.sh +#include "ls_flags.h" +#include + +enum UniversalFlags : uint32_t { + tfFullyCanonicalSig = 0x80000000, +}; + +enum AccountSetFlags : uint32_t { + tfRequireDestTag = 0x00010000, + tfOptionalDestTag = 0x00020000, + tfRequireAuth = 0x00040000, + tfOptionalAuth = 0x00080000, + tfDisallowXRP = 0x00100000, + tfAllowXRP = 0x00200000, +}; + +enum AccountFlags : uint32_t { + asfRequireDest = 1, + asfRequireAuth = 2, + asfDisallowXRP = 3, + asfDisableMaster = 4, + asfAccountTxnID = 5, + asfNoFreeze = 6, + asfGlobalFreeze = 7, + asfDefaultRipple = 8, + asfDepositAuth = 9, + asfAuthorizedNFTokenMinter = 10, + asfTshCollect = 11, + asfDisallowIncomingNFTokenOffer = 12, + asfDisallowIncomingCheck = 13, + asfDisallowIncomingPayChan = 14, + asfDisallowIncomingTrustline = 15, + asfDisallowIncomingRemit = 16, + asfAllowTrustLineClawback = 17, +}; + +enum OfferCreateFlags : uint32_t { + tfPassive = 0x00010000, + tfImmediateOrCancel = 0x00020000, + tfFillOrKill = 0x00040000, + tfSell = 0x00080000, +}; + +enum PaymentFlags : uint32_t { + tfNoRippleDirect = 0x00010000, + tfPartialPayment = 0x00020000, + tfLimitQuality = 0x00040000, +}; + +enum TrustSetFlags : uint32_t { + tfSetfAuth = 0x00010000, + tfSetNoRipple = 0x00020000, + tfClearNoRipple = 0x00040000, + tfSetFreeze = 0x00100000, + tfClearFreeze = 0x00200000, + tfSetDeepFreeze = 0x00400000, + tfClearDeepFreeze = 0x00800000 +}; + +enum EnableAmendmentFlags : uint32_t { + tfGotMajority = 0x00010000, + tfLostMajority = 0x00020000, + tfTestSuite = 0x80000000, +}; + +enum PaymentChannelClaimFlags : uint32_t { + tfRenew = 0x00010000, + tfClose = 0x00020000, +}; + +enum NFTokenMintFlags : uint32_t { + tfBurnable = 0x00000001, + tfOnlyXRP = 0x00000002, + tfTrustLine = 0x00000004, + tfTransferable = 0x00000008, + tfMutable = 0x00000010, + tfStrongTSH = 0x00008000, +}; + +enum MPTokenIssuanceCreateFlags : uint32_t { + tfMPTCanLock = lsfMPTCanLock, + tfMPTRequireAuth = lsfMPTRequireAuth, + tfMPTCanEscrow = lsfMPTCanEscrow, + tfMPTCanTrade = lsfMPTCanTrade, + tfMPTCanTransfer = lsfMPTCanTransfer, + tfMPTCanClawback = lsfMPTCanClawback, +}; + +enum MPTokenAuthorizeFlags : uint32_t { + tfMPTUnauthorize = 0x00000001, +}; + +enum MPTokenIssuanceSetFlags : uint32_t { + tfMPTLock = 0x00000001, + tfMPTUnlock = 0x00000002, +}; + +enum NFTokenCreateOfferFlags : uint32_t { + tfSellNFToken = 0x00000001, +}; + +enum ClaimRewardFlags : uint32_t { + tfOptOut = 0x00000001, +}; + +enum CronSetFlags : uint32_t { + tfCronUnset = 0x00000001, +}; + +enum AMMClawbackFlags : uint32_t { + tfClawTwoAssets = 0x00000001, +}; + +enum BridgeModifyFlags : uint32_t { + tfClearAccountCreateAmount = 0x00010000, +}; diff --git a/include/xrpl/protocol/TxFlags.h b/include/xrpl/protocol/TxFlags.h index cb6634dae..01f807193 100644 --- a/include/xrpl/protocol/TxFlags.h +++ b/include/xrpl/protocol/TxFlags.h @@ -132,7 +132,7 @@ constexpr std::uint32_t tfTrustSetMask = tfClearFreeze | tfSetDeepFreeze | tfClearDeepFreeze); // EnableAmendment flags: -enum EnableAmendmentFlags : std::uint32_t { +enum EnableAmendmentFlags : uint32_t { tfGotMajority = 0x00010000, tfLostMajority = 0x00020000, tfTestSuite = 0x80000000, From 61138058a6d73912475328da1d432742437aa0a8 Mon Sep 17 00:00:00 2001 From: tequ Date: Wed, 29 Apr 2026 15:45:35 +0900 Subject: [PATCH 3/6] Delete unused `sfHookDefinition` (#715) --- hook/sfcodes.h | 1 - include/xrpl/protocol/detail/sfields.macro | 2 +- src/libxrpl/protocol/InnerObjectFormats.cpp | 13 ------------- src/test/protocol/Hooks_test.cpp | 1 - src/xrpld/app/tx/detail/SetHook.cpp | 4 ++-- 5 files changed, 3 insertions(+), 18 deletions(-) diff --git a/hook/sfcodes.h b/hook/sfcodes.h index d1e76221d..94827a7a3 100644 --- a/hook/sfcodes.h +++ b/hook/sfcodes.h @@ -274,7 +274,6 @@ #define sfDisabledValidator ((14U << 16U) + 19U) #define sfEmittedTxn ((14U << 16U) + 20U) #define sfHookExecution ((14U << 16U) + 21U) -#define sfHookDefinition ((14U << 16U) + 22U) #define sfHookParameter ((14U << 16U) + 23U) #define sfHookGrant ((14U << 16U) + 24U) #define sfVoteEntry ((14U << 16U) + 25U) diff --git a/include/xrpl/protocol/detail/sfields.macro b/include/xrpl/protocol/detail/sfields.macro index 1db05de3d..0bfcdbae4 100644 --- a/include/xrpl/protocol/detail/sfields.macro +++ b/include/xrpl/protocol/detail/sfields.macro @@ -367,7 +367,7 @@ UNTYPED_SFIELD(sfMajority, OBJECT, 18) UNTYPED_SFIELD(sfDisabledValidator, OBJECT, 19) UNTYPED_SFIELD(sfEmittedTxn, OBJECT, 20) UNTYPED_SFIELD(sfHookExecution, OBJECT, 21) -UNTYPED_SFIELD(sfHookDefinition, OBJECT, 22) + // 22 unused UNTYPED_SFIELD(sfHookParameter, OBJECT, 23) UNTYPED_SFIELD(sfHookGrant, OBJECT, 24) UNTYPED_SFIELD(sfVoteEntry, OBJECT, 25) diff --git a/src/libxrpl/protocol/InnerObjectFormats.cpp b/src/libxrpl/protocol/InnerObjectFormats.cpp index ea0f59851..55ef5c609 100644 --- a/src/libxrpl/protocol/InnerObjectFormats.cpp +++ b/src/libxrpl/protocol/InnerObjectFormats.cpp @@ -87,19 +87,6 @@ InnerObjectFormats::InnerObjectFormats() {sfEmittedTxnID, soeREQUIRED}, {sfEmitNonce, soeOPTIONAL}}); - add(sfHookDefinition.jsonName, - sfHookDefinition.getCode(), - {{sfCreateCode, soeREQUIRED}, - {sfHookNamespace, soeREQUIRED}, - {sfHookParameters, soeREQUIRED}, - {sfHookOn, soeOPTIONAL}, - {sfHookOnIncoming, soeOPTIONAL}, - {sfHookOnOutgoing, soeOPTIONAL}, - {sfHookCanEmit, soeOPTIONAL}, - {sfHookApiVersion, soeREQUIRED}, - {sfFlags, soeREQUIRED}, - {sfFee, soeREQUIRED}}); - add(sfHook.jsonName, sfHook.getCode(), {{sfHookHash, soeOPTIONAL}, diff --git a/src/test/protocol/Hooks_test.cpp b/src/test/protocol/Hooks_test.cpp index fb61d10a7..78c1b0d28 100644 --- a/src/test/protocol/Hooks_test.cpp +++ b/src/test/protocol/Hooks_test.cpp @@ -69,7 +69,6 @@ class Hooks_test : public beast::unit_test::suite sfHookAccount, sfEmittedTxn, sfHook, - sfHookDefinition, sfHookParameter, sfHookGrant, sfEmitDetails, diff --git a/src/xrpld/app/tx/detail/SetHook.cpp b/src/xrpld/app/tx/detail/SetHook.cpp index 3e1a48a4e..c7f2ffd6a 100644 --- a/src/xrpld/app/tx/detail/SetHook.cpp +++ b/src/xrpld/app/tx/detail/SetHook.cpp @@ -425,7 +425,7 @@ SetHook::validateHookSetEntry(SetHookCtx& ctx, STObject const& hookSetObj) JLOG(ctx.j.trace()) << "HookSet(" << hook::log::NAMESPACE_MISSING << ")[" << HS_ACC() - << "]: Malformed transaction: SetHook sfHookDefinition " + << "]: Malformed transaction: SetHook ltHookDefinition " "must contain sfHookNamespace."; return false; } @@ -2001,7 +2001,7 @@ SetHook::setHook() // sfHookHash, sfHookNamespace, sfHookOn, sfHookOnOutgoing, // sfHookOnIncoming, sfHookCanEmit sfHookApiVersion, sfFlags: free - // sfHookDefinition is not reserved because it is an unowned object, + // ltHookDefinition is not reserved because it is an unowned object, // rather the uploader is billed via fee according to the following: // sfCreateCode: 5000 drops per byte // sfHookParameters: 5000 drops per byte From 0ffb6e8c2115266239e5372d5afb1a60a85be2da Mon Sep 17 00:00:00 2001 From: tequ Date: Wed, 29 Apr 2026 16:00:25 +0900 Subject: [PATCH 4/6] Replace vendored magic_enum header with Conan package dependency (#727) --- .github/workflows/clang-format.yml | 2 +- CMakeLists.txt | 1 + cmake/RippledCore.cmake | 1 + conanfile.py | 1 + src/magic/magic_enum.h | 1474 ------------------ src/xrpld/rpc/handlers/ServerDefinitions.cpp | 2 +- 6 files changed, 5 insertions(+), 1476 deletions(-) delete mode 100644 src/magic/magic_enum.h diff --git a/.github/workflows/clang-format.yml b/.github/workflows/clang-format.yml index c17607612..107b32fbf 100644 --- a/.github/workflows/clang-format.yml +++ b/.github/workflows/clang-format.yml @@ -20,7 +20,7 @@ jobs: sudo apt-get update sudo apt-get install clang-format-${CLANG_VERSION} - name: Format first-party sources - run: find include src -type f \( -name '*.cpp' -o -name '*.hpp' -o -name '*.h' -o -name '*.ipp' \) -not -path "src/magic/magic_enum.h" -exec clang-format-${CLANG_VERSION} -i {} + + run: find include src -type f \( -name '*.cpp' -o -name '*.hpp' -o -name '*.h' -o -name '*.ipp' \) -exec clang-format-${CLANG_VERSION} -i {} + - name: Check for differences id: assert run: | diff --git a/CMakeLists.txt b/CMakeLists.txt index e7cb9ddc4..532ad14d8 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -122,6 +122,7 @@ endif() find_package(nudb REQUIRED) find_package(date REQUIRED) find_package(xxHash REQUIRED) +find_package(magic_enum REQUIRED) include(deps/WasmEdge) if(TARGET nudb::core) diff --git a/cmake/RippledCore.cmake b/cmake/RippledCore.cmake index f4b070e0f..2d593599c 100644 --- a/cmake/RippledCore.cmake +++ b/cmake/RippledCore.cmake @@ -54,6 +54,7 @@ add_library(xrpl.imports.main INTERFACE) target_link_libraries(xrpl.imports.main INTERFACE LibArchive::LibArchive + magic_enum::magic_enum OpenSSL::Crypto Ripple::boost wasmedge::wasmedge diff --git a/conanfile.py b/conanfile.py index ffbae750d..ccf8332a5 100644 --- a/conanfile.py +++ b/conanfile.py @@ -29,6 +29,7 @@ class Xrpl(ConanFile): 'date/3.0.3', 'grpc/1.50.1', 'libarchive/3.7.6', + 'magic_enum/0.9.5', 'nudb/2.0.8', 'openssl/3.6.0', 'soci/4.0.3@xahaud/stable', diff --git a/src/magic/magic_enum.h b/src/magic/magic_enum.h deleted file mode 100644 index 7adf87715..000000000 --- a/src/magic/magic_enum.h +++ /dev/null @@ -1,1474 +0,0 @@ -// __ __ _ ______ _____ -// | \/ | (_) | ____| / ____|_ _ -// | \ / | __ _ __ _ _ ___ | |__ _ __ _ _ _ __ ___ | | _| |_ _| |_ -// | |\/| |/ _` |/ _` | |/ __| | __| | '_ \| | | | '_ ` _ \ | | |_ _|_ _| -// | | | | (_| | (_| | | (__ | |____| | | | |_| | | | | | | | |____|_| |_| -// |_| |_|\__,_|\__, |_|\___| |______|_| |_|\__,_|_| |_| |_| \_____| -// __/ | https://github.com/Neargye/magic_enum -// |___/ version 0.9.5 -// -// Licensed under the MIT License . -// SPDX-License-Identifier: MIT -// Copyright (c) 2019 - 2024 Daniil Goncharov . -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in all -// copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -// SOFTWARE. - -#ifndef NEARGYE_MAGIC_ENUM_HPP -#define NEARGYE_MAGIC_ENUM_HPP - -#define MAGIC_ENUM_VERSION_MAJOR 0 -#define MAGIC_ENUM_VERSION_MINOR 9 -#define MAGIC_ENUM_VERSION_PATCH 5 - -#include -#include -#include -#include -#include -#include -#include - -#if defined(MAGIC_ENUM_CONFIG_FILE) -# include MAGIC_ENUM_CONFIG_FILE -#endif - -#if !defined(MAGIC_ENUM_USING_ALIAS_OPTIONAL) -# include -#endif -#if !defined(MAGIC_ENUM_USING_ALIAS_STRING) -# include -#endif -#if !defined(MAGIC_ENUM_USING_ALIAS_STRING_VIEW) -# include -#endif - -#if defined(MAGIC_ENUM_NO_ASSERT) -# define MAGIC_ENUM_ASSERT(...) static_cast(0) -#elif !defined(MAGIC_ENUM_ASSERT) -# include -# define MAGIC_ENUM_ASSERT(...) assert((__VA_ARGS__)) -#endif - -#if defined(__clang__) -# pragma clang diagnostic push -# pragma clang diagnostic ignored "-Wunknown-warning-option" -# pragma clang diagnostic ignored "-Wenum-constexpr-conversion" -# pragma clang diagnostic ignored "-Wuseless-cast" // suppresses 'static_cast('\0')' for char_type = char (common on Linux). -#elif defined(__GNUC__) -# pragma GCC diagnostic push -# pragma GCC diagnostic ignored "-Wmaybe-uninitialized" // May be used uninitialized 'return {};'. -# pragma GCC diagnostic ignored "-Wuseless-cast" // suppresses 'static_cast('\0')' for char_type = char (common on Linux). -#elif defined(_MSC_VER) -# pragma warning(push) -# pragma warning(disable : 26495) // Variable 'static_str::chars_' is uninitialized. -# pragma warning(disable : 28020) // Arithmetic overflow: Using operator '-' on a 4 byte value and then casting the result to a 8 byte value. -# pragma warning(disable : 26451) // The expression '0<=_Param_(1)&&_Param_(1)<=1-1' is not true at this call. -# pragma warning(disable : 4514) // Unreferenced inline function has been removed. -#endif - -// Checks magic_enum compiler compatibility. -#if defined(__clang__) && __clang_major__ >= 5 || defined(__GNUC__) && __GNUC__ >= 9 || defined(_MSC_VER) && _MSC_VER >= 1910 || defined(__RESHARPER__) -# undef MAGIC_ENUM_SUPPORTED -# define MAGIC_ENUM_SUPPORTED 1 -#endif - -// Checks magic_enum compiler aliases compatibility. -#if defined(__clang__) && __clang_major__ >= 5 || defined(__GNUC__) && __GNUC__ >= 9 || defined(_MSC_VER) && _MSC_VER >= 1920 -# undef MAGIC_ENUM_SUPPORTED_ALIASES -# define MAGIC_ENUM_SUPPORTED_ALIASES 1 -#endif - -// Enum value must be greater or equals than MAGIC_ENUM_RANGE_MIN. By default MAGIC_ENUM_RANGE_MIN = -128. -// If need another min range for all enum types by default, redefine the macro MAGIC_ENUM_RANGE_MIN. -#if !defined(MAGIC_ENUM_RANGE_MIN) -# define MAGIC_ENUM_RANGE_MIN -128 -#endif - -// Enum value must be less or equals than MAGIC_ENUM_RANGE_MAX. By default MAGIC_ENUM_RANGE_MAX = 128. -// If need another max range for all enum types by default, redefine the macro MAGIC_ENUM_RANGE_MAX. -#if !defined(MAGIC_ENUM_RANGE_MAX) -# define MAGIC_ENUM_RANGE_MAX 127 -#endif - -// Improve ReSharper C++ intellisense performance with builtins, avoiding unnecessary template instantiations. -#if defined(__RESHARPER__) -# undef MAGIC_ENUM_GET_ENUM_NAME_BUILTIN -# undef MAGIC_ENUM_GET_TYPE_NAME_BUILTIN -# if __RESHARPER__ >= 20230100 -# define MAGIC_ENUM_GET_ENUM_NAME_BUILTIN(V) __rscpp_enumerator_name(V) -# define MAGIC_ENUM_GET_TYPE_NAME_BUILTIN(T) __rscpp_type_name() -# else -# define MAGIC_ENUM_GET_ENUM_NAME_BUILTIN(V) nullptr -# define MAGIC_ENUM_GET_TYPE_NAME_BUILTIN(T) nullptr -# endif -#endif - -namespace magic_enum { - -// If need another optional type, define the macro MAGIC_ENUM_USING_ALIAS_OPTIONAL. -#if defined(MAGIC_ENUM_USING_ALIAS_OPTIONAL) -MAGIC_ENUM_USING_ALIAS_OPTIONAL -#else -using std::optional; -#endif - -// If need another string_view type, define the macro MAGIC_ENUM_USING_ALIAS_STRING_VIEW. -#if defined(MAGIC_ENUM_USING_ALIAS_STRING_VIEW) -MAGIC_ENUM_USING_ALIAS_STRING_VIEW -#else -using std::string_view; -#endif - -// If need another string type, define the macro MAGIC_ENUM_USING_ALIAS_STRING. -#if defined(MAGIC_ENUM_USING_ALIAS_STRING) -MAGIC_ENUM_USING_ALIAS_STRING -#else -using std::string; -#endif - -using char_type = string_view::value_type; -static_assert(std::is_same_v, "magic_enum::customize requires same string_view::value_type and string::value_type"); -static_assert([] { - if constexpr (std::is_same_v) { - constexpr const char c[] = "abcdefghijklmnopqrstuvwxyz_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789|"; - constexpr const wchar_t wc[] = L"abcdefghijklmnopqrstuvwxyz_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789|"; - static_assert(std::size(c) == std::size(wc), "magic_enum::customize identifier characters are multichars in wchar_t."); - - for (std::size_t i = 0; i < std::size(c); ++i) { - if (c[i] != wc[i]) { - return false; - } - } - } - return true; -} (), "magic_enum::customize wchar_t is not compatible with ASCII."); - -namespace customize { - -// Enum value must be in range [MAGIC_ENUM_RANGE_MIN, MAGIC_ENUM_RANGE_MAX]. By default MAGIC_ENUM_RANGE_MIN = -128, MAGIC_ENUM_RANGE_MAX = 128. -// If need another range for all enum types by default, redefine the macro MAGIC_ENUM_RANGE_MIN and MAGIC_ENUM_RANGE_MAX. -// If need another range for specific enum type, add specialization enum_range for necessary enum type. -template -struct enum_range { - static constexpr int min = MAGIC_ENUM_RANGE_MIN; - static constexpr int max = MAGIC_ENUM_RANGE_MAX; -}; - -static_assert(MAGIC_ENUM_RANGE_MAX > MAGIC_ENUM_RANGE_MIN, "MAGIC_ENUM_RANGE_MAX must be greater than MAGIC_ENUM_RANGE_MIN."); - -namespace detail { - -enum class customize_tag { - default_tag, - invalid_tag, - custom_tag -}; - -} // namespace magic_enum::customize::detail - -class customize_t : public std::pair { - public: - constexpr customize_t(string_view srt) : std::pair{detail::customize_tag::custom_tag, srt} {} - constexpr customize_t(const char_type* srt) : customize_t{string_view{srt}} {} - constexpr customize_t(detail::customize_tag tag) : std::pair{tag, string_view{}} { - MAGIC_ENUM_ASSERT(tag != detail::customize_tag::custom_tag); - } -}; - -// Default customize. -inline constexpr auto default_tag = customize_t{detail::customize_tag::default_tag}; -// Invalid customize. -inline constexpr auto invalid_tag = customize_t{detail::customize_tag::invalid_tag}; - -// If need custom names for enum, add specialization enum_name for necessary enum type. -template -constexpr customize_t enum_name(E) noexcept { - return default_tag; -} - -// If need custom type name for enum, add specialization enum_type_name for necessary enum type. -template -constexpr customize_t enum_type_name() noexcept { - return default_tag; -} - -} // namespace magic_enum::customize - -namespace detail { - -template -struct supported -#if defined(MAGIC_ENUM_SUPPORTED) && MAGIC_ENUM_SUPPORTED || defined(MAGIC_ENUM_NO_CHECK_SUPPORT) - : std::true_type {}; -#else - : std::false_type {}; -#endif - -template , std::enable_if_t, int> = 0> -using enum_constant = std::integral_constant; - -template -inline constexpr bool always_false_v = false; - -template -struct has_is_flags : std::false_type {}; - -template -struct has_is_flags::is_flags)>> : std::bool_constant::is_flags)>>> {}; - -template -struct range_min : std::integral_constant {}; - -template -struct range_min::min)>> : std::integral_constant::min), customize::enum_range::min> {}; - -template -struct range_max : std::integral_constant {}; - -template -struct range_max::max)>> : std::integral_constant::max), customize::enum_range::max> {}; - -struct str_view { - const char* str_ = nullptr; - std::size_t size_ = 0; -}; - -template -class static_str { - public: - constexpr explicit static_str(str_view str) noexcept : static_str{str.str_, std::make_integer_sequence{}} { - MAGIC_ENUM_ASSERT(str.size_ == N); - } - - constexpr explicit static_str(string_view str) noexcept : static_str{str.data(), std::make_integer_sequence{}} { - MAGIC_ENUM_ASSERT(str.size() == N); - } - - constexpr const char_type* data() const noexcept { return chars_; } - - constexpr std::uint16_t size() const noexcept { return N; } - - constexpr operator string_view() const noexcept { return {data(), size()}; } - - private: - template - constexpr static_str(const char* str, std::integer_sequence) noexcept : chars_{static_cast(str[I])..., static_cast('\0')} {} - - template - constexpr static_str(string_view str, std::integer_sequence) noexcept : chars_{str[I]..., static_cast('\0')} {} - - char_type chars_[static_cast(N) + 1]; -}; - -template <> -class static_str<0> { - public: - constexpr explicit static_str() = default; - - constexpr explicit static_str(str_view) noexcept {} - - constexpr explicit static_str(string_view) noexcept {} - - constexpr const char_type* data() const noexcept { return nullptr; } - - constexpr std::uint16_t size() const noexcept { return 0; } - - constexpr operator string_view() const noexcept { return {}; } -}; - -template > -class case_insensitive { - static constexpr char_type to_lower(char_type c) noexcept { - return (c >= static_cast('A') && c <= static_cast('Z')) ? static_cast(c + (static_cast('a') - static_cast('A'))) : c; - } - - public: - template - constexpr auto operator()(L lhs, R rhs) const noexcept -> std::enable_if_t, char_type> && std::is_same_v, char_type>, bool> { - return Op{}(to_lower(lhs), to_lower(rhs)); - } -}; - -constexpr std::size_t find(string_view str, char_type c) noexcept { -#if defined(__clang__) && __clang_major__ < 9 && defined(__GLIBCXX__) || defined(_MSC_VER) && _MSC_VER < 1920 && !defined(__clang__) -// https://stackoverflow.com/questions/56484834/constexpr-stdstring-viewfind-last-of-doesnt-work-on-clang-8-with-libstdc -// https://developercommunity.visualstudio.com/content/problem/360432/vs20178-regression-c-failed-in-test.html - constexpr bool workaround = true; -#else - constexpr bool workaround = false; -#endif - - if constexpr (workaround) { - for (std::size_t i = 0; i < str.size(); ++i) { - if (str[i] == c) { - return i; - } - } - - return string_view::npos; - } else { - return str.find(c); - } -} - -template -constexpr bool is_default_predicate() noexcept { - return std::is_same_v, std::equal_to> || - std::is_same_v, std::equal_to<>>; -} - -template -constexpr bool is_nothrow_invocable() { - return is_default_predicate() || - std::is_nothrow_invocable_r_v; -} - -template -constexpr bool cmp_equal(string_view lhs, string_view rhs, [[maybe_unused]] BinaryPredicate&& p) noexcept(is_nothrow_invocable()) { -#if defined(_MSC_VER) && _MSC_VER < 1920 && !defined(__clang__) - // https://developercommunity.visualstudio.com/content/problem/360432/vs20178-regression-c-failed-in-test.html - // https://developercommunity.visualstudio.com/content/problem/232218/c-constexpr-string-view.html - constexpr bool workaround = true; -#else - constexpr bool workaround = false; -#endif - - if constexpr (!is_default_predicate() || workaround) { - if (lhs.size() != rhs.size()) { - return false; - } - - const auto size = lhs.size(); - for (std::size_t i = 0; i < size; ++i) { - if (!p(lhs[i], rhs[i])) { - return false; - } - } - - return true; - } else { - return lhs == rhs; - } -} - -template -constexpr bool cmp_less(L lhs, R rhs) noexcept { - static_assert(std::is_integral_v && std::is_integral_v, "magic_enum::detail::cmp_less requires integral type."); - - if constexpr (std::is_signed_v == std::is_signed_v) { - // If same signedness (both signed or both unsigned). - return lhs < rhs; - } else if constexpr (std::is_same_v) { // bool special case - return static_cast(lhs) < rhs; - } else if constexpr (std::is_same_v) { // bool special case - return lhs < static_cast(rhs); - } else if constexpr (std::is_signed_v) { - // If 'right' is negative, then result is 'false', otherwise cast & compare. - return rhs > 0 && lhs < static_cast>(rhs); - } else { - // If 'left' is negative, then result is 'true', otherwise cast & compare. - return lhs < 0 || static_cast>(lhs) < rhs; - } -} - -template -constexpr I log2(I value) noexcept { - static_assert(std::is_integral_v, "magic_enum::detail::log2 requires integral type."); - - if constexpr (std::is_same_v) { // bool special case - return MAGIC_ENUM_ASSERT(false), value; - } else { - auto ret = I{0}; - for (; value > I{1}; value >>= I{1}, ++ret) {} - - return ret; - } -} - -#if defined(__cpp_lib_array_constexpr) && __cpp_lib_array_constexpr >= 201603L -# define MAGIC_ENUM_ARRAY_CONSTEXPR 1 -#else -template -constexpr std::array, N> to_array(T (&a)[N], std::index_sequence) noexcept { - return {{a[I]...}}; -} -#endif - -template -inline constexpr bool is_enum_v = std::is_enum_v && std::is_same_v>; - -template -constexpr auto n() noexcept { - static_assert(is_enum_v, "magic_enum::detail::n requires enum type."); - - if constexpr (supported::value) { -#if defined(MAGIC_ENUM_GET_TYPE_NAME_BUILTIN) - constexpr auto name_ptr = MAGIC_ENUM_GET_TYPE_NAME_BUILTIN(E); - constexpr auto name = name_ptr ? str_view{name_ptr, std::char_traits::length(name_ptr)} : str_view{}; -#elif defined(__clang__) - str_view name; - if constexpr (sizeof(__PRETTY_FUNCTION__) == sizeof(__FUNCTION__)) { - static_assert(always_false_v, "magic_enum::detail::n requires __PRETTY_FUNCTION__."); - return str_view{}; - } else { - name.size_ = sizeof(__PRETTY_FUNCTION__) - 36; - name.str_ = __PRETTY_FUNCTION__ + 34; - } -#elif defined(__GNUC__) - auto name = str_view{__PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1}; - if constexpr (sizeof(__PRETTY_FUNCTION__) == sizeof(__FUNCTION__)) { - static_assert(always_false_v, "magic_enum::detail::n requires __PRETTY_FUNCTION__."); - return str_view{}; - } else if (name.str_[name.size_ - 1] == ']') { - name.size_ -= 50; - name.str_ += 49; - } else { - name.size_ -= 40; - name.str_ += 37; - } -#elif defined(_MSC_VER) - // CLI/C++ workaround (see https://github.com/Neargye/magic_enum/issues/284). - str_view name; - name.str_ = __FUNCSIG__; - name.str_ += 40; - name.size_ += sizeof(__FUNCSIG__) - 57; -#else - auto name = str_view{}; -#endif - std::size_t p = 0; - for (std::size_t i = name.size_; i > 0; --i) { - if (name.str_[i] == ':') { - p = i + 1; - break; - } - } - if (p > 0) { - name.size_ -= p; - name.str_ += p; - } - return name; - } else { - return str_view{}; // Unsupported compiler or Invalid customize. - } -} - -template -constexpr auto type_name() noexcept { - [[maybe_unused]] constexpr auto custom = customize::enum_type_name(); - static_assert(std::is_same_v, customize::customize_t>, "magic_enum::customize requires customize_t type."); - if constexpr (custom.first == customize::detail::customize_tag::custom_tag) { - constexpr auto name = custom.second; - static_assert(!name.empty(), "magic_enum::customize requires not empty string."); - return static_str{name}; - } else if constexpr (custom.first == customize::detail::customize_tag::invalid_tag) { - return static_str<0>{}; - } else if constexpr (custom.first == customize::detail::customize_tag::default_tag) { - constexpr auto name = n(); - return static_str{name}; - } else { - static_assert(always_false_v, "magic_enum::customize invalid."); - } -} - -template -inline constexpr auto type_name_v = type_name(); - -template -constexpr auto n() noexcept { - static_assert(is_enum_v, "magic_enum::detail::n requires enum type."); - - if constexpr (supported::value) { -#if defined(MAGIC_ENUM_GET_ENUM_NAME_BUILTIN) - constexpr auto name_ptr = MAGIC_ENUM_GET_ENUM_NAME_BUILTIN(V); - auto name = name_ptr ? str_view{name_ptr, std::char_traits::length(name_ptr)} : str_view{}; -#elif defined(__clang__) - str_view name; - if constexpr (sizeof(__PRETTY_FUNCTION__) == sizeof(__FUNCTION__)) { - static_assert(always_false_v, "magic_enum::detail::n requires __PRETTY_FUNCTION__."); - return str_view{}; - } else { - name.size_ = sizeof(__PRETTY_FUNCTION__) - 36; - name.str_ = __PRETTY_FUNCTION__ + 34; - } - if (name.size_ > 22 && name.str_[0] == '(' && name.str_[1] == 'a' && name.str_[10] == ' ' && name.str_[22] == ':') { - name.size_ -= 23; - name.str_ += 23; - } - if (name.str_[0] == '(' || name.str_[0] == '-' || (name.str_[0] >= '0' && name.str_[0] <= '9')) { - name = str_view{}; - } -#elif defined(__GNUC__) - auto name = str_view{__PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 1}; - if constexpr (sizeof(__PRETTY_FUNCTION__) == sizeof(__FUNCTION__)) { - static_assert(always_false_v, "magic_enum::detail::n requires __PRETTY_FUNCTION__."); - return str_view{}; - } else if (name.str_[name.size_ - 1] == ']') { - name.size_ -= 55; - name.str_ += 54; - } else { - name.size_ -= 40; - name.str_ += 37; - } - if (name.str_[0] == '(') { - name = str_view{}; - } -#elif defined(_MSC_VER) - str_view name; - if ((__FUNCSIG__[5] == '_' && __FUNCSIG__[35] != '(') || (__FUNCSIG__[5] == 'c' && __FUNCSIG__[41] != '(')) { - // CLI/C++ workaround (see https://github.com/Neargye/magic_enum/issues/284). - name.str_ = __FUNCSIG__; - name.str_ += 35; - name.size_ = sizeof(__FUNCSIG__) - 52; - } -#else - auto name = str_view{}; -#endif - std::size_t p = 0; - for (std::size_t i = name.size_; i > 0; --i) { - if (name.str_[i] == ':') { - p = i + 1; - break; - } - } - if (p > 0) { - name.size_ -= p; - name.str_ += p; - } - return name; - } else { - return str_view{}; // Unsupported compiler or Invalid customize. - } -} - -#if defined(_MSC_VER) && !defined(__clang__) && _MSC_VER < 1920 -# define MAGIC_ENUM_VS_2017_WORKAROUND 1 -#endif - -#if defined(MAGIC_ENUM_VS_2017_WORKAROUND) -template -constexpr auto n() noexcept { - static_assert(is_enum_v, "magic_enum::detail::n requires enum type."); - -# if defined(MAGIC_ENUM_GET_ENUM_NAME_BUILTIN) - constexpr auto name_ptr = MAGIC_ENUM_GET_ENUM_NAME_BUILTIN(V); - auto name = name_ptr ? str_view{name_ptr, std::char_traits::length(name_ptr)} : str_view{}; -# else - // CLI/C++ workaround (see https://github.com/Neargye/magic_enum/issues/284). - str_view name; - name.str_ = __FUNCSIG__; - name.size_ = sizeof(__FUNCSIG__) - 17; - std::size_t p = 0; - for (std::size_t i = name.size_; i > 0; --i) { - if (name.str_[i] == ',' || name.str_[i] == ':') { - p = i + 1; - break; - } - } - if (p > 0) { - name.size_ -= p; - name.str_ += p; - } - if (name.str_[0] == '(' || name.str_[0] == '-' || (name.str_[0] >= '0' && name.str_[0] <= '9')) { - name = str_view{}; - } - return name; -# endif -} -#endif - -template -constexpr auto enum_name() noexcept { - [[maybe_unused]] constexpr auto custom = customize::enum_name(V); - static_assert(std::is_same_v, customize::customize_t>, "magic_enum::customize requires customize_t type."); - if constexpr (custom.first == customize::detail::customize_tag::custom_tag) { - constexpr auto name = custom.second; - static_assert(!name.empty(), "magic_enum::customize requires not empty string."); - return static_str{name}; - } else if constexpr (custom.first == customize::detail::customize_tag::invalid_tag) { - return static_str<0>{}; - } else if constexpr (custom.first == customize::detail::customize_tag::default_tag) { -#if defined(MAGIC_ENUM_VS_2017_WORKAROUND) - constexpr auto name = n(); -#else - constexpr auto name = n(); -#endif - return static_str{name}; - } else { - static_assert(always_false_v, "magic_enum::customize invalid."); - } -} - -template -inline constexpr auto enum_name_v = enum_name(); - -template -constexpr bool is_valid() noexcept { -#if defined(__clang__) && __clang_major__ >= 16 - // https://reviews.llvm.org/D130058, https://reviews.llvm.org/D131307 - constexpr E v = __builtin_bit_cast(E, V); -#else - constexpr E v = static_cast(V); -#endif - [[maybe_unused]] constexpr auto custom = customize::enum_name(v); - static_assert(std::is_same_v, customize::customize_t>, "magic_enum::customize requires customize_t type."); - if constexpr (custom.first == customize::detail::customize_tag::custom_tag) { - constexpr auto name = custom.second; - static_assert(!name.empty(), "magic_enum::customize requires not empty string."); - return name.size() != 0; - } else if constexpr (custom.first == customize::detail::customize_tag::default_tag) { -#if defined(MAGIC_ENUM_VS_2017_WORKAROUND) - return n().size_ != 0; -#else - return n().size_ != 0; -#endif - } else { - return false; - } -} - -enum class enum_subtype { - common, - flags -}; - -template > -constexpr U ualue(std::size_t i) noexcept { - if constexpr (std::is_same_v) { // bool special case - static_assert(O == 0, "magic_enum::detail::ualue requires valid offset."); - - return static_cast(i); - } else if constexpr (S == enum_subtype::flags) { - return static_cast(U{1} << static_cast(static_cast(i) + O)); - } else { - return static_cast(static_cast(i) + O); - } -} - -template > -constexpr E value(std::size_t i) noexcept { - return static_cast(ualue(i)); -} - -template > -constexpr int reflected_min() noexcept { - if constexpr (S == enum_subtype::flags) { - return 0; - } else { - constexpr auto lhs = range_min::value; - constexpr auto rhs = (std::numeric_limits::min)(); - - if constexpr (cmp_less(rhs, lhs)) { - return lhs; - } else { - return rhs; - } - } -} - -template > -constexpr int reflected_max() noexcept { - if constexpr (S == enum_subtype::flags) { - return std::numeric_limits::digits - 1; - } else { - constexpr auto lhs = range_max::value; - constexpr auto rhs = (std::numeric_limits::max)(); - - if constexpr (cmp_less(lhs, rhs)) { - return lhs; - } else { - return rhs; - } - } -} - -#define MAGIC_ENUM_FOR_EACH_256(T) \ - T( 0)T( 1)T( 2)T( 3)T( 4)T( 5)T( 6)T( 7)T( 8)T( 9)T( 10)T( 11)T( 12)T( 13)T( 14)T( 15)T( 16)T( 17)T( 18)T( 19)T( 20)T( 21)T( 22)T( 23)T( 24)T( 25)T( 26)T( 27)T( 28)T( 29)T( 30)T( 31) \ - T( 32)T( 33)T( 34)T( 35)T( 36)T( 37)T( 38)T( 39)T( 40)T( 41)T( 42)T( 43)T( 44)T( 45)T( 46)T( 47)T( 48)T( 49)T( 50)T( 51)T( 52)T( 53)T( 54)T( 55)T( 56)T( 57)T( 58)T( 59)T( 60)T( 61)T( 62)T( 63) \ - T( 64)T( 65)T( 66)T( 67)T( 68)T( 69)T( 70)T( 71)T( 72)T( 73)T( 74)T( 75)T( 76)T( 77)T( 78)T( 79)T( 80)T( 81)T( 82)T( 83)T( 84)T( 85)T( 86)T( 87)T( 88)T( 89)T( 90)T( 91)T( 92)T( 93)T( 94)T( 95) \ - T( 96)T( 97)T( 98)T( 99)T(100)T(101)T(102)T(103)T(104)T(105)T(106)T(107)T(108)T(109)T(110)T(111)T(112)T(113)T(114)T(115)T(116)T(117)T(118)T(119)T(120)T(121)T(122)T(123)T(124)T(125)T(126)T(127) \ - T(128)T(129)T(130)T(131)T(132)T(133)T(134)T(135)T(136)T(137)T(138)T(139)T(140)T(141)T(142)T(143)T(144)T(145)T(146)T(147)T(148)T(149)T(150)T(151)T(152)T(153)T(154)T(155)T(156)T(157)T(158)T(159) \ - T(160)T(161)T(162)T(163)T(164)T(165)T(166)T(167)T(168)T(169)T(170)T(171)T(172)T(173)T(174)T(175)T(176)T(177)T(178)T(179)T(180)T(181)T(182)T(183)T(184)T(185)T(186)T(187)T(188)T(189)T(190)T(191) \ - T(192)T(193)T(194)T(195)T(196)T(197)T(198)T(199)T(200)T(201)T(202)T(203)T(204)T(205)T(206)T(207)T(208)T(209)T(210)T(211)T(212)T(213)T(214)T(215)T(216)T(217)T(218)T(219)T(220)T(221)T(222)T(223) \ - T(224)T(225)T(226)T(227)T(228)T(229)T(230)T(231)T(232)T(233)T(234)T(235)T(236)T(237)T(238)T(239)T(240)T(241)T(242)T(243)T(244)T(245)T(246)T(247)T(248)T(249)T(250)T(251)T(252)T(253)T(254)T(255) - -template -constexpr void valid_count(bool* valid, std::size_t& count) noexcept { -#define MAGIC_ENUM_V(O) \ - if constexpr ((I + O) < Size) { \ - if constexpr (is_valid(I + O)>()) { \ - valid[I + O] = true; \ - ++count; \ - } \ - } - - MAGIC_ENUM_FOR_EACH_256(MAGIC_ENUM_V) - - if constexpr ((I + 256) < Size) { - valid_count(valid, count); - } -#undef MAGIC_ENUM_V -} - -template -struct valid_count_t { - std::size_t count = 0; - bool valid[N] = {}; -}; - -template -constexpr auto valid_count() noexcept { - valid_count_t vc; - valid_count(vc.valid, vc.count); - return vc; -} - -template -constexpr auto values() noexcept { - constexpr auto vc = valid_count(); - - if constexpr (vc.count > 0) { -#if defined(MAGIC_ENUM_ARRAY_CONSTEXPR) - std::array values = {}; -#else - E values[vc.count] = {}; -#endif - for (std::size_t i = 0, v = 0; v < vc.count; ++i) { - if (vc.valid[i]) { - values[v++] = value(i); - } - } -#if defined(MAGIC_ENUM_ARRAY_CONSTEXPR) - return values; -#else - return to_array(values, std::make_index_sequence{}); -#endif - } else { - return std::array{}; - } -} - -template > -constexpr auto values() noexcept { - constexpr auto min = reflected_min(); - constexpr auto max = reflected_max(); - constexpr auto range_size = max - min + 1; - static_assert(range_size > 0, "magic_enum::enum_range requires valid size."); - - return values(); -} - -template > -constexpr enum_subtype subtype(std::true_type) noexcept { - if constexpr (std::is_same_v) { // bool special case - return enum_subtype::common; - } else if constexpr (has_is_flags::value) { - return customize::enum_range::is_flags ? enum_subtype::flags : enum_subtype::common; - } else { -#if defined(MAGIC_ENUM_AUTO_IS_FLAGS) - constexpr auto flags_values = values(); - constexpr auto default_values = values(); - if (flags_values.size() == 0 || default_values.size() > flags_values.size()) { - return enum_subtype::common; - } - for (std::size_t i = 0; i < default_values.size(); ++i) { - const auto v = static_cast(default_values[i]); - if (v != 0 && (v & (v - 1)) != 0) { - return enum_subtype::common; - } - } - return enum_subtype::flags; -#else - return enum_subtype::common; -#endif - } -} - -template -constexpr enum_subtype subtype(std::false_type) noexcept { - // For non-enum type return default common subtype. - return enum_subtype::common; -} - -template > -inline constexpr auto subtype_v = subtype(std::is_enum{}); - -template -inline constexpr auto values_v = values(); - -template > -using values_t = decltype((values_v)); - -template -inline constexpr auto count_v = values_v.size(); - -template > -inline constexpr auto min_v = (count_v > 0) ? static_cast(values_v.front()) : U{0}; - -template > -inline constexpr auto max_v = (count_v > 0) ? static_cast(values_v.back()) : U{0}; - -template -constexpr auto names(std::index_sequence) noexcept { - constexpr auto names = std::array{{enum_name_v[I]>...}}; - return names; -} - -template -inline constexpr auto names_v = names(std::make_index_sequence>{}); - -template > -using names_t = decltype((names_v)); - -template -constexpr auto entries(std::index_sequence) noexcept { - constexpr auto entries = std::array, sizeof...(I)>{{{values_v[I], enum_name_v[I]>}...}}; - return entries; -} - -template -inline constexpr auto entries_v = entries(std::make_index_sequence>{}); - -template > -using entries_t = decltype((entries_v)); - -template > -constexpr bool is_sparse() noexcept { - if constexpr (count_v == 0) { - return false; - } else if constexpr (std::is_same_v) { // bool special case - return false; - } else { - constexpr auto max = (S == enum_subtype::flags) ? log2(max_v) : max_v; - constexpr auto min = (S == enum_subtype::flags) ? log2(min_v) : min_v; - constexpr auto range_size = max - min + 1; - - return range_size != count_v; - } -} - -template > -inline constexpr bool is_sparse_v = is_sparse(); - -template -struct is_reflected -#if defined(MAGIC_ENUM_NO_CHECK_REFLECTED_ENUM) - : std::true_type {}; -#else - : std::bool_constant && (count_v != 0)> {}; -#endif - -template -inline constexpr bool is_reflected_v = is_reflected, S>{}; - -template -struct enable_if_enum {}; - -template -struct enable_if_enum { - using type = R; - static_assert(supported::value, "magic_enum unsupported compiler (https://github.com/Neargye/magic_enum#compiler-compatibility)."); -}; - -template , typename D = std::decay_t> -using enable_if_t = typename enable_if_enum && std::is_invocable_r_v, R>::type; - -template >, int> = 0> -using enum_concept = T; - -template > -struct is_scoped_enum : std::false_type {}; - -template -struct is_scoped_enum : std::bool_constant>> {}; - -template > -struct is_unscoped_enum : std::false_type {}; - -template -struct is_unscoped_enum : std::bool_constant>> {}; - -template >> -struct underlying_type {}; - -template -struct underlying_type : std::underlying_type> {}; - -#if defined(MAGIC_ENUM_ENABLE_HASH) || defined(MAGIC_ENUM_ENABLE_HASH_SWITCH) - -template -struct constexpr_hash_t; - -template -struct constexpr_hash_t>> { - constexpr auto operator()(Value value) const noexcept { - using U = typename underlying_type::type; - if constexpr (std::is_same_v) { // bool special case - return static_cast(value); - } else { - return static_cast(value); - } - } - using secondary_hash = constexpr_hash_t; -}; - -template -struct constexpr_hash_t>> { - static constexpr std::uint32_t crc_table[256] { - 0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L, 0x706af48fL, 0xe963a535L, 0x9e6495a3L, - 0x0edb8832L, 0x79dcb8a4L, 0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L, 0x90bf1d91L, - 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL, 0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, - 0x136c9856L, 0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L, 0xfa0f3d63L, 0x8d080df5L, - 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L, 0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL, - 0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L, 0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, - 0x26d930acL, 0x51de003aL, 0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L, 0xb8bda50fL, - 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L, 0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, - 0x76dc4190L, 0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL, 0x9fbfe4a5L, 0xe8b8d433L, - 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL, 0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L, - 0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL, 0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, - 0x65b0d9c6L, 0x12b7e950L, 0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L, 0xfbd44c65L, - 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L, 0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, - 0x4369e96aL, 0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L, 0xaa0a4c5fL, 0xdd0d7cc9L, - 0x5005713cL, 0x270241aaL, 0xbe0b1010L, 0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL, - 0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L, 0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, - 0xedb88320L, 0x9abfb3b6L, 0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L, 0x73dc1683L, - 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L, 0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, - 0xf00f9344L, 0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL, 0x196c3671L, 0x6e6b06e7L, - 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL, 0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L, - 0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L, 0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, - 0xd80d2bdaL, 0xaf0a1b4cL, 0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL, 0x4669be79L, - 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L, 0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, - 0xc5ba3bbeL, 0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L, 0x2cd99e8bL, 0x5bdeae1dL, - 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL, 0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L, - 0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL, 0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, - 0x86d3d2d4L, 0xf1d4e242L, 0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L, 0x18b74777L, - 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL, 0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, - 0xa00ae278L, 0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L, 0x4969474dL, 0x3e6e77dbL, - 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L, 0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L, - 0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L, 0xcdd70693L, 0x54de5729L, 0x23d967bfL, - 0xb3667a2eL, 0xc4614ab8L, 0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL, 0x2d02ef8dL - }; - constexpr std::uint32_t operator()(string_view value) const noexcept { - auto crc = static_cast(0xffffffffL); - for (const auto c : value) { - crc = (crc >> 8) ^ crc_table[(crc ^ static_cast(c)) & 0xff]; - } - return crc ^ 0xffffffffL; - } - - struct secondary_hash { - constexpr std::uint32_t operator()(string_view value) const noexcept { - auto acc = static_cast(2166136261ULL); - for (const auto c : value) { - acc = ((acc ^ static_cast(c)) * static_cast(16777619ULL)) & (std::numeric_limits::max)(); - } - return static_cast(acc); - } - }; -}; - -template -inline constexpr Hash hash_v{}; - -template -constexpr auto calculate_cases(std::size_t Page) noexcept { - constexpr std::array values = *GlobValues; - constexpr std::size_t size = values.size(); - - using switch_t = std::invoke_result_t; - static_assert(std::is_integral_v && !std::is_same_v); - const std::size_t values_to = (std::min)(static_cast(256), size - Page); - - std::array result{}; - auto fill = result.begin(); - { - auto first = values.begin() + static_cast(Page); - auto last = values.begin() + static_cast(Page + values_to); - while (first != last) { - *fill++ = hash_v(*first++); - } - } - - // dead cases, try to avoid case collisions - for (switch_t last_value = result[values_to - 1]; fill != result.end() && last_value != (std::numeric_limits::max)(); *fill++ = ++last_value) { - } - - { - auto it = result.begin(); - auto last_value = (std::numeric_limits::min)(); - for (; fill != result.end(); *fill++ = last_value++) { - while (last_value == *it) { - ++last_value, ++it; - } - } - } - - return result; -} - -template -constexpr R invoke_r(F&& f, Args&&... args) noexcept(std::is_nothrow_invocable_r_v) { - if constexpr (std::is_void_v) { - std::forward(f)(std::forward(args)...); - } else { - return static_cast(std::forward(f)(std::forward(args)...)); - } -} - -enum class case_call_t { - index, - value -}; - -template -inline constexpr auto default_result_type_lambda = []() noexcept(std::is_nothrow_default_constructible_v) { return T{}; }; - -template <> -inline constexpr auto default_result_type_lambda = []() noexcept {}; - -template -constexpr bool has_duplicate() noexcept { - using value_t = std::decay_t; - using hash_value_t = std::invoke_result_t; - std::arraysize()> hashes{}; - std::size_t size = 0; - for (auto elem : *Arr) { - hashes[size] = hash_v(elem); - for (auto i = size++; i > 0; --i) { - if (hashes[i] < hashes[i - 1]) { - auto tmp = hashes[i]; - hashes[i] = hashes[i - 1]; - hashes[i - 1] = tmp; - } else if (hashes[i] == hashes[i - 1]) { - return false; - } else { - break; - } - } - } - return true; -} - -#define MAGIC_ENUM_CASE(val) \ - case cases[val]: \ - if constexpr ((val) + Page < size) { \ - if (!pred(values[val + Page], searched)) { \ - break; \ - } \ - if constexpr (CallValue == case_call_t::index) { \ - if constexpr (std::is_invocable_r_v>) { \ - return detail::invoke_r(std::forward(lambda), std::integral_constant{}); \ - } else if constexpr (std::is_invocable_v>) { \ - MAGIC_ENUM_ASSERT(false && "magic_enum::detail::constexpr_switch wrong result type."); \ - } \ - } else if constexpr (CallValue == case_call_t::value) { \ - if constexpr (std::is_invocable_r_v>) { \ - return detail::invoke_r(std::forward(lambda), enum_constant{}); \ - } else if constexpr (std::is_invocable_r_v>) { \ - MAGIC_ENUM_ASSERT(false && "magic_enum::detail::constexpr_switch wrong result type."); \ - } \ - } \ - break; \ - } else [[fallthrough]]; - -template ::value_type>, - typename BinaryPredicate = std::equal_to<>, - typename Lambda, - typename ResultGetterType> -constexpr decltype(auto) constexpr_switch( - Lambda&& lambda, - typename std::decay_t::value_type searched, - ResultGetterType&& def, - BinaryPredicate&& pred = {}) { - using result_t = std::invoke_result_t; - using hash_t = std::conditional_t(), Hash, typename Hash::secondary_hash>; - static_assert(has_duplicate(), "magic_enum::detail::constexpr_switch duplicated hash found, please report it: https://github.com/Neargye/magic_enum/issues."); - constexpr std::array values = *GlobValues; - constexpr std::size_t size = values.size(); - constexpr std::array cases = calculate_cases(Page); - - switch (hash_v(searched)) { - MAGIC_ENUM_FOR_EACH_256(MAGIC_ENUM_CASE) - default: - if constexpr (size > 256 + Page) { - return constexpr_switch(std::forward(lambda), searched, std::forward(def)); - } - break; - } - return def(); -} - -#undef MAGIC_ENUM_CASE - -#endif - -} // namespace magic_enum::detail - -// Checks is magic_enum supported compiler. -inline constexpr bool is_magic_enum_supported = detail::supported::value; - -template -using Enum = detail::enum_concept; - -// Checks whether T is an Unscoped enumeration type. -// Provides the member constant value which is equal to true, if T is an [Unscoped enumeration](https://en.cppreference.com/w/cpp/language/enum#Unscoped_enumeration) type. Otherwise, value is equal to false. -template -struct is_unscoped_enum : detail::is_unscoped_enum {}; - -template -inline constexpr bool is_unscoped_enum_v = is_unscoped_enum::value; - -// Checks whether T is an Scoped enumeration type. -// Provides the member constant value which is equal to true, if T is an [Scoped enumeration](https://en.cppreference.com/w/cpp/language/enum#Scoped_enumerations) type. Otherwise, value is equal to false. -template -struct is_scoped_enum : detail::is_scoped_enum {}; - -template -inline constexpr bool is_scoped_enum_v = is_scoped_enum::value; - -// If T is a complete enumeration type, provides a member typedef type that names the underlying type of T. -// Otherwise, if T is not an enumeration type, there is no member type. Otherwise (T is an incomplete enumeration type), the program is ill-formed. -template -struct underlying_type : detail::underlying_type {}; - -template -using underlying_type_t = typename underlying_type::type; - -template -using enum_constant = detail::enum_constant; - -// Returns type name of enum. -template -[[nodiscard]] constexpr auto enum_type_name() noexcept -> detail::enable_if_t { - constexpr string_view name = detail::type_name_v>; - static_assert(!name.empty(), "magic_enum::enum_type_name enum type does not have a name."); - - return name; -} - -// Returns number of enum values. -template > -[[nodiscard]] constexpr auto enum_count() noexcept -> detail::enable_if_t { - return detail::count_v, S>; -} - -// Returns enum value at specified index. -// No bounds checking is performed: the behavior is undefined if index >= number of enum values. -template > -[[nodiscard]] constexpr auto enum_value(std::size_t index) noexcept -> detail::enable_if_t> { - using D = std::decay_t; - static_assert(detail::is_reflected_v, "magic_enum requires enum implementation and valid max and min."); - - if constexpr (detail::is_sparse_v) { - return MAGIC_ENUM_ASSERT(index < detail::count_v), detail::values_v[index]; - } else { - constexpr auto min = (S == detail::enum_subtype::flags) ? detail::log2(detail::min_v) : detail::min_v; - - return MAGIC_ENUM_ASSERT(index < detail::count_v), detail::value(index); - } -} - -// Returns enum value at specified index. -template > -[[nodiscard]] constexpr auto enum_value() noexcept -> detail::enable_if_t> { - using D = std::decay_t; - static_assert(detail::is_reflected_v, "magic_enum requires enum implementation and valid max and min."); - static_assert(I < detail::count_v, "magic_enum::enum_value out of range."); - - return enum_value(I); -} - -// Returns std::array with enum values, sorted by enum value. -template > -[[nodiscard]] constexpr auto enum_values() noexcept -> detail::enable_if_t> { - using D = std::decay_t; - static_assert(detail::is_reflected_v, "magic_enum requires enum implementation and valid max and min."); - - return detail::values_v; -} - -// Returns integer value from enum value. -template -[[nodiscard]] constexpr auto enum_integer(E value) noexcept -> detail::enable_if_t> { - return static_cast>(value); -} - -// Returns underlying value from enum value. -template -[[nodiscard]] constexpr auto enum_underlying(E value) noexcept -> detail::enable_if_t> { - return static_cast>(value); -} - -// Obtains index in enum values from enum value. -// Returns optional with index. -template > -[[nodiscard]] constexpr auto enum_index(E value) noexcept -> detail::enable_if_t> { - using D = std::decay_t; - using U = underlying_type_t; - static_assert(detail::is_reflected_v, "magic_enum requires enum implementation and valid max and min."); - - if constexpr (detail::is_sparse_v || (S == detail::enum_subtype::flags)) { -#if defined(MAGIC_ENUM_ENABLE_HASH) - return detail::constexpr_switch<&detail::values_v, detail::case_call_t::index>( - [](std::size_t i) { return optional{i}; }, - value, - detail::default_result_type_lambda>); -#else - for (std::size_t i = 0; i < detail::count_v; ++i) { - if (enum_value(i) == value) { - return i; - } - } - return {}; // Invalid value or out of range. -#endif - } else { - const auto v = static_cast(value); - if (v >= detail::min_v && v <= detail::max_v) { - return static_cast(v - detail::min_v); - } - return {}; // Invalid value or out of range. - } -} - -// Obtains index in enum values from enum value. -// Returns optional with index. -template -[[nodiscard]] constexpr auto enum_index(E value) noexcept -> detail::enable_if_t> { - using D = std::decay_t; - static_assert(detail::is_reflected_v, "magic_enum requires enum implementation and valid max and min."); - - return enum_index(value); -} - -// Obtains index in enum values from static storage enum variable. -template >> -[[nodiscard]] constexpr auto enum_index() noexcept -> detail::enable_if_t {\ - using D = std::decay_t; - static_assert(detail::is_reflected_v, "magic_enum requires enum implementation and valid max and min."); - constexpr auto index = enum_index(V); - static_assert(index, "magic_enum::enum_index enum value does not have a index."); - - return *index; -} - -// Returns name from static storage enum variable. -// This version is much lighter on the compile times and is not restricted to the enum_range limitation. -template -[[nodiscard]] constexpr auto enum_name() noexcept -> detail::enable_if_t { - constexpr string_view name = detail::enum_name_v, V>; - static_assert(!name.empty(), "magic_enum::enum_name enum value does not have a name."); - - return name; -} - -// Returns name from enum value. -// If enum value does not have name or value out of range, returns empty string. -template > -[[nodiscard]] constexpr auto enum_name(E value) noexcept -> detail::enable_if_t { - using D = std::decay_t; - static_assert(detail::is_reflected_v, "magic_enum requires enum implementation and valid max and min."); - - if (const auto i = enum_index(value)) { - return detail::names_v[*i]; - } - return {}; -} - -// Returns name from enum value. -// If enum value does not have name or value out of range, returns empty string. -template -[[nodiscard]] constexpr auto enum_name(E value) -> detail::enable_if_t { - using D = std::decay_t; - static_assert(detail::is_reflected_v, "magic_enum requires enum implementation and valid max and min."); - - return enum_name(value); -} - -// Returns std::array with names, sorted by enum value. -template > -[[nodiscard]] constexpr auto enum_names() noexcept -> detail::enable_if_t> { - using D = std::decay_t; - static_assert(detail::is_reflected_v, "magic_enum requires enum implementation and valid max and min."); - - return detail::names_v; -} - -// Returns std::array with pairs (value, name), sorted by enum value. -template > -[[nodiscard]] constexpr auto enum_entries() noexcept -> detail::enable_if_t> { - using D = std::decay_t; - static_assert(detail::is_reflected_v, "magic_enum requires enum implementation and valid max and min."); - - return detail::entries_v; -} - -// Allows you to write magic_enum::enum_cast("bar", magic_enum::case_insensitive); -inline constexpr auto case_insensitive = detail::case_insensitive<>{}; - -// Obtains enum value from integer value. -// Returns optional with enum value. -template > -[[nodiscard]] constexpr auto enum_cast(underlying_type_t value) noexcept -> detail::enable_if_t>> { - using D = std::decay_t; - static_assert(detail::is_reflected_v, "magic_enum requires enum implementation and valid max and min."); - - if constexpr (detail::is_sparse_v || (S == detail::enum_subtype::flags)) { -#if defined(MAGIC_ENUM_ENABLE_HASH) - return detail::constexpr_switch<&detail::values_v, detail::case_call_t::value>( - [](D v) { return optional{v}; }, - static_cast(value), - detail::default_result_type_lambda>); -#else - for (std::size_t i = 0; i < detail::count_v; ++i) { - if (value == static_cast>(enum_value(i))) { - return static_cast(value); - } - } - return {}; // Invalid value or out of range. -#endif - } else { - if (value >= detail::min_v && value <= detail::max_v) { - return static_cast(value); - } - return {}; // Invalid value or out of range. - } -} - -// Obtains enum value from name. -// Returns optional with enum value. -template , typename BinaryPredicate = std::equal_to<>> -[[nodiscard]] constexpr auto enum_cast(string_view value, [[maybe_unused]] BinaryPredicate p = {}) noexcept(detail::is_nothrow_invocable()) -> detail::enable_if_t>, BinaryPredicate> { - using D = std::decay_t; - static_assert(detail::is_reflected_v, "magic_enum requires enum implementation and valid max and min."); - -#if defined(MAGIC_ENUM_ENABLE_HASH) - if constexpr (detail::is_default_predicate()) { - return detail::constexpr_switch<&detail::names_v, detail::case_call_t::index>( - [](std::size_t i) { return optional{detail::values_v[i]}; }, - value, - detail::default_result_type_lambda>, - [&p](string_view lhs, string_view rhs) { return detail::cmp_equal(lhs, rhs, p); }); - } -#endif - for (std::size_t i = 0; i < detail::count_v; ++i) { - if (detail::cmp_equal(value, detail::names_v[i], p)) { - return enum_value(i); - } - } - return {}; // Invalid value or out of range. -} - -// Checks whether enum contains value with such value. -template > -[[nodiscard]] constexpr auto enum_contains(E value) noexcept -> detail::enable_if_t { - using D = std::decay_t; - using U = underlying_type_t; - - return static_cast(enum_cast(static_cast(value))); -} - -// Checks whether enum contains value with such value. -template -[[nodiscard]] constexpr auto enum_contains(E value) noexcept -> detail::enable_if_t { - using D = std::decay_t; - using U = underlying_type_t; - - return static_cast(enum_cast(static_cast(value))); -} - -// Checks whether enum contains value with such integer value. -template > -[[nodiscard]] constexpr auto enum_contains(underlying_type_t value) noexcept -> detail::enable_if_t { - using D = std::decay_t; - - return static_cast(enum_cast(value)); -} - -// Checks whether enum contains enumerator with such name. -template , typename BinaryPredicate = std::equal_to<>> -[[nodiscard]] constexpr auto enum_contains(string_view value, BinaryPredicate p = {}) noexcept(detail::is_nothrow_invocable()) -> detail::enable_if_t { - using D = std::decay_t; - - return static_cast(enum_cast(value, std::move(p))); -} - -template -inline constexpr auto as_flags = AsFlags ? detail::enum_subtype::flags : detail::enum_subtype::common; - -template -inline constexpr auto as_common = AsFlags ? detail::enum_subtype::common : detail::enum_subtype::flags; - -namespace bitwise_operators { - -template = 0> -constexpr E operator~(E rhs) noexcept { - return static_cast(~static_cast>(rhs)); -} - -template = 0> -constexpr E operator|(E lhs, E rhs) noexcept { - return static_cast(static_cast>(lhs) | static_cast>(rhs)); -} - -template = 0> -constexpr E operator&(E lhs, E rhs) noexcept { - return static_cast(static_cast>(lhs) & static_cast>(rhs)); -} - -template = 0> -constexpr E operator^(E lhs, E rhs) noexcept { - return static_cast(static_cast>(lhs) ^ static_cast>(rhs)); -} - -template = 0> -constexpr E& operator|=(E& lhs, E rhs) noexcept { - return lhs = (lhs | rhs); -} - -template = 0> -constexpr E& operator&=(E& lhs, E rhs) noexcept { - return lhs = (lhs & rhs); -} - -template = 0> -constexpr E& operator^=(E& lhs, E rhs) noexcept { - return lhs = (lhs ^ rhs); -} - -} // namespace magic_enum::bitwise_operators - -} // namespace magic_enum - -#if defined(__clang__) -# pragma clang diagnostic pop -#elif defined(__GNUC__) -# pragma GCC diagnostic pop -#elif defined(_MSC_VER) -# pragma warning(pop) -#endif - -#undef MAGIC_ENUM_GET_ENUM_NAME_BUILTIN -#undef MAGIC_ENUM_GET_TYPE_NAME_BUILTIN -#undef MAGIC_ENUM_VS_2017_WORKAROUND -#undef MAGIC_ENUM_ARRAY_CONSTEXPR -#undef MAGIC_ENUM_FOR_EACH_256 - -#endif // NEARGYE_MAGIC_ENUM_HPP diff --git a/src/xrpld/rpc/handlers/ServerDefinitions.cpp b/src/xrpld/rpc/handlers/ServerDefinitions.cpp index d51cb28c1..8441a1f51 100644 --- a/src/xrpld/rpc/handlers/ServerDefinitions.cpp +++ b/src/xrpld/rpc/handlers/ServerDefinitions.cpp @@ -32,7 +32,7 @@ #include #include #include -#include +#include #include #define MAGIC_ENUM(x, _min, _max) \ From 49fd0c33b51a7e581b3054625b0847ebcc15aa8c Mon Sep 17 00:00:00 2001 From: tequ Date: Wed, 29 Apr 2026 16:05:18 +0900 Subject: [PATCH 5/6] fixIOULockedBalanceInvariant Amendment (#732) --- include/xrpl/protocol/Feature.h | 2 +- include/xrpl/protocol/detail/features.macro | 1 + src/test/ledger/Invariants_test.cpp | 42 ++++++++++++++++++++- src/xrpld/app/tx/detail/InvariantCheck.cpp | 40 ++++++++++++++++++++ src/xrpld/app/tx/detail/InvariantCheck.h | 27 ++++++++++++- 5 files changed, 108 insertions(+), 4 deletions(-) diff --git a/include/xrpl/protocol/Feature.h b/include/xrpl/protocol/Feature.h index 3f7a39778..d5dbd3969 100644 --- a/include/xrpl/protocol/Feature.h +++ b/include/xrpl/protocol/Feature.h @@ -80,7 +80,7 @@ namespace detail { // Feature.cpp. Because it's only used to reserve storage, and determine how // large to make the FeatureBitset, it MAY be larger. It MUST NOT be less than // the actual number of amendments. A LogicError on startup will verify this. -static constexpr std::size_t numFeatures = 114; +static constexpr std::size_t numFeatures = 115; /** Amendments that this server supports and the default voting behavior. Whether they are enabled depends on the Rules defined in the validated diff --git a/include/xrpl/protocol/detail/features.macro b/include/xrpl/protocol/detail/features.macro index 080ed80c3..4791025b3 100644 --- a/include/xrpl/protocol/detail/features.macro +++ b/include/xrpl/protocol/detail/features.macro @@ -31,6 +31,7 @@ // If you add an amendment here, then do not forget to increment `numFeatures` // in include/xrpl/protocol/Feature.h. +XRPL_FIX (IOULockedBalanceInvariant, Supported::yes, VoteBehavior::DefaultNo) XRPL_FIX (ImportIssuer, Supported::yes, VoteBehavior::DefaultYes) XRPL_FEATURE(HookAPISerializedType240, Supported::yes, VoteBehavior::DefaultNo) XRPL_FEATURE(PermissionedDomains, Supported::no, VoteBehavior::DefaultNo) diff --git a/src/test/ledger/Invariants_test.cpp b/src/test/ledger/Invariants_test.cpp index 7c28c1c55..54bd6c93e 100644 --- a/src/test/ledger/Invariants_test.cpp +++ b/src/test/ledger/Invariants_test.cpp @@ -28,7 +28,6 @@ #include #include -#include namespace ripple { @@ -137,7 +136,9 @@ class Invariants_test : public beast::unit_test::suite if (sink.messages().str().find(m) == std::string::npos) { // uncomment if you want to log the invariant failure - // message log << " --> " << m << std::endl; + // message + // log << sink.messages().str() << std::endl; + // log << " --> " << m << std::endl; fail(); } } @@ -1233,6 +1234,42 @@ class Invariants_test : public beast::unit_test::suite {tecINVARIANT_FAILED, tecINVARIANT_FAILED}); } + void + testLockedBalance() + { + using namespace test::jtx; + + testcase << "ValidLockedBalance"; + + doInvariantCheck( + {{"Invariant failed: IOU locked balance is greater than balance"}}, + [&](Account const& A1, Account const& A2, ApplyContext& ac) { + IOU const USD{A2["USD"]}; + auto const sle = + std::make_shared(keylet::line(A1, A2, USD.currency)); + sle->setFieldAmount(sfHighLimit, A1["USD"](100)); + sle->setFieldAmount(sfLowLimit, A2["USD"](100)); + sle->setFieldAmount(sfBalance, USD(100)); + sle->setFieldAmount(sfLockedBalance, USD(101)); + ac.view().insert(sle); + return true; + }); + + doInvariantCheck( + {{"Invariant failed: IOU locked balance is greater than balance"}}, + [&](Account const& A1, Account const& A2, ApplyContext& ac) { + IOU const USD{A2["USD"]}; + auto const sle = + std::make_shared(keylet::line(A1, A2, USD.currency)); + sle->setFieldAmount(sfHighLimit, A1["USD"](100)); + sle->setFieldAmount(sfLowLimit, A2["USD"](100)); + sle->setFieldAmount(sfBalance, USD(-100)); + sle->setFieldAmount(sfLockedBalance, USD(-101)); + ac.view().insert(sle); + return true; + }); + } + public: void run() override @@ -1251,6 +1288,7 @@ public: testValidNewAccountRoot(); testNFTokenPageInvariants(); testPermissionedDomainInvariants(); + testLockedBalance(); } }; diff --git a/src/xrpld/app/tx/detail/InvariantCheck.cpp b/src/xrpld/app/tx/detail/InvariantCheck.cpp index 5a8e72da4..b73297d03 100644 --- a/src/xrpld/app/tx/detail/InvariantCheck.cpp +++ b/src/xrpld/app/tx/detail/InvariantCheck.cpp @@ -1982,4 +1982,44 @@ ValidAMM::finalize( return true; } +void +ValidLockedBalance::visitEntry( + bool, + std::shared_ptr const& before, + std::shared_ptr const& after) +{ + if (after && after->getType() == ltRIPPLE_STATE && + after->isFieldPresent(sfLockedBalance)) + { + iouIOULockedBalanceAfter_ = (*after)[sfLockedBalance]; + iouIOUBalanceAfter_ = (*after)[sfBalance]; + } +} + +bool +ValidLockedBalance::finalize( + STTx const& tx, + TER const result, + XRPAmount const, + ReadView const& view, + beast::Journal const& j) +{ + if (!view.rules().enabled(fixIOULockedBalanceInvariant)) + return true; + + if (iouIOULockedBalanceAfter_) + { + if ((!iouIOULockedBalanceAfter_->negative() && + *iouIOULockedBalanceAfter_ > *iouIOUBalanceAfter_) || + (iouIOULockedBalanceAfter_->negative() && + *iouIOULockedBalanceAfter_ < *iouIOUBalanceAfter_)) + { + JLOG(j.fatal()) << "Invariant failed: IOU locked balance is " + "greater than balance"; + return false; + } + } + + return true; +} } // namespace ripple diff --git a/src/xrpld/app/tx/detail/InvariantCheck.h b/src/xrpld/app/tx/detail/InvariantCheck.h index e854fd649..41445b137 100644 --- a/src/xrpld/app/tx/detail/InvariantCheck.h +++ b/src/xrpld/app/tx/detail/InvariantCheck.h @@ -680,6 +680,30 @@ private: beast::Journal const&) const; }; +class ValidLockedBalance +{ + std::optional iouIOULockedBalanceAfter_; + std::optional iouIOUBalanceAfter_; + +public: + ValidLockedBalance() + { + } + void + visitEntry( + bool, + std::shared_ptr const&, + std::shared_ptr const&); + + bool + finalize( + STTx const&, + TER const, + XRPAmount const, + ReadView const&, + beast::Journal const&); +}; + // additional invariant checks can be declared above and then added to this // tuple using InvariantChecks = std::tuple< @@ -700,7 +724,8 @@ using InvariantChecks = std::tuple< ValidClawback, ValidMPTIssuance, ValidPermissionedDomain, - ValidAMM>; + ValidAMM, + ValidLockedBalance>; /** * @brief get a tuple of all invariant checks From 9d4e5076758a6a89490d968b4878a1da85dd12db Mon Sep 17 00:00:00 2001 From: tequ Date: Wed, 29 Apr 2026 16:06:44 +0900 Subject: [PATCH 6/6] Treat suspicious gcov hit counts as coverage warnings (#737) --- cmake/CodeCoverage.cmake | 1 + 1 file changed, 1 insertion(+) diff --git a/cmake/CodeCoverage.cmake b/cmake/CodeCoverage.cmake index d2af481d8..d6323c5cc 100644 --- a/cmake/CodeCoverage.cmake +++ b/cmake/CodeCoverage.cmake @@ -380,6 +380,7 @@ function(setup_target_for_coverage_gcovr) ${GCOVR_PATH} --gcov-executable ${GCOV_TOOL} --gcov-ignore-parse-errors=negative_hits.warn_once_per_file + --gcov-ignore-parse-errors=suspicious_hits.warn_once_per_file -r ${BASEDIR} ${GCOVR_ADDITIONAL_ARGS} ${GCOVR_EXCLUDE_ARGS}