From e04b69543409bc19a579c96be235ca1e83ac1cbd Mon Sep 17 00:00:00 2001 From: JoelKatz Date: Mon, 1 Oct 2012 15:35:30 -0700 Subject: [PATCH] Burninate "Value" in "*ValueField*" functions. It was just pointless extra typing. What else would you set/get in a field, by name, other than its value? --- src/AccountState.cpp | 4 +- src/AccountState.h | 6 +- src/Ledger.cpp | 4 +- src/LedgerEntrySet.cpp | 100 ++++++++++---------- src/NetworkOPs.cpp | 14 +-- src/NicknameState.cpp | 4 +- src/OrderBook.cpp | 4 +- src/RPCServer.cpp | 4 +- src/RippleCalc.cpp | 28 +++--- src/RippleLines.cpp | 4 +- src/RippleState.cpp | 14 +-- src/SerializedLedger.cpp | 24 ++--- src/SerializedLedger.h | 2 +- src/SerializedObject.cpp | 60 ++++++------ src/SerializedObject.h | 58 ++++++------ src/SerializedTransaction.cpp | 14 +-- src/SerializedTransaction.h | 14 +-- src/SerializedValidation.cpp | 16 ++-- src/Transaction.cpp | 74 +++++++-------- src/Transaction.h | 4 +- src/TransactionAction.cpp | 172 +++++++++++++++++----------------- src/TransactionEngine.cpp | 12 +-- 22 files changed, 318 insertions(+), 318 deletions(-) diff --git a/src/AccountState.cpp b/src/AccountState.cpp index 42acd03d42..9aee8f8694 100644 --- a/src/AccountState.cpp +++ b/src/AccountState.cpp @@ -17,7 +17,7 @@ AccountState::AccountState(const NewcoinAddress& naAccountID) : mAccountID(naAcc mLedgerEntry = boost::make_shared(ltACCOUNT_ROOT); mLedgerEntry->setIndex(Ledger::getAccountRootIndex(naAccountID)); - mLedgerEntry->setValueFieldAccount(sfAccount, naAccountID.getAccountID()); + mLedgerEntry->setFieldAccount(sfAccount, naAccountID.getAccountID()); mValid = true; } @@ -49,7 +49,7 @@ void AccountState::addJson(Json::Value& val) if (mValid) { if (mLedgerEntry->isFieldPresent(sfEmailHash)) - val["UrlGravatar"] = createGravatarUrl(mLedgerEntry->getValueFieldH128(sfEmailHash)); + val["UrlGravatar"] = createGravatarUrl(mLedgerEntry->getFieldH128(sfEmailHash)); } else { diff --git a/src/AccountState.h b/src/AccountState.h index b0d68205bb..728d5ae96a 100644 --- a/src/AccountState.h +++ b/src/AccountState.h @@ -38,11 +38,11 @@ public: NewcoinAddress getAuthorizedKey() { - return mLedgerEntry->getValueFieldAccount(sfAuthorizedKey); + return mLedgerEntry->getFieldAccount(sfAuthorizedKey); } - STAmount getBalance() const { return mLedgerEntry->getValueFieldAmount(sfBalance); } - uint32 getSeq() const { return mLedgerEntry->getValueFieldU32(sfSequence); } + STAmount getBalance() const { return mLedgerEntry->getFieldAmount(sfBalance); } + uint32 getSeq() const { return mLedgerEntry->getFieldU32(sfSequence); } SerializedLedgerEntry::pointer getSLE() { return mLedgerEntry; } const SerializedLedgerEntry& peekSLE() const { return *mLedgerEntry; } diff --git a/src/Ledger.cpp b/src/Ledger.cpp index f9c4bf343f..2f3c8cfdf1 100644 --- a/src/Ledger.cpp +++ b/src/Ledger.cpp @@ -27,8 +27,8 @@ Ledger::Ledger(const NewcoinAddress& masterID, uint64 startAmount) : mTotCoins(s { // special case: put coins in root account AccountState::pointer startAccount = boost::make_shared(masterID); - startAccount->peekSLE().setValueFieldAmount(sfBalance, startAmount); - startAccount->peekSLE().setValueFieldU32(sfSequence, 1); + startAccount->peekSLE().setFieldAmount(sfBalance, startAmount); + startAccount->peekSLE().setFieldU32(sfSequence, 1); writeBack(lepCREATE, startAccount->getSLE()); #if 0 std::cerr << "Root account:"; diff --git a/src/LedgerEntrySet.cpp b/src/LedgerEntrySet.cpp index 5147ed6286..22f0798422 100644 --- a/src/LedgerEntrySet.cpp +++ b/src/LedgerEntrySet.cpp @@ -385,26 +385,26 @@ void LedgerEntrySet::calcRawMeta(Serializer& s) if (origNode->isFieldPresent(sfAmount)) { // node has an amount, covers ripple state nodes - STAmount amount = origNode->getValueFieldAmount(sfAmount); + STAmount amount = origNode->getFieldAmount(sfAmount); if (amount.isNonZero()) metaNode.addAmount(TMSPrevBalance, amount); - amount = curNode->getValueFieldAmount(sfAmount); + amount = curNode->getFieldAmount(sfAmount); if (amount.isNonZero()) metaNode.addAmount(TMSFinalBalance, amount); if (origNode->getType() == ltRIPPLE_STATE) { - metaNode.addAccount(TMSLowID, NewcoinAddress::createAccountID(origNode->getValueFieldAmount(sfLowLimit).getIssuer())); - metaNode.addAccount(TMSHighID, NewcoinAddress::createAccountID(origNode->getValueFieldAmount(sfHighLimit).getIssuer())); + metaNode.addAccount(TMSLowID, NewcoinAddress::createAccountID(origNode->getFieldAmount(sfLowLimit).getIssuer())); + metaNode.addAccount(TMSHighID, NewcoinAddress::createAccountID(origNode->getFieldAmount(sfHighLimit).getIssuer())); } } if (origNode->getType() == ltOFFER) { // check for non-zero balances - STAmount amount = origNode->getValueFieldAmount(sfTakerPays); + STAmount amount = origNode->getFieldAmount(sfTakerPays); if (amount.isNonZero()) metaNode.addAmount(TMSFinalTakerPays, amount); - amount = origNode->getValueFieldAmount(sfTakerGets); + amount = origNode->getFieldAmount(sfTakerGets); if (amount.isNonZero()) metaNode.addAmount(TMSFinalTakerGets, amount); } @@ -431,18 +431,18 @@ void LedgerEntrySet::calcRawMeta(Serializer& s) assert(origNode); if (origNode->isFieldPresent(sfAmount)) { // node has an amount, covers account root nodes and ripple nodes - STAmount amount = origNode->getValueFieldAmount(sfAmount); - if (amount != curNode->getValueFieldAmount(sfAmount)) + STAmount amount = origNode->getFieldAmount(sfAmount); + if (amount != curNode->getFieldAmount(sfAmount)) metaNode.addAmount(TMSPrevBalance, amount); } if (origNode->getType() == ltOFFER) { - STAmount amount = origNode->getValueFieldAmount(sfTakerPays); - if (amount != curNode->getValueFieldAmount(sfTakerPays)) + STAmount amount = origNode->getFieldAmount(sfTakerPays); + if (amount != curNode->getFieldAmount(sfTakerPays)) metaNode.addAmount(TMSPrevTakerPays, amount); - amount = origNode->getValueFieldAmount(sfTakerGets); - if (amount != curNode->getValueFieldAmount(sfTakerGets)) + amount = origNode->getFieldAmount(sfTakerGets); + if (amount != curNode->getFieldAmount(sfTakerGets)) metaNode.addAmount(TMSPrevTakerGets, amount); } @@ -485,7 +485,7 @@ TER LedgerEntrySet::dirAdd( } else { - uNodeDir = sleRoot->getValueFieldU64(sfIndexPrevious); // Get index to last directory node. + uNodeDir = sleRoot->getFieldU64(sfIndexPrevious); // Get index to last directory node. if (uNodeDir) { @@ -500,7 +500,7 @@ TER LedgerEntrySet::dirAdd( sleNode = sleRoot; } - svIndexes = sleNode->getValueFieldV256(sfIndexes); + svIndexes = sleNode->getFieldV256(sfIndexes); if (DIR_NODE_MAX != svIndexes.peekValue().size()) { @@ -519,7 +519,7 @@ TER LedgerEntrySet::dirAdd( { // Previous node is root node. - sleRoot->setValueFieldU64(sfIndexNext, uNodeDir); + sleRoot->setFieldU64(sfIndexNext, uNodeDir); } else { @@ -527,14 +527,14 @@ TER LedgerEntrySet::dirAdd( SLE::pointer slePrevious = entryCache(ltDIR_NODE, Ledger::getDirNodeIndex(uRootIndex, uNodeDir-1)); - slePrevious->setValueFieldU64(sfIndexNext, uNodeDir); + slePrevious->setFieldU64(sfIndexNext, uNodeDir); entryModify(slePrevious); - sleNode->setValueFieldU64(sfIndexPrevious, uNodeDir-1); + sleNode->setFieldU64(sfIndexPrevious, uNodeDir-1); } // Have root point to new node. - sleRoot->setValueFieldU64(sfIndexPrevious, uNodeDir); + sleRoot->setFieldU64(sfIndexPrevious, uNodeDir); entryModify(sleRoot); // Create the new node. @@ -544,7 +544,7 @@ TER LedgerEntrySet::dirAdd( } svIndexes.peekValue().push_back(uLedgerIndex); // Append entry. - sleNode->setValueFieldV256(sfIndexes, svIndexes); // Save entry. + sleNode->setFieldV256(sfIndexes, svIndexes); // Save entry. Log(lsINFO) << "dirAdd: creating: root: " << uRootIndex.ToString(); Log(lsINFO) << "dirAdd: appending: Entry: " << uLedgerIndex.ToString(); @@ -574,7 +574,7 @@ TER LedgerEntrySet::dirDelete( return tefBAD_LEDGER; } - STVector256 svIndexes = sleNode->getValueFieldV256(sfIndexes); + STVector256 svIndexes = sleNode->getFieldV256(sfIndexes); std::vector& vuiIndexes = svIndexes.peekValue(); std::vector::iterator it; @@ -608,14 +608,14 @@ TER LedgerEntrySet::dirDelete( vuiIndexes.clear(); } - sleNode->setValueFieldV256(sfIndexes, svIndexes); + sleNode->setFieldV256(sfIndexes, svIndexes); entryModify(sleNode); if (vuiIndexes.empty()) { // May be able to delete nodes. - uint64 uNodePrevious = sleNode->getValueFieldU64(sfIndexPrevious); - uint64 uNodeNext = sleNode->getValueFieldU64(sfIndexNext); + uint64 uNodePrevious = sleNode->getFieldU64(sfIndexPrevious); + uint64 uNodeNext = sleNode->getFieldU64(sfIndexNext); if (!uNodeCur) { @@ -646,7 +646,7 @@ TER LedgerEntrySet::dirDelete( assert(sleLast); - if (sleLast->getValueFieldV256(sfIndexes).peekValue().empty()) + if (sleLast->getFieldV256(sfIndexes).peekValue().empty()) { // Both nodes are empty. @@ -690,11 +690,11 @@ TER LedgerEntrySet::dirDelete( } // Fix previous to point to its new next. - slePrevious->setValueFieldU64(sfIndexNext, uNodeNext); + slePrevious->setFieldU64(sfIndexNext, uNodeNext); entryModify(slePrevious); // Fix next to point to its new previous. - sleNext->setValueFieldU64(sfIndexPrevious, uNodePrevious); + sleNext->setFieldU64(sfIndexPrevious, uNodePrevious); entryModify(sleNext); } // Last node. @@ -712,7 +712,7 @@ TER LedgerEntrySet::dirDelete( assert(sleRoot); - if (sleRoot->getValueFieldV256(sfIndexes).peekValue().empty()) + if (sleRoot->getFieldV256(sfIndexes).peekValue().empty()) { // Both nodes are empty. @@ -755,12 +755,12 @@ bool LedgerEntrySet::dirNext( unsigned int& uDirEntry, // <-> next entry uint256& uEntryIndex) // <-- The entry, if available. Otherwise, zero. { - STVector256 svIndexes = sleNode->getValueFieldV256(sfIndexes); + STVector256 svIndexes = sleNode->getFieldV256(sfIndexes); std::vector& vuiIndexes = svIndexes.peekValue(); if (uDirEntry == vuiIndexes.size()) { - uint64 uNodeNext = sleNode->getValueFieldU64(sfIndexNext); + uint64 uNodeNext = sleNode->getFieldU64(sfIndexNext); if (!uNodeNext) { @@ -785,13 +785,13 @@ Log(lsINFO) << boost::str(boost::format("dirNext: uDirEntry=%d uEntryIndex=%s") TER LedgerEntrySet::offerDelete(const SLE::pointer& sleOffer, const uint256& uOfferIndex, const uint160& uOwnerID) { - uint64 uOwnerNode = sleOffer->getValueFieldU64(sfOwnerNode); + uint64 uOwnerNode = sleOffer->getFieldU64(sfOwnerNode); TER terResult = dirDelete(false, uOwnerNode, Ledger::getOwnerDirIndex(uOwnerID), uOfferIndex, false); if (tesSUCCESS == terResult) { - uint256 uDirectory = sleOffer->getValueFieldH256(sfBookDirectory); - uint64 uBookNode = sleOffer->getValueFieldU64(sfBookNode); + uint256 uDirectory = sleOffer->getFieldH256(sfBookDirectory); + uint64 uBookNode = sleOffer->getFieldU64(sfBookNode); terResult = dirDelete(false, uBookNode, uDirectory, uOfferIndex, true); } @@ -804,7 +804,7 @@ TER LedgerEntrySet::offerDelete(const SLE::pointer& sleOffer, const uint256& uOf TER LedgerEntrySet::offerDelete(const uint256& uOfferIndex) { SLE::pointer sleOffer = entryCache(ltOFFER, uOfferIndex); - const uint160 uOwnerID = sleOffer->getValueFieldAccount(sfAccount).getAccountID(); + const uint160 uOwnerID = sleOffer->getFieldAccount(sfAccount).getAccountID(); return offerDelete(sleOffer, uOfferIndex, uOwnerID); } @@ -818,7 +818,7 @@ STAmount LedgerEntrySet::rippleOwed(const uint160& uToAccountID, const uint160& if (sleRippleState) { - saBalance = sleRippleState->getValueFieldAmount(sfBalance); + saBalance = sleRippleState->getFieldAmount(sfBalance); if (uToAccountID < uFromAccountID) saBalance.negate(); saBalance.setIssuer(uToAccountID); @@ -849,7 +849,7 @@ STAmount LedgerEntrySet::rippleLimit(const uint160& uToAccountID, const uint160& assert(sleRippleState); if (sleRippleState) { - saLimit = sleRippleState->getValueFieldAmount(uToAccountID < uFromAccountID ? sfLowLimit : sfHighLimit); + saLimit = sleRippleState->getFieldAmount(uToAccountID < uFromAccountID ? sfLowLimit : sfHighLimit); saLimit.setIssuer(uToAccountID); } @@ -862,7 +862,7 @@ uint32 LedgerEntrySet::rippleTransferRate(const uint160& uIssuerID) SLE::pointer sleAccount = entryCache(ltACCOUNT_ROOT, Ledger::getAccountRootIndex(uIssuerID)); uint32 uQuality = sleAccount && sleAccount->isFieldPresent(sfTransferRate) - ? sleAccount->getValueFieldU32(sfTransferRate) + ? sleAccount->getFieldU32(sfTransferRate) : QUALITY_ONE; Log(lsINFO) << boost::str(boost::format("rippleTransferRate: uIssuerID=%s account_exists=%d transfer_rate=%f") @@ -894,7 +894,7 @@ uint32 LedgerEntrySet::rippleQualityIn(const uint160& uToAccountID, const uint16 SField::ref sfField = uToAccountID < uFromAccountID ? sfLow: sfHigh; uQuality = sleRippleState->isFieldPresent(sfField) - ? sleRippleState->getValueFieldU32(sfField) + ? sleRippleState->getFieldU32(sfField) : QUALITY_ONE; if (!uQuality) @@ -924,7 +924,7 @@ STAmount LedgerEntrySet::rippleHolds(const uint160& uAccountID, const uint160& u if (sleRippleState) { - saBalance = sleRippleState->getValueFieldAmount(sfBalance); + saBalance = sleRippleState->getFieldAmount(sfBalance); if (uAccountID > uIssuerID) saBalance.negate(); // Put balance in uAccountID terms. @@ -942,7 +942,7 @@ STAmount LedgerEntrySet::accountHolds(const uint160& uAccountID, const uint160& { SLE::pointer sleAccount = entryCache(ltACCOUNT_ROOT, Ledger::getAccountRootIndex(uAccountID)); - saAmount = sleAccount->getValueFieldAmount(sfBalance); + saAmount = sleAccount->getFieldAmount(sfBalance); } else { @@ -1031,13 +1031,13 @@ void LedgerEntrySet::rippleCredit(const uint160& uSenderID, const uint160& uRece if (!bFlipped) saBalance.negate(); - sleRippleState->setValueFieldAmount(sfBalance, saBalance); - sleRippleState->setValueFieldAmount(bFlipped ? sfHighLimit : sfLowLimit, STAmount(uCurrencyID, uSenderID)); - sleRippleState->setValueFieldAmount(bFlipped ? sfLowLimit : sfHighLimit, STAmount(uCurrencyID, uReceiverID)); + sleRippleState->setFieldAmount(sfBalance, saBalance); + sleRippleState->setFieldAmount(bFlipped ? sfHighLimit : sfLowLimit, STAmount(uCurrencyID, uSenderID)); + sleRippleState->setFieldAmount(bFlipped ? sfLowLimit : sfHighLimit, STAmount(uCurrencyID, uReceiverID)); } else { - STAmount saBalance = sleRippleState->getValueFieldAmount(sfBalance); + STAmount saBalance = sleRippleState->getFieldAmount(sfBalance); if (!bFlipped) saBalance.negate(); // Put balance in low terms. @@ -1047,7 +1047,7 @@ void LedgerEntrySet::rippleCredit(const uint160& uSenderID, const uint160& uRece if (!bFlipped) saBalance.negate(); - sleRippleState->setValueFieldAmount(sfBalance, saBalance); + sleRippleState->setFieldAmount(sfBalance, saBalance); entryModify(sleRippleState); } @@ -1106,28 +1106,28 @@ void LedgerEntrySet::accountSend(const uint160& uSenderID, const uint160& uRecei Log(lsINFO) << boost::str(boost::format("accountSend> %s (%s) -> %s (%s) : %s") % NewcoinAddress::createHumanAccountID(uSenderID) - % (sleSender ? (sleSender->getValueFieldAmount(sfBalance)).getFullText() : "-") + % (sleSender ? (sleSender->getFieldAmount(sfBalance)).getFullText() : "-") % NewcoinAddress::createHumanAccountID(uReceiverID) - % (sleReceiver ? (sleReceiver->getValueFieldAmount(sfBalance)).getFullText() : "-") + % (sleReceiver ? (sleReceiver->getFieldAmount(sfBalance)).getFullText() : "-") % saAmount.getFullText()); if (sleSender) { - sleSender->setValueFieldAmount(sfBalance, sleSender->getValueFieldAmount(sfBalance) - saAmount); + sleSender->setFieldAmount(sfBalance, sleSender->getFieldAmount(sfBalance) - saAmount); entryModify(sleSender); } if (sleReceiver) { - sleReceiver->setValueFieldAmount(sfBalance, sleReceiver->getValueFieldAmount(sfBalance) + saAmount); + sleReceiver->setFieldAmount(sfBalance, sleReceiver->getFieldAmount(sfBalance) + saAmount); entryModify(sleReceiver); } Log(lsINFO) << boost::str(boost::format("accountSend< %s (%s) -> %s (%s) : %s") % NewcoinAddress::createHumanAccountID(uSenderID) - % (sleSender ? (sleSender->getValueFieldAmount(sfBalance)).getFullText() : "-") + % (sleSender ? (sleSender->getFieldAmount(sfBalance)).getFullText() : "-") % NewcoinAddress::createHumanAccountID(uReceiverID) - % (sleReceiver ? (sleReceiver->getValueFieldAmount(sfBalance)).getFullText() : "-") + % (sleReceiver ? (sleReceiver->getFieldAmount(sfBalance)).getFullText() : "-") % saAmount.getFullText()); } else diff --git a/src/NetworkOPs.cpp b/src/NetworkOPs.cpp index c645fd1fbb..ce77bf69d7 100644 --- a/src/NetworkOPs.cpp +++ b/src/NetworkOPs.cpp @@ -245,12 +245,12 @@ STVector256 NetworkOPs::getDirNodeInfo( { Log(lsDEBUG) << "getDirNodeInfo: node index: " << uNodeIndex.ToString(); - Log(lsTRACE) << "getDirNodeInfo: first: " << strHex(sleNode->getValueFieldU64(sfIndexPrevious)); - Log(lsTRACE) << "getDirNodeInfo: last: " << strHex(sleNode->getValueFieldU64(sfIndexNext)); + Log(lsTRACE) << "getDirNodeInfo: first: " << strHex(sleNode->getFieldU64(sfIndexPrevious)); + Log(lsTRACE) << "getDirNodeInfo: last: " << strHex(sleNode->getFieldU64(sfIndexNext)); - uNodePrevious = sleNode->getValueFieldU64(sfIndexPrevious); - uNodeNext = sleNode->getValueFieldU64(sfIndexNext); - svIndexes = sleNode->getValueFieldV256(sfIndexes); + uNodePrevious = sleNode->getFieldU64(sfIndexPrevious); + uNodeNext = sleNode->getFieldU64(sfIndexNext); + svIndexes = sleNode->getFieldV256(sfIndexes); Log(lsTRACE) << "getDirNodeInfo: first: " << strHex(uNodePrevious); Log(lsTRACE) << "getDirNodeInfo: last: " << strHex(uNodeNext); @@ -299,7 +299,7 @@ Json::Value NetworkOPs::getOwnerInfo(Ledger::pointer lpLedger, const NewcoinAddr do { - STVector256 svIndexes = sleNode->getValueFieldV256(sfIndexes); + STVector256 svIndexes = sleNode->getFieldV256(sfIndexes); const std::vector& vuiIndexes = svIndexes.peekValue(); BOOST_FOREACH(const uint256& uDirEntry, vuiIndexes) @@ -332,7 +332,7 @@ Json::Value NetworkOPs::getOwnerInfo(Ledger::pointer lpLedger, const NewcoinAddr } } - uNodeDir = sleNode->getValueFieldU64(sfIndexNext); + uNodeDir = sleNode->getFieldU64(sfIndexNext); if (uNodeDir) { lspNode = lepNONE; diff --git a/src/NicknameState.cpp b/src/NicknameState.cpp index e1dcb39aa8..72fbaa662f 100644 --- a/src/NicknameState.cpp +++ b/src/NicknameState.cpp @@ -14,13 +14,13 @@ bool NicknameState::haveMinimumOffer() const STAmount NicknameState::getMinimumOffer() const { return mLedgerEntry->isFieldPresent(sfMinimumOffer) - ? mLedgerEntry->getValueFieldAmount(sfMinimumOffer) + ? mLedgerEntry->getFieldAmount(sfMinimumOffer) : STAmount(); } NewcoinAddress NicknameState::getAccountID() const { - return mLedgerEntry->getValueFieldAccount(sfAccount); + return mLedgerEntry->getFieldAccount(sfAccount); } void NicknameState::addJson(Json::Value& val) diff --git a/src/OrderBook.cpp b/src/OrderBook.cpp index 9c032b9670..2cf716257e 100644 --- a/src/OrderBook.cpp +++ b/src/OrderBook.cpp @@ -10,8 +10,8 @@ OrderBook::pointer OrderBook::newOrderBook(SerializedLedgerEntry::pointer ledger OrderBook::OrderBook(SerializedLedgerEntry::pointer ledgerEntry) { - const STAmount saTakerGets = ledgerEntry->getValueFieldAmount(sfTakerGets); - const STAmount saTakerPays = ledgerEntry->getValueFieldAmount(sfTakerPays); + const STAmount saTakerGets = ledgerEntry->getFieldAmount(sfTakerGets); + const STAmount saTakerPays = ledgerEntry->getFieldAmount(sfTakerPays); mCurrencyIn = saTakerGets.getCurrency(); mCurrencyOut = saTakerPays.getCurrency(); diff --git a/src/RPCServer.cpp b/src/RPCServer.cpp index f1247f23c5..ef0feb4933 100644 --- a/src/RPCServer.cpp +++ b/src/RPCServer.cpp @@ -252,7 +252,7 @@ Json::Value RPCServer::getMasterGenerator(const uint256& uLedger, const NewcoinA return RPCError(rpcNO_ACCOUNT); } - std::vector vucCipher = sleGen->getValueFieldVL(sfGenerator); + std::vector vucCipher = sleGen->getFieldVL(sfGenerator); std::vector vucMasterGenerator = na0Private.accountPrivateDecrypt(na0Public, vucCipher); if (vucMasterGenerator.empty()) { @@ -402,7 +402,7 @@ Json::Value RPCServer::accountFromString(const uint256& uLedger, NewcoinAddress& else { // Found master public key. - std::vector vucCipher = sleGen->getValueFieldVL(sfGenerator); + std::vector vucCipher = sleGen->getFieldVL(sfGenerator); std::vector vucMasterGenerator = naRegular0Private.accountPrivateDecrypt(naRegular0Public, vucCipher); if (vucMasterGenerator.empty()) { diff --git a/src/RippleCalc.cpp b/src/RippleCalc.cpp index 1292964cb4..e768d8180a 100644 --- a/src/RippleCalc.cpp +++ b/src/RippleCalc.cpp @@ -116,8 +116,8 @@ TER RippleCalc::calcNodeAdvance( { if (bFundsDirty) { - saTakerPays = sleOffer->getValueFieldAmount(sfTakerPays); - saTakerGets = sleOffer->getValueFieldAmount(sfTakerGets); + saTakerPays = sleOffer->getFieldAmount(sfTakerPays); + saTakerGets = sleOffer->getFieldAmount(sfTakerGets); saOfferFunds = lesActive.accountFunds(uOfrOwnerID, saTakerGets); // Funds left. bFundsDirty = false; @@ -153,13 +153,13 @@ TER RippleCalc::calcNodeAdvance( { // Got a new offer. sleOffer = lesActive.entryCache(ltOFFER, uOfferIndex); - uOfrOwnerID = sleOffer->getValueFieldAccount(sfAccount).getAccountID(); + uOfrOwnerID = sleOffer->getFieldAccount(sfAccount).getAccountID(); const aciSource asLine = boost::make_tuple(uOfrOwnerID, uCurCurrencyID, uCurIssuerID); Log(lsINFO) << boost::str(boost::format("calcNodeAdvance: uOfrOwnerID=%s") % NewcoinAddress::createHumanAccountID(uOfrOwnerID)); - if (sleOffer->isFieldPresent(sfExpiration) && sleOffer->getValueFieldU32(sfExpiration) <= lesActive.getLedger()->getParentCloseTimeNC()) + if (sleOffer->isFieldPresent(sfExpiration) && sleOffer->getFieldU32(sfExpiration) <= lesActive.getLedger()->getParentCloseTimeNC()) { // Offer is expired. Log(lsINFO) << "calcNodeAdvance: expired offer"; @@ -207,8 +207,8 @@ TER RippleCalc::calcNodeAdvance( continue; } - saTakerPays = sleOffer->getValueFieldAmount(sfTakerPays); - saTakerGets = sleOffer->getValueFieldAmount(sfTakerGets); + saTakerPays = sleOffer->getFieldAmount(sfTakerPays); + saTakerGets = sleOffer->getFieldAmount(sfTakerGets); saOfferFunds = lesActive.accountFunds(uOfrOwnerID, saTakerGets); // Funds left. @@ -430,8 +430,8 @@ TER RippleCalc::calcNodeDeliverRev( lesActive.accountSend(uOfrOwnerID, uCurIssuerID, saOutPass); // Adjust offer - sleOffer->setValueFieldAmount(sfTakerGets, saTakerGets - saOutPass); - sleOffer->setValueFieldAmount(sfTakerPays, saTakerPays - saInPassAct); + sleOffer->setFieldAmount(sfTakerGets, saTakerGets - saOutPass); + sleOffer->setFieldAmount(sfTakerPays, saTakerPays - saInPassAct); lesActive.entryModify(sleOffer); @@ -580,8 +580,8 @@ TER RippleCalc::calcNodeDeliverFwd( lesActive.accountSend(uInAccountID, uOfrOwnerID, saInPassAct); // Adjust offer - sleOffer->setValueFieldAmount(sfTakerGets, saTakerGets - saOutPassAct); - sleOffer->setValueFieldAmount(sfTakerPays, saTakerPays - saInPassAct); + sleOffer->setFieldAmount(sfTakerGets, saTakerGets - saOutPassAct); + sleOffer->setFieldAmount(sfTakerPays, saTakerPays - saInPassAct); lesActive.entryModify(sleOffer); @@ -2092,11 +2092,11 @@ void TransactionEngine::calcOfferBridgeNext( SLE::pointer sleOffer = entryCache(ltOFFER, uOfferIndex); - uint160 uOfferOwnerID = sleOffer->getValueFieldAccount(sfAccount).getAccountID(); - STAmount saOfferPays = sleOffer->getValueFieldAmount(sfTakerGets); - STAmount saOfferGets = sleOffer->getValueFieldAmount(sfTakerPays); + uint160 uOfferOwnerID = sleOffer->getFieldAccount(sfAccount).getAccountID(); + STAmount saOfferPays = sleOffer->getFieldAmount(sfTakerGets); + STAmount saOfferGets = sleOffer->getFieldAmount(sfTakerPays); - if (sleOffer->isFieldPresent(sfExpiration) && sleOffer->getValueFieldU32(sfExpiration) <= mLedger->getParentCloseTimeNC()) + if (sleOffer->isFieldPresent(sfExpiration) && sleOffer->getFieldU32(sfExpiration) <= mLedger->getParentCloseTimeNC()) { // Offer is expired. Log(lsINFO) << "calcOfferFirst: encountered expired offer"; diff --git a/src/RippleLines.cpp b/src/RippleLines.cpp index e66168f58e..bae60414b1 100644 --- a/src/RippleLines.cpp +++ b/src/RippleLines.cpp @@ -25,7 +25,7 @@ void RippleLines::fillLines(const uint160& accountID, Ledger::pointer ledger) SLE::pointer rippleDir=ledger->getDirNode(lspNode, currentIndex); if (!rippleDir) return; - STVector256 svOwnerNodes = rippleDir->getValueFieldV256(sfIndexes); + STVector256 svOwnerNodes = rippleDir->getFieldV256(sfIndexes); BOOST_FOREACH(uint256& uNode, svOwnerNodes.peekValue()) { SLE::pointer sleCur = ledger->getSLE(uNode); @@ -45,7 +45,7 @@ void RippleLines::fillLines(const uint160& accountID, Ledger::pointer ledger) } } - uint64 uNodeNext = rippleDir->getValueFieldU64(sfIndexNext); + uint64 uNodeNext = rippleDir->getFieldU64(sfIndexNext); if (!uNodeNext) return; currentIndex = Ledger::getDirNodeIndex(rootIndex, uNodeNext); diff --git a/src/RippleState.cpp b/src/RippleState.cpp index 911a7380ee..673d563b3d 100644 --- a/src/RippleState.cpp +++ b/src/RippleState.cpp @@ -7,19 +7,19 @@ RippleState::RippleState(SerializedLedgerEntry::pointer ledgerEntry) : { if (!mLedgerEntry || mLedgerEntry->getType() != ltRIPPLE_STATE) return; - mLowLimit = mLedgerEntry->getValueFieldAmount(sfLowLimit); - mHighLimit = mLedgerEntry->getValueFieldAmount(sfHighLimit); + mLowLimit = mLedgerEntry->getFieldAmount(sfLowLimit); + mHighLimit = mLedgerEntry->getFieldAmount(sfHighLimit); mLowID = NewcoinAddress::createAccountID(mLowLimit.getIssuer()); mHighID = NewcoinAddress::createAccountID(mHighLimit.getIssuer()); - mLowQualityIn = mLedgerEntry->getValueFieldU32(sfLowQualityIn); - mLowQualityOut = mLedgerEntry->getValueFieldU32(sfLowQualityOut); + mLowQualityIn = mLedgerEntry->getFieldU32(sfLowQualityIn); + mLowQualityOut = mLedgerEntry->getFieldU32(sfLowQualityOut); - mHighQualityIn = mLedgerEntry->getValueFieldU32(sfHighQualityIn); - mHighQualityOut = mLedgerEntry->getValueFieldU32(sfHighQualityOut); + mHighQualityIn = mLedgerEntry->getFieldU32(sfHighQualityIn); + mHighQualityOut = mLedgerEntry->getFieldU32(sfHighQualityOut); - mBalance = mLedgerEntry->getValueFieldAmount(sfBalance); + mBalance = mLedgerEntry->getFieldAmount(sfBalance); mValid = true; } diff --git a/src/SerializedLedger.cpp b/src/SerializedLedger.cpp index 4b854d2384..9a57267eb3 100644 --- a/src/SerializedLedger.cpp +++ b/src/SerializedLedger.cpp @@ -9,7 +9,7 @@ SerializedLedgerEntry::SerializedLedgerEntry(SerializerIterator& sit, const uint : STObject(sfLedgerEntry), mIndex(index) { set(sit); - uint16 type = getValueFieldU16(sfLedgerEntryType); + uint16 type = getFieldU16(sfLedgerEntryType); mFormat = getLgrFormat(static_cast(type)); if (mFormat == NULL) throw std::runtime_error("invalid ledger entry type"); @@ -24,7 +24,7 @@ SerializedLedgerEntry::SerializedLedgerEntry(const Serializer& s, const uint256& SerializerIterator sit(s); set(sit); - uint16 type = getValueFieldU16(sfLedgerEntryType); + uint16 type = getFieldU16(sfLedgerEntryType); mFormat = getLgrFormat(static_cast(type)); if (mFormat == NULL) throw std::runtime_error("invalid ledger entry type"); @@ -42,7 +42,7 @@ SerializedLedgerEntry::SerializedLedgerEntry(LedgerEntryType type) : STObject(sf mFormat = getLgrFormat(type); if (mFormat == NULL) throw std::runtime_error("invalid ledger entry type"); set(mFormat->elements); - setValueFieldU16(sfLedgerEntryType, static_cast(mFormat->t_type)); + setFieldU16(sfLedgerEntryType, static_cast(mFormat->t_type)); } std::string SerializedLedgerEntry::getFullText() const @@ -85,25 +85,25 @@ bool SerializedLedgerEntry::isThreaded() uint256 SerializedLedgerEntry::getThreadedTransaction() { - return getValueFieldH256(sfLastTxnID); + return getFieldH256(sfLastTxnID); } uint32 SerializedLedgerEntry::getThreadedLedger() { - return getValueFieldU32(sfLastTxnSeq); + return getFieldU32(sfLastTxnSeq); } bool SerializedLedgerEntry::thread(const uint256& txID, uint32 ledgerSeq, uint256& prevTxID, uint32& prevLedgerID) { - uint256 oldPrevTxID = getValueFieldH256(sfLastTxnID); + uint256 oldPrevTxID = getFieldH256(sfLastTxnID); Log(lsTRACE) << "Thread Tx:" << txID << " prev:" << oldPrevTxID; if (oldPrevTxID == txID) return false; prevTxID = oldPrevTxID; - prevLedgerID = getValueFieldU32(sfLastTxnSeq); + prevLedgerID = getFieldU32(sfLastTxnSeq); assert(prevTxID != txID); - setValueFieldH256(sfLastTxnID, txID); - setValueFieldU32(sfLastTxnSeq, ledgerSeq); + setFieldH256(sfLastTxnID, txID); + setFieldU32(sfLastTxnSeq, ledgerSeq); return true; } @@ -119,17 +119,17 @@ bool SerializedLedgerEntry::hasTwoOwners() NewcoinAddress SerializedLedgerEntry::getOwner() { - return getValueFieldAccount(sfAccount); + return getFieldAccount(sfAccount); } NewcoinAddress SerializedLedgerEntry::getFirstOwner() { - return NewcoinAddress::createAccountID(getValueFieldAmount(sfLowLimit).getIssuer()); + return NewcoinAddress::createAccountID(getFieldAmount(sfLowLimit).getIssuer()); } NewcoinAddress SerializedLedgerEntry::getSecondOwner() { - return NewcoinAddress::createAccountID(getValueFieldAmount(sfHighLimit).getIssuer()); + return NewcoinAddress::createAccountID(getFieldAmount(sfHighLimit).getIssuer()); } std::vector SerializedLedgerEntry::getOwners() diff --git a/src/SerializedLedger.h b/src/SerializedLedger.h index 455830661e..fb5bad0dc6 100644 --- a/src/SerializedLedger.h +++ b/src/SerializedLedger.h @@ -32,7 +32,7 @@ public: void setIndex(const uint256& i) { mIndex = i; } LedgerEntryType getType() const { return mType; } - uint16 getVersion() const { return getValueFieldU16(sfLedgerEntryType); } + uint16 getVersion() const { return getFieldU16(sfLedgerEntryType); } const LedgerEntryFormat* getFormat() { return mFormat; } bool isThreadedType(); // is this a ledger entry that can be threaded diff --git a/src/SerializedObject.cpp b/src/SerializedObject.cpp index 5cf6a4e7dc..a217c02681 100644 --- a/src/SerializedObject.cpp +++ b/src/SerializedObject.cpp @@ -450,7 +450,7 @@ std::string STObject::getFieldString(SField::ref field) const return rf->getText(); } -unsigned char STObject::getValueFieldU8(SField::ref field) const +unsigned char STObject::getFieldU8(SField::ref field) const { const SerializedType* rf = peekAtPField(field); if (!rf) throw std::runtime_error("Field not found"); @@ -461,7 +461,7 @@ unsigned char STObject::getValueFieldU8(SField::ref field) const return cf->getValue(); } -uint16 STObject::getValueFieldU16(SField::ref field) const +uint16 STObject::getFieldU16(SField::ref field) const { const SerializedType* rf = peekAtPField(field); if (!rf) throw std::runtime_error("Field not found"); @@ -472,7 +472,7 @@ uint16 STObject::getValueFieldU16(SField::ref field) const return cf->getValue(); } -uint32 STObject::getValueFieldU32(SField::ref field) const +uint32 STObject::getFieldU32(SField::ref field) const { const SerializedType* rf = peekAtPField(field); if (!rf) throw std::runtime_error("Field not found"); @@ -483,7 +483,7 @@ uint32 STObject::getValueFieldU32(SField::ref field) const return cf->getValue(); } -uint64 STObject::getValueFieldU64(SField::ref field) const +uint64 STObject::getFieldU64(SField::ref field) const { const SerializedType* rf = peekAtPField(field); if (!rf) throw std::runtime_error("Field not found"); @@ -494,7 +494,7 @@ uint64 STObject::getValueFieldU64(SField::ref field) const return cf->getValue(); } -uint128 STObject::getValueFieldH128(SField::ref field) const +uint128 STObject::getFieldH128(SField::ref field) const { const SerializedType* rf = peekAtPField(field); if (!rf) throw std::runtime_error("Field not found"); @@ -505,7 +505,7 @@ uint128 STObject::getValueFieldH128(SField::ref field) const return cf->getValue(); } -uint160 STObject::getValueFieldH160(SField::ref field) const +uint160 STObject::getFieldH160(SField::ref field) const { const SerializedType* rf = peekAtPField(field); if (!rf) throw std::runtime_error("Field not found"); @@ -516,7 +516,7 @@ uint160 STObject::getValueFieldH160(SField::ref field) const return cf->getValue(); } -uint256 STObject::getValueFieldH256(SField::ref field) const +uint256 STObject::getFieldH256(SField::ref field) const { const SerializedType* rf = peekAtPField(field); if (!rf) throw std::runtime_error("Field not found"); @@ -527,7 +527,7 @@ uint256 STObject::getValueFieldH256(SField::ref field) const return cf->getValue(); } -NewcoinAddress STObject::getValueFieldAccount(SField::ref field) const +NewcoinAddress STObject::getFieldAccount(SField::ref field) const { const SerializedType* rf = peekAtPField(field); if (!rf) @@ -545,7 +545,7 @@ NewcoinAddress STObject::getValueFieldAccount(SField::ref field) const return cf->getValueNCA(); } -uint160 STObject::getValueFieldAccount160(SField::ref field) const +uint160 STObject::getFieldAccount160(SField::ref field) const { uint160 a; const SerializedType* rf = peekAtPField(field); @@ -567,7 +567,7 @@ uint160 STObject::getValueFieldAccount160(SField::ref field) const return a; } -std::vector STObject::getValueFieldVL(SField::ref field) const +std::vector STObject::getFieldVL(SField::ref field) const { const SerializedType* rf = peekAtPField(field); if (!rf) throw std::runtime_error("Field not found"); @@ -578,7 +578,7 @@ std::vector STObject::getValueFieldVL(SField::ref field) const return cf->getValue(); } -STAmount STObject::getValueFieldAmount(SField::ref field) const +STAmount STObject::getFieldAmount(SField::ref field) const { const SerializedType* rf = peekAtPField(field); if (!rf) throw std::runtime_error("Field not found"); @@ -589,7 +589,7 @@ STAmount STObject::getValueFieldAmount(SField::ref field) const return *cf; } -STPathSet STObject::getValueFieldPathSet(SField::ref field) const +STPathSet STObject::getFieldPathSet(SField::ref field) const { const SerializedType* rf = peekAtPField(field); if (!rf) throw std::runtime_error("Field not found"); @@ -600,7 +600,7 @@ STPathSet STObject::getValueFieldPathSet(SField::ref field) const return *cf; } -STVector256 STObject::getValueFieldV256(SField::ref field) const +STVector256 STObject::getFieldV256(SField::ref field) const { const SerializedType* rf = peekAtPField(field); if (!rf) throw std::runtime_error("Field not found"); @@ -611,7 +611,7 @@ STVector256 STObject::getValueFieldV256(SField::ref field) const return *cf; } -void STObject::setValueFieldU8(SField::ref field, unsigned char v) +void STObject::setFieldU8(SField::ref field, unsigned char v) { SerializedType* rf = getPField(field); if (!rf) throw std::runtime_error("Field not found"); @@ -621,7 +621,7 @@ void STObject::setValueFieldU8(SField::ref field, unsigned char v) cf->setValue(v); } -void STObject::setValueFieldU16(SField::ref field, uint16 v) +void STObject::setFieldU16(SField::ref field, uint16 v) { SerializedType* rf = getPField(field); if (!rf) throw std::runtime_error("Field not found"); @@ -631,7 +631,7 @@ void STObject::setValueFieldU16(SField::ref field, uint16 v) cf->setValue(v); } -void STObject::setValueFieldU32(SField::ref field, uint32 v) +void STObject::setFieldU32(SField::ref field, uint32 v) { SerializedType* rf = getPField(field); if (!rf) throw std::runtime_error("Field not found"); @@ -641,7 +641,7 @@ void STObject::setValueFieldU32(SField::ref field, uint32 v) cf->setValue(v); } -void STObject::setValueFieldU64(SField::ref field, uint64 v) +void STObject::setFieldU64(SField::ref field, uint64 v) { SerializedType* rf = getPField(field); if (!rf) throw std::runtime_error("Field not found"); @@ -651,7 +651,7 @@ void STObject::setValueFieldU64(SField::ref field, uint64 v) cf->setValue(v); } -void STObject::setValueFieldH128(SField::ref field, const uint128& v) +void STObject::setFieldH128(SField::ref field, const uint128& v) { SerializedType* rf = getPField(field); if (!rf) throw std::runtime_error("Field not found"); @@ -661,7 +661,7 @@ void STObject::setValueFieldH128(SField::ref field, const uint128& v) cf->setValue(v); } -void STObject::setValueFieldH160(SField::ref field, const uint160& v) +void STObject::setFieldH160(SField::ref field, const uint160& v) { SerializedType* rf = getPField(field); if (!rf) throw std::runtime_error("Field not found"); @@ -671,7 +671,7 @@ void STObject::setValueFieldH160(SField::ref field, const uint160& v) cf->setValue(v); } -void STObject::setValueFieldH256(SField::ref field, const uint256& v) +void STObject::setFieldH256(SField::ref field, const uint256& v) { SerializedType* rf = getPField(field); if (!rf) throw std::runtime_error("Field not found"); @@ -681,7 +681,7 @@ void STObject::setValueFieldH256(SField::ref field, const uint256& v) cf->setValue(v); } -void STObject::setValueFieldV256(SField::ref field, const STVector256& v) +void STObject::setFieldV256(SField::ref field, const STVector256& v) { SerializedType* rf = getPField(field); if (!rf) throw std::runtime_error("Field not found"); @@ -691,7 +691,7 @@ void STObject::setValueFieldV256(SField::ref field, const STVector256& v) cf->setValue(v); } -void STObject::setValueFieldAccount(SField::ref field, const uint160& v) +void STObject::setFieldAccount(SField::ref field, const uint160& v) { SerializedType* rf = getPField(field); if (!rf) throw std::runtime_error("Field not found"); @@ -701,7 +701,7 @@ void STObject::setValueFieldAccount(SField::ref field, const uint160& v) cf->setValueH160(v); } -void STObject::setValueFieldVL(SField::ref field, const std::vector& v) +void STObject::setFieldVL(SField::ref field, const std::vector& v) { SerializedType* rf = getPField(field); if (!rf) throw std::runtime_error("Field not found"); @@ -711,7 +711,7 @@ void STObject::setValueFieldVL(SField::ref field, const std::vectorsetValue(v); } -void STObject::setValueFieldAmount(SField::ref field, const STAmount &v) +void STObject::setFieldAmount(SField::ref field, const STAmount &v) { SerializedType* rf = getPField(field); if (!rf) throw std::runtime_error("Field not found"); @@ -721,7 +721,7 @@ void STObject::setValueFieldAmount(SField::ref field, const STAmount &v) (*cf) = v; } -void STObject::setValueFieldPathSet(SField::ref field, const STPathSet &v) +void STObject::setFieldPathSet(SField::ref field, const STPathSet &v) { SerializedType* rf = getPField(field); if (!rf) throw std::runtime_error("Field not found"); @@ -961,7 +961,7 @@ void STObject::unitTest() if (!object1.isFieldPresent(sfTest2)) throw std::runtime_error("STObject Error"); if ((object1.getFlags() != 1) || (object2.getFlags() != 0)) throw std::runtime_error("STObject error"); - if (object1.getValueFieldH256(sfTest2) != uint256()) throw std::runtime_error("STObject error"); + if (object1.getFieldH256(sfTest2) != uint256()) throw std::runtime_error("STObject error"); if (object1.getSerializer() == object2.getSerializer()) throw std::runtime_error("STObject error"); object1.makeFieldAbsent(sfTest2); @@ -973,7 +973,7 @@ void STObject::unitTest() if (object1.isFieldPresent(sfTest2)) throw std::runtime_error("STObject error"); if (copy.isFieldPresent(sfTest2)) throw std::runtime_error("STObject error"); if (object1.getSerializer() != copy.getSerializer()) throw std::runtime_error("STObject error"); - copy.setValueFieldU32(sfTest3, 1); + copy.setFieldU32(sfTest3, 1); if (object1.getSerializer() == copy.getSerializer()) throw std::runtime_error("STObject error"); #ifdef DEBUG Log(lsDEBUG) << copy.getJson(0); @@ -983,15 +983,15 @@ void STObject::unitTest() { std::cerr << "tol: i=" << i << std::endl; std::vector j(i, 2); - object1.setValueFieldVL(sfTest1, j); + object1.setFieldVL(sfTest1, j); Serializer s; object1.add(s); SerializerIterator it(s); STObject object3(testSOElements[0], it, "TestElement3"); - if (object1.getValueFieldVL(sfTest1) != j) throw std::runtime_error("STObject error"); - if (object3.getValueFieldVL(sfTest1) != j) throw std::runtime_error("STObject error"); + if (object1.getFieldVL(sfTest1) != j) throw std::runtime_error("STObject error"); + if (object3.getFieldVL(sfTest1) != j) throw std::runtime_error("STObject error"); } } diff --git a/src/SerializedObject.h b/src/SerializedObject.h index 321e8c1c78..a60a3efba2 100644 --- a/src/SerializedObject.h +++ b/src/SerializedObject.h @@ -95,36 +95,36 @@ public: // these throw if the field type doesn't match, or return default values if the // field is optional but not present std::string getFieldString(SField::ref field) const; - unsigned char getValueFieldU8(SField::ref field) const; - uint16 getValueFieldU16(SField::ref field) const; - uint32 getValueFieldU32(SField::ref field) const; - uint64 getValueFieldU64(SField::ref field) const; - uint128 getValueFieldH128(SField::ref field) const; - uint160 getValueFieldH160(SField::ref field) const; - uint256 getValueFieldH256(SField::ref field) const; - NewcoinAddress getValueFieldAccount(SField::ref field) const; - uint160 getValueFieldAccount160(SField::ref field) const; - std::vector getValueFieldVL(SField::ref field) const; - std::vector getValueFieldTL(SField::ref field) const; - STAmount getValueFieldAmount(SField::ref field) const; - STPathSet getValueFieldPathSet(SField::ref field) const; - STVector256 getValueFieldV256(SField::ref field) const; + unsigned char getFieldU8(SField::ref field) const; + uint16 getFieldU16(SField::ref field) const; + uint32 getFieldU32(SField::ref field) const; + uint64 getFieldU64(SField::ref field) const; + uint128 getFieldH128(SField::ref field) const; + uint160 getFieldH160(SField::ref field) const; + uint256 getFieldH256(SField::ref field) const; + NewcoinAddress getFieldAccount(SField::ref field) const; + uint160 getFieldAccount160(SField::ref field) const; + std::vector getFieldVL(SField::ref field) const; + std::vector getFieldTL(SField::ref field) const; + STAmount getFieldAmount(SField::ref field) const; + STPathSet getFieldPathSet(SField::ref field) const; + STVector256 getFieldV256(SField::ref field) const; - void setValueFieldU8(SField::ref field, unsigned char); - void setValueFieldU16(SField::ref field, uint16); - void setValueFieldU32(SField::ref field, uint32); - void setValueFieldU64(SField::ref field, uint64); - void setValueFieldH128(SField::ref field, const uint128&); - void setValueFieldH160(SField::ref field, const uint160&); - void setValueFieldH256(SField::ref field, const uint256&); - void setValueFieldVL(SField::ref field, const std::vector&); - void setValueFieldTL(SField::ref field, const std::vector&); - void setValueFieldAccount(SField::ref field, const uint160&); - void setValueFieldAccount(SField::ref field, const NewcoinAddress& addr) - { setValueFieldAccount(field, addr.getAccountID()); } - void setValueFieldAmount(SField::ref field, const STAmount&); - void setValueFieldPathSet(SField::ref field, const STPathSet&); - void setValueFieldV256(SField::ref field, const STVector256& v); + void setFieldU8(SField::ref field, unsigned char); + void setFieldU16(SField::ref field, uint16); + void setFieldU32(SField::ref field, uint32); + void setFieldU64(SField::ref field, uint64); + void setFieldH128(SField::ref field, const uint128&); + void setFieldH160(SField::ref field, const uint160&); + void setFieldH256(SField::ref field, const uint256&); + void setFieldVL(SField::ref field, const std::vector&); + void setFieldTL(SField::ref field, const std::vector&); + void setFieldAccount(SField::ref field, const uint160&); + void setFieldAccount(SField::ref field, const NewcoinAddress& addr) + { setFieldAccount(field, addr.getAccountID()); } + void setFieldAmount(SField::ref field, const STAmount&); + void setFieldPathSet(SField::ref field, const STPathSet&); + void setFieldV256(SField::ref field, const STVector256& v); bool isFieldPresent(SField::ref field) const; SerializedType* makeFieldPresent(SField::ref field); diff --git a/src/SerializedTransaction.cpp b/src/SerializedTransaction.cpp index 5059848b46..3c3643ea3e 100644 --- a/src/SerializedTransaction.cpp +++ b/src/SerializedTransaction.cpp @@ -13,7 +13,7 @@ SerializedTransaction::SerializedTransaction(TransactionType type) : STObject(sf if (mFormat == NULL) throw std::runtime_error("invalid transaction type"); set(mFormat->elements); - setValueFieldU16(sfTransactionType, mFormat->t_type); + setFieldU16(sfTransactionType, mFormat->t_type); } SerializedTransaction::SerializedTransaction(SerializerIterator& sit) : STObject(sfTransaction) @@ -26,7 +26,7 @@ SerializedTransaction::SerializedTransaction(SerializerIterator& sit) : STObject } set(sit); - mType = static_cast(getValueFieldU16(sfTransactionType)); + mType = static_cast(getFieldU16(sfTransactionType)); mFormat = getTxnFormat(mType); if (!mFormat) @@ -94,7 +94,7 @@ std::vector SerializedTransaction::getSignature() const { try { - return getValueFieldVL(sfTxnSignature); + return getFieldVL(sfTxnSignature); } catch (...) { @@ -106,14 +106,14 @@ void SerializedTransaction::sign(const NewcoinAddress& naAccountPrivate) { std::vector signature; naAccountPrivate.accountPrivateSign(getSigningHash(), signature); - setValueFieldVL(sfTxnSignature, signature); + setFieldVL(sfTxnSignature, signature); } bool SerializedTransaction::checkSign(const NewcoinAddress& naAccountPublic) const { try { - return naAccountPublic.accountPublicVerify(getSigningHash(), getValueFieldVL(sfTxnSignature)); + return naAccountPublic.accountPublicVerify(getSigningHash(), getFieldVL(sfTxnSignature)); } catch (...) { @@ -123,12 +123,12 @@ bool SerializedTransaction::checkSign(const NewcoinAddress& naAccountPublic) con void SerializedTransaction::setSigningPubKey(const NewcoinAddress& naSignPubKey) { - setValueFieldVL(sfSigningPubKey, naSignPubKey.getAccountPublic()); + setFieldVL(sfSigningPubKey, naSignPubKey.getAccountPublic()); } void SerializedTransaction::setSourceAccount(const NewcoinAddress& naSource) { - setValueFieldAccount(sfAccount, naSource); + setFieldAccount(sfAccount, naSource); } Json::Value SerializedTransaction::getJson(int options) const diff --git a/src/SerializedTransaction.h b/src/SerializedTransaction.h index f38f9c73fd..0d9f59e529 100644 --- a/src/SerializedTransaction.h +++ b/src/SerializedTransaction.h @@ -39,21 +39,21 @@ public: // outer transaction functions / signature functions std::vector getSignature() const; - void setSignature(const std::vector& s) { setValueFieldVL(sfTxnSignature, s); } + void setSignature(const std::vector& s) { setFieldVL(sfTxnSignature, s); } uint256 getSigningHash() const; TransactionType getTxnType() const { return mType; } - STAmount getTransactionFee() const { return getValueFieldAmount(sfFee); } - void setTransactionFee(const STAmount& fee) { setValueFieldAmount(sfFee, fee); } + STAmount getTransactionFee() const { return getFieldAmount(sfFee); } + void setTransactionFee(const STAmount& fee) { setFieldAmount(sfFee, fee); } - NewcoinAddress getSourceAccount() const { return getValueFieldAccount(sfAccount); } - std::vector getSigningPubKey() const { return getValueFieldVL(sfSigningPubKey); } + NewcoinAddress getSourceAccount() const { return getFieldAccount(sfAccount); } + std::vector getSigningPubKey() const { return getFieldVL(sfSigningPubKey); } void setSigningPubKey(const NewcoinAddress& naSignPubKey); void setSourceAccount(const NewcoinAddress& naSource); std::string getTransactionType() const { return mFormat->t_name; } - uint32 getSequence() const { return getValueFieldU32(sfSequence); } - void setSequence(uint32 seq) { return setValueFieldU32(sfSequence, seq); } + uint32 getSequence() const { return getFieldU32(sfSequence); } + void setSequence(uint32 seq) { return setFieldU32(sfSequence, seq); } std::vector getAffectedAccounts() const; diff --git a/src/SerializedValidation.cpp b/src/SerializedValidation.cpp index edd4fe721b..0a937c8d18 100644 --- a/src/SerializedValidation.cpp +++ b/src/SerializedValidation.cpp @@ -27,10 +27,10 @@ SerializedValidation::SerializedValidation(const uint256& ledgerHash, uint32 sig const NewcoinAddress& naSeed, bool isFull) : STObject(sValidationFormat, sfValidation), mSignature(sfSignature), mTrusted(false) { - setValueFieldH256(sfLedgerHash, ledgerHash); - setValueFieldU32(sfSigningTime, signTime); + setFieldH256(sfLedgerHash, ledgerHash); + setFieldU32(sfSigningTime, signTime); if (naSeed.isValid()) - setValueFieldVL(sfSigningPubKey, NewcoinAddress::createNodePublic(naSeed).getNodePublic()); + setFieldVL(sfSigningPubKey, NewcoinAddress::createNodePublic(naSeed).getNodePublic()); if (!isFull) setFlag(sFullFlag); NewcoinAddress::createNodePrivate(naSeed).signNodePrivate(getSigningHash(), mSignature.peekValue()); @@ -51,17 +51,17 @@ uint256 SerializedValidation::getSigningHash() const uint256 SerializedValidation::getLedgerHash() const { - return getValueFieldH256(sfLedgerHash); + return getFieldH256(sfLedgerHash); } uint32 SerializedValidation::getSignTime() const { - return getValueFieldU32(sfSigningTime); + return getFieldU32(sfSigningTime); } uint32 SerializedValidation::getFlags() const { - return getValueFieldU32(sfFlags); + return getFieldU32(sfFlags); } bool SerializedValidation::isValid() const @@ -73,7 +73,7 @@ bool SerializedValidation::isValid(const uint256& signingHash) const { try { - NewcoinAddress naPublicKey = NewcoinAddress::createNodePublic(getValueFieldVL(sfSigningPubKey)); + NewcoinAddress naPublicKey = NewcoinAddress::createNodePublic(getFieldVL(sfSigningPubKey)); return naPublicKey.isValid() && naPublicKey.verifyNodePublic(signingHash, mSignature.peekValue()); } catch (...) @@ -85,7 +85,7 @@ bool SerializedValidation::isValid(const uint256& signingHash) const NewcoinAddress SerializedValidation::getSignerPublic() const { NewcoinAddress a; - a.setNodePublic(getValueFieldVL(sfSigningPubKey)); + a.setNodePublic(getFieldVL(sfSigningPubKey)); return a; } diff --git a/src/Transaction.cpp b/src/Transaction.cpp index 40c20d9130..76bd2a9408 100644 --- a/src/Transaction.cpp +++ b/src/Transaction.cpp @@ -79,7 +79,7 @@ Transaction::Transaction( if (uSourceTag) { mTransaction->makeFieldPresent(sfSourceTag); - mTransaction->setValueFieldU32(sfSourceTag, uSourceTag); + mTransaction->setFieldU32(sfSourceTag, uSourceTag); } } @@ -127,24 +127,24 @@ Transaction::pointer Transaction::setAccountSet( ) { if (!bEmailHash) - mTransaction->setValueFieldH128(sfEmailHash, uEmailHash); + mTransaction->setFieldH128(sfEmailHash, uEmailHash); if (!bWalletLocator) - mTransaction->setValueFieldH256(sfWalletLocator, uWalletLocator); + mTransaction->setFieldH256(sfWalletLocator, uWalletLocator); if (naMessagePublic.isValid()) - mTransaction->setValueFieldVL(sfMessageKey, naMessagePublic.getAccountPublic()); + mTransaction->setFieldVL(sfMessageKey, naMessagePublic.getAccountPublic()); if (bDomain) - mTransaction->setValueFieldVL(sfDomain, vucDomain); + mTransaction->setFieldVL(sfDomain, vucDomain); if (bTransferRate) - mTransaction->setValueFieldU32(sfTransferRate, uTransferRate); + mTransaction->setFieldU32(sfTransferRate, uTransferRate); if (bPublish) { - mTransaction->setValueFieldH256(sfPublishHash, uPublishHash); - mTransaction->setValueFieldU32(sfPublishSize, uPublishSize); + mTransaction->setFieldH256(sfPublishHash, uPublishHash); + mTransaction->setFieldU32(sfPublishSize, uPublishSize); } sign(naPrivateKey); @@ -188,9 +188,9 @@ Transaction::pointer Transaction::setClaim( const std::vector& vucPubKey, const std::vector& vucSignature) { - mTransaction->setValueFieldVL(sfGenerator, vucGenerator); - mTransaction->setValueFieldVL(sfPublicKey, vucPubKey); - mTransaction->setValueFieldVL(sfSignature, vucSignature); + mTransaction->setFieldVL(sfGenerator, vucGenerator); + mTransaction->setFieldVL(sfPublicKey, vucPubKey); + mTransaction->setFieldVL(sfSignature, vucSignature); sign(naPrivateKey); @@ -222,9 +222,9 @@ Transaction::pointer Transaction::setCreate( const NewcoinAddress& naCreateAccountID, const STAmount& saFund) { - mTransaction->setValueFieldU32(sfFlags, tfCreateAccount); - mTransaction->setValueFieldAccount(sfDestination, naCreateAccountID); - mTransaction->setValueFieldAmount(sfAmount, saFund); + mTransaction->setFieldU32(sfFlags, tfCreateAccount); + mTransaction->setFieldAccount(sfDestination, naCreateAccountID); + mTransaction->setFieldAmount(sfAmount, saFund); sign(naPrivateKey); @@ -257,13 +257,13 @@ Transaction::pointer Transaction::setCreditSet( bool bQualityOut, uint32 uQualityOut) { - mTransaction->setValueFieldAmount(sfLimitAmount, saLimitAmount); + mTransaction->setFieldAmount(sfLimitAmount, saLimitAmount); if (bQualityIn) - mTransaction->setValueFieldU32(sfQualityIn, uQualityIn); + mTransaction->setFieldU32(sfQualityIn, uQualityIn); if (bQualityOut) - mTransaction->setValueFieldU32(sfQualityOut, uQualityOut); + mTransaction->setFieldU32(sfQualityOut, uQualityOut); sign(naPrivateKey); @@ -300,11 +300,11 @@ Transaction::pointer Transaction::setNicknameSet( bool bSetOffer, const STAmount& saMinimumOffer) { - mTransaction->setValueFieldH256(sfNickname, uNickname); + mTransaction->setFieldH256(sfNickname, uNickname); // XXX Make sure field is present even for 0! if (bSetOffer) - mTransaction->setValueFieldAmount(sfMinimumOffer, saMinimumOffer); + mTransaction->setFieldAmount(sfMinimumOffer, saMinimumOffer); sign(naPrivateKey); @@ -340,13 +340,13 @@ Transaction::pointer Transaction::setOfferCreate( uint32 uExpiration) { if (bPassive) - mTransaction->setValueFieldU32(sfFlags, tfPassive); + mTransaction->setFieldU32(sfFlags, tfPassive); - mTransaction->setValueFieldAmount(sfTakerPays, saTakerPays); - mTransaction->setValueFieldAmount(sfTakerGets, saTakerGets); + mTransaction->setFieldAmount(sfTakerPays, saTakerPays); + mTransaction->setFieldAmount(sfTakerGets, saTakerGets); if (uExpiration) - mTransaction->setValueFieldU32(sfExpiration, uExpiration); + mTransaction->setFieldU32(sfExpiration, uExpiration); sign(naPrivateKey); @@ -377,7 +377,7 @@ Transaction::pointer Transaction::setOfferCancel( const NewcoinAddress& naPrivateKey, uint32 uSequence) { - mTransaction->setValueFieldU32(sfOfferSequence, uSequence); + mTransaction->setFieldU32(sfOfferSequence, uSequence); sign(naPrivateKey); @@ -405,7 +405,7 @@ Transaction::pointer Transaction::setPasswordFund( const NewcoinAddress& naPrivateKey, const NewcoinAddress& naDstAccountID) { - mTransaction->setValueFieldAccount(sfDestination, naDstAccountID); + mTransaction->setFieldAccount(sfDestination, naDstAccountID); sign(naPrivateKey); @@ -436,10 +436,10 @@ Transaction::pointer Transaction::setPasswordSet( const std::vector& vucPubKey, const std::vector& vucSignature) { - mTransaction->setValueFieldAccount(sfAuthorizedKey, naAuthKeyID); - mTransaction->setValueFieldVL(sfGenerator, vucGenerator); - mTransaction->setValueFieldVL(sfPublicKey, vucPubKey); - mTransaction->setValueFieldVL(sfSignature, vucSignature); + mTransaction->setFieldAccount(sfAuthorizedKey, naAuthKeyID); + mTransaction->setFieldVL(sfGenerator, vucGenerator); + mTransaction->setFieldVL(sfPublicKey, vucPubKey); + mTransaction->setFieldVL(sfSignature, vucSignature); sign(naPrivateKey); @@ -476,17 +476,17 @@ Transaction::pointer Transaction::setPayment( const bool bPartial, const bool bLimit) { - mTransaction->setValueFieldAccount(sfDestination, naDstAccountID); - mTransaction->setValueFieldAmount(sfAmount, saAmount); + mTransaction->setFieldAccount(sfDestination, naDstAccountID); + mTransaction->setFieldAmount(sfAmount, saAmount); if (saAmount != saSendMax || saAmount.getCurrency() != saSendMax.getCurrency()) { - mTransaction->setValueFieldAmount(sfSendMax, saSendMax); + mTransaction->setFieldAmount(sfSendMax, saSendMax); } if (spsPaths.getPathCount()) { - mTransaction->setValueFieldPathSet(sfPaths, spsPaths); + mTransaction->setFieldPathSet(sfPaths, spsPaths); } sign(naPrivateKey); @@ -523,10 +523,10 @@ Transaction::pointer Transaction::setWalletAdd( const NewcoinAddress& naNewPubKey, const std::vector& vucSignature) { - mTransaction->setValueFieldAmount(sfAmount, saAmount); - mTransaction->setValueFieldAccount(sfAuthorizedKey, naAuthKeyID); - mTransaction->setValueFieldVL(sfPublicKey, naNewPubKey.getAccountPublic()); - mTransaction->setValueFieldVL(sfSignature, vucSignature); + mTransaction->setFieldAmount(sfAmount, saAmount); + mTransaction->setFieldAccount(sfAuthorizedKey, naAuthKeyID); + mTransaction->setFieldVL(sfPublicKey, naNewPubKey.getAccountPublic()); + mTransaction->setFieldVL(sfSignature, vucSignature); sign(naPrivateKey); diff --git a/src/Transaction.h b/src/Transaction.h index ae064f2df2..9ae05685d6 100644 --- a/src/Transaction.h +++ b/src/Transaction.h @@ -272,10 +272,10 @@ public: const uint256& getID() const { return mTransactionID; } const NewcoinAddress& getFromAccount() const { return mAccountFrom; } - STAmount getAmount() const { return mTransaction->getValueFieldU64(sfAmount); } + STAmount getAmount() const { return mTransaction->getFieldU64(sfAmount); } STAmount getFee() const { return mTransaction->getTransactionFee(); } uint32 getFromAccountSeq() const { return mTransaction->getSequence(); } - uint32 getIdent() const { return mTransaction->getValueFieldU32(sfSourceTag); } + uint32 getIdent() const { return mTransaction->getFieldU32(sfSourceTag); } std::vector getSignature() const { return mTransaction->getSignature(); } uint32 getLedger() const { return mInLedger; } TransStatus getStatus() const { return mStatus; } diff --git a/src/TransactionAction.cpp b/src/TransactionAction.cpp index 64dd343863..acdeacadb9 100644 --- a/src/TransactionAction.cpp +++ b/src/TransactionAction.cpp @@ -29,9 +29,9 @@ TER TransactionEngine::setAuthorized(const SerializedTransaction& txn, bool bMus // Otherwise, people could deny access to generators. // - std::vector vucCipher = txn.getValueFieldVL(sfGenerator); - std::vector vucPubKey = txn.getValueFieldVL(sfPublicKey); - std::vector vucSignature = txn.getValueFieldVL(sfSignature); + std::vector vucCipher = txn.getFieldVL(sfGenerator); + std::vector vucPubKey = txn.getFieldVL(sfPublicKey); + std::vector vucSignature = txn.getFieldVL(sfSignature); NewcoinAddress naAccountPublic = NewcoinAddress::createAccountPublic(vucPubKey); if (!naAccountPublic.accountPublicVerify(Serializer::getSHA512Half(vucCipher), vucSignature)) @@ -52,7 +52,7 @@ TER TransactionEngine::setAuthorized(const SerializedTransaction& txn, bool bMus sleGen = entryCreate(ltGENERATOR_MAP, Ledger::getGeneratorIndex(hGeneratorID)); - sleGen->setValueFieldVL(sfGenerator, vucCipher); + sleGen->setFieldVL(sfGenerator, vucCipher); } else if (bMustSetGenerator) { @@ -66,9 +66,9 @@ TER TransactionEngine::setAuthorized(const SerializedTransaction& txn, bool bMus // Set the public key needed to use the account. uint160 uAuthKeyID = bMustSetGenerator ? hGeneratorID // Claim - : txn.getValueFieldAccount160(sfAuthorizedKey); // PasswordSet + : txn.getFieldAccount160(sfAuthorizedKey); // PasswordSet - mTxnAccount->setValueFieldAccount(sfAuthorizedKey, uAuthKeyID); + mTxnAccount->setFieldAccount(sfAuthorizedKey, uAuthKeyID); return tesSUCCESS; } @@ -83,7 +83,7 @@ TER TransactionEngine::doAccountSet(const SerializedTransaction& txn) if (txn.isFieldPresent(sfEmailHash)) { - uint128 uHash = txn.getValueFieldH128(sfEmailHash); + uint128 uHash = txn.getFieldH128(sfEmailHash); if (!uHash) { @@ -95,7 +95,7 @@ TER TransactionEngine::doAccountSet(const SerializedTransaction& txn) { Log(lsINFO) << "doAccountSet: set email hash"; - mTxnAccount->setValueFieldH128(sfEmailHash, uHash); + mTxnAccount->setFieldH128(sfEmailHash, uHash); } } @@ -105,7 +105,7 @@ TER TransactionEngine::doAccountSet(const SerializedTransaction& txn) if (txn.isFieldPresent(sfWalletLocator)) { - uint256 uHash = txn.getValueFieldH256(sfWalletLocator); + uint256 uHash = txn.getFieldH256(sfWalletLocator); if (!uHash) { @@ -117,7 +117,7 @@ TER TransactionEngine::doAccountSet(const SerializedTransaction& txn) { Log(lsINFO) << "doAccountSet: set wallet locator"; - mTxnAccount->setValueFieldH256(sfWalletLocator, uHash); + mTxnAccount->setFieldH256(sfWalletLocator, uHash); } } @@ -133,7 +133,7 @@ TER TransactionEngine::doAccountSet(const SerializedTransaction& txn) { Log(lsINFO) << "doAccountSet: set message key"; - mTxnAccount->setValueFieldVL(sfMessageKey, txn.getValueFieldVL(sfMessageKey)); + mTxnAccount->setFieldVL(sfMessageKey, txn.getFieldVL(sfMessageKey)); } // @@ -142,7 +142,7 @@ TER TransactionEngine::doAccountSet(const SerializedTransaction& txn) if (txn.isFieldPresent(sfDomain)) { - std::vector vucDomain = txn.getValueFieldVL(sfDomain); + std::vector vucDomain = txn.getFieldVL(sfDomain); if (vucDomain.empty()) { @@ -154,7 +154,7 @@ TER TransactionEngine::doAccountSet(const SerializedTransaction& txn) { Log(lsINFO) << "doAccountSet: set domain"; - mTxnAccount->setValueFieldVL(sfDomain, vucDomain); + mTxnAccount->setFieldVL(sfDomain, vucDomain); } } @@ -164,7 +164,7 @@ TER TransactionEngine::doAccountSet(const SerializedTransaction& txn) if (txn.isFieldPresent(sfTransferRate)) { - uint32 uRate = txn.getValueFieldU32(sfTransferRate); + uint32 uRate = txn.getFieldU32(sfTransferRate); if (!uRate || uRate == QUALITY_ONE) { @@ -176,7 +176,7 @@ TER TransactionEngine::doAccountSet(const SerializedTransaction& txn) { Log(lsINFO) << "doAccountSet: set transfer rate"; - mTxnAccount->setValueFieldU32(sfTransferRate, uRate); + mTxnAccount->setFieldU32(sfTransferRate, uRate); } else { @@ -201,8 +201,8 @@ TER TransactionEngine::doAccountSet(const SerializedTransaction& txn) } else if (bPublishHash && bPublishSize) { - uint256 uHash = txn.getValueFieldH256(sfPublishHash); - uint32 uSize = txn.getValueFieldU32(sfPublishSize); + uint256 uHash = txn.getFieldH256(sfPublishHash); + uint32 uSize = txn.getFieldU32(sfPublishSize); if (!uHash) { @@ -215,8 +215,8 @@ TER TransactionEngine::doAccountSet(const SerializedTransaction& txn) { Log(lsINFO) << "doAccountSet: set publish"; - mTxnAccount->setValueFieldH256(sfPublishHash, uHash); - mTxnAccount->setValueFieldU32(sfPublishSize, uSize); + mTxnAccount->setFieldH256(sfPublishHash, uHash); + mTxnAccount->setFieldU32(sfPublishSize, uSize); } } @@ -241,11 +241,11 @@ TER TransactionEngine::doCreditSet(const SerializedTransaction& txn) TER terResult = tesSUCCESS; Log(lsINFO) << "doCreditSet>"; - const STAmount saLimitAmount = txn.getValueFieldAmount(sfLimitAmount); + const STAmount saLimitAmount = txn.getFieldAmount(sfLimitAmount); const bool bQualityIn = txn.isFieldPresent(sfQualityIn); - const uint32 uQualityIn = bQualityIn ? txn.getValueFieldU32(sfQualityIn) : 0; + const uint32 uQualityIn = bQualityIn ? txn.getFieldU32(sfQualityIn) : 0; const bool bQualityOut = txn.isFieldPresent(sfQualityOut); - const uint32 uQualityOut = bQualityIn ? txn.getValueFieldU32(sfQualityOut) : 0; + const uint32 uQualityOut = bQualityIn ? txn.getFieldU32(sfQualityOut) : 0; const uint160 uCurrencyID = saLimitAmount.getCurrency(); uint160 uDstAccountID = saLimitAmount.getIssuer(); const bool bFlipped = mTxnAccountID > uDstAccountID; // true, iff current is not lowest. @@ -285,12 +285,12 @@ TER TransactionEngine::doCreditSet(const SerializedTransaction& txn) if (!saLimitAmount) { // Zeroing line. - uint160 uLowID = sleRippleState->getValueFieldAmount(sfLowLimit).getIssuer(); - uint160 uHighID = sleRippleState->getValueFieldAmount(sfHighLimit).getIssuer(); + uint160 uLowID = sleRippleState->getFieldAmount(sfLowLimit).getIssuer(); + uint160 uHighID = sleRippleState->getFieldAmount(sfHighLimit).getIssuer(); bool bLow = uLowID == uSrcAccountID; bool bHigh = uLowID == uDstAccountID; - bool bBalanceZero = !sleRippleState->getValueFieldAmount(sfBalance); - STAmount saDstLimit = sleRippleState->getValueFieldAmount(bSendLow ? sfLowLimit : sfHighLimit); + bool bBalanceZero = !sleRippleState->getFieldAmount(sfBalance); + STAmount saDstLimit = sleRippleState->getFieldAmount(bSendLow ? sfLowLimit : sfHighLimit); bool bDstLimitZero = !saDstLimit; assert(bLow || bHigh); @@ -307,7 +307,7 @@ TER TransactionEngine::doCreditSet(const SerializedTransaction& txn) if (!bDelIndex) { - sleRippleState->setValueFieldAmount(bFlipped ? sfHighLimit: sfLowLimit, saLimitAllow); + sleRippleState->setFieldAmount(bFlipped ? sfHighLimit: sfLowLimit, saLimitAllow); if (!bQualityIn) { @@ -315,7 +315,7 @@ TER TransactionEngine::doCreditSet(const SerializedTransaction& txn) } else if (uQualityIn) { - sleRippleState->setValueFieldU32(bFlipped ? sfLowQualityIn : sfHighQualityIn, uQualityIn); + sleRippleState->setFieldU32(bFlipped ? sfLowQualityIn : sfHighQualityIn, uQualityIn); } else { @@ -328,7 +328,7 @@ TER TransactionEngine::doCreditSet(const SerializedTransaction& txn) } else if (uQualityOut) { - sleRippleState->setValueFieldU32(bFlipped ? sfLowQualityOut : sfHighQualityOut, uQualityOut); + sleRippleState->setFieldU32(bFlipped ? sfLowQualityOut : sfHighQualityOut, uQualityOut); } else { @@ -354,14 +354,14 @@ TER TransactionEngine::doCreditSet(const SerializedTransaction& txn) Log(lsINFO) << "doCreditSet: Creating ripple line: " << sleRippleState->getIndex().ToString(); - sleRippleState->setValueFieldAmount(sfBalance, STAmount(uCurrencyID, ACCOUNT_ONE)); // Zero balance in currency. - sleRippleState->setValueFieldAmount(bFlipped ? sfHighLimit : sfLowLimit, saLimitAllow); - sleRippleState->setValueFieldAmount(bFlipped ? sfLowLimit : sfHighLimit, STAmount(uCurrencyID, uDstAccountID)); + sleRippleState->setFieldAmount(sfBalance, STAmount(uCurrencyID, ACCOUNT_ONE)); // Zero balance in currency. + sleRippleState->setFieldAmount(bFlipped ? sfHighLimit : sfLowLimit, saLimitAllow); + sleRippleState->setFieldAmount(bFlipped ? sfLowLimit : sfHighLimit, STAmount(uCurrencyID, uDstAccountID)); if (uQualityIn) - sleRippleState->setValueFieldU32(bFlipped ? sfHighQualityIn : sfLowQualityIn, uQualityIn); + sleRippleState->setFieldU32(bFlipped ? sfHighQualityIn : sfLowQualityIn, uQualityIn); if (uQualityOut) - sleRippleState->setValueFieldU32(bFlipped ? sfHighQualityOut : sfLowQualityOut, uQualityOut); + sleRippleState->setFieldU32(bFlipped ? sfHighQualityOut : sfLowQualityOut, uQualityOut); uint64 uSrcRef; // Ignored, dirs never delete. @@ -380,20 +380,20 @@ TER TransactionEngine::doNicknameSet(const SerializedTransaction& txn) { std::cerr << "doNicknameSet>" << std::endl; - const uint256 uNickname = txn.getValueFieldH256(sfNickname); + const uint256 uNickname = txn.getFieldH256(sfNickname); const bool bMinOffer = txn.isFieldPresent(sfMinimumOffer); - const STAmount saMinOffer = bMinOffer ? txn.getValueFieldAmount(sfAmount) : STAmount(); + const STAmount saMinOffer = bMinOffer ? txn.getFieldAmount(sfAmount) : STAmount(); SLE::pointer sleNickname = entryCache(ltNICKNAME, uNickname); if (sleNickname) { // Edit old entry. - sleNickname->setValueFieldAccount(sfAccount, mTxnAccountID); + sleNickname->setFieldAccount(sfAccount, mTxnAccountID); if (bMinOffer && saMinOffer) { - sleNickname->setValueFieldAmount(sfMinimumOffer, saMinOffer); + sleNickname->setFieldAmount(sfMinimumOffer, saMinOffer); } else { @@ -411,10 +411,10 @@ TER TransactionEngine::doNicknameSet(const SerializedTransaction& txn) std::cerr << "doNicknameSet: Creating nickname node: " << sleNickname->getIndex().ToString() << std::endl; - sleNickname->setValueFieldAccount(sfAccount, mTxnAccountID); + sleNickname->setFieldAccount(sfAccount, mTxnAccountID); if (bMinOffer && saMinOffer) - sleNickname->setValueFieldAmount(sfMinimumOffer, saMinOffer); + sleNickname->setFieldAmount(sfMinimumOffer, saMinOffer); } std::cerr << "doNicknameSet<" << std::endl; @@ -426,7 +426,7 @@ TER TransactionEngine::doPasswordFund(const SerializedTransaction& txn) { std::cerr << "doPasswordFund>" << std::endl; - const uint160 uDstAccountID = txn.getValueFieldAccount160(sfDestination); + const uint160 uDstAccountID = txn.getFieldAccount160(sfDestination); SLE::pointer sleDst = mTxnAccountID == uDstAccountID ? mTxnAccount : entryCache(ltACCOUNT_ROOT, Ledger::getAccountRootIndex(uDstAccountID)); @@ -488,9 +488,9 @@ TER TransactionEngine::doPayment(const SerializedTransaction& txn, const Transac const bool bNoRippleDirect = isSetBit(uTxFlags, tfNoRippleDirect); const bool bPaths = txn.isFieldPresent(sfPaths); const bool bMax = txn.isFieldPresent(sfSendMax); - const uint160 uDstAccountID = txn.getValueFieldAccount160(sfDestination); - const STAmount saDstAmount = txn.getValueFieldAmount(sfAmount); - const STAmount saMaxAmount = bMax ? txn.getValueFieldAmount(sfSendMax) : saDstAmount; + const uint160 uDstAccountID = txn.getFieldAccount160(sfDestination); + const STAmount saDstAmount = txn.getFieldAmount(sfAmount); + const STAmount saMaxAmount = bMax ? txn.getFieldAmount(sfSendMax) : saDstAmount; const uint160 uSrcCurrency = saMaxAmount.getCurrency(); const uint160 uDstCurrency = saDstAmount.getCurrency(); @@ -550,8 +550,8 @@ TER TransactionEngine::doPayment(const SerializedTransaction& txn, const Transac // Create the account. sleDst = entryCreate(ltACCOUNT_ROOT, Ledger::getAccountRootIndex(uDstAccountID)); - sleDst->setValueFieldAccount(sfAccount, uDstAccountID); - sleDst->setValueFieldU32(sfSequence, 1); + sleDst->setFieldAccount(sfAccount, uDstAccountID); + sleDst->setFieldU32(sfSequence, 1); } else { @@ -566,7 +566,7 @@ TER TransactionEngine::doPayment(const SerializedTransaction& txn, const Transac { // Ripple payment - STPathSet spsPaths = txn.getValueFieldPathSet(sfPaths); + STPathSet spsPaths = txn.getFieldPathSet(sfPaths); STAmount saMaxAmountAct; STAmount saDstAmountAct; @@ -589,7 +589,7 @@ TER TransactionEngine::doPayment(const SerializedTransaction& txn, const Transac { // Direct XNS payment. - STAmount saSrcXNSBalance = mTxnAccount->getValueFieldAmount(sfBalance); + STAmount saSrcXNSBalance = mTxnAccount->getFieldAmount(sfBalance); if (saSrcXNSBalance < saDstAmount) { @@ -600,8 +600,8 @@ TER TransactionEngine::doPayment(const SerializedTransaction& txn, const Transac } else { - mTxnAccount->setValueFieldAmount(sfBalance, saSrcXNSBalance - saDstAmount); - sleDst->setValueFieldAmount(sfBalance, sleDst->getValueFieldAmount(sfBalance) + saDstAmount); + mTxnAccount->setFieldAmount(sfBalance, saSrcXNSBalance - saDstAmount); + sleDst->setFieldAmount(sfBalance, sleDst->getFieldAmount(sfBalance) + saDstAmount); terResult = tesSUCCESS; } @@ -626,9 +626,9 @@ TER TransactionEngine::doWalletAdd(const SerializedTransaction& txn) { std::cerr << "WalletAdd>" << std::endl; - const std::vector vucPubKey = txn.getValueFieldVL(sfPublicKey); - const std::vector vucSignature = txn.getValueFieldVL(sfSignature); - const uint160 uAuthKeyID = txn.getValueFieldAccount160(sfAuthorizedKey); + const std::vector vucPubKey = txn.getFieldVL(sfPublicKey); + const std::vector vucSignature = txn.getFieldVL(sfSignature); + const uint160 uAuthKeyID = txn.getFieldAccount160(sfAuthorizedKey); const NewcoinAddress naMasterPubKey = NewcoinAddress::createAccountPublic(vucPubKey); const uint160 uDstAccountID = naMasterPubKey.getAccountID(); @@ -648,8 +648,8 @@ TER TransactionEngine::doWalletAdd(const SerializedTransaction& txn) return tefCREATED; } - STAmount saAmount = txn.getValueFieldAmount(sfAmount); - STAmount saSrcBalance = mTxnAccount->getValueFieldAmount(sfBalance); + STAmount saAmount = txn.getFieldAmount(sfAmount); + STAmount saSrcBalance = mTxnAccount->getFieldAmount(sfBalance); if (saSrcBalance < saAmount) { @@ -663,15 +663,15 @@ TER TransactionEngine::doWalletAdd(const SerializedTransaction& txn) } // Deduct initial balance from source account. - mTxnAccount->setValueFieldAmount(sfBalance, saSrcBalance-saAmount); + mTxnAccount->setFieldAmount(sfBalance, saSrcBalance-saAmount); // Create the account. sleDst = entryCreate(ltACCOUNT_ROOT, Ledger::getAccountRootIndex(uDstAccountID)); - sleDst->setValueFieldAccount(sfAccount, uDstAccountID); - sleDst->setValueFieldU32(sfSequence, 1); - sleDst->setValueFieldAmount(sfBalance, saAmount); - sleDst->setValueFieldAccount(sfAuthorizedKey, uAuthKeyID); + sleDst->setFieldAccount(sfAccount, uDstAccountID); + sleDst->setFieldU32(sfSequence, 1); + sleDst->setFieldAmount(sfBalance, saAmount); + sleDst->setFieldAccount(sfAuthorizedKey, uAuthKeyID); std::cerr << "WalletAdd<" << std::endl; @@ -770,11 +770,11 @@ TER TransactionEngine::takeOffers( Log(lsINFO) << "takeOffers: considering offer : " << sleOffer->getJson(0); - const uint160 uOfferOwnerID = sleOffer->getValueFieldAccount(sfAccount).getAccountID(); - STAmount saOfferPays = sleOffer->getValueFieldAmount(sfTakerGets); - STAmount saOfferGets = sleOffer->getValueFieldAmount(sfTakerPays); + const uint160 uOfferOwnerID = sleOffer->getFieldAccount(sfAccount).getAccountID(); + STAmount saOfferPays = sleOffer->getFieldAmount(sfTakerGets); + STAmount saOfferGets = sleOffer->getFieldAmount(sfTakerPays); - if (sleOffer->isFieldPresent(sfExpiration) && sleOffer->getValueFieldU32(sfExpiration) <= mLedger->getParentCloseTimeNC()) + if (sleOffer->isFieldPresent(sfExpiration) && sleOffer->getFieldU32(sfExpiration) <= mLedger->getParentCloseTimeNC()) { // Offer is expired. Expired offers are considered unfunded. Delete it. Log(lsINFO) << "takeOffers: encountered expired offer"; @@ -849,10 +849,10 @@ TER TransactionEngine::takeOffers( // Adjust offer // Offer owner will pay less. Subtract what taker just got. - sleOffer->setValueFieldAmount(sfTakerGets, saOfferPays -= saSubTakerGot); + sleOffer->setFieldAmount(sfTakerGets, saOfferPays -= saSubTakerGot); // Offer owner will get less. Subtract what owner just paid. - sleOffer->setValueFieldAmount(sfTakerPays, saOfferGets -= saSubTakerPaid); + sleOffer->setFieldAmount(sfTakerPays, saOfferGets -= saSubTakerPaid); entryModify(sleOffer); @@ -919,8 +919,8 @@ TER TransactionEngine::doOfferCreate(const SerializedTransaction& txn) Log(lsWARNING) << "doOfferCreate> " << txn.getJson(0); const uint32 txFlags = txn.getFlags(); const bool bPassive = isSetBit(txFlags, tfPassive); - STAmount saTakerPays = txn.getValueFieldAmount(sfTakerPays); - STAmount saTakerGets = txn.getValueFieldAmount(sfTakerGets); + STAmount saTakerPays = txn.getFieldAmount(sfTakerPays); + STAmount saTakerGets = txn.getFieldAmount(sfTakerGets); Log(lsINFO) << boost::str(boost::format("doOfferCreate: saTakerPays=%s saTakerGets=%s") % saTakerPays.getFullText() @@ -928,7 +928,7 @@ Log(lsINFO) << boost::str(boost::format("doOfferCreate: saTakerPays=%s saTakerGe const uint160 uPaysIssuerID = saTakerPays.getIssuer(); const uint160 uGetsIssuerID = saTakerGets.getIssuer(); - const uint32 uExpiration = txn.getValueFieldU32(sfExpiration); + const uint32 uExpiration = txn.getFieldU32(sfExpiration); const bool bHaveExpiration = txn.isFieldPresent(sfExpiration); const uint32 uSequence = txn.getSequence(); @@ -1090,16 +1090,16 @@ Log(lsINFO) << boost::str(boost::format("doOfferCreate: saTakerPays=%s saTakerGe Log(lsWARNING) << "doOfferCreate: uPaysCurrency=" << saTakerPays.getHumanCurrency(); Log(lsWARNING) << "doOfferCreate: uGetsCurrency=" << saTakerGets.getHumanCurrency(); - sleOffer->setValueFieldAccount(sfAccount, mTxnAccountID); - sleOffer->setValueFieldU32(sfSequence, uSequence); - sleOffer->setValueFieldH256(sfBookDirectory, uDirectory); - sleOffer->setValueFieldAmount(sfTakerPays, saTakerPays); - sleOffer->setValueFieldAmount(sfTakerGets, saTakerGets); - sleOffer->setValueFieldU64(sfOwnerNode, uOwnerNode); - sleOffer->setValueFieldU64(sfBookNode, uBookNode); + sleOffer->setFieldAccount(sfAccount, mTxnAccountID); + sleOffer->setFieldU32(sfSequence, uSequence); + sleOffer->setFieldH256(sfBookDirectory, uDirectory); + sleOffer->setFieldAmount(sfTakerPays, saTakerPays); + sleOffer->setFieldAmount(sfTakerGets, saTakerGets); + sleOffer->setFieldU64(sfOwnerNode, uOwnerNode); + sleOffer->setFieldU64(sfBookNode, uBookNode); if (uExpiration) - sleOffer->setValueFieldU32(sfExpiration, uExpiration); + sleOffer->setFieldU32(sfExpiration, uExpiration); if (bPassive) sleOffer->setFlag(lsfPassive); @@ -1114,7 +1114,7 @@ Log(lsINFO) << boost::str(boost::format("doOfferCreate: saTakerPays=%s saTakerGe TER TransactionEngine::doOfferCancel(const SerializedTransaction& txn) { TER terResult; - const uint32 uSequence = txn.getValueFieldU32(sfOfferSequence); + const uint32 uSequence = txn.getFieldU32(sfOfferSequence); const uint256 uOfferIndex = Ledger::getOfferIndex(mTxnAccountID, uSequence); SLE::pointer sleOffer = entryCache(ltOFFER, uOfferIndex); @@ -1141,14 +1141,14 @@ TER TransactionEngine::doContractAdd(const SerializedTransaction& txn) { Log(lsWARNING) << "doContractAdd> " << txn.getJson(0); - const uint32 expiration = txn.getValueFieldU32(sfExpiration); -// const uint32 bondAmount = txn.getValueFieldU32(sfBondAmount); -// const uint32 stampEscrow = txn.getValueFieldU32(sfStampEscrow); - STAmount rippleEscrow = txn.getValueFieldAmount(sfRippleEscrow); - std::vector createCode = txn.getValueFieldVL(sfCreateCode); - std::vector fundCode = txn.getValueFieldVL(sfFundCode); - std::vector removeCode = txn.getValueFieldVL(sfRemoveCode); - std::vector expireCode = txn.getValueFieldVL(sfExpireCode); + const uint32 expiration = txn.getFieldU32(sfExpiration); +// const uint32 bondAmount = txn.getFieldU32(sfBondAmount); +// const uint32 stampEscrow = txn.getFieldU32(sfStampEscrow); + STAmount rippleEscrow = txn.getFieldAmount(sfRippleEscrow); + std::vector createCode = txn.getFieldVL(sfCreateCode); + std::vector fundCode = txn.getFieldVL(sfFundCode); + std::vector removeCode = txn.getFieldVL(sfRemoveCode); + std::vector expireCode = txn.getFieldVL(sfExpireCode); // make sure // expiration hasn't passed diff --git a/src/TransactionEngine.cpp b/src/TransactionEngine.cpp index 6452ca0775..a89562dd01 100644 --- a/src/TransactionEngine.cpp +++ b/src/TransactionEngine.cpp @@ -136,7 +136,7 @@ TER TransactionEngine::applyTransaction(const SerializedTransaction& txn, Transa case ttNICKNAME_SET: { - SLE::pointer sleNickname = entryCache(ltNICKNAME, txn.getValueFieldH256(sfNickname)); + SLE::pointer sleNickname = entryCache(ltNICKNAME, txn.getFieldH256(sfNickname)); if (!sleNickname) saCost = theConfig.FEE_NICKNAME_CREATE; @@ -222,7 +222,7 @@ TER TransactionEngine::applyTransaction(const SerializedTransaction& txn, Transa } else { - saSrcBalance = mTxnAccount->getValueFieldAmount(sfBalance); + saSrcBalance = mTxnAccount->getFieldAmount(sfBalance); bHaveAuthKey = mTxnAccount->isFieldPresent(sfAuthorizedKey); } @@ -279,7 +279,7 @@ TER TransactionEngine::applyTransaction(const SerializedTransaction& txn, Transa default: // Verify the transaction's signing public key is the key authorized for signing. - if (bHaveAuthKey && naSigningPubKey.getAccountID() == mTxnAccount->getValueFieldAccount(sfAuthorizedKey).getAccountID()) + if (bHaveAuthKey && naSigningPubKey.getAccountID() == mTxnAccount->getFieldAccount(sfAuthorizedKey).getAccountID()) { // Authorized to continue. nothing(); @@ -322,7 +322,7 @@ TER TransactionEngine::applyTransaction(const SerializedTransaction& txn, Transa } else { - mTxnAccount->setValueFieldAmount(sfBalance, saSrcBalance - saPaid); + mTxnAccount->setFieldAmount(sfBalance, saSrcBalance - saPaid); } // Validate sequence @@ -332,7 +332,7 @@ TER TransactionEngine::applyTransaction(const SerializedTransaction& txn, Transa } else if (saCost) { - uint32 a_seq = mTxnAccount->getValueFieldU32(sfSequence); + uint32 a_seq = mTxnAccount->getFieldU32(sfSequence); Log(lsTRACE) << "Aseq=" << a_seq << ", Tseq=" << t_seq; @@ -359,7 +359,7 @@ TER TransactionEngine::applyTransaction(const SerializedTransaction& txn, Transa } else { - mTxnAccount->setValueFieldU32(sfSequence, t_seq + 1); + mTxnAccount->setFieldU32(sfSequence, t_seq + 1); } } else