ARCHIVE/rippled
1
0
Fork 0
mirror of https://github.com/XRPLF/rippled.git synced 2025-12-06 17:27:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

Burninate "Value" in "*ValueField*" functions. It was just pointless extra typing.

Browse Source 
What else would you set/get in a field, by name, other than its value?
This commit is contained in:
JoelKatz
2012-10-01 15:35:30 -07:00
parent 18d3773da4
commit e04b695434
22 changed files with 318 additions and 318 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/AccountState.cpp
View File

@@ -17,7 +17,7 @@ AccountState::AccountState(const NewcoinAddress& naAccountID) : mAccountID(naAcc
mLedgerEntry = boost::make_shared<SerializedLedgerEntry>(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
{

6
src/AccountState.h
View File

@@ -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; }

4
src/Ledger.cpp
View File

@@ -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<AccountState>(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:";

100
src/LedgerEntrySet.cpp
View File

@@ -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<uint256>& vuiIndexes = svIndexes.peekValue();
std::vector<uint256>::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<uint256>& 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

14
src/NetworkOPs.cpp
View File

@@ -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<uint256>& 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;

4
src/NicknameState.cpp
View File

@@ -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)

4
src/OrderBook.cpp
View File

@@ -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();

4
src/RPCServer.cpp
View File

@@ -252,7 +252,7 @@ Json::Value RPCServer::getMasterGenerator(const uint256& uLedger, const NewcoinA
return RPCError(rpcNO_ACCOUNT);
}
std::vector<unsigned char> vucCipher = sleGen->getValueFieldVL(sfGenerator);
std::vector<unsigned char> vucCipher = sleGen->getFieldVL(sfGenerator);
std::vector<unsigned char> 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<unsigned char> vucCipher = sleGen->getValueFieldVL(sfGenerator);
std::vector<unsigned char> vucCipher = sleGen->getFieldVL(sfGenerator);
std::vector<unsigned char> vucMasterGenerator = naRegular0Private.accountPrivateDecrypt(naRegular0Public, vucCipher);
if (vucMasterGenerator.empty())
{

28
src/RippleCalc.cpp
View File

@@ -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";

4
src/RippleLines.cpp
View File

@@ -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);

14
src/RippleState.cpp
View File

@@ -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;
}

24
src/SerializedLedger.cpp
View File

@@ -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<LedgerEntryType>(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<LedgerEntryType>(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<uint16>(mFormat->t_type));
setFieldU16(sfLedgerEntryType, static_cast<uint16>(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<uint256> SerializedLedgerEntry::getOwners()

2
src/SerializedLedger.h
View File

@@ -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

60
src/SerializedObject.cpp
View File

@@ -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<unsigned char> STObject::getValueFieldVL(SField::ref field) const
std::vector<unsigned char> 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<unsigned char> 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<unsigned char>& v)
void STObject::setFieldVL(SField::ref field, const std::vector<unsigned char>& 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::vector<unsigned cha
cf->setValue(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<unsigned char> 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");
}
}

58
src/SerializedObject.h
View File

@@ -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<unsigned char> getValueFieldVL(SField::ref field) const;
std::vector<TaggedListItem> 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<unsigned char> getFieldVL(SField::ref field) const;
std::vector<TaggedListItem> 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<unsigned char>&);
void setValueFieldTL(SField::ref field, const std::vector<TaggedListItem>&);
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<unsigned char>&);
void setFieldTL(SField::ref field, const std::vector<TaggedListItem>&);
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);

14
src/SerializedTransaction.cpp
View File

@@ -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<TransactionType>(getValueFieldU16(sfTransactionType));
mType = static_cast<TransactionType>(getFieldU16(sfTransactionType));
mFormat = getTxnFormat(mType);
if (!mFormat)
@@ -94,7 +94,7 @@ std::vector<unsigned char> SerializedTransaction::getSignature() const
{
try
{
return getValueFieldVL(sfTxnSignature);
return getFieldVL(sfTxnSignature);
}
catch (...)
{
@@ -106,14 +106,14 @@ void SerializedTransaction::sign(const NewcoinAddress& naAccountPrivate)
{
std::vector<unsigned char> 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

14
src/SerializedTransaction.h
View File

@@ -39,21 +39,21 @@ public:
// outer transaction functions / signature functions
std::vector<unsigned char> getSignature() const;
void setSignature(const std::vector<unsigned char>& s) { setValueFieldVL(sfTxnSignature, s); }
void setSignature(const std::vector<unsigned char>& 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<unsigned char> getSigningPubKey() const { return getValueFieldVL(sfSigningPubKey); }
NewcoinAddress getSourceAccount() const { return getFieldAccount(sfAccount); }
std::vector<unsigned char> 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<NewcoinAddress> getAffectedAccounts() const;

16
src/SerializedValidation.cpp
View File

@@ -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;
}

74
src/Transaction.cpp
View File

@@ -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<unsigned char>& vucPubKey,
const std::vector<unsigned char>& 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<unsigned char>& vucPubKey,
const std::vector<unsigned char>& 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<unsigned char>& 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);

4
src/Transaction.h
View File

@@ -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<unsigned char> getSignature() const { return mTransaction->getSignature(); }
uint32 getLedger() const { return mInLedger; }
TransStatus getStatus() const { return mStatus; }

172
src/TransactionAction.cpp
View File

@@ -29,9 +29,9 @@ TER TransactionEngine::setAuthorized(const SerializedTransaction& txn, bool bMus
// Otherwise, people could deny access to generators.
//
std::vector<unsigned char> vucCipher = txn.getValueFieldVL(sfGenerator);
std::vector<unsigned char> vucPubKey = txn.getValueFieldVL(sfPublicKey);
std::vector<unsigned char> vucSignature = txn.getValueFieldVL(sfSignature);
std::vector<unsigned char> vucCipher = txn.getFieldVL(sfGenerator);
std::vector<unsigned char> vucPubKey = txn.getFieldVL(sfPublicKey);
std::vector<unsigned char> 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<unsigned char> vucDomain = txn.getValueFieldVL(sfDomain);
std::vector<unsigned char> 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<unsigned char> vucPubKey = txn.getValueFieldVL(sfPublicKey);
const std::vector<unsigned char> vucSignature = txn.getValueFieldVL(sfSignature);
const uint160 uAuthKeyID = txn.getValueFieldAccount160(sfAuthorizedKey);
const std::vector<unsigned char> vucPubKey = txn.getFieldVL(sfPublicKey);
const std::vector<unsigned char> 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<unsigned char> createCode = txn.getValueFieldVL(sfCreateCode);
std::vector<unsigned char> fundCode = txn.getValueFieldVL(sfFundCode);
std::vector<unsigned char> removeCode = txn.getValueFieldVL(sfRemoveCode);
std::vector<unsigned char> 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<unsigned char> createCode = txn.getFieldVL(sfCreateCode);
std::vector<unsigned char> fundCode = txn.getFieldVL(sfFundCode);
std::vector<unsigned char> removeCode = txn.getFieldVL(sfRemoveCode);
std::vector<unsigned char> expireCode = txn.getFieldVL(sfExpireCode);
// make sure
// expiration hasn't passed

12
src/TransactionEngine.cpp
View File

@@ -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