Cleanups and whitespace fixes.

src/Amount.cpp

@@ -1114,9 +1114,9 @@ BOOST_AUTO_TEST_CASE( CustomCurrency_test )
 		BOOST_FAIL("STAmount divide fail");
 
 	STAmount a1(currency, 60), a2 (currency, 10, -1);
-	if(STAmount::divide(a2, a1, currency) != STAmount::setRate(STAmount::getRate(a1, a2), currency))
+	if (STAmount::divide(a2, a1, currency) != STAmount::setRate(STAmount::getRate(a1, a2), currency))
 		BOOST_FAIL("STAmount setRate(getRate) fail");
-	if(STAmount::divide(a1, a2, currency) != STAmount::setRate(STAmount::getRate(a2, a1), currency))
+	if (STAmount::divide(a1, a2, currency) != STAmount::setRate(STAmount::getRate(a2, a1), currency))
 		BOOST_FAIL("STAmount setRate(getRate) fail");
 
 	BOOST_TEST_MESSAGE("Amount CC Complete");

src/LedgerConsensus.cpp

@@ -146,7 +146,7 @@ void LCTransaction::setVote(const uint160& peer, bool votesYes)
 		++mYays;
 		res.first->second = true;
 	}
-	else if(!votesYes && res.first->second)
+	else if (!votesYes && res.first->second)
 	{ // changes vote to no
 		Log(lsTRACE) << "Peer " << peer.GetHex() << " now votes NO on " << mTransactionID.GetHex();
 		++mNays;
@@ -270,7 +270,7 @@ void LedgerConsensus::takeInitialPosition(Ledger& initialLedger)
 
 	// if any peers have taken a contrary position, process disputes
 	boost::unordered_set<uint256> found;
-	for(boost::unordered_map<uint160, LedgerProposal::pointer>::iterator it = mPeerPositions.begin(),
+	for (boost::unordered_map<uint160, LedgerProposal::pointer>::iterator it = mPeerPositions.begin(),
 		end = mPeerPositions.end(); it != end; ++it)
 	{
 		uint256 set = it->second->getCurrentHash();
@@ -296,14 +296,14 @@ void LedgerConsensus::createDisputes(SHAMap::pointer m1, SHAMap::pointer m2)
 {
 	SHAMap::SHAMapDiff differences;
 	m1->compare(m2, differences, 16384);
-	for(SHAMap::SHAMapDiff::iterator pos = differences.begin(), end = differences.end(); pos != end; ++pos)
+	for (SHAMap::SHAMapDiff::iterator pos = differences.begin(), end = differences.end(); pos != end; ++pos)
 	{ // create disputed transactions (from the ledger that has them)
 		if (pos->second.first)
 		{
 			assert(!pos->second.second);
 			addDisputedTransaction(pos->first, pos->second.first->peekData());
 		}
-		else if(pos->second.second)
+		else if (pos->second.second)
 		{
 			assert(!pos->second.first);
 			addDisputedTransaction(pos->first, pos->second.second->peekData());
@@ -371,7 +371,7 @@ void LedgerConsensus::adjustCount(SHAMap::pointer map, const std::vector<uint160
 		it != end; ++it)
 	{
 		bool setHas = map->hasItem(it->second->getTransactionID());
-		for(std::vector<uint160>::const_iterator pit = peers.begin(), pend = peers.end(); pit != pend; ++pit)
+		for (std::vector<uint160>::const_iterator pit = peers.begin(), pend = peers.end(); pit != pend; ++pit)
 			it->second->setVote(*pit, setHas);
 	}
 }
@@ -492,7 +492,7 @@ void LedgerConsensus::updateOurPositions()
 	SHAMap::pointer ourPosition;
 	std::vector<uint256> addedTx, removedTx;
 
-	for(boost::unordered_map<uint256, LCTransaction::pointer>::iterator it = mDisputes.begin(),
+	for (boost::unordered_map<uint256, LCTransaction::pointer>::iterator it = mDisputes.begin(),
 			end = mDisputes.end(); it != end; ++it)
 	{
 		if (it->second->updatePosition(mClosePercent, mProposing))
@@ -942,7 +942,7 @@ void LedgerConsensus::accept(SHAMap::pointer set)
 		Log(lsINFO) << "We closed at " << boost::lexical_cast<std::string>(mCloseTime);
 		uint64 closeTotal = mCloseTime;
 		int closeCount = 1;
-		for(std::map<uint32, int>::iterator it = mCloseTimes.begin(), end = mCloseTimes.end(); it != end; ++it)
+		for (std::map<uint32, int>::iterator it = mCloseTimes.begin(), end = mCloseTimes.end(); it != end; ++it)
 		{
 			Log(lsINFO) << boost::lexical_cast<std::string>(it->second) << " time votes for "
 				<< boost::lexical_cast<std::string>(it->first);
@@ -956,9 +956,8 @@ void LedgerConsensus::accept(SHAMap::pointer set)
 	}
 
 #ifdef DEBUG
-	Json::StyledStreamWriter ssw;
-	if (1)
 	{
+		Json::StyledStreamWriter ssw;
 		Log(lsTRACE) << "newLCL";
 		Json::Value p;
 		newLCL->addJson(p, LEDGER_JSON_DUMP_TXNS | LEDGER_JSON_DUMP_STATE);

src/PubKeyCache.cpp

@@ -6,7 +6,6 @@
 
 CKey::pointer PubKeyCache::locate(const NewcoinAddress& id)
 {
-	if(1)
 	{ // is it in cache
 		boost::mutex::scoped_lock sl(mLock);
 		std::map<NewcoinAddress, CKey::pointer>::iterator it(mCache.find(id));

src/SHAMap.cpp

@@ -262,7 +262,7 @@ SHAMapItem::pointer SHAMap::firstBelow(SHAMapTreeNode* node)
 				break;
 			}
 		if (!foundNode) return SHAMapItem::pointer();
-	} while (1);
+	} while (true);
 }
 
 SHAMapItem::pointer SHAMap::lastBelow(SHAMapTreeNode* node)
@@ -284,7 +284,7 @@ SHAMapItem::pointer SHAMap::lastBelow(SHAMapTreeNode* node)
 				break;
 			}
 		if (!foundNode) return SHAMapItem::pointer();
-	} while (1);
+	} while (true);
 }
 
 SHAMapItem::pointer SHAMap::onlyBelow(SHAMapTreeNode* node)
@@ -359,22 +359,23 @@ SHAMapItem::pointer SHAMap::peekNextItem(const uint256& id)
 	boost::recursive_mutex::scoped_lock sl(mLock);
 
 	std::stack<SHAMapTreeNode::pointer> stack = getStack(id, true, false);
-	while(!stack.empty())
+	while (!stack.empty())
 	{
 		SHAMapTreeNode::pointer node = stack.top();
 		stack.pop();
 
-		if(node->isLeaf())
+		if (node->isLeaf())
 		{
-			if(node->peekItem()->getTag()>id)
+			if (node->peekItem()->getTag() > id)
 				return node->peekItem();
 		}
-		else for(int i = node->selectBranch(id) + 1; i < 16; ++i)
-			if(!node->isEmptyBranch(i))
+		else for (int i = node->selectBranch(id) + 1; i < 16; ++i)
+			if (!node->isEmptyBranch(i))
 			{
 				node = getNode(node->getChildNodeID(i), node->getChildHash(i), false);
 				SHAMapItem::pointer item = firstBelow(node.get());
-				if (!item) throw std::runtime_error("missing node");
+				if (!item)
+					throw std::runtime_error("missing node");
 				return item;
 			}
 	}
@@ -392,17 +393,18 @@ SHAMapItem::pointer SHAMap::peekPrevItem(const uint256& id)
 		SHAMapTreeNode::pointer node = stack.top();
 		stack.pop();
 
-		if(node->isLeaf())
+		if (node->isLeaf())
 		{
-			if(node->peekItem()->getTag()<id)
+			if (node->peekItem()->getTag() < id)
 				return node->peekItem();
 		}
-		else for(int i = node->selectBranch(id) - 1; i >= 0; --i)
-				if(!node->isEmptyBranch(i))
+		else for (int i = node->selectBranch(id) - 1; i >= 0; --i)
+				if (!node->isEmptyBranch(i))
 				{
 					node = getNode(node->getChildNodeID(i), node->getChildHash(i), false);
 					SHAMapItem::pointer item = firstBelow(node.get());
-					if (!item) throw std::runtime_error("missing node");
+					if (!item)
+						throw std::runtime_error("missing node");
 					return item;
 				}
 	}
@@ -414,7 +416,8 @@ SHAMapItem::pointer SHAMap::peekItem(const uint256& id)
 {
 	boost::recursive_mutex::scoped_lock sl(mLock);
 	SHAMapTreeNode* leaf = walkToPointer(id);
-	if (!leaf) return SHAMapItem::pointer();
+	if (!leaf)
+		return SHAMapItem::pointer();
 	return leaf->peekItem();
 }
 
@@ -432,7 +435,7 @@ bool SHAMap::delItem(const uint256& id)
 	assert(mState != Immutable);
 
 	std::stack<SHAMapTreeNode::pointer> stack = getStack(id, true, false);
-	if(stack.empty())
+	if (stack.empty())
 		throw std::runtime_error("missing node");
 
 	SHAMapTreeNode::pointer leaf=stack.top();
@@ -442,7 +445,7 @@ bool SHAMap::delItem(const uint256& id)
 
 	SHAMapTreeNode::TNType type=leaf->getType();
 	returnNode(leaf, true);
-	if(mTNByID.erase(*leaf)==0)
+	if (mTNByID.erase(*leaf) == 0)
 		assert(false);
 
 	uint256 prevHash;
@@ -460,8 +463,8 @@ bool SHAMap::delItem(const uint256& id)
 		}
 		if (!node->isRoot())
 		{ // we may have made this a node with 1 or 0 children
-			int bc=node->getBranchCount();
-			if(bc==0)
+			int bc = node->getBranchCount();
+			if (bc == 0)
 			{
 #ifdef DEBUG
 				std::cerr << "delItem makes empty node" << std::endl;
@@ -470,10 +473,10 @@ bool SHAMap::delItem(const uint256& id)
 				if (!mTNByID.erase(*node))
 					assert(false);
 			}
-			else if(bc==1)
+			else if (bc == 1)
 			{ // pull up on the thread
 				SHAMapItem::pointer item = onlyBelow(node.get());
-				if(item)
+				if (item)
 				{
 					eraseChildren(node);
 #ifdef ST_DEBUG
@@ -521,7 +524,7 @@ bool SHAMap::addGiveItem(SHAMapItem::pointer item, bool isTransaction, bool hasM
 	uint256 prevHash;
 	returnNode(node, true);
 
-	if(node->isInner())
+	if (node->isInner())
 	{ // easy case, we end on an inner node
 #ifdef ST_DEBUG
 		std::cerr << "aGI inner " << node->getString() << std::endl;
@@ -530,7 +533,7 @@ bool SHAMap::addGiveItem(SHAMapItem::pointer item, bool isTransaction, bool hasM
 		assert(node->isEmptyBranch(branch));
 		SHAMapTreeNode::pointer newNode =
 			boost::make_shared<SHAMapTreeNode>(node->getChildNodeID(branch), item, type, mSeq);
-		if(!mTNByID.insert(std::make_pair(SHAMapNode(*newNode), newNode)).second)
+		if (!mTNByID.insert(std::make_pair(SHAMapNode(*newNode), newNode)).second)
 		{
 			std::cerr << "Node: " << node->getString() << std::endl;
 			std::cerr << "NewNode: " << newNode->getString() << std::endl;
@@ -562,7 +565,7 @@ bool SHAMap::addGiveItem(SHAMapItem::pointer item, bool isTransaction, bool hasM
 			SHAMapTreeNode::pointer newNode =
 				boost::make_shared<SHAMapTreeNode>(mSeq, node->getChildNodeID(b1));
 			newNode->makeInner();
-			if(!mTNByID.insert(std::make_pair(SHAMapNode(*newNode), newNode)).second)
+			if (!mTNByID.insert(std::make_pair(SHAMapNode(*newNode), newNode)).second)
 				assert(false);
 			stack.push(node);
 			node = newNode;
@@ -579,7 +582,7 @@ bool SHAMap::addGiveItem(SHAMapItem::pointer item, bool isTransaction, bool hasM
 
 		newNode = boost::make_shared<SHAMapTreeNode>(node->getChildNodeID(b2), otherItem, type, mSeq);
 		assert(newNode->isValid() && newNode->isLeaf());
-		if(!mTNByID.insert(std::make_pair(SHAMapNode(*newNode), newNode)).second)
+		if (!mTNByID.insert(std::make_pair(SHAMapNode(*newNode), newNode)).second)
 			assert(false);
 		node->setChildHash(b2, newNode->getNodeHash());
 	}
@@ -635,7 +638,7 @@ SHAMapTreeNode::pointer SHAMap::fetchNodeExternal(const SHAMapNode& id, const ui
 		throw SHAMapMissingNode(id, hash);
 
 	HashedObject::pointer obj(theApp->getHashedObjectStore().retrieve(hash));
-	if(!obj)
+	if (!obj)
 		throw SHAMapMissingNode(id, hash);
 	assert(Serializer::getSHA512Half(obj->getData()) == hash);
 
@@ -665,7 +668,7 @@ int SHAMap::flushDirty(int maxNodes, HashedObjectType t, uint32 seq)
 	int flushed = 0;
 	Serializer s;
 
-	if(mDirtyNodes)
+	if (mDirtyNodes)
 	{
 		boost::unordered_map<SHAMapNode, SHAMapTreeNode::pointer>& dirtyNodes = *mDirtyNodes;
 		boost::unordered_map<SHAMapNode, SHAMapTreeNode::pointer>::iterator it = dirtyNodes.begin();
@@ -714,10 +717,10 @@ void SHAMap::dump(bool hash)
 #if 0
 	std::cerr << "SHAMap::dump" << std::endl;
 	SHAMapItem::pointer i=peekFirstItem();
-	while(i)
+	while (i)
 	{
 		std::cerr << "Item: id=" << i->getTag().GetHex() << std::endl;
-		i=peekNextItem(i->getTag());
+		i = peekNextItem(i->getTag());
 	}
 	std::cerr << "SHAMap::dump done" << std::endl;
 #endif
@@ -728,7 +731,8 @@ void SHAMap::dump(bool hash)
 			it != mTNByID.end(); ++it)
 	{
 		std::cerr << it->second->getString() << std::endl;
-		if(hash) std::cerr << "   " << it->second->getNodeHash().GetHex() << std::endl;
+		if (hash)
+			std::cerr << "   " << it->second->getNodeHash().GetHex() << std::endl;
 	}
 
 }
@@ -756,8 +760,8 @@ BOOST_AUTO_TEST_CASE( SHAMap_test )
 	SHAMap sMap;
 	SHAMapItem i1(h1, IntToVUC(1)), i2(h2, IntToVUC(2)), i3(h3, IntToVUC(3)), i4(h4, IntToVUC(4)), i5(h5, IntToVUC(5));
 
-	if(!sMap.addItem(i2, true, false)) BOOST_FAIL("no add");
-	if(!sMap.addItem(i1, true, false)) BOOST_FAIL("no add");
+	if (!sMap.addItem(i2, true, false)) BOOST_FAIL("no add");
+	if (!sMap.addItem(i1, true, false)) BOOST_FAIL("no add");
 
 	SHAMapItem::pointer i;
 

src/SHAMapNodes.cpp

@@ -27,50 +27,50 @@ uint256 SHAMapNode::smMasks[65];
 
 bool SHAMapNode::operator<(const SHAMapNode &s) const
 {
-	if(s.mDepth<mDepth) return true;
-	if(s.mDepth>mDepth) return false;
-	return mNodeID<s.mNodeID;
+	if (s.mDepth < mDepth) return true;
+	if (s.mDepth > mDepth) return false;
+	return mNodeID < s.mNodeID;
 }
 
 bool SHAMapNode::operator>(const SHAMapNode &s) const
 {
-	if(s.mDepth<mDepth) return false;
-	if(s.mDepth>mDepth) return true;
-	return mNodeID>s.mNodeID;
+	if (s.mDepth < mDepth) return false;
+	if (s.mDepth > mDepth) return true;
+	return mNodeID > s.mNodeID;
 }
 
 bool SHAMapNode::operator<=(const SHAMapNode &s) const
 {
-	if(s.mDepth<mDepth) return true;
-	if(s.mDepth>mDepth) return false;
-	return mNodeID<=s.mNodeID;
+	if (s.mDepth < mDepth) return true;
+	if (s.mDepth > mDepth) return false;
+	return mNodeID <= s.mNodeID;
 }
 
 bool SHAMapNode::operator>=(const SHAMapNode &s) const
 {
-	if(s.mDepth<mDepth) return false;
-	if(s.mDepth>mDepth) return true;
-	return mNodeID>=s.mNodeID;
+	if (s.mDepth < mDepth) return false;
+	if (s.mDepth > mDepth) return true;
+	return mNodeID >= s.mNodeID;
 }
 
 bool SHAMapNode::operator==(const SHAMapNode &s) const
 {
-	return (s.mDepth==mDepth) && (s.mNodeID==mNodeID);
+	return (s.mDepth == mDepth) && (s.mNodeID == mNodeID);
 }
 
 bool SHAMapNode::operator!=(const SHAMapNode &s) const
 {
-	return (s.mDepth!=mDepth) || (s.mNodeID!=mNodeID);
+	return (s.mDepth != mDepth) || (s.mNodeID != mNodeID);
 }
 
 bool SHAMapNode::operator==(const uint256 &s) const
 {
-	return s==mNodeID;
+	return s == mNodeID;
 }
 
 bool SHAMapNode::operator!=(const uint256 &s) const
 {
-	return s!=mNodeID;
+	return s != mNodeID;
 }
 
 static bool j = SHAMapNode::ClassInit();
@@ -78,7 +78,7 @@ static bool j = SHAMapNode::ClassInit();
 bool SHAMapNode::ClassInit()
 { // set up the depth masks
 	uint256 selector;
-	for(int i = 0; i < 64; i += 2)
+	for (int i = 0; i < 64; i += 2)
 	{
 		smMasks[i] = selector;
 		*(selector.begin() + (i / 2)) = 0xF0;
@@ -476,7 +476,7 @@ std::string SHAMapTreeNode::getString() const
 	ret += ")";
 	if (isInner())
 	{
-		for(int i = 0; i < 16; ++i)
+		for (int i = 0; i < 16; ++i)
 			if (!isEmptyBranch(i))
 			{
 				ret += "\nb";

src/SNTPClient.cpp

@@ -204,7 +204,7 @@ void SNTPClient::init(const std::vector<std::string>& servers)
 
 void SNTPClient::queryAll()
 {
-	while(doQuery())
+	while (doQuery())
 		nothing();
 }
 

src/SerializedTypes.h

@@ -655,7 +655,7 @@ public:
 	int getLength() const;
 	SerializedTypeID getSType() const { return STI_TL; }
 	std::string getText() const;
-	void add(Serializer& s) const { if(s.addTaggedList(value)<0) throw(0); }
+	void add(Serializer& s) const { if (s.addTaggedList(value) < 0) throw(0); }
 
 	const std::vector<TaggedListItem>& peekValue() const { return value; }
 	std::vector<TaggedListItem>& peekValue() { return value; }

src/TransactionMeta.cpp

@@ -205,7 +205,7 @@ TransactionMetaSet::TransactionMetaSet(uint32 ledger, const std::vector<unsigned
 		if (node.isZero())
 			break;
 		mNodes.insert(std::make_pair(node, TransactionMetaNode(node, sit)));
-	} while(1);
+	} while (true);
 }
 
 void TransactionMetaSet::addRaw(Serializer& s)