From 2ed8edc19d69519b81a192afebf5f5573c5383cf Mon Sep 17 00:00:00 2001 From: Nik Bougalis Date: Mon, 14 Apr 2014 21:21:19 -0700 Subject: [PATCH] Make is_set_bit a universal template function --- src/ripple_app/book/Taker.h | 4 +- src/ripple_app/ledger/Ledger.cpp | 10 ++-- src/ripple_app/ledger/LedgerEntrySet.cpp | 8 +-- src/ripple_app/paths/PathRequest.cpp | 2 +- src/ripple_app/paths/PathState.cpp | 50 +++++++++---------- src/ripple_app/paths/Pathfinder.cpp | 6 +-- src/ripple_app/paths/RippleCalc.cpp | 12 ++--- src/ripple_app/paths/RippleState.h | 8 +-- .../transactors/AccountSetTransactor.cpp | 18 +++---- .../transactors/ChangeTransactor.cpp | 2 +- .../transactors/OfferCreateTransactor.cpp | 20 ++++---- .../transactors/PaymentTransactor.cpp | 12 ++--- src/ripple_app/transactors/Transactor.cpp | 6 +-- .../transactors/TrustSetTransactor.cpp | 16 +++--- src/ripple_app/tx/TransactionEngine.cpp | 6 +-- src/ripple_basics/utility/PlatformMacros.h | 14 +++++- src/ripple_overlay/impl/PeerImp.h | 8 +-- 17 files changed, 107 insertions(+), 95 deletions(-) diff --git a/src/ripple_app/book/Taker.h b/src/ripple_app/book/Taker.h index 631b28651..decf43db6 100644 --- a/src/ripple_app/book/Taker.h +++ b/src/ripple_app/book/Taker.h @@ -41,8 +41,8 @@ public: explicit Options (std::uint32_t tx_flags) - : sell (isSetBit (tx_flags, tfSell)) - , passive (isSetBit (tx_flags, tfPassive)) + : sell (is_bit_set (tx_flags, tfSell)) + , passive (is_bit_set (tx_flags, tfPassive)) { } diff --git a/src/ripple_app/ledger/Ledger.cpp b/src/ripple_app/ledger/Ledger.cpp index 727eef12b..15739ed04 100644 --- a/src/ripple_app/ledger/Ledger.cpp +++ b/src/ripple_app/ledger/Ledger.cpp @@ -1019,7 +1019,7 @@ Json::Value Ledger::getJson (int options) { Json::Value ledger (Json::objectValue); - bool bFull = isSetBit (options, LEDGER_JSON_FULL); + bool bFull = is_bit_set (options, LEDGER_JSON_FULL); ScopedLockType sl (mLock); @@ -1057,7 +1057,7 @@ Json::Value Ledger::getJson (int options) ledger["closed"] = false; } - if (mTransactionMap && (bFull || isSetBit (options, LEDGER_JSON_DUMP_TXRP))) + if (mTransactionMap && (bFull || is_bit_set (options, LEDGER_JSON_DUMP_TXRP))) { Json::Value txns (Json::arrayValue); SHAMapTreeNode::TNType type; @@ -1065,7 +1065,7 @@ Json::Value Ledger::getJson (int options) for (SHAMapItem::pointer item = mTransactionMap->peekFirstItem (type); !!item; item = mTransactionMap->peekNextItem (item->getTag (), type)) { - if (bFull || isSetBit (options, LEDGER_JSON_EXPAND)) + if (bFull || is_bit_set (options, LEDGER_JSON_EXPAND)) { if (type == SHAMapTreeNode::tnTRANSACTION_NM) { @@ -1099,10 +1099,10 @@ Json::Value Ledger::getJson (int options) ledger["transactions"] = txns; } - if (mAccountStateMap && (bFull || isSetBit (options, LEDGER_JSON_DUMP_STATE))) + if (mAccountStateMap && (bFull || is_bit_set (options, LEDGER_JSON_DUMP_STATE))) { Json::Value& state = (ledger["accountState"] = Json::arrayValue); - if (bFull || isSetBit (options, LEDGER_JSON_EXPAND)) + if (bFull || is_bit_set (options, LEDGER_JSON_EXPAND)) visitStateItems(BIND_TYPE(stateItemFullAppender, std::ref(state), P_1)); else mAccountStateMap->visitLeaves(BIND_TYPE(stateItemTagAppender, std::ref(state), P_1)); diff --git a/src/ripple_app/ledger/LedgerEntrySet.cpp b/src/ripple_app/ledger/LedgerEntrySet.cpp index 4af517d43..90b0dad4f 100644 --- a/src/ripple_app/ledger/LedgerEntrySet.cpp +++ b/src/ripple_app/ledger/LedgerEntrySet.cpp @@ -1527,8 +1527,8 @@ TER LedgerEntrySet::rippleCredit (const uint160& uSenderID, const uint160& uRece // YYY Could skip this if rippling in reverse. if (saBefore > zero // Sender balance was positive. && saBalance <= zero // Sender is zero or negative. - && isSetBit ((uFlags = sleRippleState->getFieldU32 (sfFlags)), !bSenderHigh ? lsfLowReserve : lsfHighReserve) // Sender reserve is set. - && !isSetBit (uFlags, !bSenderHigh ? lsfLowNoRipple : lsfHighNoRipple) + && is_bit_set ((uFlags = sleRippleState->getFieldU32 (sfFlags)), !bSenderHigh ? lsfLowReserve : lsfHighReserve) // Sender reserve is set. + && !is_bit_set (uFlags, !bSenderHigh ? lsfLowNoRipple : lsfHighNoRipple) && !sleRippleState->getFieldAmount (!bSenderHigh ? sfLowLimit : sfHighLimit) // Sender trust limit is 0. && !sleRippleState->getFieldU32 (!bSenderHigh ? sfLowQualityIn : sfHighQualityIn) // Sender quality in is 0. && !sleRippleState->getFieldU32 (!bSenderHigh ? sfLowQualityOut : sfHighQualityOut)) // Sender quality out is 0. @@ -1541,7 +1541,7 @@ TER LedgerEntrySet::rippleCredit (const uint160& uSenderID, const uint160& uRece sleRippleState->setFieldU32 (sfFlags, uFlags & (!bSenderHigh ? ~lsfLowReserve : ~lsfHighReserve)); // Clear reserve flag. bDelete = !saBalance // Balance is zero. - && !isSetBit (uFlags, bSenderHigh ? lsfLowReserve : lsfHighReserve); // Receiver reserve is clear. + && !is_bit_set (uFlags, bSenderHigh ? lsfLowReserve : lsfHighReserve); // Receiver reserve is clear. } if (bSenderHigh) @@ -1644,7 +1644,7 @@ TER LedgerEntrySet::accountSend (const uint160& uSenderID, const uint160& uRecei { if (sleSender->getFieldAmount (sfBalance) < saAmount) { - terResult = isSetBit (mParams, tapOPEN_LEDGER) ? telFAILED_PROCESSING : tecFAILED_PROCESSING; + terResult = is_bit_set (mParams, tapOPEN_LEDGER) ? telFAILED_PROCESSING : tecFAILED_PROCESSING; } else { diff --git a/src/ripple_app/paths/PathRequest.cpp b/src/ripple_app/paths/PathRequest.cpp index 73d98d31e..7dc6e0581 100644 --- a/src/ripple_app/paths/PathRequest.cpp +++ b/src/ripple_app/paths/PathRequest.cpp @@ -153,7 +153,7 @@ bool PathRequest::isValid (RippleLineCache::ref crCache) } else { - bool includeXRP = !isSetBit (asDst->peekSLE ().getFlags(), lsfDisallowXRP); + bool includeXRP = !is_bit_set (asDst->peekSLE ().getFlags(), lsfDisallowXRP); boost::unordered_set usDestCurrID = usAccountDestCurrencies (raDstAccount, crCache, includeXRP); diff --git a/src/ripple_app/paths/PathState.cpp b/src/ripple_app/paths/PathState.cpp index 57313d3a8..648758b97 100644 --- a/src/ripple_app/paths/PathState.cpp +++ b/src/ripple_app/paths/PathState.cpp @@ -51,14 +51,14 @@ Json::Value PathState::Node::getJson () const jvNode["type"] = uFlags; - if (isSetBit (uFlags, STPathElement::typeAccount) || !!uAccountID) - jvFlags.append (!!isSetBit (uFlags, STPathElement::typeAccount) == !!uAccountID ? "account" : "-account"); + if (is_bit_set (uFlags, STPathElement::typeAccount) || !!uAccountID) + jvFlags.append (!!is_bit_set (uFlags, STPathElement::typeAccount) == !!uAccountID ? "account" : "-account"); - if (isSetBit (uFlags, STPathElement::typeCurrency) || !!uCurrencyID) - jvFlags.append (!!isSetBit (uFlags, STPathElement::typeCurrency) == !!uCurrencyID ? "currency" : "-currency"); + if (is_bit_set (uFlags, STPathElement::typeCurrency) || !!uCurrencyID) + jvFlags.append (!!is_bit_set (uFlags, STPathElement::typeCurrency) == !!uCurrencyID ? "currency" : "-currency"); - if (isSetBit (uFlags, STPathElement::typeIssuer) || !!uIssuerID) - jvFlags.append (!!isSetBit (uFlags, STPathElement::typeIssuer) == !!uIssuerID ? "issuer" : "-issuer"); + if (is_bit_set (uFlags, STPathElement::typeIssuer) || !!uIssuerID) + jvFlags.append (!!is_bit_set (uFlags, STPathElement::typeIssuer) == !!uIssuerID ? "issuer" : "-issuer"); jvNode["flags"] = jvFlags; @@ -182,12 +182,12 @@ TER PathState::pushNode ( const bool bFirst = vpnNodes.empty (); const Node& pnPrv = bFirst ? Node () : vpnNodes.back (); // true, iff node is a ripple account. false, iff node is an offer node. - const bool bAccount = isSetBit (iType, STPathElement::typeAccount); + const bool bAccount = is_bit_set (iType, STPathElement::typeAccount); // true, iff currency supplied. // Currency is specified for the output of the current node. - const bool bCurrency = isSetBit (iType, STPathElement::typeCurrency); + const bool bCurrency = is_bit_set (iType, STPathElement::typeCurrency); // Issuer is specified for the output of the current node. - const bool bIssuer = isSetBit (iType, STPathElement::typeIssuer); + const bool bIssuer = is_bit_set (iType, STPathElement::typeIssuer); TER terResult = tesSUCCESS; WriteLog (lsTRACE, RippleCalc) << "pushNode> " @@ -266,7 +266,7 @@ TER PathState::pushNode ( if (tesSUCCESS == terResult && !vpnNodes.empty ()) { const Node& pnBck = vpnNodes.back (); - bool bBckAccount = isSetBit (pnBck.uFlags, STPathElement::typeAccount); + bool bBckAccount = is_bit_set (pnBck.uFlags, STPathElement::typeAccount); if (bBckAccount) { @@ -305,8 +305,8 @@ TER PathState::pushNode ( terResult = terNO_ACCOUNT; } - else if ((isSetBit (sleBck->getFieldU32 (sfFlags), lsfRequireAuth) - && !isSetBit (sleRippleState->getFieldU32 (sfFlags), (bHigh ? lsfHighAuth : lsfLowAuth))) + else if ((is_bit_set (sleBck->getFieldU32 (sfFlags), lsfRequireAuth) + && !is_bit_set (sleRippleState->getFieldU32 (sfFlags), (bHigh ? lsfHighAuth : lsfLowAuth))) && sleRippleState->getFieldAmount(sfBalance) == zero) // CHECKME { WriteLog (lsWARNING, RippleCalc) << "pushNode: delay: can't receive IOUs from issuer without auth."; @@ -687,7 +687,7 @@ void PathState::setCanonical ( const Node& pnCur = psExpanded.vpnNodes[uNode]; const Node& pnNxt = psExpanded.vpnNodes[uNode + 1]; - const bool bCurAccount = isSetBit (pnCur.uFlags, STPathElement::typeAccount); + const bool bCurAccount = is_bit_set (pnCur.uFlags, STPathElement::typeAccount); bool bSkip = false; @@ -707,8 +707,8 @@ void PathState::setCanonical ( else { // Currently at an offer. - const bool bPrvAccount = isSetBit (pnPrv.uFlags, STPathElement::typeAccount); - const bool bNxtAccount = isSetBit (pnNxt.uFlags, STPathElement::typeAccount); + const bool bPrvAccount = is_bit_set (pnPrv.uFlags, STPathElement::typeAccount); + const bool bNxtAccount = is_bit_set (pnNxt.uFlags, STPathElement::typeAccount); if (bPrvAccount && bNxtAccount // Offer surrounded by accounts. && pnPrv.uCurrencyID != pnNxt.uCurrencyID) @@ -784,9 +784,9 @@ void PathState::checkNoRipple ( terStatus = terNO_LINE; } else if ( - isSetBit (sleIn->getFieldU32 (sfFlags), + is_bit_set (sleIn->getFieldU32 (sfFlags), (secondAccount > firstAccount) ? lsfHighNoRipple : lsfLowNoRipple) && - isSetBit (sleOut->getFieldU32 (sfFlags), + is_bit_set (sleOut->getFieldU32 (sfFlags), (secondAccount > thirdAccount) ? lsfHighNoRipple : lsfLowNoRipple)) { WriteLog (lsINFO, RippleCalc) << "Path violates noRipple constraint between " << @@ -810,7 +810,7 @@ void PathState::checkNoRipple (uint160 const& uDstAccountID, uint160 const& uSrc { // There's just one link in the path // We only need to check source-node-dest - if (isSetBit (vpnNodes[0].uFlags, STPathElement::typeAccount) && + if (is_bit_set (vpnNodes[0].uFlags, STPathElement::typeAccount) && (vpnNodes[0].uAccountID != uSrcAccountID) && (vpnNodes[0].uAccountID != uDstAccountID)) { @@ -824,8 +824,8 @@ void PathState::checkNoRipple (uint160 const& uDstAccountID, uint160 const& uSrc } // Check source <-> first <-> second - if (isSetBit (vpnNodes[0].uFlags, STPathElement::typeAccount) && - isSetBit (vpnNodes[1].uFlags, STPathElement::typeAccount) && + if (is_bit_set (vpnNodes[0].uFlags, STPathElement::typeAccount) && + is_bit_set (vpnNodes[1].uFlags, STPathElement::typeAccount) && (vpnNodes[0].uAccountID != uSrcAccountID)) { if ((vpnNodes[0].uCurrencyID != vpnNodes[1].uCurrencyID)) @@ -844,8 +844,8 @@ void PathState::checkNoRipple (uint160 const& uDstAccountID, uint160 const& uSrc // Check second_from_last <-> last <-> destination size_t s = vpnNodes.size() - 2; - if (isSetBit (vpnNodes[s].uFlags, STPathElement::typeAccount) && - isSetBit (vpnNodes[s+1].uFlags, STPathElement::typeAccount) && + if (is_bit_set (vpnNodes[s].uFlags, STPathElement::typeAccount) && + is_bit_set (vpnNodes[s+1].uFlags, STPathElement::typeAccount) && (uDstAccountID != vpnNodes[s+1].uAccountID)) { if ((vpnNodes[s].uCurrencyID != vpnNodes[s+1].uCurrencyID)) @@ -868,9 +868,9 @@ void PathState::checkNoRipple (uint160 const& uDstAccountID, uint160 const& uSrc for (int i = 1; i < (vpnNodes.size() - 1); ++i) { - if (isSetBit (vpnNodes[i-1].uFlags, STPathElement::typeAccount) && - isSetBit (vpnNodes[i].uFlags, STPathElement::typeAccount) && - isSetBit (vpnNodes[i+1].uFlags, STPathElement::typeAccount)) + if (is_bit_set (vpnNodes[i-1].uFlags, STPathElement::typeAccount) && + is_bit_set (vpnNodes[i].uFlags, STPathElement::typeAccount) && + is_bit_set (vpnNodes[i+1].uFlags, STPathElement::typeAccount)) { // two consecutive account-to-account links uint160 const& currencyID = vpnNodes[i].uCurrencyID; diff --git a/src/ripple_app/paths/Pathfinder.cpp b/src/ripple_app/paths/Pathfinder.cpp index e71790403..9c742227c 100644 --- a/src/ripple_app/paths/Pathfinder.cpp +++ b/src/ripple_app/paths/Pathfinder.cpp @@ -588,7 +588,7 @@ bool Pathfinder::isNoRipple (const uint160& setByID, const uint160& setOnID, con { SLE::pointer sleRipple = mLedger->getSLEi (Ledger::getRippleStateIndex (setByID, setOnID, currencyID)); return sleRipple && - isSetBit (sleRipple->getFieldU32 (sfFlags), (setByID > setOnID) ? lsfHighNoRipple : lsfLowNoRipple); + is_bit_set (sleRipple->getFieldU32 (sfFlags), (setByID > setOnID) ? lsfHighNoRipple : lsfLowNoRipple); } // Does this path end on an account-to-account link whose last account @@ -601,7 +601,7 @@ bool Pathfinder::isNoRippleOut (const STPath& currentPath) // Last link must be an account STPathElement const& endElement = *(currentPath.end() - 1); - if (!isSetBit(endElement.getNodeType(), STPathElement::typeAccount)) + if (!is_bit_set(endElement.getNodeType(), STPathElement::typeAccount)) return false; // What account are we leaving? @@ -640,7 +640,7 @@ void Pathfinder::addLink( SLE::pointer sleEnd = mLedger->getSLEi(Ledger::getAccountRootIndex(uEndAccount)); if (sleEnd) { - bool const bRequireAuth = isSetBit(sleEnd->getFieldU32(sfFlags), lsfRequireAuth); + bool const bRequireAuth = is_bit_set(sleEnd->getFieldU32(sfFlags), lsfRequireAuth); bool const bIsEndCurrency = (uEndCurrency == mDstAmount.getCurrency()); bool const bIsNoRippleOut = isNoRippleOut (currentPath); diff --git a/src/ripple_app/paths/RippleCalc.cpp b/src/ripple_app/paths/RippleCalc.cpp index ff557fbe3..379b0ee4a 100644 --- a/src/ripple_app/paths/RippleCalc.cpp +++ b/src/ripple_app/paths/RippleCalc.cpp @@ -1150,8 +1150,8 @@ TER RippleCalc::calcNodeAccountRev (const unsigned int uNode, PathState& psCur, PathState::Node& pnNxt = psCur.vpnNodes[uNode == uLast ? uLast : uNode + 1]; // Current is allowed to redeem to next. - const bool bPrvAccount = !uNode || isSetBit (pnPrv.uFlags, STPathElement::typeAccount); - const bool bNxtAccount = uNode == uLast || isSetBit (pnNxt.uFlags, STPathElement::typeAccount); + const bool bPrvAccount = !uNode || is_bit_set (pnPrv.uFlags, STPathElement::typeAccount); + const bool bNxtAccount = uNode == uLast || is_bit_set (pnNxt.uFlags, STPathElement::typeAccount); const uint160& uCurAccountID = pnCur.uAccountID; const uint160& uPrvAccountID = bPrvAccount ? pnPrv.uAccountID : uCurAccountID; @@ -1513,8 +1513,8 @@ TER RippleCalc::calcNodeAccountFwd ( PathState::Node& pnCur = psCur.vpnNodes[uNode]; PathState::Node& pnNxt = psCur.vpnNodes[uNode == uLast ? uLast : uNode + 1]; - const bool bPrvAccount = isSetBit (pnPrv.uFlags, STPathElement::typeAccount); - const bool bNxtAccount = isSetBit (pnNxt.uFlags, STPathElement::typeAccount); + const bool bPrvAccount = is_bit_set (pnPrv.uFlags, STPathElement::typeAccount); + const bool bNxtAccount = is_bit_set (pnNxt.uFlags, STPathElement::typeAccount); const uint160& uCurAccountID = pnCur.uAccountID; const uint160& uPrvAccountID = bPrvAccount ? pnPrv.uAccountID : uCurAccountID; @@ -1840,7 +1840,7 @@ TER RippleCalc::calcNodeAccountFwd ( TER RippleCalc::calcNodeFwd (const unsigned int uNode, PathState& psCur, const bool bMultiQuality) { const PathState::Node& pnCur = psCur.vpnNodes[uNode]; - const bool bCurAccount = isSetBit (pnCur.uFlags, STPathElement::typeAccount); + const bool bCurAccount = is_bit_set (pnCur.uFlags, STPathElement::typeAccount); WriteLog (lsTRACE, RippleCalc) << boost::str (boost::format ("calcNodeFwd> uNode=%d") % uNode); @@ -1875,7 +1875,7 @@ TER RippleCalc::calcNodeFwd (const unsigned int uNode, PathState& psCur, const b TER RippleCalc::calcNodeRev (const unsigned int uNode, PathState& psCur, const bool bMultiQuality) { PathState::Node& pnCur = psCur.vpnNodes[uNode]; - bool const bCurAccount = isSetBit (pnCur.uFlags, STPathElement::typeAccount); + bool const bCurAccount = is_bit_set (pnCur.uFlags, STPathElement::typeAccount); TER terResult; // Do current node reverse. diff --git a/src/ripple_app/paths/RippleState.h b/src/ripple_app/paths/RippleState.h index 89b5e0dca..44a50ef61 100644 --- a/src/ripple_app/paths/RippleState.h +++ b/src/ripple_app/paths/RippleState.h @@ -59,22 +59,22 @@ public: // True, Provided auth to peer. bool getAuth () const { - return isSetBit (mFlags, mViewLowest ? lsfLowAuth : lsfHighAuth); + return is_bit_set (mFlags, mViewLowest ? lsfLowAuth : lsfHighAuth); } bool getAuthPeer () const { - return isSetBit (mFlags, !mViewLowest ? lsfLowAuth : lsfHighAuth); + return is_bit_set (mFlags, !mViewLowest ? lsfLowAuth : lsfHighAuth); } bool getNoRipple () const { - return isSetBit (mFlags, mViewLowest ? lsfLowNoRipple : lsfHighNoRipple); + return is_bit_set (mFlags, mViewLowest ? lsfLowNoRipple : lsfHighNoRipple); } bool getNoRipplePeer () const { - return isSetBit (mFlags, !mViewLowest ? lsfLowNoRipple : lsfHighNoRipple); + return is_bit_set (mFlags, !mViewLowest ? lsfLowNoRipple : lsfHighNoRipple); } const STAmount& getBalance () const diff --git a/src/ripple_app/transactors/AccountSetTransactor.cpp b/src/ripple_app/transactors/AccountSetTransactor.cpp index f20556285..139aae6bd 100644 --- a/src/ripple_app/transactors/AccountSetTransactor.cpp +++ b/src/ripple_app/transactors/AccountSetTransactor.cpp @@ -53,20 +53,20 @@ TER AccountSetTransactor::doApply () return temINVALID_FLAG; } - if (bSetRequireAuth && !isSetBit (uFlagsIn, lsfRequireAuth)) + if (bSetRequireAuth && !is_bit_set (uFlagsIn, lsfRequireAuth)) { if (!mEngine->view().dirIsEmpty (Ledger::getOwnerDirIndex (mTxnAccountID))) { m_journal.trace << "Retry: Owner directory not empty."; - return isSetBit(mParams, tapRETRY) ? terOWNERS : tecOWNERS; + return is_bit_set(mParams, tapRETRY) ? terOWNERS : tecOWNERS; } m_journal.trace << "Set RequireAuth."; uFlagsOut |= lsfRequireAuth; } - if (bClearRequireAuth && isSetBit (uFlagsIn, lsfRequireAuth)) + if (bClearRequireAuth && is_bit_set (uFlagsIn, lsfRequireAuth)) { m_journal.trace << "Clear RequireAuth."; uFlagsOut &= ~lsfRequireAuth; @@ -82,13 +82,13 @@ TER AccountSetTransactor::doApply () return temINVALID_FLAG; } - if (bSetRequireDest && !isSetBit (uFlagsIn, lsfRequireDestTag)) + if (bSetRequireDest && !is_bit_set (uFlagsIn, lsfRequireDestTag)) { m_journal.trace << "Set lsfRequireDestTag."; uFlagsOut |= lsfRequireDestTag; } - if (bClearRequireDest && isSetBit (uFlagsIn, lsfRequireDestTag)) + if (bClearRequireDest && is_bit_set (uFlagsIn, lsfRequireDestTag)) { m_journal.trace << "Clear lsfRequireDestTag."; uFlagsOut &= ~lsfRequireDestTag; @@ -104,13 +104,13 @@ TER AccountSetTransactor::doApply () return temINVALID_FLAG; } - if (bSetDisallowXRP && !isSetBit (uFlagsIn, lsfDisallowXRP)) + if (bSetDisallowXRP && !is_bit_set (uFlagsIn, lsfDisallowXRP)) { m_journal.trace << "Set lsfDisallowXRP."; uFlagsOut |= lsfDisallowXRP; } - if (bClearDisallowXRP && isSetBit (uFlagsIn, lsfDisallowXRP)) + if (bClearDisallowXRP && is_bit_set (uFlagsIn, lsfDisallowXRP)) { m_journal.trace << "Clear lsfDisallowXRP."; uFlagsOut &= ~lsfDisallowXRP; @@ -126,7 +126,7 @@ TER AccountSetTransactor::doApply () return temINVALID_FLAG; } - if ((uSetFlag == asfDisableMaster) && !isSetBit (uFlagsIn, lsfDisableMaster)) + if ((uSetFlag == asfDisableMaster) && !is_bit_set (uFlagsIn, lsfDisableMaster)) { if (!mTxnAccount->isFieldPresent (sfRegularKey)) return tecNO_REGULAR_KEY; @@ -135,7 +135,7 @@ TER AccountSetTransactor::doApply () uFlagsOut |= lsfDisableMaster; } - if ((uClearFlag == asfDisableMaster) && isSetBit (uFlagsIn, lsfDisableMaster)) + if ((uClearFlag == asfDisableMaster) && is_bit_set (uFlagsIn, lsfDisableMaster)) { m_journal.trace << "Clear lsfDisableMaster."; uFlagsOut &= ~lsfDisableMaster; diff --git a/src/ripple_app/transactors/ChangeTransactor.cpp b/src/ripple_app/transactors/ChangeTransactor.cpp index 6acd1f87a..ca10fa966 100644 --- a/src/ripple_app/transactors/ChangeTransactor.cpp +++ b/src/ripple_app/transactors/ChangeTransactor.cpp @@ -80,7 +80,7 @@ TER ChangeTransactor::preCheck () return temBAD_SRC_ACCOUNT; } - if (isSetBit (mParams, tapOPEN_LEDGER)) + if (is_bit_set (mParams, tapOPEN_LEDGER)) { m_journal.warning << "Change transaction against open ledger"; return temINVALID; diff --git a/src/ripple_app/transactors/OfferCreateTransactor.cpp b/src/ripple_app/transactors/OfferCreateTransactor.cpp index bc8e94a01..f23c17d86 100644 --- a/src/ripple_app/transactors/OfferCreateTransactor.cpp +++ b/src/ripple_app/transactors/OfferCreateTransactor.cpp @@ -731,10 +731,10 @@ TER OfferCreateTransactor::doApply () "OfferCreate> " << mTxn.getJson (0); std::uint32_t const uTxFlags = mTxn.getFlags (); - bool const bPassive = isSetBit (uTxFlags, tfPassive); - bool const bImmediateOrCancel = isSetBit (uTxFlags, tfImmediateOrCancel); - bool const bFillOrKill = isSetBit (uTxFlags, tfFillOrKill); - bool const bSell = isSetBit (uTxFlags, tfSell); + bool const bPassive = is_bit_set (uTxFlags, tfPassive); + bool const bImmediateOrCancel = is_bit_set (uTxFlags, tfImmediateOrCancel); + bool const bFillOrKill = is_bit_set (uTxFlags, tfFillOrKill); + bool const bSell = is_bit_set (uTxFlags, tfSell); STAmount saTakerPays = mTxn.getFieldAmount (sfTakerPays); STAmount saTakerGets = mTxn.getFieldAmount (sfTakerGets); @@ -906,9 +906,9 @@ TER OfferCreateTransactor::doApply () "delay: can't receive IOUs from non-existent issuer: " << RippleAddress::createHumanAccountID (uPaysIssuerID); - terResult = isSetBit (mParams, tapRETRY) ? terNO_ACCOUNT : tecNO_ISSUER; + terResult = is_bit_set (mParams, tapRETRY) ? terNO_ACCOUNT : tecNO_ISSUER; } - else if (isSetBit (sleTakerPays->getFieldU32 (sfFlags), lsfRequireAuth)) + else if (is_bit_set (sleTakerPays->getFieldU32 (sfFlags), lsfRequireAuth)) { SLE::pointer sleRippleState (mEngine->entryCache ( ltRIPPLE_STATE, @@ -923,16 +923,16 @@ TER OfferCreateTransactor::doApply () if (!sleRippleState) { - terResult = isSetBit (mParams, tapRETRY) + terResult = is_bit_set (mParams, tapRETRY) ? terNO_LINE : tecNO_LINE; } - else if (!isSetBit (sleRippleState->getFieldU32 (sfFlags), (canonical_gt ? lsfHighAuth : lsfLowAuth))) + else if (!is_bit_set (sleRippleState->getFieldU32 (sfFlags), (canonical_gt ? lsfHighAuth : lsfLowAuth))) { m_journal.debug << "delay: can't receive IOUs from issuer without auth."; - terResult = isSetBit (mParams, tapRETRY) ? terNO_AUTH : tecNO_AUTH; + terResult = is_bit_set (mParams, tapRETRY) ? terNO_AUTH : tecNO_AUTH; } } } @@ -940,7 +940,7 @@ TER OfferCreateTransactor::doApply () STAmount saPaid; STAmount saGot; bool bUnfunded = false; - const bool bOpenLedger = isSetBit (mParams, tapOPEN_LEDGER); + const bool bOpenLedger = is_bit_set (mParams, tapOPEN_LEDGER); if ((tesSUCCESS == terResult) && !bExpired) { diff --git a/src/ripple_app/transactors/PaymentTransactor.cpp b/src/ripple_app/transactors/PaymentTransactor.cpp index baaaaba99..e2e28061a 100644 --- a/src/ripple_app/transactors/PaymentTransactor.cpp +++ b/src/ripple_app/transactors/PaymentTransactor.cpp @@ -23,9 +23,9 @@ TER PaymentTransactor::doApply () { // Ripple if source or destination is non-native or if there are paths. std::uint32_t const uTxFlags = mTxn.getFlags (); - bool const bPartialPayment = isSetBit (uTxFlags, tfPartialPayment); - bool const bLimitQuality = isSetBit (uTxFlags, tfLimitQuality); - bool const bNoRippleDirect = isSetBit (uTxFlags, tfNoRippleDirect); + bool const bPartialPayment = is_bit_set (uTxFlags, tfPartialPayment); + bool const bLimitQuality = is_bit_set (uTxFlags, tfLimitQuality); + bool const bNoRippleDirect = is_bit_set (uTxFlags, tfNoRippleDirect); bool const bPaths = mTxn.isFieldPresent (sfPaths); bool const bMax = mTxn.isFieldPresent (sfSendMax); uint160 const uDstAccountID = mTxn.getFieldAccount160 (sfDestination); @@ -154,7 +154,7 @@ TER PaymentTransactor::doApply () // Another transaction could create the account and then this transaction would succeed. return tecNO_DST; } - else if (isSetBit (mParams, tapOPEN_LEDGER) && bPartialPayment) + else if (is_bit_set (mParams, tapOPEN_LEDGER) && bPartialPayment) { // Make retry work smaller, by rejecting this. m_journal.trace << @@ -211,7 +211,7 @@ TER PaymentTransactor::doApply () try { - bool const openLedger = isSetBit (mParams, tapOPEN_LEDGER); + bool const openLedger = is_bit_set (mParams, tapOPEN_LEDGER); bool const tooManyPaths = spsPaths.size () > MaxPathSize; terResult = openLedger && tooManyPaths @@ -230,7 +230,7 @@ TER PaymentTransactor::doApply () bLimitQuality, bNoRippleDirect, // Always compute for finalizing ledger. false, // Not standalone, delete unfundeds. - isSetBit (mParams, tapOPEN_LEDGER)); + is_bit_set (mParams, tapOPEN_LEDGER)); if (isTerRetry(terResult)) terResult = tecPATH_DRY; diff --git a/src/ripple_app/transactors/Transactor.cpp b/src/ripple_app/transactors/Transactor.cpp index ca32b4c1e..cb7594850 100644 --- a/src/ripple_app/transactors/Transactor.cpp +++ b/src/ripple_app/transactors/Transactor.cpp @@ -92,7 +92,7 @@ Transactor::Transactor ( void Transactor::calculateFee () { mFeeDue = STAmount (mEngine->getLedger ()->scaleFeeLoad ( - calculateBaseFee (), isSetBit (mParams, tapADMIN))); + calculateBaseFee (), is_bit_set (mParams, tapADMIN))); } std::uint64_t Transactor::calculateBaseFee () @@ -108,7 +108,7 @@ TER Transactor::payFee () return temBAD_AMOUNT; // Only check fee is sufficient when the ledger is open. - if (isSetBit (mParams, tapOPEN_LEDGER) && saPaid < mFeeDue) + if (is_bit_set (mParams, tapOPEN_LEDGER) && saPaid < mFeeDue) { m_journal.trace << "Insufficient fee paid: " << saPaid.getText () << "/" << mFeeDue.getText (); @@ -239,7 +239,7 @@ TER Transactor::preCheck () // Consistency: really signed. if (!mTxn.isKnownGood ()) { - if (mTxn.isKnownBad () || (!isSetBit (mParams, tapNO_CHECK_SIGN) && !mTxn.checkSign (mSigningPubKey))) + if (mTxn.isKnownBad () || (!is_bit_set (mParams, tapNO_CHECK_SIGN) && !mTxn.checkSign (mSigningPubKey))) { mTxn.setBad (); m_journal.warning << "apply: Invalid transaction (bad signature)"; diff --git a/src/ripple_app/transactors/TrustSetTransactor.cpp b/src/ripple_app/transactors/TrustSetTransactor.cpp index 2b24f0c73..241f667a4 100644 --- a/src/ripple_app/transactors/TrustSetTransactor.cpp +++ b/src/ripple_app/transactors/TrustSetTransactor.cpp @@ -54,11 +54,11 @@ TER TrustSetTransactor::doApply () return temINVALID_FLAG; } - bool const bSetAuth = isSetBit (uTxFlags, tfSetfAuth); - bool const bSetNoRipple = isSetBit (uTxFlags, tfSetNoRipple); - bool const bClearNoRipple = isSetBit (uTxFlags, tfClearNoRipple); + bool const bSetAuth = is_bit_set (uTxFlags, tfSetfAuth); + bool const bSetNoRipple = is_bit_set (uTxFlags, tfSetNoRipple); + bool const bClearNoRipple = is_bit_set (uTxFlags, tfClearNoRipple); - if (bSetAuth && !isSetBit (mTxnAccount->getFieldU32 (sfFlags), lsfRequireAuth)) + if (bSetAuth && !is_bit_set (mTxnAccount->getFieldU32 (sfFlags), lsfRequireAuth)) { m_journal.trace << "Retry: Auth not required."; @@ -248,19 +248,19 @@ TER TrustSetTransactor::doApply () bool const bLowReserveSet = uLowQualityIn || uLowQualityOut || - isSetBit (uFlagsOut, lsfLowNoRipple) || + is_bit_set (uFlagsOut, lsfLowNoRipple) || !!saLowLimit || saLowBalance > zero; bool const bLowReserveClear = !bLowReserveSet; bool const bHighReserveSet = uHighQualityIn || uHighQualityOut || - isSetBit (uFlagsOut, lsfHighNoRipple) || + is_bit_set (uFlagsOut, lsfHighNoRipple) || !!saHighLimit || saHighBalance > zero; bool const bHighReserveClear = !bHighReserveSet; bool const bDefault = bLowReserveClear && bHighReserveClear; - bool const bLowReserved = isSetBit (uFlagsIn, lsfLowReserve); - bool const bHighReserved = isSetBit (uFlagsIn, lsfHighReserve); + bool const bLowReserved = is_bit_set (uFlagsIn, lsfLowReserve); + bool const bHighReserved = is_bit_set (uFlagsIn, lsfHighReserve); bool bReserveIncrease = false; diff --git a/src/ripple_app/tx/TransactionEngine.cpp b/src/ripple_app/tx/TransactionEngine.cpp index ff7f81228..af362655a 100644 --- a/src/ripple_app/tx/TransactionEngine.cpp +++ b/src/ripple_app/tx/TransactionEngine.cpp @@ -127,7 +127,7 @@ TER TransactionEngine::applyTransaction (const SerializedTransaction& txn, Trans if (isTesSuccess (terResult)) didApply = true; - else if (isTecClaim (terResult) && !isSetBit (params, tapRETRY)) + else if (isTecClaim (terResult) && !is_bit_set (params, tapRETRY)) { // only claim the transaction fee WriteLog (lsDEBUG, TransactionEngine) << "Reprocessing to only claim fee"; @@ -188,7 +188,7 @@ TER TransactionEngine::applyTransaction (const SerializedTransaction& txn, Trans Serializer s; txn.add (s); - if (isSetBit (params, tapOPEN_LEDGER)) + if (is_bit_set (params, tapOPEN_LEDGER)) { if (!mLedger->addTransaction (txID, s)) { @@ -216,7 +216,7 @@ TER TransactionEngine::applyTransaction (const SerializedTransaction& txn, Trans mTxnAccount.reset (); mNodes.clear (); - if (!isSetBit (params, tapOPEN_LEDGER) && isTemMalformed (terResult)) + if (!is_bit_set (params, tapOPEN_LEDGER) && isTemMalformed (terResult)) { // XXX Malformed or failed transaction in closed ledger must bow out. } diff --git a/src/ripple_basics/utility/PlatformMacros.h b/src/ripple_basics/utility/PlatformMacros.h index 1df19b542..73445e0ce 100644 --- a/src/ripple_basics/utility/PlatformMacros.h +++ b/src/ripple_basics/utility/PlatformMacros.h @@ -21,6 +21,7 @@ #define RIPPLE_PLATFORMMACROS_H #include +#include "../../beast/beast/cxx14/type_traits.h" // namespace ripple { @@ -30,11 +31,22 @@ namespace ripple { #define P_3 std::placeholders::_3 #define P_4 std::placeholders::_4 +template +inline +std::enable_if_t< + (std::is_integral::value || std::is_enum::value) && + (std::is_integral::value || std::is_enum::value), +bool> +is_bit_set(X const x, Y const y) +{ + return (x & y); +} + // VFALCO TODO Clean this stuff up. Remove as much as possible // DEPRECATED #define nothing() do {} while (0) #define NUMBER(x) (sizeof(x)/sizeof((x)[0])) -#define isSetBit(x,y) (!!((x) & (y))) +#define is_bit_set(x,y) (!!((x) & (y))) } // ripple diff --git a/src/ripple_overlay/impl/PeerImp.h b/src/ripple_overlay/impl/PeerImp.h index edfac9444..39b3a3d5d 100644 --- a/src/ripple_overlay/impl/PeerImp.h +++ b/src/ripple_overlay/impl/PeerImp.h @@ -1521,13 +1521,13 @@ private: if (! getApp().getHashRouter ().addSuppressionPeer (txID, m_shortId, flags)) { // we have seen this transaction recently - if (isSetBit (flags, SF_BAD)) + if (is_bit_set (flags, SF_BAD)) { charge (Resource::feeInvalidSignature); return; } - if (!isSetBit (flags, SF_RETRY)) + if (!is_bit_set (flags, SF_RETRY)) return; } @@ -2616,7 +2616,7 @@ private: return; } - bool needCheck = ! isSetBit (flags, SF_SIGGOOD); + bool needCheck = ! is_bit_set (flags, SF_SIGGOOD); Transaction::pointer tx = boost::make_shared (stx, needCheck); @@ -2629,7 +2629,7 @@ private: else getApp().getHashRouter ().setFlag (stx->getTransactionID (), SF_SIGGOOD); - getApp().getOPs ().processTransaction (tx, isSetBit (flags, SF_TRUSTED), false, false); + getApp().getOPs ().processTransaction (tx, is_bit_set (flags, SF_TRUSTED), false, false); #ifndef TRUST_NETWORK }