2010-11-11 Tatsuhiro Tsujikawa <t-tujikawa@users.sourceforge.net>

	To match the behavior of friend operator functions in
	SharedHandle.h to std::tr1::shared_ptr, we intentionally broke
	these functions and modified code so that our code does not depend
	on old behavior.
	* src/AbstractCommand.cc
	* src/DHTAbstractNodeLookupTask.h
	* src/DHTBucket.cc
	* src/DHTMessageReceiver.cc
	* src/DHTNodeLookupEntry.cc
	* src/DHTRoutingTable.cc
	* src/DefaultBtRequestFactory.cc
	* src/DefaultPeerStorage.cc
	* src/DefaultPieceStorage.cc
	* src/DownloadContext.cc
	* src/EpollEventPoll.cc
	* src/Event.h
	* src/HttpConnection.cc
	* src/KqueueEventPoll.cc
	* src/MultiDiskAdaptor.cc
	* src/PeerAbstractCommand.cc
	* src/PieceStatMan.cc
	* src/PollEventPoll.cc
	* src/PortEventPoll.cc
	* src/SegmentMan.cc
	* src/SelectEventPoll.cc
	* src/SelectEventPoll.h
	* src/ServerStatMan.cc
	* src/SharedHandle.h
	* src/UnknownLengthPieceStorage.cc
	* src/a2functional.h
	* src/option_processing.cc
	* src/version_usage.cc
	* test/BNodeTest.cc
	* test/DHTAnnouncePeerMessageTest.cc
	* test/DHTBucketTest.cc
	* test/DHTFindNodeMessageTest.cc
	* test/DHTGetPeersMessageTest.cc
	* test/DHTIDCloserTest.cc
	* test/DHTMessageFactoryImplTest.cc
	* test/DHTPingMessageTest.cc
	* test/DefaultBtRequestFactoryTest.cc
	* test/DefaultPeerStorageTest.cc
	* test/SequentialPickerTest.cc
	* test/SingletonHolderTest.cc

28 files changed, 176 insertions, 88 deletions

