ARCHIVE/rippled
1
0
Fork 0
mirror of https://github.com/XRPLF/rippled.git synced 2025-11-20 11:05:54 +00:00
Code Issues Packages Projects Releases Wiki Activity

Bugfixes and some copy avoidance.

Browse Source
This commit is contained in:
JoelKatz
2011-12-16 20:15:51 -08:00
parent 8083b677e2
commit da5579f9fe
4 changed files with 39 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
LedgerHistory.cpp
View File

@@ -11,7 +11,7 @@ void LedgerHistory::addLedger(Ledger::pointer ledger)
{ {
uint256 h(ledger->getHash()); uint256 h(ledger->getHash());
boost::recursive_mutex::scoped_lock sl(mLock); boost::recursive_mutex::scoped_lock sl(mLock);
if(!mLedgersByHash[h]) mLedgersByHash[h]=ledger; if(!mLedgersByHash.count(h)) mLedgersByHash.insert(std::make_pair(h, ledger));
} }
void LedgerHistory::addAcceptedLedger(Ledger::pointer ledger) void LedgerHistory::addAcceptedLedger(Ledger::pointer ledger)
@@ -19,44 +19,40 @@ void LedgerHistory::addAcceptedLedger(Ledger::pointer ledger)
assert(ledger && ledger->isAccepted()); assert(ledger && ledger->isAccepted());
uint256 h(ledger->getHash()); uint256 h(ledger->getHash());
boost::recursive_mutex::scoped_lock sl(mLock); boost::recursive_mutex::scoped_lock sl(mLock);
if(!!mLedgersByHash[h]) return; mLedgersByIndex.insert(std::make_pair(ledger->getLedgerSeq(), ledger));
mLedgersByHash[h]=ledger; mLedgersByHash.insert(std::make_pair(h, ledger));
mLedgersByIndex[ledger->getLedgerSeq()]=ledger;
theApp->getIOService().post(boost::bind(&Ledger::saveAcceptedLedger, ledger)); theApp->getIOService().post(boost::bind(&Ledger::saveAcceptedLedger, ledger));
} }
Ledger::pointer LedgerHistory::getLedgerBySeq(uint32 index) Ledger::pointer LedgerHistory::getLedgerBySeq(uint32 index)
{ {
boost::recursive_mutex::scoped_lock sl(mLock); boost::recursive_mutex::scoped_lock sl(mLock);
Ledger::pointer ret(mLedgersByIndex[index]); if(mLedgersByIndex.count(index)) return mLedgersByIndex[index];
if(ret) return ret;
sl.unlock(); sl.unlock();
ret=Ledger::loadByIndex(index); Ledger::pointer ret(Ledger::loadByIndex(index));
if(!ret) return ret; if(!ret) return ret;
assert(ret->getLedgerSeq()==index); assert(ret->getLedgerSeq()==index);
uint256 h=ret->getHash(); uint256 h=ret->getHash();
sl.lock(); sl.lock();
mLedgersByIndex[index]=ret; mLedgersByIndex.insert(std::make_pair(index, ret));
mLedgersByHash[h]=ret; mLedgersByHash.insert(std::make_pair(h, ret));
return ret; return ret;
} }
Ledger::pointer LedgerHistory::getLedgerByHash(const uint256& hash) Ledger::pointer LedgerHistory::getLedgerByHash(const uint256& hash)
{ {
boost::recursive_mutex::scoped_lock sl(mLock); boost::recursive_mutex::scoped_lock sl(mLock);
Ledger::pointer ret(mLedgersByHash[hash]); if(mLedgersByHash.count(hash)!=0) return mLedgersByHash[hash];
if(ret) return ret;
sl.unlock(); sl.unlock();
ret=Ledger::loadByHash(hash); Ledger::pointer ret=Ledger::loadByHash(hash);
if(!ret) return ret; if(!ret) return ret;
assert(ret->getHash()==hash); assert(ret->getHash()==hash);
sl.lock(); sl.lock();
mLedgersByHash[hash]=ret; mLedgersByHash.insert(std::make_pair(hash, ret));
if(ret->isAccepted()) mLedgersByIndex[ret->getLedgerSeq()]=ret; if(ret->isAccepted()) mLedgersByIndex.insert(std::make_pair(ret->getLedgerSeq(), ret));
return ret; return ret;
} }
@@ -65,12 +61,12 @@ Ledger::pointer LedgerHistory::canonicalizeLedger(Ledger::pointer ledger, bool s
uint256 h(ledger->getHash()); uint256 h(ledger->getHash());
boost::recursive_mutex::scoped_lock sl(mLock); boost::recursive_mutex::scoped_lock sl(mLock);
Ledger::pointer ret(mLedgersByHash[h]); if(mLedgersByHash.count(h)!=0) return mLedgersByHash[h];
if(ret) return ret;
if(!save) return ledger; if(!save) return ledger;
assert(ret->getHash()==h);
mLedgersByHash[h]=ledger; assert(ledger->getHash()==h);
if(ret->isAccepted()) mLedgersByIndex[ret->getLedgerSeq()]=ledger; mLedgersByHash.insert(std::make_pair(h, ledger));
if(ledger->isAccepted()) mLedgersByIndex.insert(std::make_pair(ledger->getLedgerSeq(), ledger));
return ledger; return ledger;
} }

