ARCHIVE/rippled
1
0
Fork 0
mirror of https://github.com/XRPLF/rippled.git synced 2025-11-19 18:45:52 +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());
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)
@@ -19,44 +19,40 @@ void LedgerHistory::addAcceptedLedger(Ledger::pointer ledger)
assert(ledger && ledger->isAccepted());
uint256 h(ledger->getHash());
boost::recursive_mutex::scoped_lock sl(mLock);
if(!!mLedgersByHash[h]) return;
mLedgersByHash[h]=ledger;
mLedgersByIndex[ledger->getLedgerSeq()]=ledger;
mLedgersByIndex.insert(std::make_pair(ledger->getLedgerSeq(), ledger));
mLedgersByHash.insert(std::make_pair(h, ledger));
theApp->getIOService().post(boost::bind(&Ledger::saveAcceptedLedger, ledger));
}
Ledger::pointer LedgerHistory::getLedgerBySeq(uint32 index)
{
boost::recursive_mutex::scoped_lock sl(mLock);
Ledger::pointer ret(mLedgersByIndex[index]);
if(ret) return ret;
if(mLedgersByIndex.count(index)) return mLedgersByIndex[index];
sl.unlock();
ret=Ledger::loadByIndex(index);
Ledger::pointer ret(Ledger::loadByIndex(index));
if(!ret) return ret;
assert(ret->getLedgerSeq()==index);
uint256 h=ret->getHash();
sl.lock();
mLedgersByIndex[index]=ret;
mLedgersByHash[h]=ret;
mLedgersByIndex.insert(std::make_pair(index, ret));
mLedgersByHash.insert(std::make_pair(h, ret));
return ret;
}
Ledger::pointer LedgerHistory::getLedgerByHash(const uint256& hash)
{
boost::recursive_mutex::scoped_lock sl(mLock);
Ledger::pointer ret(mLedgersByHash[hash]);
if(ret) return ret;
if(mLedgersByHash.count(hash)!=0) return mLedgersByHash[hash];
sl.unlock();
ret=Ledger::loadByHash(hash);
Ledger::pointer ret=Ledger::loadByHash(hash);
if(!ret) return ret;
assert(ret->getHash()==hash);
sl.lock();
mLedgersByHash[hash]=ret;
if(ret->isAccepted()) mLedgersByIndex[ret->getLedgerSeq()]=ret;
mLedgersByHash.insert(std::make_pair(hash, ret));
if(ret->isAccepted()) mLedgersByIndex.insert(std::make_pair(ret->getLedgerSeq(), ret));
return ret;
}
@@ -65,12 +61,12 @@ Ledger::pointer LedgerHistory::canonicalizeLedger(Ledger::pointer ledger, bool s
uint256 h(ledger->getHash());
boost::recursive_mutex::scoped_lock sl(mLock);
Ledger::pointer ret(mLedgersByHash[h]);
if(ret) return ret;
if(mLedgersByHash.count(h)!=0) return mLedgersByHash[h];
if(!save) return ledger;
assert(ret->getHash()==h);
mLedgersByHash[h]=ledger;
if(ret->isAccepted()) mLedgersByIndex[ret->getLedgerSeq()]=ledger;
assert(ledger->getHash()==h);
mLedgersByHash.insert(std::make_pair(h, ledger));
if(ledger->isAccepted()) mLedgersByIndex.insert(std::make_pair(ledger->getLedgerSeq(), ledger));
return ledger;
}

4
LedgerMaster.cpp
View File

