Some const-correctness.

const SLE::pointer & -> SLE::ref

src/AccountState.cpp

@@ -21,7 +21,7 @@ AccountState::AccountState(const NewcoinAddress& naAccountID) : mAccountID(naAcc
 	mValid = true;
 }
 
-AccountState::AccountState(const SerializedLedgerEntry::pointer& ledgerEntry, const NewcoinAddress& naAccountID) :
+AccountState::AccountState(SLE::ref ledgerEntry, const NewcoinAddress& naAccountID) :
 	mAccountID(naAccountID), mLedgerEntry(ledgerEntry), mValid(false)
 {
 	if (!mLedgerEntry)

src/AccountState.h

@@ -29,7 +29,7 @@ private:
 
 public:
 	AccountState(const NewcoinAddress& naAccountID);						// For new accounts
-	AccountState(const SerializedLedgerEntry::pointer& ledgerEntry,const NewcoinAddress& naAccountI);	// For accounts in a ledger
+	AccountState(SLE::ref ledgerEntry,const NewcoinAddress& naAccountI);	// For accounts in a ledger
 
 	bool	bHaveAuthorizedKey()
 	{

src/ConnectionPool.cpp

@@ -340,7 +340,7 @@ std::vector<Peer::pointer> ConnectionPool::getPeerVector()
 
 // Now know peer's node public key.  Determine if we want to stay connected.
 // <-- bNew: false = redundant
-bool ConnectionPool::peerConnected(const Peer::pointer& peer, const NewcoinAddress& naPeer,
+bool ConnectionPool::peerConnected(Peer::ref peer, const NewcoinAddress& naPeer,
 	const std::string& strIP, int iPort)
 {
 	bool	bNew	= false;
@@ -399,7 +399,7 @@ bool ConnectionPool::peerConnected(const Peer::pointer& peer, const NewcoinAddre
 }
 
 // We maintain a map of public key to peer for connected and verified peers.  Maintain it.
-void ConnectionPool::peerDisconnected(const Peer::pointer& peer, const NewcoinAddress& naPeer)
+void ConnectionPool::peerDisconnected(Peer::ref peer, const NewcoinAddress& naPeer)
 {
 	if (naPeer.isValid())
 	{
@@ -486,7 +486,7 @@ bool ConnectionPool::peerScanSet(const std::string& strIp, int iPort)
 }
 
 // --> strIp: not empty
-void ConnectionPool::peerClosed(const Peer::pointer& peer, const std::string& strIp, int iPort)
+void ConnectionPool::peerClosed(Peer::ref peer, const std::string& strIp, int iPort)
 {
 	ipPort		ipPeer			= make_pair(strIp, iPort);
 	bool		bScanRefresh	= false;
@@ -541,7 +541,7 @@ void ConnectionPool::peerClosed(const Peer::pointer& peer, const std::string& st
 		scanRefresh();
 }
 
-void ConnectionPool::peerVerified(const Peer::pointer& peer)
+void ConnectionPool::peerVerified(Peer::ref peer)
 {
 	if (mScanning && mScanning == peer)
 	{

src/ConnectionPool.h

@@ -72,16 +72,16 @@ public:
 
 	// We know peers node public key.
 	// <-- bool: false=reject
-	bool peerConnected(const Peer::pointer& peer, const NewcoinAddress& naPeer, const std::string& strIP, int iPort);
+	bool peerConnected(Peer::ref peer, const NewcoinAddress& naPeer, const std::string& strIP, int iPort);
 
 	// No longer connected.
-	void peerDisconnected(const Peer::pointer& peer, const NewcoinAddress& naPeer);
+	void peerDisconnected(Peer::ref peer, const NewcoinAddress& naPeer);
 
 	// As client accepted.
-	void peerVerified(const Peer::pointer& peer);
+	void peerVerified(Peer::ref peer);
 
 	// As client failed connect and be accepted.
-	void peerClosed(const Peer::pointer& peer, const std::string& strIp, int iPort);
+	void peerClosed(Peer::ref peer, const std::string& strIp, int iPort);
 
 	Json::Value getPeersJson();
 	std::vector<Peer::pointer> getPeerVector();

src/Ledger.cpp

@@ -508,7 +508,7 @@ void Ledger::setCloseTime(boost::posix_time::ptime ptm)
 }
 
 // XXX Use shared locks where possible?
-LedgerStateParms Ledger::writeBack(LedgerStateParms parms, const SLE::pointer& entry)
+LedgerStateParms Ledger::writeBack(LedgerStateParms parms, SLE::ref entry)
 {
 	ScopedLock l(mAccountStateMap->Lock());
 	bool create = false;

src/Ledger.h

@@ -157,7 +157,7 @@ public:
 
 	// high-level functions
 	AccountState::pointer getAccountState(const NewcoinAddress& acctID);
-	LedgerStateParms writeBack(LedgerStateParms parms, const SLE::pointer&);
+	LedgerStateParms writeBack(LedgerStateParms parms, SLE::ref);
 	SLE::pointer getAccountRoot(const uint160& accountID);
 	SLE::pointer getAccountRoot(const NewcoinAddress& naAccountID);
 

src/LedgerAcquire.cpp

@@ -20,7 +20,7 @@ PeerSet::PeerSet(const uint256& hash, int interval) : mHash(hash), mTimerInterva
 	assert((mTimerInterval > 10) && (mTimerInterval < 30000));
 }
 
-void PeerSet::peerHas(const Peer::pointer& ptr)
+void PeerSet::peerHas(Peer::ref ptr)
 {
 	boost::recursive_mutex::scoped_lock sl(mLock);
 	std::vector< boost::weak_ptr<Peer> >::iterator it = mPeers.begin();
@@ -40,7 +40,7 @@ void PeerSet::peerHas(const Peer::pointer& ptr)
 	newPeer(ptr);
 }
 
-void PeerSet::badPeer(const Peer::pointer& ptr)
+void PeerSet::badPeer(Peer::ref ptr)
 {
 	boost::recursive_mutex::scoped_lock sl(mLock);
 	std::vector< boost::weak_ptr<Peer> >::iterator it = mPeers.begin();
@@ -142,7 +142,7 @@ void LedgerAcquire::addOnComplete(boost::function<void (LedgerAcquire::pointer)>
 	mLock.unlock();
 }
 
-void LedgerAcquire::trigger(const Peer::pointer& peer, bool timer)
+void LedgerAcquire::trigger(Peer::ref peer, bool timer)
 {
 	if (mAborted || mComplete || mFailed)
 		return;
@@ -257,7 +257,7 @@ void LedgerAcquire::trigger(const Peer::pointer& peer, bool timer)
 		resetTimer();
 }
 
-void PeerSet::sendRequest(const newcoin::TMGetLedger& tmGL, const Peer::pointer& peer)
+void PeerSet::sendRequest(const newcoin::TMGetLedger& tmGL, Peer::ref peer)
 {
 	if (!peer)
 		sendRequest(tmGL);
@@ -435,7 +435,7 @@ void LedgerAcquireMaster::dropLedger(const uint256& hash)
 	mLedgers.erase(hash);
 }
 
-bool LedgerAcquireMaster::gotLedgerData(newcoin::TMLedgerData& packet, const Peer::pointer& peer)
+bool LedgerAcquireMaster::gotLedgerData(newcoin::TMLedgerData& packet, Peer::ref peer)
 {
 #ifdef LA_DEBUG
 	Log(lsTRACE) << "got data for acquiring ledger ";

src/LedgerAcquire.h

@@ -31,7 +31,7 @@ protected:
 	virtual ~PeerSet() { ; }
 
 	void sendRequest(const newcoin::TMGetLedger& message);
-	void sendRequest(const newcoin::TMGetLedger& message, const Peer::pointer& peer);
+	void sendRequest(const newcoin::TMGetLedger& message, Peer::ref peer);
 
 public:
 	const uint256& getHash() const		{ return mHash; }
@@ -41,12 +41,12 @@ public:
 
 	void progress()						{ mProgress = true; }
 
-	void peerHas(const Peer::pointer&);
+	void peerHas(Peer::ref);
-	void badPeer(const Peer::pointer&);
+	void badPeer(Peer::ref);
 	void resetTimer();
 
 protected:
-	virtual void newPeer(const Peer::pointer&) = 0;
+	virtual void newPeer(Peer::ref) = 0;
 	virtual void onTimer(void) = 0;
 	virtual boost::weak_ptr<PeerSet> pmDowncast() = 0;
 
@@ -72,7 +72,7 @@ protected:
 	void done();
 	void onTimer();
 
-	void newPeer(const Peer::pointer& peer) { trigger(peer, false); }
+	void newPeer(Peer::ref peer) { trigger(peer, false); }
 
 	boost::weak_ptr<PeerSet> pmDowncast();
 
@@ -92,7 +92,7 @@ public:
 	bool takeTxRootNode(const std::vector<unsigned char>& data);
 	bool takeAsNode(const std::list<SHAMapNode>& IDs, const std::list<std::vector<unsigned char> >& data);
 	bool takeAsRootNode(const std::vector<unsigned char>& data);
-	void trigger(const Peer::pointer&, bool timer);
+	void trigger(Peer::ref, bool timer);
 };
 
 class LedgerAcquireMaster
@@ -108,7 +108,7 @@ public:
 	LedgerAcquire::pointer find(const uint256& hash);
 	bool hasLedger(const uint256& ledgerHash);
 	void dropLedger(const uint256& ledgerHash);
-	bool gotLedgerData(newcoin::TMLedgerData& packet, const Peer::pointer&);
+	bool gotLedgerData(newcoin::TMLedgerData& packet, Peer::ref);
 };
 
 #endif

src/LedgerConsensus.cpp

@@ -45,7 +45,7 @@ boost::weak_ptr<PeerSet> TransactionAcquire::pmDowncast()
 	return boost::shared_polymorphic_downcast<PeerSet, TransactionAcquire>(shared_from_this());
 }
 
-void TransactionAcquire::trigger(const Peer::pointer& peer, bool timer)
+void TransactionAcquire::trigger(Peer::ref peer, bool timer)
 {
 	if (mComplete || mFailed)
 		return;
@@ -87,7 +87,7 @@ void TransactionAcquire::trigger(const Peer::pointer& peer, bool timer)
 }
 
 bool TransactionAcquire::takeNodes(const std::list<SHAMapNode>& nodeIDs,
-	const std::list< std::vector<unsigned char> >& data, const Peer::pointer& peer)
+	const std::list< std::vector<unsigned char> >& data, Peer::ref peer)
 {
 	if (mComplete)
 		return true;
@@ -286,7 +286,7 @@ void LedgerConsensus::handleLCL(const uint256& lclHash)
 		mAcquiringLedger = theApp->getMasterLedgerAcquire().findCreate(mPrevLedgerHash);
 		std::vector<Peer::pointer> peerList = theApp->getConnectionPool().getPeerVector();
 		bool found = false;
-		BOOST_FOREACH(Peer::pointer& peer, peerList)
+		BOOST_FOREACH(Peer::ref peer, peerList)
 		{
 			if (peer->hasLedger(mPrevLedgerHash))
 			{
@@ -296,7 +296,7 @@ void LedgerConsensus::handleLCL(const uint256& lclHash)
 		}
 		if (!found)
 		{
-			BOOST_FOREACH(Peer::pointer& peer, peerList)
+			BOOST_FOREACH(Peer::ref peer, peerList)
 				mAcquiringLedger->peerHas(peer);
 		}
 		mHaveCorrectLCL = false;
@@ -798,7 +798,7 @@ bool LedgerConsensus::peerPosition(const LedgerProposal::pointer& newPosition)
 	return true;
 }
 
-bool LedgerConsensus::peerHasSet(const Peer::pointer& peer, const uint256& hashSet, newcoin::TxSetStatus status)
+bool LedgerConsensus::peerHasSet(Peer::ref peer, const uint256& hashSet, newcoin::TxSetStatus status)
 {
 	if (status != newcoin::tsHAVE) // Indirect requests are for future support
 		return true;
@@ -815,7 +815,7 @@ bool LedgerConsensus::peerHasSet(const Peer::pointer& peer, const uint256& hashS
 	return true;
 }
 
-bool LedgerConsensus::peerGaveNodes(const Peer::pointer& peer, const uint256& setHash,
+bool LedgerConsensus::peerGaveNodes(Peer::ref peer, const uint256& setHash,
 	const std::list<SHAMapNode>& nodeIDs, const std::list< std::vector<unsigned char> >& nodeData)
 {
 	boost::unordered_map<uint256, TransactionAcquire::pointer>::iterator acq = mAcquiring.find(setHash);

src/LedgerConsensus.h

@@ -28,10 +28,10 @@ protected:
 	bool				mHaveRoot;
 
 	void onTimer()					{ trigger(Peer::pointer(), true); }
-	void newPeer(const Peer::pointer& peer)	{ trigger(peer, false); }
+	void newPeer(Peer::ref peer)	{ trigger(peer, false); }
 
 	void done();
-	void trigger(const Peer::pointer&, bool timer);
+	void trigger(Peer::ref, bool timer);
 	boost::weak_ptr<PeerSet> pmDowncast();
 
 public:
@@ -41,7 +41,7 @@ public:
 	SHAMap::pointer getMap()			{ return mMap; }
 
 	bool takeNodes(const std::list<SHAMapNode>& IDs, const std::list< std::vector<unsigned char> >& data,
-		const Peer::pointer&);
+		Peer::ref);
 };
 
 class LCTransaction
@@ -119,7 +119,7 @@ protected:
 	static void Saccept(boost::shared_ptr<LedgerConsensus> This, SHAMap::pointer txSet);
 	void accept(const SHAMap::pointer& txSet);
 
-	void weHave(const uint256& id, const Peer::pointer& avoidPeer);
+	void weHave(const uint256& id, Peer::ref avoidPeer);
 	void startAcquiring(const TransactionAcquire::pointer&);
 	SHAMap::pointer find(const uint256& hash);
 
@@ -174,9 +174,9 @@ public:
 	bool peerPosition(const LedgerProposal::pointer&);
 	void deferProposal(const LedgerProposal::pointer& proposal,	const NewcoinAddress& peerPublic);
 
-	bool peerHasSet(const Peer::pointer& peer, const uint256& set, newcoin::TxSetStatus status);
+	bool peerHasSet(Peer::ref peer, const uint256& set, newcoin::TxSetStatus status);
 
-	bool peerGaveNodes(const Peer::pointer& peer, const uint256& setHash,
+	bool peerGaveNodes(Peer::ref peer, const uint256& setHash,
 		const std::list<SHAMapNode>& nodeIDs, const std::list< std::vector<unsigned char> >& nodeData);
 };
 

src/LedgerEntrySet.cpp

@@ -61,7 +61,7 @@ LedgerEntryAction LedgerEntrySet::hasEntry(const uint256& index) const
 	return it->second.mAction;
 }
 
-void LedgerEntrySet::entryCache(const SLE::pointer& sle)
+void LedgerEntrySet::entryCache(SLE::ref sle)
 {
 	boost::unordered_map<uint256, LedgerEntrySetEntry>::iterator it = mEntries.find(sle->getIndex());
 	if (it == mEntries.end())
@@ -82,7 +82,7 @@ void LedgerEntrySet::entryCache(const SLE::pointer& sle)
 	}
 }
 
-void LedgerEntrySet::entryCreate(const SLE::pointer& sle)
+void LedgerEntrySet::entryCreate(SLE::ref sle)
 {
 	boost::unordered_map<uint256, LedgerEntrySetEntry>::iterator it = mEntries.find(sle->getIndex());
 	if (it == mEntries.end())
@@ -112,7 +112,7 @@ void LedgerEntrySet::entryCreate(const SLE::pointer& sle)
 	}
 }
 
-void LedgerEntrySet::entryModify(const SLE::pointer& sle)
+void LedgerEntrySet::entryModify(SLE::ref sle)
 {
 	boost::unordered_map<uint256, LedgerEntrySetEntry>::iterator it = mEntries.find(sle->getIndex());
 	if (it == mEntries.end())
@@ -147,7 +147,7 @@ void LedgerEntrySet::entryModify(const SLE::pointer& sle)
 	}
  }
 
-void LedgerEntrySet::entryDelete(const SLE::pointer& sle, bool unfunded)
+void LedgerEntrySet::entryDelete(SLE::ref sle, bool unfunded)
 {
 	boost::unordered_map<uint256, LedgerEntrySetEntry>::iterator it = mEntries.find(sle->getIndex());
 	if (it == mEntries.end())
@@ -268,7 +268,7 @@ bool LedgerEntrySet::threadTx(TransactionMetaNode& metaNode, const NewcoinAddres
 	return threadTx(metaNode, sle, ledger, newMods);
 }
 
-bool LedgerEntrySet::threadTx(TransactionMetaNode& metaNode, SLE::pointer& threadTo, Ledger::ref ledger,
+bool LedgerEntrySet::threadTx(TransactionMetaNode& metaNode, SLE::ref threadTo, Ledger::ref ledger,
 	boost::unordered_map<uint256, SLE::pointer>& newMods)
 {  // node = the node that was modified/deleted/created
    // threadTo = the node that needs to know
@@ -282,7 +282,7 @@ bool LedgerEntrySet::threadTx(TransactionMetaNode& metaNode, SLE::pointer& threa
 	return false;
 }
 
-bool LedgerEntrySet::threadOwners(TransactionMetaNode& metaNode, SLE::pointer& node, Ledger::ref ledger,
+bool LedgerEntrySet::threadOwners(TransactionMetaNode& metaNode, SLE::ref node, Ledger::ref ledger,
 	boost::unordered_map<uint256, SLE::pointer>& newMods)
 { // thread new or modified node to owner or owners
 	if (node->hasOneOwner()) // thread to owner's account

src/LedgerEntrySet.h

@@ -24,7 +24,7 @@ public:
 	LedgerEntryAction	mAction;
 	int					mSeq;
 
-	LedgerEntrySetEntry(const SLE::pointer& e, LedgerEntryAction a, int s) : mEntry(e), mAction(a), mSeq(s) { ; }
+	LedgerEntrySetEntry(SLE::ref e, LedgerEntryAction a, int s) : mEntry(e), mAction(a), mSeq(s) { ; }
 };
 
 
@@ -44,10 +44,10 @@ protected:
 	bool threadTx(TransactionMetaNode& metaNode, const NewcoinAddress& threadTo, Ledger::ref ledger,
 		boost::unordered_map<uint256, SLE::pointer>& newMods);
 
-	bool threadTx(TransactionMetaNode& metaNode, SLE::pointer& threadTo, Ledger::ref ledger,
+	bool threadTx(TransactionMetaNode& metaNode, SLE::ref threadTo, Ledger::ref ledger,
 	    boost::unordered_map<uint256, SLE::pointer>& newMods);
 
-	bool threadOwners(TransactionMetaNode& metaNode, SLE::pointer& node, Ledger::ref ledger,
+	bool threadOwners(TransactionMetaNode& metaNode, SLE::ref node, Ledger::ref ledger,
 		boost::unordered_map<uint256, SLE::pointer>& newMods);
 
 public:
@@ -66,10 +66,10 @@ public:
 	// basic entry functions
 	SLE::pointer getEntry(const uint256& index, LedgerEntryAction&);
 	LedgerEntryAction hasEntry(const uint256& index) const;
-	void entryCache(const SLE::pointer&);		// Add this entry to the cache
+	void entryCache(SLE::ref);		// Add this entry to the cache
-	void entryCreate(const SLE::pointer&);		// This entry will be created
+	void entryCreate(SLE::ref);		// This entry will be created
-	void entryDelete(const SLE::pointer&, bool unfunded);
+	void entryDelete(SLE::ref, bool unfunded);
-	void entryModify(const SLE::pointer&);		// This entry will be modified
+	void entryModify(SLE::ref);		// This entry will be modified
 
 	Json::Value getJson(int) const;
 	void calcRawMeta(Serializer&, Ledger::ref originalLedger);

src/NetworkOPs.cpp

@@ -444,7 +444,7 @@ bool NetworkOPs::checkLastClosedLedger(const std::vector<Peer::pointer>& peerLis
 		ourVC.highNode = theApp->getWallet().getNodePublic();
 	}
 
-	BOOST_FOREACH(const Peer::pointer& it, peerList)
+	BOOST_FOREACH(Peer::ref it, peerList)
 	{
 		if (!it)
 		{
@@ -522,7 +522,7 @@ bool NetworkOPs::checkLastClosedLedger(const std::vector<Peer::pointer>& peerLis
 		{ // add more peers
 			int count = 0;
 			std::vector<Peer::pointer> peers=theApp->getConnectionPool().getPeerVector();
-			BOOST_FOREACH(const Peer::pointer& it, peerList)
+			BOOST_FOREACH(Peer::ref it, peerList)
 			{
 				if (it->getClosedLedgerHash() == closedLedger)
 				{
@@ -532,7 +532,7 @@ bool NetworkOPs::checkLastClosedLedger(const std::vector<Peer::pointer>& peerLis
 			}
 			if (!count)
 			{ // just ask everyone
-				BOOST_FOREACH(const Peer::pointer& it, peerList)
+				BOOST_FOREACH(Peer::ref it, peerList)
 					if (it->isConnected())
 						mAcquiringLedger->peerHas(it);
 			}
@@ -691,7 +691,7 @@ void NetworkOPs::endConsensus(bool correctLCL)
 	Log(lsTRACE) << "Ledger " << deadLedger.GetHex() << " is now dead";
 	theApp->getValidations().addDeadLedger(deadLedger);
 	std::vector<Peer::pointer> peerList = theApp->getConnectionPool().getPeerVector();
-	BOOST_FOREACH(const Peer::pointer& it, peerList)
+	BOOST_FOREACH(Peer::ref it, peerList)
 		if (it && (it->getClosedLedgerHash() == deadLedger))
 		{
 			Log(lsTRACE) << "Killing obsolete peer status";

src/Peer.cpp

@@ -140,7 +140,7 @@ void Peer::handleVerifyTimer(const boost::system::error_code& ecResult)
 
 // Begin trying to connect. We are not connected till we know and accept peer's public key.
 // Only takes IP addresses (not domains).
-void Peer::connect(const std::string strIp, int iPort)
+void Peer::connect(const std::string& strIp, int iPort)
 {
 	int	iPortAct	= (iPort <= 0) ? SYSTEM_PEER_PORT : iPort;
 

src/Peer.h

@@ -25,12 +25,13 @@ class Peer : public boost::enable_shared_from_this<Peer>
 {
 public:
 	typedef boost::shared_ptr<Peer>			pointer;
+	typedef const boost::shared_ptr<Peer>&	ref;
 
 	static const int psbGotHello = 0, psbSentHello = 1, psbInMap = 2, psbTrusted = 3;
 	static const int psbNoLedgers = 4, psbNoTransactions = 5, psbDownLevel = 6;
 
 	void			handleConnect(const boost::system::error_code& error, boost::asio::ip::tcp::resolver::iterator it);
-	static void		sHandleConnect(const Peer::pointer& ptr, const boost::system::error_code& error,
+	static void		sHandleConnect(Peer::ref ptr, const boost::system::error_code& error,
 		boost::asio::ip::tcp::resolver::iterator it)
 	{ ptr->handleConnect(error, it); }
 
@@ -50,11 +51,11 @@ private:
 	boost::asio::deadline_timer									mVerifyTimer;
 
 	void			handleStart(const boost::system::error_code& ecResult);
-	static void		sHandleStart(const Peer::pointer& ptr, const boost::system::error_code& ecResult)
+	static void		sHandleStart(Peer::ref ptr, const boost::system::error_code& ecResult)
 	{ ptr->handleStart(ecResult); }
 
 	void			handleVerifyTimer(const boost::system::error_code& ecResult);
-	static void		sHandleVerifyTimer(const Peer::pointer& ptr, const boost::system::error_code& ecResult)
+	static void		sHandleVerifyTimer(Peer::ref ptr, const boost::system::error_code& ecResult)
 	{ ptr->handleVerifyTimer(ecResult); }
 
 protected:
@@ -68,19 +69,19 @@ protected:
 	Peer(boost::asio::io_service& io_service, boost::asio::ssl::context& ctx);
 
 	void handleShutdown(const boost::system::error_code& error) { ; }
-	static void sHandleShutdown(const Peer::pointer& ptr, const boost::system::error_code& error)
+	static void sHandleShutdown(Peer::ref ptr, const boost::system::error_code& error)
 	{ ptr->handleShutdown(error); }
 
 	void handle_write(const boost::system::error_code& error, size_t bytes_transferred);
-	static void sHandle_write(const Peer::pointer& ptr, const boost::system::error_code& error, size_t bytes_transferred)
+	static void sHandle_write(Peer::ref ptr, const boost::system::error_code& error, size_t bytes_transferred)
 	{ ptr->handle_write(error, bytes_transferred); }
 
 	void handle_read_header(const boost::system::error_code& error);
-	static void sHandle_read_header(const Peer::pointer& ptr, const boost::system::error_code& error)
+	static void sHandle_read_header(Peer::ref ptr, const boost::system::error_code& error)
 	{ ptr->handle_read_header(error); }
 
 	void handle_read_body(const boost::system::error_code& error);
-	static void sHandle_read_body(const Peer::pointer& ptr, const boost::system::error_code& error)
+	static void sHandle_read_body(Peer::ref ptr, const boost::system::error_code& error)
 	{ ptr->handle_read_body(error); }
 
 	void processReadBuffer();
@@ -134,10 +135,10 @@ public:
 		return mSocketSsl.lowest_layer();
 	}
 
-	void connect(const std::string strIp, int iPort);
+	void connect(const std::string& strIp, int iPort);
 	void connected(const boost::system::error_code& error);
 	void detach(const char *);
-	bool samePeer(const Peer::pointer& p)	{ return samePeer(*p); }
+	bool samePeer(Peer::ref p)			{ return samePeer(*p); }
 	bool samePeer(const Peer& p)		{ return this == &p; }
 
 	void sendPacket(const PackedMessage::pointer& packet);

src/SerializedLedger.h

@@ -9,6 +9,7 @@ class SerializedLedgerEntry : public SerializedType
 {
 public:
 	typedef boost::shared_ptr<SerializedLedgerEntry>		pointer;
+	typedef const boost::shared_ptr<SerializedLedgerEntry>&	ref;
 
 protected:
 	uint256						mIndex;