4
LedgerMaster.cpp
View File

@@ -27,9 +27,9 @@ uint64 LedgerMaster::getBalance(std::string& addr)
bool LedgerMaster::addHeldTransaction(Transaction::pointer transaction) bool LedgerMaster::addHeldTransaction(Transaction::pointer transaction)
{ {
boost::recursive_mutex::scoped_lock ml(mLock); boost::recursive_mutex::scoped_lock ml(mLock);
if(!mHeldTransactionsByID[transaction->getID()]) if(mHeldTransactionsByID.count(transaction->getID())==0)
{ {
mHeldTransactionsByID[transaction->getID()]=transaction; mHeldTransactionsByID.insert(std::make_pair(transaction->getID(), transaction));
return true; return true;
} }
return false; return false;

12
SHAMap.cpp
View File

@@ -21,7 +21,7 @@ void SHAMap::dirtyUp(const uint256& id)
if(!leaf) throw SHAMapException(MissingNode); if(!leaf) throw SHAMapException(MissingNode);
uint256 hVal=leaf->getNodeHash(); uint256 hVal=leaf->getNodeHash();
if(mDirtyLeafNodes) (*mDirtyLeafNodes)[*leaf]=leaf; if(mDirtyLeafNodes) mDirtyLeafNodes->insert(std::make_pair(SHAMapNode(*leaf), leaf));
if(!hVal) if(!hVal)
{ {
#ifdef ST_DEBUG #ifdef ST_DEBUG
@@ -44,7 +44,7 @@ void SHAMap::dirtyUp(const uint256& id)
#ifdef ST_DEBUG #ifdef ST_DEBUG
std::cerr << "Dirty " << node->getString() << std::endl; std::cerr << "Dirty " << node->getString() << std::endl;
#endif #endif
if(mDirtyInnerNodes) (*mDirtyInnerNodes)[*node]=node; if(mDirtyInnerNodes) mDirtyInnerNodes->insert(std::make_pair(SHAMapNode(*node), node));
hVal=node->getNodeHash(); hVal=node->getNodeHash();
if(!hVal) if(!hVal)
{ {
@@ -143,7 +143,7 @@ SHAMapInnerNode::pointer SHAMap::getInner(const SHAMapNode& id, const uint256& h
node=SHAMapInnerNode::pointer(new SHAMapInnerNode(id, rawNode, mSeq)); node=SHAMapInnerNode::pointer(new SHAMapInnerNode(id, rawNode, mSeq));
if(node->getNodeHash()!=hash) throw SHAMapException(InvalidNode); if(node->getNodeHash()!=hash) throw SHAMapException(InvalidNode);
mInnerNodeByID[id]=node; mInnerNodeByID.insert(std::make_pair(id, node));
if(id.getDepth()==0) root=node; if(id.getDepth()==0) root=node;
return node; return node;
} }
@@ -154,7 +154,7 @@ SHAMapLeafNode::pointer SHAMap::returnLeaf(SHAMapLeafNode::pointer leaf, bool mo
{ {
leaf=SHAMapLeafNode::pointer(new SHAMapLeafNode(*leaf, mSeq)); leaf=SHAMapLeafNode::pointer(new SHAMapLeafNode(*leaf, mSeq));
mLeafByID[*leaf]=leaf; mLeafByID[*leaf]=leaf;
if(mDirtyLeafNodes) (*mDirtyLeafNodes)[*leaf]=leaf; if(mDirtyLeafNodes) mDirtyLeafNodes->insert(std::make_pair(SHAMapNode(*leaf), leaf));
} }
return leaf; return leaf;
} }
@@ -167,8 +167,8 @@ SHAMapInnerNode::pointer SHAMap::returnNode(SHAMapInnerNode::pointer node, bool
std::cerr << "Node(" << node->getString() << ") bumpseq" << std::endl; std::cerr << "Node(" << node->getString() << ") bumpseq" << std::endl;
#endif #endif
node=SHAMapInnerNode::pointer(new SHAMapInnerNode(*node, mSeq)); node=SHAMapInnerNode::pointer(new SHAMapInnerNode(*node, mSeq));
mInnerNodeByID[*node]=node; mInnerNodeByID.insert(std::make_pair(SHAMapNode(*node), node));
if(mDirtyInnerNodes) (*mDirtyInnerNodes)[*node]=node; if(mDirtyInnerNodes) mDirtyInnerNodes->insert(std::make_pair(SHAMapNode(*node), node));
} }
return node; return node;
} }

30
SHAMapDiff.cpp
View File

@@ -34,8 +34,8 @@ bool SHAMap::compare(SHAMap::pointer otherMap, SHAMapDiff& differences, int maxC
SHAMapLeafNode::pointer thisNode=getLeaf(node.mNodeID, node.mOurHash, false); SHAMapLeafNode::pointer thisNode=getLeaf(node.mNodeID, node.mOurHash, false);
for(SHAMapItem::pointer item=thisNode->firstItem(); item; item=thisNode->nextItem(item->getTag())) for(SHAMapItem::pointer item=thisNode->firstItem(); item; item=thisNode->nextItem(item->getTag()))
{ // items in leaf only in our tree { // items in leaf only in our tree
differences[item->getTag()]= differences.insert(std::make_pair(item->getTag(),
std::pair<SHAMapItem::pointer, SHAMapItem::pointer>(item, SHAMapItem::pointer()); std::make_pair(item, SHAMapItem::pointer())));
if((--maxCount)<=0) return false; if((--maxCount)<=0) return false;
} }
} }
@@ -44,8 +44,8 @@ bool SHAMap::compare(SHAMap::pointer otherMap, SHAMapDiff& differences, int maxC
SHAMapLeafNode::pointer otherNode=otherMap->getLeaf(node.mNodeID, node.mOtherHash, false); SHAMapLeafNode::pointer otherNode=otherMap->getLeaf(node.mNodeID, node.mOtherHash, false);
for(SHAMapItem::pointer item=otherNode->firstItem(); item; item=otherNode->nextItem(item->getTag())) for(SHAMapItem::pointer item=otherNode->firstItem(); item; item=otherNode->nextItem(item->getTag()))
{ // items in leaf only in our tree { // items in leaf only in our tree
differences[item->getTag()]= differences.insert(std::make_pair(item->getTag(),
std::pair<SHAMapItem::pointer, SHAMapItem::pointer>(SHAMapItem::pointer(), item); std::make_pair(SHAMapItem::pointer(), item)));
if((--maxCount)<=0) return false; if((--maxCount)<=0) return false;
} }
} }
@@ -59,24 +59,24 @@ bool SHAMap::compare(SHAMap::pointer otherMap, SHAMapDiff& differences, int maxC
{ {
if(!otherItem) if(!otherItem)
{ // we have items, other tree does not { // we have items, other tree does not
differences[ourItem->getTag()]= differences.insert(std::make_pair(ourItem->getTag(),
std::pair<SHAMapItem::pointer, SHAMapItem::pointer>(ourItem, otherItem); std::make_pair(ourItem, otherItem)));
if((--maxCount)<=0) return false; if((--maxCount)<=0) return false;
otherItem=otherNode->nextItem(otherItem->getTag()); otherItem=otherNode->nextItem(otherItem->getTag());
} }
else if(!ourItem) else if(!ourItem)
{ // we have no items, other tree does { // we have no items, other tree does
differences[otherItem->getTag()]= differences.insert(std::make_pair(otherItem->getTag(),
std::pair<SHAMapItem::pointer, SHAMapItem::pointer>(ourItem, otherItem); std::make_pair(ourItem, otherItem)));
if((--maxCount)<=0) return false; if((--maxCount)<=0) return false;
ourItem=thisNode->nextItem(ourItem->getTag()); otherItem=thisNode->nextItem(otherItem->getTag());
} }
else if(ourItem->getTag()==otherItem->getTag()) else if(ourItem->getTag()==otherItem->getTag())
{ // we have items with the same tag { // we have items with the same tag
if(ourItem->getData()!=otherItem->getData()) if(ourItem->getData()!=otherItem->getData())
{ // different data { // different data
differences[ourItem->getTag()]= differences.insert(std::make_pair(ourItem->getTag(),
std::pair<SHAMapItem::pointer, SHAMapItem::pointer>(ourItem, otherItem); std::make_pair(ourItem, otherItem)));
if((--maxCount)<=0) return false; if((--maxCount)<=0) return false;
} }
ourItem=thisNode->nextItem(ourItem->getTag()); ourItem=thisNode->nextItem(ourItem->getTag());
@@ -84,15 +84,15 @@ bool SHAMap::compare(SHAMap::pointer otherMap, SHAMapDiff& differences, int maxC
} }
else if(ourItem->getTag()<otherItem->getTag()) else if(ourItem->getTag()<otherItem->getTag())
{ // our item comes first { // our item comes first
differences[ourItem->getTag()]= differences.insert(std::make_pair(ourItem->getTag(),
std::pair<SHAMapItem::pointer, SHAMapItem::pointer>(ourItem, SHAMapItem::pointer()); std::make_pair(ourItem, SHAMapItem::pointer())));
if((--maxCount)<=0) return false; if((--maxCount)<=0) return false;
ourItem=thisNode->nextItem(ourItem->getTag()); ourItem=thisNode->nextItem(ourItem->getTag());
} }
else else
{ // other item comes first { // other item comes first
differences[otherItem->getTag()]= differences.insert(std::make_pair(otherItem->getTag(),
std::pair<SHAMapItem::pointer, SHAMapItem::pointer>(SHAMapItem::pointer(), otherItem); std::make_pair(SHAMapItem::pointer(), otherItem)));
if((--maxCount)<=0) return false; if((--maxCount)<=0) return false;
otherItem=otherNode->nextItem(otherItem->getTag()); otherItem=otherNode->nextItem(otherItem->getTag());
} }