@@ -27,9 +27,9 @@ uint64 LedgerMaster::getBalance(std::string& addr)
bool LedgerMaster::addHeldTransaction(Transaction::pointer transaction)
{
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 false;

12
SHAMap.cpp
View File

@@ -21,7 +21,7 @@ void SHAMap::dirtyUp(const uint256& id)
if(!leaf) throw SHAMapException(MissingNode);
uint256 hVal=leaf->getNodeHash();
if(mDirtyLeafNodes) (*mDirtyLeafNodes)[*leaf]=leaf;
if(mDirtyLeafNodes) mDirtyLeafNodes->insert(std::make_pair(SHAMapNode(*leaf), leaf));
if(!hVal)
{
#ifdef ST_DEBUG
@@ -44,7 +44,7 @@ void SHAMap::dirtyUp(const uint256& id)
#ifdef ST_DEBUG
std::cerr << "Dirty " << node->getString() << std::endl;
#endif
if(mDirtyInnerNodes) (*mDirtyInnerNodes)[*node]=node;
if(mDirtyInnerNodes) mDirtyInnerNodes->insert(std::make_pair(SHAMapNode(*node), node));
hVal=node->getNodeHash();
if(!hVal)
{
@@ -143,7 +143,7 @@ SHAMapInnerNode::pointer SHAMap::getInner(const SHAMapNode& id, const uint256& h
node=SHAMapInnerNode::pointer(new SHAMapInnerNode(id, rawNode, mSeq));
if(node->getNodeHash()!=hash) throw SHAMapException(InvalidNode);
mInnerNodeByID[id]=node;
mInnerNodeByID.insert(std::make_pair(id, node));
if(id.getDepth()==0) root=node;
return node;
}
@@ -154,7 +154,7 @@ SHAMapLeafNode::pointer SHAMap::returnLeaf(SHAMapLeafNode::pointer leaf, bool mo
{
leaf=SHAMapLeafNode::pointer(new SHAMapLeafNode(*leaf, mSeq));
mLeafByID[*leaf]=leaf;
if(mDirtyLeafNodes) (*mDirtyLeafNodes)[*leaf]=leaf;
if(mDirtyLeafNodes) mDirtyLeafNodes->insert(std::make_pair(SHAMapNode(*leaf), leaf));
}
return leaf;
}
@@ -167,8 +167,8 @@ SHAMapInnerNode::pointer SHAMap::returnNode(SHAMapInnerNode::pointer node, bool
std::cerr << "Node(" << node->getString() << ") bumpseq" << std::endl;
#endif
node=SHAMapInnerNode::pointer(new SHAMapInnerNode(*node, mSeq));
mInnerNodeByID[*node]=node;
if(mDirtyInnerNodes) (*mDirtyInnerNodes)[*node]=node;
mInnerNodeByID.insert(std::make_pair(SHAMapNode(*node), node));
if(mDirtyInnerNodes) mDirtyInnerNodes->insert(std::make_pair(SHAMapNode(*node), 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);
for(SHAMapItem::pointer item=thisNode->firstItem(); item; item=thisNode->nextItem(item->getTag()))
{ // items in leaf only in our tree
differences[item->getTag()]=
std::pair<SHAMapItem::pointer, SHAMapItem::pointer>(item, SHAMapItem::pointer());
differences.insert(std::make_pair(item->getTag(),
std::make_pair(item, SHAMapItem::pointer())));
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);
for(SHAMapItem::pointer item=otherNode->firstItem(); item; item=otherNode->nextItem(item->getTag()))
{ // items in leaf only in our tree
differences[item->getTag()]=
std::pair<SHAMapItem::pointer, SHAMapItem::pointer>(SHAMapItem::pointer(), item);
differences.insert(std::make_pair(item->getTag(),
std::make_pair(SHAMapItem::pointer(), item)));
if((--maxCount)<=0) return false;
}
}
@@ -59,24 +59,24 @@ bool SHAMap::compare(SHAMap::pointer otherMap, SHAMapDiff& differences, int maxC
{
if(!otherItem)
{ // we have items, other tree does not
differences[ourItem->getTag()]=
std::pair<SHAMapItem::pointer, SHAMapItem::pointer>(ourItem, otherItem);
differences.insert(std::make_pair(ourItem->getTag(),
std::make_pair(ourItem, otherItem)));
if((--maxCount)<=0) return false;
otherItem=otherNode->nextItem(otherItem->getTag());
}
else if(!ourItem)
{ // we have no items, other tree does
differences[otherItem->getTag()]=
std::pair<SHAMapItem::pointer, SHAMapItem::pointer>(ourItem, otherItem);
differences.insert(std::make_pair(otherItem->getTag(),
std::make_pair(ourItem, otherItem)));
if((--maxCount)<=0) return false;
ourItem=thisNode->nextItem(ourItem->getTag());
otherItem=thisNode->nextItem(otherItem->getTag());
}
else if(ourItem->getTag()==otherItem->getTag())
{ // we have items with the same tag
if(ourItem->getData()!=otherItem->getData())
{ // different data
differences[ourItem->getTag()]=
std::pair<SHAMapItem::pointer, SHAMapItem::pointer>(ourItem, otherItem);
differences.insert(std::make_pair(ourItem->getTag(),
std::make_pair(ourItem, otherItem)));
if((--maxCount)<=0) return false;
}
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())
{ // our item comes first
differences[ourItem->getTag()]=
std::pair<SHAMapItem::pointer, SHAMapItem::pointer>(ourItem, SHAMapItem::pointer());
differences.insert(std::make_pair(ourItem->getTag(),
std::make_pair(ourItem, SHAMapItem::pointer())));
if((--maxCount)<=0) return false;
ourItem=thisNode->nextItem(ourItem->getTag());
}
else
{ // other item comes first
differences[otherItem->getTag()]=
std::pair<SHAMapItem::pointer, SHAMapItem::pointer>(SHAMapItem::pointer(), otherItem);
differences.insert(std::make_pair(otherItem->getTag(),
std::make_pair(SHAMapItem::pointer(), otherItem)));
if((--maxCount)<=0) return false;
otherItem=otherNode->nextItem(otherItem->getTag());
}