diff --git a/src/AbstractCommand.cc b/src/AbstractCommand.cc
index c83ef87b..1375c8b3 100644
--- a/src/AbstractCommand.cc
+++ b/src/AbstractCommand.cc
@@ -462,7 +462,7 @@ void AbstractCommand::setReadCheckSocket(const SocketHandle& socket) {
     disableReadCheckSocket();
   } else {
     if(checkSocketIsReadable_) {
-      if(readCheckTarget_ != socket) {
+      if(*readCheckTarget_ != *socket) {
         e_->deleteSocketForReadCheck(readCheckTarget_, this);
         e_->addSocketForReadCheck(socket, this);
         readCheckTarget_ = socket;
@@ -498,7 +498,7 @@ void AbstractCommand::setWriteCheckSocket(const SocketHandle& socket) {
     disableWriteCheckSocket();
   } else {
     if(checkSocketIsWritable_) {
-      if(writeCheckTarget_ != socket) {
+      if(*writeCheckTarget_ != *socket) {
         e_->deleteSocketForWriteCheck(writeCheckTarget_, this);
         e_->addSocketForWriteCheck(socket, this);
         writeCheckTarget_ = socket;
diff --git a/src/DHTAbstractNodeLookupTask.h b/src/DHTAbstractNodeLookupTask.h
index 869e0597..0922d8fa 100644
--- a/src/DHTAbstractNodeLookupTask.h
+++ b/src/DHTAbstractNodeLookupTask.h
@@ -54,6 +54,7 @@
 #include "Logger.h"
 #include "util.h"
 #include "DHTIDCloser.h"
+#include "a2functional.h"
 
 namespace aria2 {
 
@@ -203,7 +204,10 @@ public:
                          static_cast<unsigned long>(count));
     }
     std::stable_sort(entries_.begin(), entries_.end(), DHTIDCloser(targetID_));
-    entries_.erase(std::unique(entries_.begin(), entries_.end()), entries_.end());
+    entries_.erase
+      (std::unique(entries_.begin(), entries_.end(),
+                   DerefEqualTo<SharedHandle<DHTNodeLookupEntry> >()),
+       entries_.end());
     if(getLogger()->debug()) {
       getLogger()->debug("%lu node lookup entries are unique.",
                          static_cast<unsigned long>(entries_.size()));
@@ -223,7 +227,7 @@ public:
     --inFlightMessage_;
     for(std::deque<SharedHandle<DHTNodeLookupEntry> >::iterator i =
           entries_.begin(), eoi = entries_.end(); i != eoi; ++i) {
-      if((*i)->node == node) {
+      if(*(*i)->node == *node) {
         entries_.erase(i);
         break;
       }
diff --git a/src/DHTBucket.cc b/src/DHTBucket.cc
index acaa04ad..258b7ada 100644
--- a/src/DHTBucket.cc
+++ b/src/DHTBucket.cc
@@ -111,7 +111,7 @@ bool DHTBucket::addNode(const SharedHandle<DHTNode>& node)
 {
   notifyUpdate();
   std::deque<SharedHandle<DHTNode> >::iterator itr =
-    std::find(nodes_.begin(), nodes_.end(), node);
+    std::find_if(nodes_.begin(), nodes_.end(), derefEqual(node));
   if(itr == nodes_.end()) {
     if(nodes_.size() < K) {
       nodes_.push_back(node);
@@ -145,7 +145,7 @@ void DHTBucket::dropNode(const SharedHandle<DHTNode>& node)
 {
   if(cachedNodes_.size()) {
     std::deque<SharedHandle<DHTNode> >::iterator itr =
-      find(nodes_.begin(), nodes_.end(), node);
+      std::find_if(nodes_.begin(), nodes_.end(), derefEqual(node));
     if(itr != nodes_.end()) {
       nodes_.erase(itr);
       nodes_.push_back(cachedNodes_.front());
@@ -157,7 +157,7 @@ void DHTBucket::dropNode(const SharedHandle<DHTNode>& node)
 void DHTBucket::moveToHead(const SharedHandle<DHTNode>& node)
 {
   std::deque<SharedHandle<DHTNode> >::iterator itr =
-    std::find(nodes_.begin(), nodes_.end(), node);
+    std::find_if(nodes_.begin(), nodes_.end(), derefEqual(node));
   if(itr != nodes_.end()) {
     nodes_.erase(itr);
     nodes_.push_front(node);
@@ -167,7 +167,7 @@ void DHTBucket::moveToHead(const SharedHandle<DHTNode>& node)
 void DHTBucket::moveToTail(const SharedHandle<DHTNode>& node)
 {
   std::deque<SharedHandle<DHTNode> >::iterator itr =
-    std::find(nodes_.begin(), nodes_.end(), node);
+    std::find_if(nodes_.begin(), nodes_.end(), derefEqual(node));
   if(itr != nodes_.end()) {
     nodes_.erase(itr);
     nodes_.push_back(node);
@@ -233,7 +233,7 @@ SharedHandle<DHTNode> DHTBucket::getNode(const unsigned char* nodeID, const std:
   node->setIPAddress(ipaddr);
   node->setPort(port);
   std::deque<SharedHandle<DHTNode> >::const_iterator itr =
-    std::find(nodes_.begin(), nodes_.end(), node);
+    std::find_if(nodes_.begin(), nodes_.end(), derefEqual(node));
   if(itr == nodes_.end()) {
     return SharedHandle<DHTNode>();
   } else {
diff --git a/src/DHTMessageReceiver.cc b/src/DHTMessageReceiver.cc
index 3883272b..ddcb9891 100644
--- a/src/DHTMessageReceiver.cc
+++ b/src/DHTMessageReceiver.cc
@@ -109,7 +109,7 @@ SharedHandle<DHTMessage> DHTMessageReceiver::receiveMessage()
     } else {
       SharedHandle<DHTQueryMessage> message =
         factory_->createQueryMessage(dict, remoteAddr, remotePort);
-      if(message->getLocalNode() == message->getRemoteNode()) {
+      if(*message->getLocalNode() == *message->getRemoteNode()) {
         // drop message from localnode
         logger_->info("Received DHT message from localnode.");
         return handleUnknownMessage(data, sizeof(data), remoteAddr, remotePort);
diff --git a/src/DHTNodeLookupEntry.cc b/src/DHTNodeLookupEntry.cc
index 7596db18..58cb5825 100644
--- a/src/DHTNodeLookupEntry.cc
+++ b/src/DHTNodeLookupEntry.cc
@@ -45,7 +45,7 @@ DHTNodeLookupEntry::DHTNodeLookupEntry():
 
 bool DHTNodeLookupEntry::operator==(const DHTNodeLookupEntry& entry) const
 {
-  return node == entry.node;
+  return *node == *entry.node;
 }
 
 } // namespace aria2
diff --git a/src/DHTRoutingTable.cc b/src/DHTRoutingTable.cc
index f7876082..5d4bf18f 100644
--- a/src/DHTRoutingTable.cc
+++ b/src/DHTRoutingTable.cc
@@ -77,7 +77,7 @@ bool DHTRoutingTable::addNode(const SharedHandle<DHTNode>& node, bool good)
   if(logger_->debug()) {
     logger_->debug("Trying to add node:%s", node->toString().c_str());
   }
-  if(localNode_ == node) {
+  if(*localNode_ == *node) {
     if(logger_->debug()) {
       logger_->debug("Adding node with the same ID with localnode is not"
                      " allowed.");
diff --git a/src/DefaultBtRequestFactory.cc b/src/DefaultBtRequestFactory.cc
index 005e0786..7a3f022a 100644
--- a/src/DefaultBtRequestFactory.cc
+++ b/src/DefaultBtRequestFactory.cc
@@ -99,8 +99,9 @@ void DefaultBtRequestFactory::removeCompletedPiece() {
 void DefaultBtRequestFactory::removeTargetPiece
 (const SharedHandle<Piece>& piece)
 {
-  pieces_.erase(std::remove(pieces_.begin(), pieces_.end(), piece),
-               pieces_.end());
+  pieces_.erase(std::remove_if(pieces_.begin(), pieces_.end(),
+                               derefEqual(piece)),
+                pieces_.end());
   dispatcher_->doAbortOutstandingRequestAction(piece);
   pieceStorage_->cancelPiece(piece);
 }
diff --git a/src/DefaultPeerStorage.cc b/src/DefaultPeerStorage.cc
index a565a82a..eebac966 100644
--- a/src/DefaultPeerStorage.cc
+++ b/src/DefaultPeerStorage.cc
@@ -45,6 +45,7 @@
 #include "BtLeecherStateChoke.h"
 #include "PieceStorage.h"
 #include "wallclock.h"
+#include "a2functional.h"
 
 namespace aria2 {
 
@@ -75,7 +76,7 @@ public:
   FindIdenticalPeer(const SharedHandle<Peer>& peer):peer_(peer) {}
 
   bool operator()(const SharedHandle<Peer>& peer) const {
-    return (peer_ == peer) ||
+    return (*peer_ == *peer) ||
       ((peer_->getIPAddress() == peer->getIPAddress()) &&
        (peer_->getPort() == peer->getPort()));
   }
@@ -337,7 +338,7 @@ void DefaultPeerStorage::onReturningPeer(const SharedHandle<Peer>& peer)
 void DefaultPeerStorage::returnPeer(const SharedHandle<Peer>& peer)
 {
   std::deque<SharedHandle<Peer> >::iterator itr =
-    std::find(peers_.begin(), peers_.end(), peer);
+    std::find_if(peers_.begin(), peers_.end(), derefEqual(peer));
   if(itr == peers_.end()) {
     if(logger_->debug()) {
       logger_->debug("Cannot find peer %s:%u in PeerStorage.",
diff --git a/src/DefaultPieceStorage.cc b/src/DefaultPieceStorage.cc
index 5b9d2eaf..1a187c19 100644
--- a/src/DefaultPieceStorage.cc
+++ b/src/DefaultPieceStorage.cc
@@ -127,7 +127,8 @@ SharedHandle<Piece> DefaultPieceStorage::getPiece(size_t index)
 void DefaultPieceStorage::addUsedPiece(const SharedHandle<Piece>& piece)
 {
   std::deque<SharedHandle<Piece> >::iterator i =
-    std::lower_bound(usedPieces_.begin(), usedPieces_.end(), piece);
+    std::lower_bound(usedPieces_.begin(), usedPieces_.end(), piece,
+                     DerefLess<SharedHandle<Piece> >());
   usedPieces_.insert(i, piece);
   if(logger_->debug()) {
     logger_->debug("usedPieces_.size()=%lu",
@@ -141,8 +142,9 @@ SharedHandle<Piece> DefaultPieceStorage::findUsedPiece(size_t index) const
   p->setIndex(index);
 
   std::deque<SharedHandle<Piece> >::const_iterator i =
-    std::lower_bound(usedPieces_.begin(), usedPieces_.end(), p);
-  if(i != usedPieces_.end() && (*i) == p) {
+    std::lower_bound(usedPieces_.begin(), usedPieces_.end(), p,
+                     DerefLess<SharedHandle<Piece> >());
+  if(i != usedPieces_.end() && *(*i) == *p) {
     return *i;
   } else {
     p.reset(0);
@@ -365,8 +367,9 @@ void DefaultPieceStorage::deleteUsedPiece(const SharedHandle<Piece>& piece)
     return;
   }
   std::deque<SharedHandle<Piece> >::iterator i = 
-    std::lower_bound(usedPieces_.begin(), usedPieces_.end(), piece);
-  if(i != usedPieces_.end() && (*i) == piece) {
+    std::lower_bound(usedPieces_.begin(), usedPieces_.end(), piece,
+                     DerefLess<SharedHandle<Piece> >());
+  if(i != usedPieces_.end() && *(*i) == *piece) {
     usedPieces_.erase(i);
   }
 }
@@ -723,7 +726,8 @@ void DefaultPieceStorage::addInFlightPiece
 (const std::vector<SharedHandle<Piece> >& pieces)
 {
   usedPieces_.insert(usedPieces_.end(), pieces.begin(), pieces.end());
-  std::sort(usedPieces_.begin(), usedPieces_.end());
+  std::sort(usedPieces_.begin(), usedPieces_.end(),
+            DerefLess<SharedHandle<Piece> >());
 }
 
 size_t DefaultPieceStorage::countInFlightPiece()
diff --git a/src/DownloadContext.cc b/src/DownloadContext.cc
index ac84fd3e..f0397634 100644
--- a/src/DownloadContext.cc
+++ b/src/DownloadContext.cc
@@ -41,6 +41,7 @@
 #include "util.h"
 #include "wallclock.h"
 #include "DlAbortEx.h"
+#include "a2functional.h"
 
 namespace aria2 {
 
@@ -102,7 +103,8 @@ DownloadContext::findFileEntryByOffset(off_t offset) const
   SharedHandle<FileEntry> obj(new FileEntry());
   obj->setOffset(offset);
   std::vector<SharedHandle<FileEntry> >::const_iterator i =
-    std::upper_bound(fileEntries_.begin(), fileEntries_.end(), obj);
+    std::upper_bound(fileEntries_.begin(), fileEntries_.end(), obj,
+                     DerefLess<SharedHandle<FileEntry> >());
   if(i != fileEntries_.end() && (*i)->getOffset() == offset) {
     return *i;
   } else {
diff --git a/src/EpollEventPoll.cc b/src/EpollEventPoll.cc
index 75db479d..d7077fdb 100644
--- a/src/EpollEventPoll.cc
+++ b/src/EpollEventPoll.cc
@@ -43,6 +43,7 @@
 #include "LogFactory.h"
 #include "Logger.h"
 #include "util.h"
+#include "a2functional.h"
 
 namespace aria2 {
 
@@ -166,10 +167,11 @@ bool EpollEventPoll::addEvents(sock_t socket,
 {
   SharedHandle<KSocketEntry> socketEntry(new KSocketEntry(socket));
   std::deque<SharedHandle<KSocketEntry> >::iterator i =
-    std::lower_bound(socketEntries_.begin(), socketEntries_.end(), socketEntry);
+    std::lower_bound(socketEntries_.begin(), socketEntries_.end(), socketEntry,
+                     DerefLess<SharedHandle<KSocketEntry> >());
   int r = 0;
   int errNum = 0;
-  if(i != socketEntries_.end() && (*i) == socketEntry) {
+  if(i != socketEntries_.end() && *(*i) == *socketEntry) {
 
     event.addSelf(*i);
 
@@ -229,8 +231,9 @@ bool EpollEventPoll::deleteEvents(sock_t socket,
 {
   SharedHandle<KSocketEntry> socketEntry(new KSocketEntry(socket));
   std::deque<SharedHandle<KSocketEntry> >::iterator i =
-    std::lower_bound(socketEntries_.begin(), socketEntries_.end(), socketEntry);
-  if(i != socketEntries_.end() && (*i) == socketEntry) {
+    std::lower_bound(socketEntries_.begin(), socketEntries_.end(), socketEntry,
+                     DerefLess<SharedHandle<KSocketEntry> >());
+  if(i != socketEntries_.end() && *(*i) == *socketEntry) {
 
     event.removeSelf(*i);
 
@@ -295,7 +298,8 @@ bool EpollEventPoll::addNameResolver
   SharedHandle<KAsyncNameResolverEntry> entry
     (new KAsyncNameResolverEntry(resolver, command));
   std::deque<SharedHandle<KAsyncNameResolverEntry> >::iterator itr =
-    std::find(nameResolverEntries_.begin(), nameResolverEntries_.end(), entry);
+    std::find_if(nameResolverEntries_.begin(), nameResolverEntries_.end(),
+                 derefEqual(entry));
   if(itr == nameResolverEntries_.end()) {
     nameResolverEntries_.push_back(entry);
     entry->addSocketEvents(this);
@@ -311,7 +315,8 @@ bool EpollEventPoll::deleteNameResolver
   SharedHandle<KAsyncNameResolverEntry> entry
     (new KAsyncNameResolverEntry(resolver, command));
   std::deque<SharedHandle<KAsyncNameResolverEntry> >::iterator itr =
-    std::find(nameResolverEntries_.begin(), nameResolverEntries_.end(), entry);
+    std::find_if(nameResolverEntries_.begin(), nameResolverEntries_.end(),
+                 derefEqual(entry));
   if(itr == nameResolverEntries_.end()) {
     return false;
   } else {
diff --git a/src/Event.h b/src/Event.h
index 83e0cfb4..ce10c332 100644
--- a/src/Event.h
+++ b/src/Event.h
@@ -151,7 +151,7 @@ public:
 
   bool operator==(const ADNSEvent& event) const
   {
-    return resolver_ == event.resolver_;
+    return *resolver_ == *event.resolver_;
   }
     
   virtual int getEvents() const
@@ -323,7 +323,7 @@ public:
 
   bool operator==(const AsyncNameResolverEntry& entry)
   {
-    return nameResolver_ == entry.nameResolver_ &&
+    return *nameResolver_ == *entry.nameResolver_ &&
       command_ == entry.command_;
   }
 
diff --git a/src/HttpConnection.cc b/src/HttpConnection.cc
index 56710e62..127ff192 100644
--- a/src/HttpConnection.cc
+++ b/src/HttpConnection.cc
@@ -165,7 +165,7 @@ bool HttpConnection::isIssued(const SharedHandle<Segment>& segment) const
   for(HttpRequestEntries::const_iterator itr = outstandingHttpRequests_.begin(),
         eoi = outstandingHttpRequests_.end(); itr != eoi; ++itr) {
     SharedHandle<HttpRequest> httpRequest = (*itr)->getHttpRequest();
-    if(httpRequest->getSegment() == segment) {
+    if(*httpRequest->getSegment() == *segment) {
       return true;
     }
   }
diff --git a/src/KqueueEventPoll.cc b/src/KqueueEventPoll.cc
index be4b7a5a..dfa500b4 100644
--- a/src/KqueueEventPoll.cc
+++ b/src/KqueueEventPoll.cc
@@ -170,12 +170,13 @@ bool KqueueEventPoll::addEvents
 {
   SharedHandle<KSocketEntry> socketEntry(new KSocketEntry(socket));
   std::deque<SharedHandle<KSocketEntry> >::iterator i =
-    std::lower_bound(socketEntries_.begin(), socketEntries_.end(), socketEntry);
+    std::lower_bound(socketEntries_.begin(), socketEntries_.end(), socketEntry,
+                     DerefLess<SharedHandle<KSocketEntry> >());
   int r = 0;
   struct timespec zeroTimeout = { 0, 0 };
   struct kevent changelist[2];
   size_t n;
-  if(i != socketEntries_.end() && (*i) == socketEntry) {
+  if(i != socketEntries_.end() && *(*i) == *socketEntry) {
     event.addSelf(*i);
     n = (*i)->getEvents(changelist);
   } else {
@@ -221,8 +222,9 @@ bool KqueueEventPoll::deleteEvents(sock_t socket,
 {
   SharedHandle<KSocketEntry> socketEntry(new KSocketEntry(socket));
   std::deque<SharedHandle<KSocketEntry> >::iterator i =
-    std::lower_bound(socketEntries_.begin(), socketEntries_.end(), socketEntry);
-  if(i != socketEntries_.end() && (*i) == socketEntry) {
+    std::lower_bound(socketEntries_.begin(), socketEntries_.end(), socketEntry,
+                     DerefLess<SharedHandle<KSocketEntry> >());
+  if(i != socketEntries_.end() && *(*i) == *socketEntry) {
     event.removeSelf(*i);
     int r = 0;
     struct timespec zeroTimeout = { 0, 0 };
@@ -272,7 +274,8 @@ bool KqueueEventPoll::addNameResolver
   SharedHandle<KAsyncNameResolverEntry> entry
     (new KAsyncNameResolverEntry(resolver, command));
   std::deque<SharedHandle<KAsyncNameResolverEntry> >::iterator itr =
-    std::find(nameResolverEntries_.begin(), nameResolverEntries_.end(), entry);
+    std::find_if(nameResolverEntries_.begin(), nameResolverEntries_.end(),
+                 derefEqual(entry));
   if(itr == nameResolverEntries_.end()) {
     nameResolverEntries_.push_back(entry);
     entry->addSocketEvents(this);
@@ -288,7 +291,8 @@ bool KqueueEventPoll::deleteNameResolver
   SharedHandle<KAsyncNameResolverEntry> entry
     (new KAsyncNameResolverEntry(resolver, command));
   std::deque<SharedHandle<KAsyncNameResolverEntry> >::iterator itr =
-    std::find(nameResolverEntries_.begin(), nameResolverEntries_.end(), entry);
+    std::find_if(nameResolverEntries_.begin(), nameResolverEntries_.end(),
+                 derefEqual(entry));
   if(itr == nameResolverEntries_.end()) {
     return false;
   } else {
diff --git a/src/MultiDiskAdaptor.cc b/src/MultiDiskAdaptor.cc
index 288d06e6..05dcb719 100644
--- a/src/MultiDiskAdaptor.cc
+++ b/src/MultiDiskAdaptor.cc
@@ -119,7 +119,7 @@ void DiskWriterEntry::setDiskWriter(const SharedHandle<DiskWriter>& diskWriter)
 
 bool DiskWriterEntry::operator<(const DiskWriterEntry& entry) const
 {
-  return fileEntry_ < entry.fileEntry_;
+  return *fileEntry_ < *entry.fileEntry_;
 }
 
 void DiskWriterEntry::enableDirectIO()
diff --git a/src/PeerAbstractCommand.cc b/src/PeerAbstractCommand.cc
index 4a663839..ef6a2af2 100644
--- a/src/PeerAbstractCommand.cc
+++ b/src/PeerAbstractCommand.cc
@@ -148,7 +148,7 @@ void PeerAbstractCommand::setReadCheckSocket(const SocketHandle& socket)
     disableReadCheckSocket();
   } else {
     if(checkSocketIsReadable_) {
-      if(readCheckTarget_ != socket) {
+      if(*readCheckTarget_ != *socket) {
         e_->deleteSocketForReadCheck(readCheckTarget_, this);
         e_->addSocketForReadCheck(socket, this);
         readCheckTarget_ = socket;
@@ -176,7 +176,7 @@ void PeerAbstractCommand::setWriteCheckSocket(const SocketHandle& socket)
     disableWriteCheckSocket();
   } else {
     if(checkSocketIsWritable_) {
-      if(writeCheckTarget_ != socket) {
+      if(*writeCheckTarget_ != *socket) {
         e_->deleteSocketForWriteCheck(writeCheckTarget_, this);
         e_->addSocketForWriteCheck(socket, this);
         writeCheckTarget_ = socket;
diff --git a/src/PieceStatMan.cc b/src/PieceStatMan.cc
index af442f43..2fd8818b 100644
--- a/src/PieceStatMan.cc
+++ b/src/PieceStatMan.cc
@@ -103,7 +103,7 @@ public:
 
   bool operator()(size_t lhs, size_t rhs) const
   {
-    return pieceStats_[lhs] < pieceStats_[rhs];
+    return *pieceStats_[lhs] < *pieceStats_[rhs];
   }
 };
 } // namespace
diff --git a/src/PollEventPoll.cc b/src/PollEventPoll.cc
index eaa174f1..1af0771d 100644
--- a/src/PollEventPoll.cc
+++ b/src/PollEventPoll.cc
@@ -41,6 +41,7 @@
 #include "Command.h"
 #include "LogFactory.h"
 #include "Logger.h"
+#include "a2functional.h"
 
 namespace aria2 {
 
@@ -97,8 +98,9 @@ void PollEventPoll::poll(const struct timeval& tv)
       if(first->revents) {
         se->setSocket(first->fd);
         std::deque<SharedHandle<KSocketEntry> >::iterator itr =
-          std::lower_bound(socketEntries_.begin(), socketEntries_.end(), se);
-        if(itr != socketEntries_.end() && (*itr) == se) {
+          std::lower_bound(socketEntries_.begin(), socketEntries_.end(), se,
+                           DerefLess<SharedHandle<KSocketEntry> >());
+        if(itr != socketEntries_.end() && *(*itr) == *se) {
           (*itr)->processEvents(first->revents);
         } else {
           if(logger_->debug()) {
@@ -150,8 +152,9 @@ bool PollEventPoll::addEvents
 {
   SharedHandle<KSocketEntry> socketEntry(new KSocketEntry(socket));
   std::deque<SharedHandle<KSocketEntry> >::iterator i =
-    std::lower_bound(socketEntries_.begin(), socketEntries_.end(), socketEntry);
-  if(i != socketEntries_.end() && (*i) == socketEntry) {
+    std::lower_bound(socketEntries_.begin(), socketEntries_.end(), socketEntry,
+                     DerefLess<SharedHandle<KSocketEntry> >());
+  if(i != socketEntries_.end() && *(*i) == *socketEntry) {
     event.addSelf(*i);
     for(struct pollfd* first = pollfds_, *last = pollfds_+pollfdNum_;
         first != last; ++first) {
@@ -197,8 +200,9 @@ bool PollEventPoll::deleteEvents
 {
   SharedHandle<KSocketEntry> socketEntry(new KSocketEntry(socket));
   std::deque<SharedHandle<KSocketEntry> >::iterator i =
-    std::lower_bound(socketEntries_.begin(), socketEntries_.end(), socketEntry);
-  if(i != socketEntries_.end() && (*i) == socketEntry) {
+    std::lower_bound(socketEntries_.begin(), socketEntries_.end(), socketEntry,
+                     DerefLess<SharedHandle<KSocketEntry> >());
+  if(i != socketEntries_.end() && *(*i) == *socketEntry) {
     event.removeSelf(*i);
     for(struct pollfd* first = pollfds_, *last = pollfds_+pollfdNum_;
         first != last; ++first) {
@@ -246,7 +250,8 @@ bool PollEventPoll::addNameResolver
   SharedHandle<KAsyncNameResolverEntry> entry
     (new KAsyncNameResolverEntry(resolver, command));
   std::deque<SharedHandle<KAsyncNameResolverEntry> >::iterator itr =
-    std::find(nameResolverEntries_.begin(), nameResolverEntries_.end(), entry);
+    std::find_if(nameResolverEntries_.begin(), nameResolverEntries_.end(),
+                 derefEqual(entry));
   if(itr == nameResolverEntries_.end()) {
     nameResolverEntries_.push_back(entry);
     entry->addSocketEvents(this);
@@ -262,7 +267,8 @@ bool PollEventPoll::deleteNameResolver
   SharedHandle<KAsyncNameResolverEntry> entry
     (new KAsyncNameResolverEntry(resolver, command));
   std::deque<SharedHandle<KAsyncNameResolverEntry> >::iterator itr =
-    std::find(nameResolverEntries_.begin(), nameResolverEntries_.end(), entry);
+    std::find_if(nameResolverEntries_.begin(), nameResolverEntries_.end(),
+                 derefEqual(entry));
   if(itr == nameResolverEntries_.end()) {
     return false;
   } else {
diff --git a/src/PortEventPoll.cc b/src/PortEventPoll.cc
index cb3757cd..363c619f 100644
--- a/src/PortEventPoll.cc
+++ b/src/PortEventPoll.cc
@@ -173,10 +173,11 @@ bool PortEventPoll::addEvents(sock_t socket,
 {
   SharedHandle<KSocketEntry> socketEntry(new KSocketEntry(socket));
   std::deque<SharedHandle<KSocketEntry> >::iterator i =
-    std::lower_bound(socketEntries_.begin(), socketEntries_.end(), socketEntry);
+    std::lower_bound(socketEntries_.begin(), socketEntries_.end(), socketEntry,
+                     DerefLess<SharedHandle<KSocketEntry> >());
   int r = 0;
   int errNum = 0;
-  if(i != socketEntries_.end() && (*i) == socketEntry) {
+  if(i != socketEntries_.end() && *(*i) == *socketEntry) {
     event.addSelf(*i);
     A2PortEvent pv = (*i)->getEvents();
     r = port_associate(port_, PORT_SOURCE_FD, (*i)->getSocket(),
@@ -226,8 +227,9 @@ bool PortEventPoll::deleteEvents(sock_t socket,
 {
   SharedHandle<KSocketEntry> socketEntry(new KSocketEntry(socket));
   std::deque<SharedHandle<KSocketEntry> >::iterator i =
-    std::lower_bound(socketEntries_.begin(), socketEntries_.end(), socketEntry);
-  if(i != socketEntries_.end() && (*i) == socketEntry) {
+    std::lower_bound(socketEntries_.begin(), socketEntries_.end(), socketEntry,
+                     DerefLess<SharedHandle<KSocketEntry> >());
+  if(i != socketEntries_.end() && *(*i) == *socketEntry) {
     event.removeSelf(*i);
     int r = 0;
     int errNum = 0;
@@ -280,7 +282,8 @@ bool PortEventPoll::addNameResolver
   SharedHandle<KAsyncNameResolverEntry> entry
     (new KAsyncNameResolverEntry(resolver, command));
   std::deque<SharedHandle<KAsyncNameResolverEntry> >::iterator itr =
-    std::find(nameResolverEntries_.begin(), nameResolverEntries_.end(), entry);
+    std::find_if(nameResolverEntries_.begin(), nameResolverEntries_.end(),
+                 derefEqual(entry));
   if(itr == nameResolverEntries_.end()) {
     nameResolverEntries_.push_back(entry);
     entry->addSocketEvents(this);
@@ -296,7 +299,8 @@ bool PortEventPoll::deleteNameResolver
   SharedHandle<KAsyncNameResolverEntry> entry
     (new KAsyncNameResolverEntry(resolver, command));
   std::deque<SharedHandle<KAsyncNameResolverEntry> >::iterator itr =
-    std::find(nameResolverEntries_.begin(), nameResolverEntries_.end(), entry);
+    std::find_if(nameResolverEntries_.begin(), nameResolverEntries_.end(),
+                 derefEqual(entry));
   if(itr == nameResolverEntries_.end()) {
     return false;
   } else {
diff --git a/src/SegmentMan.cc b/src/SegmentMan.cc
index ced3df30..bc83c6f5 100644
--- a/src/SegmentMan.cc
+++ b/src/SegmentMan.cc
@@ -280,7 +280,7 @@ void SegmentMan::cancelSegment
 {
   for(SegmentEntries::iterator itr = usedSegmentEntries_.begin(),
         eoi = usedSegmentEntries_.end(); itr != eoi;) {
-    if((*itr)->cuid == cuid && (*itr)->segment == segment) {
+    if((*itr)->cuid == cuid && *(*itr)->segment == *segment) {
       cancelSegment((*itr)->segment);
       itr = usedSegmentEntries_.erase(itr);
       //eoi = usedSegmentEntries_.end();
diff --git a/src/SelectEventPoll.cc b/src/SelectEventPoll.cc
index 473091e3..4297b55e 100644
--- a/src/SelectEventPoll.cc
+++ b/src/SelectEventPoll.cc
@@ -44,6 +44,7 @@
 #include "Command.h"
 #include "LogFactory.h"
 #include "Logger.h"
+#include "a2functional.h"
 
 namespace aria2 {
 
@@ -278,8 +279,9 @@ bool SelectEventPoll::addEvents(sock_t socket, Command* command,
 {
   SharedHandle<SocketEntry> socketEntry(new SocketEntry(socket));
   std::deque<SharedHandle<SocketEntry> >::iterator i =
-    std::lower_bound(socketEntries_.begin(), socketEntries_.end(), socketEntry);
-  if(i != socketEntries_.end() && (*i) == socketEntry) {
+    std::lower_bound(socketEntries_.begin(), socketEntries_.end(), socketEntry,
+                     DerefLess<SharedHandle<SocketEntry> >());
+  if(i != socketEntries_.end() && *(*i) == *socketEntry) {
     (*i)->addCommandEvent(command, events);
   } else {
     socketEntries_.insert(i, socketEntry);
@@ -294,8 +296,9 @@ bool SelectEventPoll::deleteEvents(sock_t socket, Command* command,
 {
   SharedHandle<SocketEntry> socketEntry(new SocketEntry(socket));
   std::deque<SharedHandle<SocketEntry> >::iterator i =
-    std::lower_bound(socketEntries_.begin(), socketEntries_.end(), socketEntry);
-  if(i != socketEntries_.end() && (*i) == socketEntry) {
+    std::lower_bound(socketEntries_.begin(), socketEntries_.end(), socketEntry,
+                     DerefLess<SharedHandle<SocketEntry> >());
+  if(i != socketEntries_.end() && *(*i) == *socketEntry) {
     (*i)->removeCommandEvent(command, events);
     if((*i)->eventEmpty()) {
       socketEntries_.erase(i);
@@ -317,7 +320,8 @@ bool SelectEventPoll::addNameResolver
   SharedHandle<AsyncNameResolverEntry> entry
     (new AsyncNameResolverEntry(resolver, command));
   std::deque<SharedHandle<AsyncNameResolverEntry> >::iterator itr =
-    std::find(nameResolverEntries_.begin(), nameResolverEntries_.end(), entry);
+    std::find_if(nameResolverEntries_.begin(), nameResolverEntries_.end(),
+                 derefEqual(entry));
   if(itr == nameResolverEntries_.end()) {
     nameResolverEntries_.push_back(entry);
     return true;
@@ -332,7 +336,8 @@ bool SelectEventPoll::deleteNameResolver
   SharedHandle<AsyncNameResolverEntry> entry
     (new AsyncNameResolverEntry(resolver, command));
   std::deque<SharedHandle<AsyncNameResolverEntry> >::iterator itr =
-    std::find(nameResolverEntries_.begin(), nameResolverEntries_.end(), entry);
+    std::find_if(nameResolverEntries_.begin(), nameResolverEntries_.end(),
+                 derefEqual(entry));
   if(itr == nameResolverEntries_.end()) {
     return false;
   } else {
diff --git a/src/SelectEventPoll.h b/src/SelectEventPoll.h
index 5396fdfe..705d9eb9 100644
--- a/src/SelectEventPoll.h
+++ b/src/SelectEventPoll.h
@@ -143,7 +143,7 @@ private:
 
     bool operator==(const AsyncNameResolverEntry& entry)
     {
-      return nameResolver_ == entry.nameResolver_ &&
+      return *nameResolver_ == *entry.nameResolver_ &&
         command_ == entry.command_;
     }
 
diff --git a/src/ServerStatMan.cc b/src/ServerStatMan.cc
index ba74481e..4b1f93b6 100644
--- a/src/ServerStatMan.cc
+++ b/src/ServerStatMan.cc
@@ -43,6 +43,7 @@
 #include "ServerStat.h"
 #include "util.h"
 #include "RecoverableException.h"
+#include "a2functional.h"
 
 namespace aria2 {
 
@@ -55,7 +56,8 @@ SharedHandle<ServerStat> ServerStatMan::find(const std::string& hostname,
 {
   SharedHandle<ServerStat> ss(new ServerStat(hostname, protocol));
   std::deque<SharedHandle<ServerStat> >::const_iterator i =
-    std::lower_bound(serverStats_.begin(), serverStats_.end(), ss);
+    std::lower_bound(serverStats_.begin(), serverStats_.end(), ss,
+                     DerefLess<SharedHandle<ServerStat> >());
   if(i != serverStats_.end() &&
      (*i)->getHostname() == hostname && (*i)->getProtocol() == protocol) {
     return *i;
@@ -67,9 +69,10 @@ SharedHandle<ServerStat> ServerStatMan::find(const std::string& hostname,
 bool ServerStatMan::add(const SharedHandle<ServerStat>& serverStat)
 {
   std::deque<SharedHandle<ServerStat> >::iterator i =
-    std::lower_bound(serverStats_.begin(), serverStats_.end(), serverStat);
+    std::lower_bound(serverStats_.begin(), serverStats_.end(), serverStat,
+                     DerefLess<SharedHandle<ServerStat> >());
 
-  if(i != serverStats_.end() && (*i) == serverStat) {
+  if(i != serverStats_.end() && *(*i) == *serverStat) {
     return false;
   } else {
     serverStats_.insert(i, serverStat);
@@ -79,8 +82,10 @@ bool ServerStatMan::add(const SharedHandle<ServerStat>& serverStat)
 
 bool ServerStatMan::save(std::ostream& out) const
 {
-  std::copy(serverStats_.begin(), serverStats_.end(),
-            std::ostream_iterator<SharedHandle<ServerStat> >(out, "\n"));
+  for(std::deque<SharedHandle<ServerStat> >::const_iterator i =
+        serverStats_.begin(), eoi = serverStats_.end(); i != eoi; ++i) {
+    out << *(*i) << "\n";
+  }
   out.flush();
   return !out.bad();
 }
diff --git a/src/SharedHandle.h b/src/SharedHandle.h
index 2fe5d62f..9e08f819 100644
--- a/src/SharedHandle.h
+++ b/src/SharedHandle.h
@@ -35,6 +35,7 @@
 #ifndef D_SHARED_HANDLE_H
 #define D_SHARED_HANDLE_H
 
+#include <cassert>
 #include <iosfwd>
 
 namespace aria2 {
@@ -236,6 +237,11 @@ public:
 
   T* operator->() const { return obj_; }
 
+  T& operator*() const {
+    assert(obj_);
+    return *obj_;
+  }
+
   T* get() const {
     return obj_;
   }
@@ -273,25 +279,26 @@ static_pointer_cast(const SharedHandle<S>& t) {
   return SharedHandle<T>(t, static_cast<T*>(t.get()));
 }
 
+// Intentionally renamed obj_ as obj_x to cause error
 template<typename T>
 std::ostream& operator<<(std::ostream& o, const SharedHandle<T>& sp) {
-  o << *sp.obj_;
+  o << *sp.obj_x;
   return o;
 }
 
 template<typename T1, typename T2>
 bool operator==(const SharedHandle<T1>& t1, const SharedHandle<T2>& t2) {
-  return *t1.obj_ == *t2.obj_;
+  return *t1.obj_x == *t2.obj_;
 }
 
 template<typename T1, typename T2>
 bool operator!=(const SharedHandle<T1>& t1, const SharedHandle<T2>& t2) {
-  return *t1.obj_ != *t2.obj_;
+  return *t1.obj_x != *t2.obj_;
 }
 
 template<typename T1, typename T2>
 bool operator<(const SharedHandle<T1>& t1, const SharedHandle<T2>& t2) {
-  return *t1.obj_ < *t2.obj_;
+  return *t1.obj_x < *t2.obj_;
 }
 
 template<typename T>
@@ -357,6 +364,11 @@ public:
 
   T* operator->() const { return obj_; }
 
+  T& operator*() const {
+    assert(obj_);
+    return *obj_;
+  }
+
   T* get() const {
     if(isNull()) {
       return 0;
@@ -378,25 +390,26 @@ public:
   }
 };
 
+// Intentionally renamed obj_ as obj_x to cause error
 template<typename T>
 std::ostream& operator<<(std::ostream& o, const WeakHandle<T>& sp) {
-  o << *sp.obj_;
+  o << *sp.obj_x;
   return o;
 }
 
 template<typename T1, typename T2>
 bool operator==(const WeakHandle<T1>& t1, const WeakHandle<T2>& t2) {
-  return *t1.obj_ == *t2.obj_;
+  return *t1.obj_x == *t2.obj_;
 }
 
 template<typename T1, typename T2>
 bool operator!=(const WeakHandle<T1>& t1, const WeakHandle<T2>& t2) {
-  return *t1.obj_ != *t2.obj_;
+  return *t1.obj_x != *t2.obj_;
 }
 
 template<typename T1, typename T2>
 bool operator<(const WeakHandle<T1>& t1, const WeakHandle<T2>& t2) {
-  return *t1.obj_ < *t2.obj_;
+  return *t1.obj_x < *t2.obj_;
 }
 
 template<typename T, typename S>
diff --git a/src/UnknownLengthPieceStorage.cc b/src/UnknownLengthPieceStorage.cc
index 4c967f9e..6cc6e936 100644
--- a/src/UnknownLengthPieceStorage.cc
+++ b/src/UnknownLengthPieceStorage.cc
@@ -167,7 +167,7 @@ SharedHandle<Piece> UnknownLengthPieceStorage::getPiece(size_t index)
 
 void UnknownLengthPieceStorage::completePiece(const SharedHandle<Piece>& piece)
 {
-  if(piece_ == piece) {
+  if(*piece_ == *piece) {
     downloadFinished_ = true;
     totalLength_ = piece_->getLength();
     diskAdaptor_->setTotalLength(totalLength_);
@@ -177,7 +177,7 @@ void UnknownLengthPieceStorage::completePiece(const SharedHandle<Piece>& piece)
 
 void UnknownLengthPieceStorage::cancelPiece(const SharedHandle<Piece>& piece)
 {
-  if(piece_ == piece) {
+  if(*piece_ == *piece) {
     piece_.reset();
   }
 }
diff --git a/src/a2functional.h b/src/a2functional.h
index 7b90cf9e..2cfc6669 100644
--- a/src/a2functional.h
+++ b/src/a2functional.h
@@ -431,6 +431,39 @@ bool in(T x, S s, S t)
   return s <= x && x <= t;
 }
 
+template<typename T>
+struct DerefLess {
+  bool operator()(const T& lhs, const T& rhs) const
+  {
+    return *lhs < *rhs;
+  }
+};
+
+template<typename T>
+struct DerefEqualTo {
+  bool operator()(const T& lhs, const T& rhs) const
+  {
+    return *lhs == *rhs;
+  }
+};
+
+template<typename T>
+struct DerefEqual {
+  T target;
+
+  DerefEqual(const T& t):target(t) {}
+  bool operator()(const T& other) const
+  {
+    return *target == *other;
+  }
+};
+
+template<typename T>
+struct DerefEqual<T> derefEqual(const T& t)
+{
+  return DerefEqual<T>(t);
+}
+
 } // namespace aria2
 
 #endif // D_A2_FUNCTIONAL_H
diff --git a/src/option_processing.cc b/src/option_processing.cc
index 831ec244..ee3e4884 100644
--- a/src/option_processing.cc
+++ b/src/option_processing.cc
@@ -174,7 +174,7 @@ void option_processing(Option& op, std::vector<std::string>& uris,
   } catch(OptionHandlerException& e) {
     std::cerr << e.stackTrace() << "\n"
               << "Usage:" << "\n"
-              << oparser.findByName(e.getOptionName())
+              << *oparser.findByName(e.getOptionName())
               << std::endl;
     exit(downloadresultcode::UNKNOWN_ERROR);
   } catch(Exception& e) {
diff --git a/src/version_usage.cc b/src/version_usage.cc
index 5d018b69..6662e290 100644
--- a/src/version_usage.cc
+++ b/src/version_usage.cc
@@ -101,10 +101,10 @@ void showUsage(const std::string& keyword, const OptionParser& oparser) {
     }
     std::cout << "\n"
               << _("Options:") << "\n";
-
-    std::copy(handlers.begin(), handlers.end(),
-              std::ostream_iterator<SharedHandle<OptionHandler> >
-              (std::cout, "\n\n"));
+    for(std::vector<SharedHandle<OptionHandler> >::const_iterator i =
+          handlers.begin(), eoi = handlers.end(); i != eoi; ++i) {
+      std::cout << *(*i) << "\n\n";
+    }
   } else {    
     std::vector<SharedHandle<OptionHandler> > handlers =
       oparser.findByNameSubstring(keyword);
@@ -113,13 +113,14 @@ void showUsage(const std::string& keyword, const OptionParser& oparser) {
                                   " '%s'."), keyword.c_str())
                 << "\n"
                 << _("Options:") << "\n";
-      std::copy(handlers.begin(), handlers.end(),
-                std::ostream_iterator<SharedHandle<OptionHandler> >
-                (std::cout, "\n\n"));
+      for(std::vector<SharedHandle<OptionHandler> >::const_iterator i =
+            handlers.begin(), eoi = handlers.end(); i != eoi; ++i) {
+        std::cout << *(*i) << "\n\n";
+      }
     } else {
       std::cout << StringFormat(_("No option matching with '%s'."),
                                 keyword.c_str())
-                << "\n" << oparser.findByName("help") << "\n";
+                << "\n" << *oparser.findByName("help") << "\n";
     }
   }