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

	Use vector instead of deque for containers which is used for
	mostly read-only purpose.

ChangeLog

@@ -1,3 +1,8 @@
+2010-02-28  Tatsuhiro Tsujikawa  <t-tujikawa@users.sourceforge.net>
+
+	Use vector instead of deque for containers which is used for
+	mostly read-only purpose.
+
 2010-02-28  Tatsuhiro Tsujikawa  <t-tujikawa@users.sourceforge.net>
 
 	Fixed typo

src/AbstractBtMessage.cc

@@ -59,12 +59,10 @@ void AbstractBtMessage::setPeer(const SharedHandle<Peer>& peer)
   this->peer = peer;
 }
 
-bool AbstractBtMessage::validate(std::deque<std::string>& errors)
+void AbstractBtMessage::validate()
 {
   if(validator.get()) {
-    return validator->validate(errors);
-  } else {
-    return true;
+    validator->validate();
   }
 }
 

src/AbstractBtMessage.h

@@ -37,8 +37,6 @@
 
 #include "BtMessage.h"
 
-#include <deque>
-
 namespace aria2 {
 
 class PieceStorage;
@@ -122,7 +120,7 @@ public:
 
   virtual void doReceivedAction() {}
 
-  virtual bool validate(std::deque<std::string>& errors);
+  virtual void validate();
   
   virtual void onQueued() {}
 

src/AbstractCommand.cc

@@ -255,7 +255,7 @@ void AbstractCommand::tryReserved() {
   if(logger->debug()) {
     logger->debug("CUID#%d - Trying reserved/pooled request.", cuid);
   }
-  Commands commands;
+  std::vector<Command*> commands;
   _requestGroup->createNextCommand(commands, e, 1);
   e->setNoWait(true);
   e->addCommand(commands);
@@ -503,7 +503,7 @@ bool AbstractCommand::asyncResolveHostname()
   }
 }
 
-const std::deque<std::string>& AbstractCommand::getResolvedAddresses()
+const std::vector<std::string>& AbstractCommand::getResolvedAddresses()
 {
   return _asyncNameResolver->getResolvedAddresses();
 }
@@ -533,10 +533,10 @@ bool AbstractCommand::nameResolveFinished() const {
 
 void AbstractCommand::prepareForNextAction(Command* nextCommand)
 {
-  CheckIntegrityEntryHandle entry
+  SharedHandle<CheckIntegrityEntry> entry
     (new StreamCheckIntegrityEntry(_requestGroup, nextCommand));
 
-  std::deque<Command*> commands;
+  std::vector<Command*> commands;
   try {
     _requestGroup->processCheckIntegrityEntry(commands, entry, e);
   } catch(RecoverableException& e) {

src/AbstractCommand.h

@@ -63,7 +63,7 @@ protected:
   SharedHandle<FileEntry> _fileEntry;
   DownloadEngine* e;
   SharedHandle<SocketCore> socket;
-  std::deque<SharedHandle<Segment> > _segments;
+  std::vector<SharedHandle<Segment> > _segments;
 
 #ifdef ENABLE_ASYNC_DNS
   SharedHandle<AsyncNameResolver> _asyncNameResolver;
@@ -74,7 +74,7 @@ protected:
 
   bool asyncResolveHostname();
 
-  const std::deque<std::string>& getResolvedAddresses();
+  const std::vector<std::string>& getResolvedAddresses();
 #endif // ENABLE_ASYNC_DNS
 
   void tryReserved();

src/AbstractProxyRequestCommand.cc

@@ -51,7 +51,7 @@ namespace aria2 {
 
 AbstractProxyRequestCommand::AbstractProxyRequestCommand
 (int cuid,
- const RequestHandle& req,
+ const SharedHandle<Request>& req,
  const SharedHandle<FileEntry>& fileEntry,
  RequestGroup* requestGroup,
  DownloadEngine* e,
@@ -76,7 +76,7 @@ bool AbstractProxyRequestCommand::executeInternal() {
        (socket, _connectedHostname, _connectedAddr, _connectedPort)) {
       return true;
     }
-    HttpRequestHandle httpRequest(new HttpRequest());
+    SharedHandle<HttpRequest> httpRequest(new HttpRequest());
     httpRequest->setUserAgent(getOption()->get(PREF_USER_AGENT));
     httpRequest->setRequest(req);
     httpRequest->setProxyRequest(_proxyRequest);

src/AbstractProxyResponseCommand.cc

@@ -51,7 +51,7 @@ namespace aria2 {
 
 AbstractProxyResponseCommand::AbstractProxyResponseCommand
 (int cuid,
- const RequestHandle& req,
+ const SharedHandle<Request>& req,
  const SharedHandle<FileEntry>& fileEntry,
  RequestGroup* requestGroup,
  const HttpConnectionHandle& httpConnection,
@@ -63,7 +63,7 @@ AbstractProxyResponseCommand::AbstractProxyResponseCommand
 AbstractProxyResponseCommand::~AbstractProxyResponseCommand() {}
 
 bool AbstractProxyResponseCommand::executeInternal() {
-  HttpResponseHandle httpResponse = httpConnection->receiveResponse();
+  SharedHandle<HttpResponse> httpResponse = httpConnection->receiveResponse();
   if(httpResponse.isNull()) {
     // the server has not responded our request yet.
     e->commands.push_back(this);

src/ActivePeerConnectionCommand.cc

@@ -114,7 +114,7 @@ bool ActivePeerConnectionCommand::execute() {
 
       for(unsigned int numAdd = numConnection;
           numAdd > 0 && _peerStorage->isPeerAvailable(); --numAdd) {
-        PeerHandle peer = _peerStorage->getUnusedPeer();
+        SharedHandle<Peer> peer = _peerStorage->getUnusedPeer();
         connectToPeer(peer);
       }
       if(_btRuntime->getConnections() == 0 &&
@@ -127,7 +127,7 @@ bool ActivePeerConnectionCommand::execute() {
   return false;
 }
 
-void ActivePeerConnectionCommand::connectToPeer(const PeerHandle& peer)
+void ActivePeerConnectionCommand::connectToPeer(const SharedHandle<Peer>& peer)
 {
   if(peer.isNull()) {
     return;

src/AnnounceList.cc

@@ -54,7 +54,8 @@ AnnounceList::AnnounceList(const BDE& announceList):
   reconfigure(announceList);
 }
 
-AnnounceList::AnnounceList(const AnnounceTiers& announceTiers):
+AnnounceList::AnnounceList
+(const std::deque<SharedHandle<AnnounceTier> >& announceTiers):
   tiers(announceTiers), currentTrackerInitialized(false)  {
   resetIterator();
 }
@@ -77,7 +78,7 @@ void AnnounceList::reconfigure(const BDE& announceList)
         }
       }
       if(!urls.empty()) {
-        AnnounceTierHandle tier(new AnnounceTier(urls));
+        SharedHandle<AnnounceTier> tier(new AnnounceTier(urls));
         tiers.push_back(tier);
       }
     }
@@ -88,7 +89,7 @@ void AnnounceList::reconfigure(const BDE& announceList)
 void AnnounceList::reconfigure(const std::string& url) {
   std::deque<std::string> urls;
   urls.push_back(url);
-  tiers.push_back(AnnounceTierHandle(new AnnounceTier(urls)));
+  tiers.push_back(SharedHandle<AnnounceTier>(new AnnounceTier(urls)));
   resetIterator();
 }
 
@@ -171,7 +172,7 @@ std::string AnnounceList::getEventString() const {
 
 class FindStoppedAllowedTier {
 public:
-  bool operator()(const AnnounceTierHandle& tier) const {
+  bool operator()(const SharedHandle<AnnounceTier>& tier) const {
     switch(tier->event) {
     case AnnounceTier::DOWNLOADING:
     case AnnounceTier::STOPPED:
@@ -186,7 +187,7 @@ public:
 
 class FindCompletedAllowedTier {
 public:
-  bool operator()(const AnnounceTierHandle& tier) const {
+  bool operator()(const SharedHandle<AnnounceTier>& tier) const {
     switch(tier->event) {
     case AnnounceTier::DOWNLOADING:
     case AnnounceTier::COMPLETED:
@@ -205,7 +206,8 @@ size_t AnnounceList::countCompletedAllowedTier() const {
   return count_if(tiers.begin(), tiers.end(), FindCompletedAllowedTier());
 }
 
-void AnnounceList::setCurrentTier(const AnnounceTiers::iterator& itr) {
+void AnnounceList::setCurrentTier
+(const std::deque<SharedHandle<AnnounceTier> >::iterator& itr) {
   if(itr != tiers.end()) {
     currentTier = itr;
     currentTracker = (*currentTier)->urls.begin();
@@ -224,21 +226,23 @@ find_wrap_if(InputIterator first, InputIterator last,
 }
 
 void AnnounceList::moveToStoppedAllowedTier() {
-  AnnounceTiers::iterator itr = find_wrap_if(tiers.begin(), tiers.end(),
-                                             currentTier,
-                                             FindStoppedAllowedTier());
+  std::deque<SharedHandle<AnnounceTier> >::iterator itr =
+    find_wrap_if(tiers.begin(), tiers.end(),
+                 currentTier,
+                 FindStoppedAllowedTier());
   setCurrentTier(itr);
 }
 
 void AnnounceList::moveToCompletedAllowedTier() {
-  AnnounceTiers::iterator itr = find_wrap_if(tiers.begin(), tiers.end(),
-                                             currentTier,
-                                             FindCompletedAllowedTier());
+  std::deque<SharedHandle<AnnounceTier> >::iterator itr =
+    find_wrap_if(tiers.begin(), tiers.end(),
+                 currentTier,
+                 FindCompletedAllowedTier());
   setCurrentTier(itr);
 }
 
 void AnnounceList::shuffle() {
-  for(AnnounceTiers::iterator itr = tiers.begin();
+  for(std::deque<SharedHandle<AnnounceTier> >::iterator itr = tiers.begin();
       itr != tiers.end(); ++itr) {
     std::deque<std::string>& urls = (*itr)->urls;
     std::random_shuffle(urls.begin(), urls.end(),

src/AnnounceTier.h

@@ -93,9 +93,6 @@ public:
   }
 };
 
-typedef SharedHandle<AnnounceTier> AnnounceTierHandle;
-typedef std::deque<AnnounceTierHandle> AnnounceTiers;
-
 } // namespace aria2
 
 #endif // _D_ANNOUNCE_TIER_H_

src/AsyncNameResolver.h

@@ -38,7 +38,7 @@
 #include "common.h"
 
 #include <string>
-#include <deque>
+#include <vector>
 
 #include <ares.h>
 
@@ -65,7 +65,7 @@ private:
   STATUS status;
   ares_channel channel;
 
-  std::deque<std::string> _resolvedAddresses;
+  std::vector<std::string> _resolvedAddresses;
   std::string error;
   std::string _hostname;
 public:
@@ -75,7 +75,7 @@ public:
 
   void resolve(const std::string& name);
 
-  const std::deque<std::string>& getResolvedAddresses() const
+  const std::vector<std::string>& getResolvedAddresses() const
   {
     return _resolvedAddresses;
   }

src/AuthConfigFactory.cc

@@ -162,7 +162,7 @@ AuthResolverHandle AuthConfigFactory::createFtpAuthResolver
   return resolver;
 }
 
-void AuthConfigFactory::setNetrc(const NetrcHandle& netrc)
+void AuthConfigFactory::setNetrc(const SharedHandle<Netrc>& netrc)
 {
   _netrc = netrc;
 }

src/BDE.h

@@ -39,7 +39,7 @@
 
 #include <map>
 #include <string>
-#include <deque>
+#include <vector>
 
 #include "SharedHandle.h"
 #include "DlAbortEx.h"
@@ -51,7 +51,7 @@ class BDE;
 class BDE {
 public:
   typedef std::map<std::string, BDE> Dict;
-  typedef std::deque<BDE> List;
+  typedef std::vector<BDE> List;
   typedef int64_t Integer;
 private:
   enum TYPE{

src/BNode.cc

@@ -33,11 +33,13 @@
  */
 /* copyright --> */
 #include "BNode.h"
-#include "DHTBucket.h"
-#include "DHTNode.h"
+
 #include <functional>
 #include <algorithm>
 
+#include "DHTBucket.h"
+#include "DHTNode.h"
+
 namespace aria2 {
 
 BNode::BNode(const SharedHandle<DHTBucket>& bucket):
@@ -114,7 +116,7 @@ SharedHandle<DHTBucket> BNode::findBucketFor(BNode* b, const unsigned char* key)
 }
 
 
-void BNode::findClosestKNodes(std::deque<SharedHandle<DHTNode> >& nodes,
+void BNode::findClosestKNodes(std::vector<SharedHandle<DHTNode> >& nodes,
                               BNode* b, const unsigned char* key)
 {
   BNode* bnode = findBNodeFor(b, key);
@@ -128,7 +130,7 @@ void BNode::findClosestKNodes(std::deque<SharedHandle<DHTNode> >& nodes,
   if(nodes.size() >= DHTBucket::K) {
     return;
   }
-  std::deque<const BNode*> visited;
+  std::vector<const BNode*> visited;
   visited.push_back(bnode);
 
   BNode* up = bnode->getUp();
@@ -163,7 +165,7 @@ void BNode::findClosestKNodes(std::deque<SharedHandle<DHTNode> >& nodes,
     {
       SharedHandle<DHTBucket> bucket = bnode->getBucket();
       if(!bucket.isNull()) {
-        std::deque<SharedHandle<DHTNode> > goodNodes;
+        std::vector<SharedHandle<DHTNode> > goodNodes;
         bucket->getGoodNodes(goodNodes);
         size_t r = DHTBucket::K-nodes.size();
         if(goodNodes.size() <= r) {
@@ -176,10 +178,10 @@ void BNode::findClosestKNodes(std::deque<SharedHandle<DHTNode> >& nodes,
   }
 }
 
-void BNode::enumerateBucket(std::deque<SharedHandle<DHTBucket> >& buckets,
+void BNode::enumerateBucket(std::vector<SharedHandle<DHTBucket> >& buckets,
                             const BNode* b)
 {
-  std::deque<const BNode*> visited;
+  std::vector<const BNode*> visited;
   visited.push_back(b);
   while(1) {
     if(!b) {

src/BNode.h

@@ -36,8 +36,10 @@
 #define _D_BNODE_H_
 
 #include "common.h"
+
+#include <vector>
+
 #include "SharedHandle.h"
-#include <deque>
 
 namespace aria2 {
 
@@ -93,10 +95,10 @@ public:
 
   static SharedHandle<DHTBucket> findBucketFor(BNode* b, const unsigned char* key);
 
-  static void findClosestKNodes(std::deque<SharedHandle<DHTNode> >& nodes,
+  static void findClosestKNodes(std::vector<SharedHandle<DHTNode> >& nodes,
                                 BNode* b, const unsigned char* key);
 
-  static void enumerateBucket(std::deque<SharedHandle<DHTBucket> >& buckets,
+  static void enumerateBucket(std::vector<SharedHandle<DHTBucket> >& buckets,
                               const BNode* b);
 };
 

src/BitfieldMan.h

@@ -36,10 +36,11 @@
 #define _D_BITFIELD_MAN_H_
 
 #include "common.h"
-#include "SharedHandle.h"
-#include <deque>
+
 #include <vector>
 
+#include "SharedHandle.h"
+
 namespace aria2 {
 
 class BitfieldMan {

src/BtBitfieldMessageValidator.h

@@ -51,12 +51,11 @@ public:
     message(message),
     numPiece(numPiece) {}
 
-  virtual bool validate(Errors& error) {
-    // TODO
+  virtual void validate()
+  {
     bittorrent::checkBitfield(message->getBitfield(),
                               message->getBitfieldLength(),
                               numPiece);
-    return true;
   }
 };
 

src/BtCheckIntegrityEntry.cc

@@ -49,8 +49,8 @@ BtCheckIntegrityEntry::BtCheckIntegrityEntry(RequestGroup* requestGroup):
 
 BtCheckIntegrityEntry::~BtCheckIntegrityEntry() {}
 
-void BtCheckIntegrityEntry::onDownloadIncomplete(std::deque<Command*>& commands,
-                                                 DownloadEngine* e)
+void BtCheckIntegrityEntry::onDownloadIncomplete
+(std::vector<Command*>& commands, DownloadEngine* e)
 {
   const SharedHandle<DiskAdaptor>& diskAdaptor =
     _requestGroup->getPieceStorage()->getDiskAdaptor();
@@ -65,8 +65,8 @@ void BtCheckIntegrityEntry::onDownloadIncomplete(std::deque<Command*>& commands,
   proceedFileAllocation(commands, entry, e);
 }
 
-void BtCheckIntegrityEntry::onDownloadFinished(std::deque<Command*>& commands,
-                                               DownloadEngine* e)
+void BtCheckIntegrityEntry::onDownloadFinished
+(std::vector<Command*>& commands, DownloadEngine* e)
 {
   // TODO Currently,when all the checksums
   // are valid, then aira2 goes to seeding mode. Sometimes it is better

src/BtCheckIntegrityEntry.h

@@ -45,10 +45,10 @@ public:
 
   virtual ~BtCheckIntegrityEntry();
 
-  virtual void onDownloadFinished(std::deque<Command*>& commands,
+  virtual void onDownloadFinished(std::vector<Command*>& commands,
                                   DownloadEngine* e);
 
-  virtual void onDownloadIncomplete(std::deque<Command*>& commands,
+  virtual void onDownloadIncomplete(std::vector<Command*>& commands,
                                     DownloadEngine* e);
 };
 

src/BtDependency.cc

@@ -51,8 +51,8 @@
 
 namespace aria2 {
 
-BtDependency::BtDependency(const RequestGroupWeakHandle& dependant,
-                           const RequestGroupHandle& dependee):
+BtDependency::BtDependency(const WeakHandle<RequestGroup>& dependant,
+                           const SharedHandle<RequestGroup>& dependee):
   _dependant(dependant),
   _dependee(dependee),
   _logger(LogFactory::getInstance()) {}
@@ -74,13 +74,13 @@ static void copyValues(const SharedHandle<FileEntry>& d,
 bool BtDependency::resolve()
 {
   if(_dependee->getNumCommand() == 0 && _dependee->downloadFinished()) {
-    RequestGroupHandle dependee = _dependee;
+    SharedHandle<RequestGroup> dependee = _dependee;
     // cut reference here
     _dependee.reset();
     SharedHandle<DownloadContext> context(new DownloadContext());
     context->setDir(_dependant->getDownloadContext()->getDir());
     try {
-      DiskAdaptorHandle diskAdaptor =
+      SharedHandle<DiskAdaptor> diskAdaptor =
         dependee->getPieceStorage()->getDiskAdaptor();
       diskAdaptor->openExistingFile();
       std::string content = util::toString(diskAdaptor);

src/BtExtendedMessage.cc

@@ -99,7 +99,7 @@ std::string BtExtendedMessage::toString() const {
 
 BtExtendedMessageHandle
 BtExtendedMessage::create(const SharedHandle<ExtensionMessageFactory>& factory,
-                          const PeerHandle& peer,
+                          const SharedHandle<Peer>& peer,
                           const unsigned char* data, size_t dataLength)
 {
   bittorrent::assertPayloadLengthGreater(1, dataLength, NAME);

src/BtFileAllocationEntry.cc

@@ -49,8 +49,8 @@ BtFileAllocationEntry::BtFileAllocationEntry(RequestGroup* requestGroup):
 
 BtFileAllocationEntry::~BtFileAllocationEntry() {}
 
-void BtFileAllocationEntry::prepareForNextAction(std::deque<Command*>& commands,
-                                                 DownloadEngine* e)
+void BtFileAllocationEntry::prepareForNextAction
+(std::vector<Command*>& commands, DownloadEngine* e)
 {
   BtSetup().setup(commands, _requestGroup, e, _requestGroup->getOption().get());
   if(!_requestGroup->downloadFinished()) {

src/BtFileAllocationEntry.h

@@ -45,7 +45,7 @@ public:
 
   virtual ~BtFileAllocationEntry();
 
-  virtual void prepareForNextAction(std::deque<Command*>& commands,
+  virtual void prepareForNextAction(std::vector<Command*>& commands,
                                     DownloadEngine* e);
 };
 

src/BtHandshakeMessageValidator.h

@@ -57,8 +57,8 @@ public:
     memcpy(this->infoHash, infoHash, sizeof(this->infoHash));
   }
 
-  virtual bool validate(Errors& error) {
-    // TODO
+  virtual void validate()
+  {
     if(message->getPstrlen() != 19) {
       throw DL_ABORT_EX(StringFormat("invalid handshake pstrlen=%u",
                                      message->getPstrlen()).str());
@@ -74,7 +74,6 @@ public:
                       util::toHex(infoHash, 20).c_str(),
                       util::toHex(message->getInfoHash(), 20).c_str()).str());
     }
-    return true;
   }
 };
 

src/BtLeecherStateChoke.cc

@@ -120,12 +120,12 @@ public:
 };
 
 void BtLeecherStateChoke::plannedOptimisticUnchoke
-(std::deque<PeerEntry>& peerEntries)
+(std::vector<PeerEntry>& peerEntries)
 {
   std::for_each(peerEntries.begin(), peerEntries.end(),
                 std::mem_fun_ref(&PeerEntry::disableOptUnchoking));
   
-  std::deque<PeerEntry>::iterator i =
+  std::vector<PeerEntry>::iterator i =
     std::partition(peerEntries.begin(), peerEntries.end(),
                    PeerFilter(true, true));
   if(i != peerEntries.begin()) {
@@ -136,9 +136,9 @@ void BtLeecherStateChoke::plannedOptimisticUnchoke
   }
 }
 
-void BtLeecherStateChoke::regularUnchoke(std::deque<PeerEntry>& peerEntries)
+void BtLeecherStateChoke::regularUnchoke(std::vector<PeerEntry>& peerEntries)
 {
-  std::deque<PeerEntry>::iterator rest =
+  std::vector<PeerEntry>::iterator rest =
     std::partition(peerEntries.begin(), peerEntries.end(),
                    std::mem_fun_ref(&PeerEntry::isRegularUnchoker));
   
@@ -151,7 +151,7 @@ void BtLeecherStateChoke::regularUnchoke(std::deque<PeerEntry>& peerEntries)
   int count = 3;
 
   bool fastOptUnchoker = false;
-  std::deque<PeerEntry>::iterator peerIter = peerEntries.begin();
+  std::vector<PeerEntry>::iterator peerIter = peerEntries.begin();
   for(;peerIter != rest && count; ++peerIter, --count) {
     (*peerIter).disableChokingRequired();
     _logger->info("RU: %s, dlspd=%u",
@@ -165,7 +165,7 @@ void BtLeecherStateChoke::regularUnchoke(std::deque<PeerEntry>& peerEntries)
   if(fastOptUnchoker) {
     std::random_shuffle(peerIter, peerEntries.end(),
                         *(SimpleRandomizer::getInstance().get()));
-    for(std::deque<PeerEntry>::iterator i = peerIter; i != peerEntries.end();
+    for(std::vector<PeerEntry>::iterator i = peerIter; i != peerEntries.end();
         ++i) {
       if((*i).getPeer()->peerInterested()) {
         (*i).enableOptUnchoking();
@@ -196,12 +196,13 @@ public:
 };
 
 void
-BtLeecherStateChoke::executeChoke(const std::deque<SharedHandle<Peer> >& peerSet)
+BtLeecherStateChoke::executeChoke
+(const std::vector<SharedHandle<Peer> >& peerSet)
 {
   _logger->info("Leecher state, %d choke round started", _round);
   _lastRound.reset();
 
-  std::deque<PeerEntry> peerEntries;
+  std::vector<PeerEntry> peerEntries;
   std::transform(peerSet.begin(), peerSet.end(),
                  std::back_inserter(peerEntries),
                  BtLeecherStateChokeGenPeerEntry());

src/BtLeecherStateChoke.h

@@ -37,7 +37,7 @@
 
 #include "common.h"
 
-#include <deque>
+#include <vector>
 
 #include "SharedHandle.h"
 #include "TimeA2.h"
@@ -82,9 +82,9 @@ private:
     void disableOptUnchoking();
   };
 
-  void plannedOptimisticUnchoke(std::deque<PeerEntry>& peerEntries);
+  void plannedOptimisticUnchoke(std::vector<PeerEntry>& peerEntries);
 
-  void regularUnchoke(std::deque<PeerEntry>& peerEntries);
+  void regularUnchoke(std::vector<PeerEntry>& peerEntries);
 
   friend class PeerFilter;
   friend class BtLeecherStateChokeGenPeerEntry;
@@ -93,7 +93,7 @@ public:
 
   ~BtLeecherStateChoke();
 
-  void executeChoke(const std::deque<SharedHandle<Peer> >& peerSet);
+  void executeChoke(const std::vector<SharedHandle<Peer> >& peerSet);
 
   const Time& getLastRound() const;
 };

src/BtMessage.h

@@ -38,7 +38,6 @@
 #include "common.h"
 
 #include <string>
-#include <deque>
 
 #include "SharedHandle.h"
 #include "BtAbortOutstandingRequestEvent.h"
@@ -69,7 +68,7 @@ public:
 
   virtual void send() = 0;
 
-  virtual bool validate(std::deque<std::string>& errors) = 0;
+  virtual void validate() = 0;
 
   virtual void onAbortOutstandingRequestEvent
   (const BtAbortOutstandingRequestEvent& event) = 0;
@@ -86,7 +85,6 @@ public:
 };
 
 typedef SharedHandle<BtMessage> BtMessageHandle;
-typedef std::deque<BtMessageHandle> BtMessages;
 
 } // namespace aria2
 

src/BtMessageDispatcher.h

@@ -36,9 +36,11 @@
 #define _D_BT_MESSAGE_DISPATCHER_H_
 
 #include "common.h"
+
+#include <vector>
+
 #include "SharedHandle.h"
 #include "RequestSlot.h"
-#include <deque>
 
 namespace aria2 {
 
@@ -52,7 +54,7 @@ public:
   virtual void addMessageToQueue(const SharedHandle<BtMessage>& btMessage) = 0;
 
   virtual void
-  addMessageToQueue(const std::deque<SharedHandle<BtMessage> >& btMessages) = 0;
+  addMessageToQueue(const std::vector<SharedHandle<BtMessage> >& btMessages) =0;
 
   virtual void sendMessages() = 0;
 

src/BtMessageValidator.h

@@ -36,19 +36,19 @@
 #define _D_BT_MESSAGE_VALIDATOR_H_
 
 #include "common.h"
-#include "SharedHandle.h"
+
 #include <string>
-#include <deque>
 
-namespace aria2 {
+#include "SharedHandle.h"
 
-typedef std::deque<std::string> Errors;
+namespace aria2 {
 
 class BtMessageValidator {
 public:
   virtual ~BtMessageValidator() {}
 
-  virtual bool validate(Errors& errors) = 0;
+  // Throws RecoverableException on error.
+  virtual void validate() = 0;
 };
 
 typedef SharedHandle<BtMessageValidator> BtMessageValidatorHandle;

src/BtPieceMessage.cc

@@ -86,7 +86,7 @@ void BtPieceMessage::doReceivedAction() {
   peer->updateDownloadLength(blockLength);
   if(!RequestSlot::isNull(slot)) {
     peer->snubbing(false);
-    PieceHandle piece = pieceStorage->getPiece(index);
+    SharedHandle<Piece> piece = pieceStorage->getPiece(index);
     off_t offset = (off_t)index*_downloadContext->getPieceLength()+begin;
     if(logger->debug()) {
       logger->debug(MSG_PIECE_RECEIVED,
@@ -183,7 +183,7 @@ std::string BtPieceMessage::toString() const {
                    util::itos(begin), ", length=", util::itos(blockLength));
 }
 
-bool BtPieceMessage::checkPieceHash(const PieceHandle& piece) {
+bool BtPieceMessage::checkPieceHash(const SharedHandle<Piece>& piece) {
   if(piece->isHashCalculated()) {
     if(logger->debug()) {
       logger->debug("Hash is available!! index=%lu",
@@ -199,13 +199,13 @@ bool BtPieceMessage::checkPieceHash(const PieceHandle& piece) {
   }
 }
 
-void BtPieceMessage::onNewPiece(const PieceHandle& piece) {
+void BtPieceMessage::onNewPiece(const SharedHandle<Piece>& piece) {
   logger->info(MSG_GOT_NEW_PIECE, cuid, piece->getIndex());
   pieceStorage->completePiece(piece);
   pieceStorage->advertisePiece(cuid, piece->getIndex());
 }
 
-void BtPieceMessage::onWrongPiece(const PieceHandle& piece) {
+void BtPieceMessage::onWrongPiece(const SharedHandle<Piece>& piece) {
   logger->info(MSG_GOT_WRONG_PIECE, cuid, piece->getIndex());
   erasePieceOnDisk(piece);
   piece->clearAllBlock();
@@ -213,7 +213,7 @@ void BtPieceMessage::onWrongPiece(const PieceHandle& piece) {
   requestFactory->removeTargetPiece(piece);
 }
 
-void BtPieceMessage::erasePieceOnDisk(const PieceHandle& piece) {
+void BtPieceMessage::erasePieceOnDisk(const SharedHandle<Piece>& piece) {
   size_t BUFSIZE = 4096;
   unsigned char buf[BUFSIZE];
   memset(buf, 0, BUFSIZE);

src/BtPieceMessageValidator.h

@@ -54,11 +54,10 @@ public:
     numPiece(numPiece),
     pieceLength(pieceLength) {}
 
-  virtual bool validate(Errors& error) {
-    // TODO
+  virtual void validate()
+  {
     bittorrent::checkIndex(message->getIndex(), numPiece);
     bittorrent::checkBegin(message->getBegin(), pieceLength);
-    return true;
   }
 };
 

src/BtPostDownloadHandler.cc

@@ -63,7 +63,7 @@ BtPostDownloadHandler::BtPostDownloadHandler()
 BtPostDownloadHandler::~BtPostDownloadHandler() {}
 
 void BtPostDownloadHandler::getNextRequestGroups
-(std::deque<SharedHandle<RequestGroup> >& groups,
+(std::vector<SharedHandle<RequestGroup> >& groups,
  RequestGroup* requestGroup)
 {
   _logger->info("Generating RequestGroups for Torrent file %s",
@@ -77,9 +77,9 @@ void BtPostDownloadHandler::getNextRequestGroups
     requestGroup->getPieceStorage()->getDiskAdaptor()->closeFile();
     throw;
   }
-  std::deque<SharedHandle<RequestGroup> > newRgs;
+  std::vector<SharedHandle<RequestGroup> > newRgs;
   createRequestGroupForBitTorrent(newRgs, requestGroup->getOption(),
-                                  std::deque<std::string>(),
+                                  std::vector<std::string>(),
                                   content);
   requestGroup->followedBy(newRgs.begin(), newRgs.end());
   groups.insert(groups.end(), newRgs.begin(), newRgs.end());

src/BtPostDownloadHandler.h

@@ -47,12 +47,10 @@ public:
   virtual ~BtPostDownloadHandler();
 
   virtual void
-  getNextRequestGroups(std::deque<SharedHandle<RequestGroup> >& groups,
+  getNextRequestGroups(std::vector<SharedHandle<RequestGroup> >& groups,
                        RequestGroup* requestGroup);
 };
 
-typedef SharedHandle<BtPostDownloadHandler> BtPostDownloadHandlerHandle;
-
 } // namespace aria2
 
 #endif // _D_BT_POST_DOWNLOAD_HANDLER_H_

src/BtRequestFactory.h

@@ -36,8 +36,10 @@
 #define _D_BT_REQUEST_FACTORY_H_
 
 #include "common.h"
+
+#include <vector>
+
 #include "SharedHandle.h"
-#include <deque>
 
 namespace aria2 {
 
@@ -68,20 +70,20 @@ public:
    * The number of objects returned is capped by max.
    */
   virtual void createRequestMessages
-  (std::deque<SharedHandle<BtMessage> >& requests, size_t max) = 0;
+  (std::vector<SharedHandle<BtMessage> >& requests, size_t max) = 0;
 
   /**
    * Use this method in end game mode.
    *
    */
   virtual void createRequestMessagesOnEndGame
-  (std::deque<SharedHandle<BtMessage> >& requests, size_t max) = 0;
+  (std::vector<SharedHandle<BtMessage> >& requests, size_t max) = 0;
 
   /**
    * Stores the list of index of pieces added using addTargetPiece() into
    * indexes.
    */
-  virtual void getTargetPieceIndexes(std::deque<size_t>& indexes) const = 0;
+  virtual void getTargetPieceIndexes(std::vector<size_t>& indexes) const = 0;
 
 };
 

src/BtSeederStateChoke.cc

@@ -83,13 +83,13 @@ void BtSeederStateChoke::PeerEntry::disableOptUnchoking()
 }
 
 void BtSeederStateChoke::unchoke
-(std::deque<BtSeederStateChoke::PeerEntry>& peers)
+(std::vector<BtSeederStateChoke::PeerEntry>& peers)
 {
   int count = (_round == 2) ? 4 : 3;
 
   std::sort(peers.begin(), peers.end());
 
-  std::deque<PeerEntry>::iterator r = peers.begin();
+  std::vector<PeerEntry>::iterator r = peers.begin();
   for(; r != peers.end() && count; ++r, --count) {
     (*r).getPeer()->chokingRequired(false);
     _logger->info("RU: %s, ulspd=%u", (*r).getPeer()->ipaddr.c_str(),
@@ -140,12 +140,13 @@ public:
 };
 
 void
-BtSeederStateChoke::executeChoke(const std::deque<SharedHandle<Peer> >& peerSet)
+BtSeederStateChoke::executeChoke
+(const std::vector<SharedHandle<Peer> >& peerSet)
 {
   _logger->info("Seeder state, %d choke round started", _round);
   _lastRound.reset();
 
-  std::deque<PeerEntry> peerEntries;
+  std::vector<PeerEntry> peerEntries;
 
   std::for_each(peerSet.begin(), peerSet.end(), ChokingRequired());
 

src/BtSeederStateChoke.h

@@ -37,7 +37,7 @@
 
 #include "common.h"
 
-#include <deque>
+#include <vector>
 
 #include "SharedHandle.h"
 #include "TimeA2.h"
@@ -76,7 +76,7 @@ private:
     void disableOptUnchoking();
   };
 
-  void unchoke(std::deque<PeerEntry>& peers);
+  void unchoke(std::vector<PeerEntry>& peers);
 
   friend class GenPeerEntry;
   friend class NotInterestedPeer;
@@ -85,7 +85,7 @@ public:
 
   ~BtSeederStateChoke();
 
-  void executeChoke(const std::deque<SharedHandle<Peer> >& peerSet);
+  void executeChoke(const std::vector<SharedHandle<Peer> >& peerSet);
 
   const Time& getLastRound() const { return _lastRound; }
 };

src/BtSetup.cc

@@ -74,7 +74,7 @@ namespace aria2 {
 
 BtSetup::BtSetup():_logger(LogFactory::getInstance()) {}
 
-void BtSetup::setup(std::deque<Command*>& commands,
+void BtSetup::setup(std::vector<Command*>& commands,
                     RequestGroup* requestGroup,
                     DownloadEngine* e,
                     const Option* option)

src/BtSetup.h

@@ -36,7 +36,7 @@
 #define _D_BT_SETUP_H_
 
 #include "common.h"
-#include <deque>
+#include <vector>
 
 namespace aria2 {
 
@@ -52,7 +52,7 @@ private:
 public:
   BtSetup();
 
-  void setup(std::deque<Command*>& commands,
+  void setup(std::vector<Command*>& commands,
              RequestGroup* requestGroup,
              DownloadEngine* e,
              const Option* option);

src/CheckIntegrityCommand.cc

@@ -47,7 +47,7 @@ namespace aria2 {
 
 CheckIntegrityCommand::CheckIntegrityCommand
 (int32_t cuid, RequestGroup* requestGroup, DownloadEngine* e,
- const CheckIntegrityEntryHandle& entry):
+ const SharedHandle<CheckIntegrityEntry>& entry):
   RealtimeCommand(cuid, requestGroup, e),
   _entry(entry)
 {}
@@ -69,7 +69,7 @@ bool CheckIntegrityCommand::executeInternal()
     if(_requestGroup->downloadFinished()) {
       logger->notice(MSG_VERIFICATION_SUCCESSFUL,
                      _requestGroup->getDownloadContext()->getBasePath().c_str());
-      std::deque<Command*> commands;
+      std::vector<Command*> commands;
       try {
         _entry->onDownloadFinished(commands, _e);
       } catch(RecoverableException& e) {
@@ -80,7 +80,7 @@ bool CheckIntegrityCommand::executeInternal()
     } else {
       logger->error(MSG_VERIFICATION_FAILED,
                     _requestGroup->getDownloadContext()->getBasePath().c_str());
-      std::deque<Command*> commands;
+      std::vector<Command*> commands;
       try {
         _entry->onDownloadIncomplete(commands,_e);
       } catch(RecoverableException& e) {

src/CheckIntegrityEntry.cc

@@ -86,7 +86,7 @@ void CheckIntegrityEntry::cutTrailingGarbage()
 }
 
 void CheckIntegrityEntry::proceedFileAllocation
-(std::deque<Command*>& commands,
+(std::vector<Command*>& commands,
  const SharedHandle<FileAllocationEntry>& entry,
  DownloadEngine* e)
 {

src/CheckIntegrityEntry.h

@@ -37,7 +37,8 @@
 
 #include "RequestGroupEntry.h"
 #include "ProgressAwareEntry.h"
-#include <deque>
+
+#include <vector>
 
 namespace aria2 {
 
@@ -50,7 +51,7 @@ class CheckIntegrityEntry : public RequestGroupEntry,
 protected:
   SharedHandle<IteratableValidator> _validator;
 
-  void proceedFileAllocation(std::deque<Command*>& commands,
+  void proceedFileAllocation(std::vector<Command*>& commands,
                              const SharedHandle<FileAllocationEntry>& entry,
                              DownloadEngine* e);
 public:
@@ -70,18 +71,15 @@ public:
 
   virtual void initValidator() = 0;
 
-  virtual void onDownloadFinished(std::deque<Command*>& commands,
+  virtual void onDownloadFinished(std::vector<Command*>& commands,
                                   DownloadEngine* e) = 0;
 
-  virtual void onDownloadIncomplete(std::deque<Command*>& commands,
+  virtual void onDownloadIncomplete(std::vector<Command*>& commands,
                                     DownloadEngine* e) = 0;
 
   void cutTrailingGarbage();
 };
 
-typedef SharedHandle<CheckIntegrityEntry> CheckIntegrityEntryHandle;
-typedef std::deque<CheckIntegrityEntryHandle> CheckIntegrityEntries;
-
 } // namespace aria2
 
 #endif // _D_CHECK_INTEGRITY_ENTRY_H_

src/ChecksumCheckIntegrityEntry.cc

@@ -62,13 +62,13 @@ void ChecksumCheckIntegrityEntry::initValidator()
 }
 
 void
-ChecksumCheckIntegrityEntry::onDownloadFinished(std::deque<Command*>& commands,
-                                                DownloadEngine* e)
+ChecksumCheckIntegrityEntry::onDownloadFinished
+(std::vector<Command*>& commands, DownloadEngine* e)
 {}
 
 void
-ChecksumCheckIntegrityEntry::onDownloadIncomplete(std::deque<Command*>& commands,
-                                                  DownloadEngine* e)
+ChecksumCheckIntegrityEntry::onDownloadIncomplete
+(std::vector<Command*>& commands, DownloadEngine* e)
 {}
 
 } // namespace aria2

src/ChecksumCheckIntegrityEntry.h

@@ -50,10 +50,10 @@ public:
 
   virtual void initValidator();
 
-  virtual void onDownloadFinished(std::deque<Command*>& commands,
+  virtual void onDownloadFinished(std::vector<Command*>& commands,
                                   DownloadEngine* e);
 
-  virtual void onDownloadIncomplete(std::deque<Command*>& commands,
+  virtual void onDownloadIncomplete(std::vector<Command*>& commands,
                                     DownloadEngine* e);
 };
 

src/Command.h

@@ -37,7 +37,6 @@
 
 #include "common.h"
 #include <stdint.h>
-#include <deque>
 
 namespace aria2 {
 
@@ -105,8 +104,6 @@ public:
   void clearIOEvents();
 };
 
-typedef std::deque<Command*> Commands;
-
 } // namespace aria2
 
 #endif // _D_COMMAND_H_

src/ConsoleStatCalc.cc

@@ -120,7 +120,7 @@ static void printProgress
   SharedHandle<PeerStorage> ps =
     e->getBtRegistry()->get(rg->getGID())._peerStorage;
   if(!ps.isNull()) {
-    std::deque<SharedHandle<Peer> > peers;
+    std::vector<SharedHandle<Peer> > peers;
     ps->getActivePeers(peers);
     o << " " << "SEED:"
       << countSeeder(peers.begin(), peers.end());
@@ -250,7 +250,8 @@ ConsoleStatCalc::calculateStat(const DownloadEngine* e)
       std::cout << "\n";
     }
 
-    RequestGroupHandle firstRequestGroup = e->_requestGroupMan->getRequestGroup(0);
+    SharedHandle<RequestGroup> firstRequestGroup =
+      e->_requestGroupMan->getRequestGroup(0);
 
     printProgress(o, firstRequestGroup, e, sizeFormatter);
 
@@ -297,7 +298,8 @@ ConsoleStatCalc::calculateStat(const DownloadEngine* e)
   }
 #ifdef ENABLE_MESSAGE_DIGEST
   {
-    CheckIntegrityEntryHandle entry = e->_checkIntegrityMan->getPickedEntry();
+    SharedHandle<CheckIntegrityEntry> entry =
+      e->_checkIntegrityMan->getPickedEntry();
     if(!entry.isNull()) {
       o << " "
         << "[Checksum:"

src/Cookie.h

@@ -38,7 +38,6 @@
 #include "common.h"
 
 #include <string>
-#include <deque>
 
 #include "a2time.h"
 
@@ -155,8 +154,6 @@ public:
   static std::string normalizeDomain(const std::string& domain);
 };
 
-typedef std::deque<Cookie> Cookies;
-
 } // namespace aria2
 
 #endif // _D_COOKIE_H_

src/CookieStorage.cc

@@ -140,14 +140,6 @@ bool CookieStorage::store(const Cookie& cookie)
   return added;
 }
 
-void CookieStorage::storeCookies(const std::deque<Cookie>& cookies)
-{
-  for(std::deque<Cookie>::const_iterator i = cookies.begin();
-      i != cookies.end(); ++i) {
-    store(*i);
-  }
-}
-
 bool CookieStorage::parseAndStore(const std::string& setCookieString,
                                   const std::string& requestHost,
                                   const std::string& requestPath)
@@ -240,11 +232,11 @@ bool CookieStorage::contains(const Cookie& cookie) const
   }
 }
 
-std::deque<Cookie> CookieStorage::criteriaFind(const std::string& requestHost,
+std::vector<Cookie> CookieStorage::criteriaFind(const std::string& requestHost,
                                                const std::string& requestPath,
                                                time_t date, bool secure)
 {
-  std::deque<Cookie> res;
+  std::vector<Cookie> res;
   bool numericHost = util::isNumericHost(requestHost);
   searchCookieByDomainSuffix
     ((!numericHost && requestHost.find(A2STR::DOT_C) == std::string::npos)?
@@ -307,14 +299,16 @@ bool CookieStorage::load(const std::string& filename)
   try {
     if(std::string(header) == "SQLite format 3") {
 #ifdef HAVE_SQLITE3
-      storeCookies(Sqlite3MozCookieParser().parse(filename));
+      std::vector<Cookie> cookies = Sqlite3MozCookieParser().parse(filename);
+      storeCookies(cookies.begin(), cookies.end());
 #else // !HAVE_SQLITE3
       throw DL_ABORT_EX
         ("Cannot read SQLite3 database because SQLite3 support is disabled by"
          " configuration.");
 #endif // !HAVE_SQLITE3
     } else {
-      storeCookies(NsCookieParser().parse(filename));
+      std::vector<Cookie> cookies = NsCookieParser().parse(filename);
+      storeCookies(cookies.begin(), cookies.end());
     }
     return true;
   } catch(RecoverableException& e) {

src/CookieStorage.h

@@ -39,6 +39,7 @@
 
 #include <string>
 #include <deque>
+#include <vector>
 #include <algorithm>
 
 #include "a2time.h"
@@ -122,7 +123,13 @@ private:
 
   Logger* _logger;
 
-  void storeCookies(const std::deque<Cookie>& cookies);
+  template<typename InputIterator>
+  void storeCookies(InputIterator first, InputIterator last)
+  {
+    for(; first != last; ++first) {
+      store(*first);
+    }
+  }
 public:
   CookieStorage();
 
@@ -140,9 +147,9 @@ public:
 
   // Finds cookies matched with given criteria and returns them.
   // Matched cookies' _lastAccess property is updated.
-  std::deque<Cookie> criteriaFind(const std::string& requestHost,
-                                  const std::string& requestPath,
-                                  time_t date, bool secure);
+  std::vector<Cookie> criteriaFind(const std::string& requestHost,
+                                   const std::string& requestPath,
+                                   time_t date, bool secure);
 
   // Loads Cookies from file denoted by filename.  If compiled with
   // libsqlite3, this method automatically detects the specified file

src/DHTAbstractNodeLookupTask.cc

@@ -38,7 +38,6 @@
 #include "DHTMessageFactory.h"
 #include "DHTMessage.h"
 #include "DHTNode.h"
-#include "DHTNodeLookupEntry.h"
 #include "DHTMessageCallbackImpl.h"
 #include "DHTBucket.h"
 #include "LogFactory.h"
@@ -60,13 +59,13 @@ void DHTAbstractNodeLookupTask::onReceived(const SharedHandle<DHTMessage>& messa
 {
   --_inFlightMessage;
   onReceivedInternal(message);
-  std::deque<SharedHandle<DHTNode> > nodes;
+  std::vector<SharedHandle<DHTNode> > nodes;
   getNodesFromMessage(nodes, message);
-  std::deque<SharedHandle<DHTNodeLookupEntry> > newEntries;
+  std::vector<SharedHandle<DHTNodeLookupEntry> > newEntries;
   toEntries(newEntries, nodes);
 
   size_t count = 0;
-  for(std::deque<SharedHandle<DHTNodeLookupEntry> >::const_iterator i =
+  for(std::vector<SharedHandle<DHTNodeLookupEntry> >::const_iterator i =
         newEntries.begin(); i != newEntries.end(); ++i) {
     if(memcmp(_localNode->getID(), (*i)->_node->getID(), DHT_ID_LENGTH) != 0) {
       _entries.push_front(*i);
@@ -132,7 +131,9 @@ void DHTAbstractNodeLookupTask::sendMessageAndCheckFinish()
 
 void DHTAbstractNodeLookupTask::sendMessage()
 {
-  for(std::deque<SharedHandle<DHTNodeLookupEntry> >::iterator i = _entries.begin(); i != _entries.end() && _inFlightMessage < ALPHA; ++i) {
+  for(std::deque<SharedHandle<DHTNodeLookupEntry> >::iterator i =
+        _entries.begin();
+      i != _entries.end() && _inFlightMessage < ALPHA; ++i) {
     if((*i)->_used == false) {
       ++_inFlightMessage;
       (*i)->_used = true;
@@ -151,7 +152,7 @@ void DHTAbstractNodeLookupTask::updateBucket()
 
 void DHTAbstractNodeLookupTask::startup()
 {
-  std::deque<SharedHandle<DHTNode> > nodes;
+  std::vector<SharedHandle<DHTNode> > nodes;
   _routingTable->getClosestKNodes(nodes, _targetID);
   _entries.clear();
   toEntries(_entries, nodes);
@@ -170,14 +171,4 @@ void DHTAbstractNodeLookupTask::startup()
   }
 }
 
-void DHTAbstractNodeLookupTask::toEntries
-(std::deque<SharedHandle<DHTNodeLookupEntry> >& entries,
- const std::deque<SharedHandle<DHTNode> >& nodes) const
-{
-  for(std::deque<SharedHandle<DHTNode> >::const_iterator i = nodes.begin(); i != nodes.end(); ++i) {
-    SharedHandle<DHTNodeLookupEntry> e(new DHTNodeLookupEntry(*i));
-    entries.push_back(e);
-  }
-}
-
 } // namespace aria2

src/DHTAbstractNodeLookupTask.h

@@ -36,14 +36,17 @@
 #define _D_DHT_ABSTRACT_NODE_LOOKUP_TASK_H_
 
 #include "DHTAbstractTask.h"
+
+#include <deque>
+#include <vector>
+
 #include "DHTMessageCallbackListener.h"
 #include "DHTConstants.h"
-#include <deque>
+#include "DHTNodeLookupEntry.h"
 
 namespace aria2 {
 
 class DHTNode;
-class DHTNodeLookupEntry;
 class DHTMessage;
 
 class DHTAbstractNodeLookupTask:public DHTAbstractTask, public DHTMessageCallbackListener {
@@ -54,8 +57,16 @@ protected:
   
   size_t _inFlightMessage;
   
-  void toEntries(std::deque<SharedHandle<DHTNodeLookupEntry> >& entries,
-                 const std::deque<SharedHandle<DHTNode> >& nodes) const;
+  template<typename Container>
+  void toEntries
+  (Container& entries, const std::vector<SharedHandle<DHTNode> >& nodes) const
+  {
+    for(std::vector<SharedHandle<DHTNode> >::const_iterator i = nodes.begin();
+        i != nodes.end(); ++i) {
+      SharedHandle<DHTNodeLookupEntry> e(new DHTNodeLookupEntry(*i));
+      entries.push_back(e);
+    }
+  }
 
   void sendMessage();
 
@@ -73,7 +84,7 @@ public:
 
   virtual void onTimeout(const SharedHandle<DHTNode>& node);
 
-  virtual void getNodesFromMessage(std::deque<SharedHandle<DHTNode> >& nodes,
+  virtual void getNodesFromMessage(std::vector<SharedHandle<DHTNode> >& nodes,
                                    const SharedHandle<DHTMessage>& message) = 0;
   
   virtual void onReceivedInternal(const SharedHandle<DHTMessage>& message) {}

src/DHTAutoSaveCommand.cc

@@ -98,13 +98,13 @@ void DHTAutoSaveCommand::save()
       }
     }
   }
-  std::deque<SharedHandle<DHTNode> > nodes;
-  std::deque<SharedHandle<DHTBucket> > buckets;
+  std::vector<SharedHandle<DHTNode> > nodes;
+  std::vector<SharedHandle<DHTBucket> > buckets;
   _routingTable->getBuckets(buckets);
-  for(std::deque<SharedHandle<DHTBucket> >::const_iterator i = buckets.begin(); i != buckets.end(); ++i) {
-
+  for(std::vector<SharedHandle<DHTBucket> >::const_iterator i = buckets.begin();
+      i != buckets.end(); ++i) {
     const SharedHandle<DHTBucket>& bucket = *i;
-    std::deque<SharedHandle<DHTNode> > goodNodes;
+    std::vector<SharedHandle<DHTNode> > goodNodes;
     bucket->getGoodNodes(goodNodes);
     nodes.insert(nodes.end(), goodNodes.begin(), goodNodes.end());
   }

src/DHTBucket.cc

@@ -214,9 +214,10 @@ SharedHandle<DHTBucket> DHTBucket::split()
   return rBucket;
 }
 
-void DHTBucket::getGoodNodes(std::deque<SharedHandle<DHTNode> >& goodNodes) const
+void DHTBucket::getGoodNodes
+(std::vector<SharedHandle<DHTNode> >& goodNodes) const
 {
-  goodNodes = _nodes;
+  goodNodes.insert(goodNodes.end(), _nodes.begin(), _nodes.end());  
   goodNodes.erase(std::remove_if(goodNodes.begin(), goodNodes.end(),
                                  mem_fun_sh(&DHTNode::isBad)), goodNodes.end());
 }

src/DHTBucket.h

@@ -36,11 +36,14 @@
 #define _D_DHT_BUCKET_H_
 
 #include "common.h"
+
+#include <string>
+#include <deque>
+#include <vector>
+
 #include "SharedHandle.h"
 #include "DHTConstants.h"
 #include "TimeA2.h"
-#include <string>
-#include <deque>
 
 namespace aria2 {
 
@@ -123,7 +126,7 @@ public:
     return _nodes;
   }
 
-  void getGoodNodes(std::deque<SharedHandle<DHTNode> >& nodes) const;
+  void getGoodNodes(std::vector<SharedHandle<DHTNode> >& nodes) const;
 
   void dropNode(const SharedHandle<DHTNode>& node);
 

src/DHTBucketRefreshTask.cc

@@ -51,9 +51,10 @@ DHTBucketRefreshTask::~DHTBucketRefreshTask() {}
 
 void DHTBucketRefreshTask::startup()
 {
-  std::deque<SharedHandle<DHTBucket> > buckets;
+  std::vector<SharedHandle<DHTBucket> > buckets;
   _routingTable->getBuckets(buckets);
-  for(std::deque<SharedHandle<DHTBucket> >::iterator i = buckets.begin(); i != buckets.end(); ++i) {
+  for(std::vector<SharedHandle<DHTBucket> >::iterator i = buckets.begin();
+      i != buckets.end(); ++i) {
     if(_forceRefresh || (*i)->needsRefresh()) {
       (*i)->notifyUpdate();
       unsigned char targetID[DHT_ID_LENGTH];

src/DHTConnectionImpl.cc

@@ -35,7 +35,6 @@
 #include "DHTConnectionImpl.h"
 
 #include <utility>
-#include <deque>
 #include <algorithm>
 
 #include "LogFactory.h"
@@ -54,11 +53,11 @@ DHTConnectionImpl::~DHTConnectionImpl() {}
 
 bool DHTConnectionImpl::bind(uint16_t& port, IntSequence& ports)
 {
-  std::deque<int32_t> randPorts = ports.flush();
+  std::vector<int32_t> randPorts = ports.flush();
   std::random_shuffle(randPorts.begin(), randPorts.end(),
                       *SimpleRandomizer::getInstance().get());
   
-  for(std::deque<int32_t>::const_iterator portItr = randPorts.begin();
+  for(std::vector<int32_t>::const_iterator portItr = randPorts.begin();
       portItr != randPorts.end(); ++portItr) {
     if(!(0 < (*portItr) && (*portItr) <= 65535)) {
       continue;

src/DHTEntryPointNameResolveCommand.cc

@@ -55,10 +55,12 @@
 
 namespace aria2 {
 
-DHTEntryPointNameResolveCommand::DHTEntryPointNameResolveCommand(int32_t cuid, DownloadEngine* e, const std::deque<std::pair<std::string, uint16_t> >& entryPoints):
+DHTEntryPointNameResolveCommand::DHTEntryPointNameResolveCommand
+(int32_t cuid, DownloadEngine* e,
+ const std::vector<std::pair<std::string, uint16_t> >& entryPoints):
   Command(cuid),
   _e(e),
-  _entryPoints(entryPoints),
+  _entryPoints(entryPoints.begin(), entryPoints.end()),
   _bootstrapEnabled(false)
 {}
 
@@ -82,7 +84,7 @@ bool DHTEntryPointNameResolveCommand::execute()
   try {
 #ifdef ENABLE_ASYNC_DNS
     if(_e->option->getAsBool(PREF_ASYNC_DNS)) {
-      while(_entryPoints.size()) {
+      while(!_entryPoints.empty()) {
         std::string hostname = _entryPoints.front().first;
         try {
           if(resolveHostname(hostname, _resolver)) {
@@ -99,17 +101,17 @@ bool DHTEntryPointNameResolveCommand::execute()
           logger->error(EX_EXCEPTION_CAUGHT, e);
         }
         _resolver->reset();
-        _entryPoints.erase(_entryPoints.begin());
+        _entryPoints.pop_front();
       }
     } else
 #endif // ENABLE_ASYNC_DNS
       {
         NameResolver res;
         res.setSocktype(SOCK_DGRAM);
-        while(_entryPoints.size()) {
+        while(!_entryPoints.empty()) {
           std::string hostname = _entryPoints.front().first;
           try {
-            std::deque<std::string> addrs;
+            std::vector<std::string> addrs;
             res.resolve(addrs, hostname);
           
             std::pair<std::string, uint16_t> p(addrs.front(),
@@ -119,7 +121,7 @@ bool DHTEntryPointNameResolveCommand::execute()
           } catch(RecoverableException& e) {
             logger->error(EX_EXCEPTION_CAUGHT, e);
           }
-          _entryPoints.erase(_entryPoints.begin());
+          _entryPoints.pop_front();
         }
       }
     if(_bootstrapEnabled && _resolvedEntryPoints.size()) {

src/DHTEntryPointNameResolveCommand.h

@@ -36,10 +36,13 @@
 #define _D_DHT_ENTRY_POINT_NAME_RESOVE_COMMAND_H_
 
 #include "Command.h"
-#include "SharedHandle.h"
+
 #include <utility>
+#include <vector>
 #include <deque>
 
+#include "SharedHandle.h"
+
 namespace aria2 {
 
 class DHTTaskQueue;
@@ -69,7 +72,7 @@ private:
 
   std::deque<std::pair<std::string, uint16_t> > _entryPoints;
 
-  std::deque<std::pair<std::string, uint16_t> > _resolvedEntryPoints;
+  std::vector<std::pair<std::string, uint16_t> > _resolvedEntryPoints;
 
   bool _bootstrapEnabled;
 
@@ -85,8 +88,9 @@ private:
 #endif // ENABLE_ASYNC_DNS
 
 public:
-  DHTEntryPointNameResolveCommand(int32_t cuid, DownloadEngine* e,
-                                  const std::deque<std::pair<std:: string, uint16_t> >& entryPoints);
+  DHTEntryPointNameResolveCommand
+  (int32_t cuid, DownloadEngine* e,
+   const std::vector<std::pair<std:: string, uint16_t> >& entryPoints);
 
   virtual ~DHTEntryPointNameResolveCommand();
 

src/DHTFindNodeMessage.cc

@@ -63,7 +63,7 @@ DHTFindNodeMessage::~DHTFindNodeMessage() {}
 
 void DHTFindNodeMessage::doReceivedAction()
 {
-  std::deque<SharedHandle<DHTNode> > nodes;
+  std::vector<SharedHandle<DHTNode> > nodes;
   _routingTable->getClosestKNodes(nodes, _targetNodeID);
   SharedHandle<DHTMessage> reply =
     _factory->createFindNodeReplyMessage(_remoteNode, nodes, _transactionID);

src/DHTFindNodeReplyMessage.cc

@@ -61,7 +61,8 @@ DHTFindNodeReplyMessage::~DHTFindNodeReplyMessage() {}
 
 void DHTFindNodeReplyMessage::doReceivedAction()
 {
-  for(std::deque<SharedHandle<DHTNode> >::iterator i = _closestKNodes.begin(); i != _closestKNodes.end(); ++i) {
+  for(std::vector<SharedHandle<DHTNode> >::iterator i = _closestKNodes.begin();
+      i != _closestKNodes.end(); ++i) {
     if(memcmp((*i)->getID(), _localNode->getID(), DHT_ID_LENGTH) != 0) {
       _routingTable->addNode(*i);
     }
@@ -75,7 +76,7 @@ BDE DHTFindNodeReplyMessage::getResponse()
   size_t offset = 0;
   unsigned char buffer[DHTBucket::K*26];
   // TODO if _closestKNodes.size() > DHTBucket::K ??
-  for(std::deque<SharedHandle<DHTNode> >::const_iterator i =
+  for(std::vector<SharedHandle<DHTNode> >::const_iterator i =
         _closestKNodes.begin();
       i != _closestKNodes.end() && offset < DHTBucket::K*26; ++i) {
     SharedHandle<DHTNode> node = *i;
@@ -96,7 +97,8 @@ std::string DHTFindNodeReplyMessage::getMessageType() const
 
 void DHTFindNodeReplyMessage::validate() const {}
 
-void DHTFindNodeReplyMessage::setClosestKNodes(const std::deque<SharedHandle<DHTNode> >& closestKNodes)
+void DHTFindNodeReplyMessage::setClosestKNodes
+(const std::vector<SharedHandle<DHTNode> >& closestKNodes)
 {
   _closestKNodes = closestKNodes;
 }

src/DHTFindNodeReplyMessage.h

@@ -36,13 +36,13 @@
 #define _D_DHT_FIND_NODE_REPLY_MESSAGE_H_
 
 #include "DHTResponseMessage.h"
-#include <deque>
+#include <vector>
 
 namespace aria2 {
 
 class DHTFindNodeReplyMessage:public DHTResponseMessage {
 private:
-  std::deque<SharedHandle<DHTNode> > _closestKNodes;
+  std::vector<SharedHandle<DHTNode> > _closestKNodes;
 protected:
   virtual std::string toStringOptional() const;
 public:
@@ -60,12 +60,13 @@ public:
 
   virtual void validate() const;
 
-  const std::deque<SharedHandle<DHTNode> >& getClosestKNodes() const
+  const std::vector<SharedHandle<DHTNode> >& getClosestKNodes() const
   {
     return _closestKNodes;
   }
 
-  void setClosestKNodes(const std::deque<SharedHandle<DHTNode> >& closestKNodes);
+  void setClosestKNodes
+  (const std::vector<SharedHandle<DHTNode> >& closestKNodes);
 
   static const std::string FIND_NODE;
   

src/DHTGetPeersMessage.cc

@@ -70,11 +70,11 @@ void DHTGetPeersMessage::doReceivedAction()
                                                    _remoteNode->getIPAddress(),
                                                    _remoteNode->getPort());
   // Check to see localhost has the contents which has same infohash
-  std::deque<SharedHandle<Peer> > peers;
+  std::vector<SharedHandle<Peer> > peers;
   _peerAnnounceStorage->getPeers(peers, _infoHash);
   SharedHandle<DHTMessage> reply;
   if(peers.empty()) {
-    std::deque<SharedHandle<DHTNode> > nodes;
+    std::vector<SharedHandle<DHTNode> > nodes;
     _routingTable->getClosestKNodes(nodes, _infoHash);
     reply =
       _factory->createGetPeersReplyMessage(_remoteNode, nodes, token,

src/DHTGetPeersReplyMessage.cc

@@ -58,10 +58,11 @@ const std::string DHTGetPeersReplyMessage::VALUES("values");
 
 const std::string DHTGetPeersReplyMessage::NODES("nodes");
 
-DHTGetPeersReplyMessage::DHTGetPeersReplyMessage(const SharedHandle<DHTNode>& localNode,
-                                                 const SharedHandle<DHTNode>& remoteNode,
-                                                 const std::string& token,
-                                                 const std::string& transactionID):
+DHTGetPeersReplyMessage::DHTGetPeersReplyMessage
+(const SharedHandle<DHTNode>& localNode,
+ const SharedHandle<DHTNode>& remoteNode,
+ const std::string& token,
+ const std::string& transactionID):
   DHTResponseMessage(localNode, remoteNode, transactionID),
   _token(token) {}
 
@@ -80,7 +81,7 @@ BDE DHTGetPeersReplyMessage::getResponse()
   if(_values.empty()) {
     size_t offset = 0;
     unsigned char buffer[DHTBucket::K*26];
-    for(std::deque<SharedHandle<DHTNode> >::const_iterator i =
+    for(std::vector<SharedHandle<DHTNode> >::const_iterator i =
           _closestKNodes.begin();
         i != _closestKNodes.end() && offset < DHTBucket::K*26; ++i) {
       SharedHandle<DHTNode> node = *i;
@@ -113,7 +114,7 @@ BDE DHTGetPeersReplyMessage::getResponse()
     // number of peer info that a message can carry.
     static const size_t MAX_VALUES_SIZE = 100;
     BDE valuesList = BDE::list();
-    for(std::deque<SharedHandle<Peer> >::const_iterator i = _values.begin();
+    for(std::vector<SharedHandle<Peer> >::const_iterator i = _values.begin();
         i != _values.end() && valuesList.size() < MAX_VALUES_SIZE; ++i) {
       const SharedHandle<Peer>& peer = *i;
       unsigned char buffer[6];
@@ -133,16 +134,6 @@ std::string DHTGetPeersReplyMessage::getMessageType() const
 
 void DHTGetPeersReplyMessage::validate() const {}
 
-void DHTGetPeersReplyMessage::setClosestKNodes(const std::deque<SharedHandle<DHTNode> >& closestKNodes)
-{
-  _closestKNodes = closestKNodes;
-}
-
-void DHTGetPeersReplyMessage::setValues(const std::deque<SharedHandle<Peer> >& peers)
-{
-  _values = peers;
-}
-
 std::string DHTGetPeersReplyMessage::toStringOptional() const
 {
   return strconcat("token=", util::toHex(_token),

src/DHTGetPeersReplyMessage.h

@@ -37,7 +37,7 @@
 
 #include "DHTResponseMessage.h"
 
-#include <deque>
+#include <vector>
 
 #include "DHTConstants.h"
 
@@ -49,9 +49,9 @@ class DHTGetPeersReplyMessage:public DHTResponseMessage {
 private:
   std::string _token;
 
-  std::deque<SharedHandle<DHTNode> > _closestKNodes;
+  std::vector<SharedHandle<DHTNode> > _closestKNodes;
 
-  std::deque<SharedHandle<Peer> > _values;
+  std::vector<SharedHandle<Peer> > _values;
 protected:
   virtual std::string toStringOptional() const;
 public:
@@ -70,19 +70,26 @@ public:
 
   virtual void validate() const;
 
-  const std::deque<SharedHandle<DHTNode> >& getClosestKNodes() const
+  const std::vector<SharedHandle<DHTNode> >& getClosestKNodes() const
   {
     return _closestKNodes;
   }
 
-  const std::deque<SharedHandle<Peer> >& getValues() const
+  const std::vector<SharedHandle<Peer> >& getValues() const
   {
     return _values;
   }
 
-  void setClosestKNodes(const std::deque<SharedHandle<DHTNode> >& closestKNodes);
+  void setClosestKNodes
+  (const std::vector<SharedHandle<DHTNode> >& closestKNodes)
+  {
+    _closestKNodes = closestKNodes;
+  }
 
-  void setValues(const std::deque<SharedHandle<Peer> >& peers);
+  void setValues(const std::vector<SharedHandle<Peer> >& peers)
+  {
+    _values = peers;
+  }
   
   const std::string& getToken() const
   {

src/DHTMessageFactory.h

@@ -38,7 +38,7 @@
 #include "common.h"
 
 #include <string>
-#include <deque>
+#include <vector>
 
 #include "SharedHandle.h"
 #include "A2STR.h"
@@ -78,9 +78,10 @@ public:
                         const std::string& transactionID = A2STR::NIL) = 0;
 
   virtual SharedHandle<DHTMessage>
-  createFindNodeReplyMessage(const SharedHandle<DHTNode>& remoteNode,
-                             const std::deque<SharedHandle<DHTNode> >& closestKNodes,
-                             const std::string& transactionID) = 0;
+  createFindNodeReplyMessage
+  (const SharedHandle<DHTNode>& remoteNode,
+   const std::vector<SharedHandle<DHTNode> >& closestKNodes,
+   const std::string& transactionID) = 0;
 
   virtual SharedHandle<DHTMessage>
   createGetPeersMessage(const SharedHandle<DHTNode>& remoteNode,
@@ -88,16 +89,18 @@ public:
                         const std::string& transactionID = A2STR::NIL) = 0;
 
   virtual SharedHandle<DHTMessage>
-  createGetPeersReplyMessage(const SharedHandle<DHTNode>& remoteNode,
-                             const std::deque<SharedHandle<DHTNode> >& closestKNodes,
-                             const std::string& token,
-                             const std::string& transactionID) = 0;
+  createGetPeersReplyMessage
+  (const SharedHandle<DHTNode>& remoteNode,
+   const std::vector<SharedHandle<DHTNode> >& closestKNodes,
+   const std::string& token,
+   const std::string& transactionID) = 0;
 
   virtual SharedHandle<DHTMessage>
-  createGetPeersReplyMessage(const SharedHandle<DHTNode>& remoteNode,
-                             const std::deque<SharedHandle<Peer> >& peers,
-                             const std::string& token,
-                             const std::string& transactionID) = 0;
+  createGetPeersReplyMessage
+  (const SharedHandle<DHTNode>& remoteNode,
+   const std::vector<SharedHandle<Peer> >& peers,
+   const std::string& token,
+   const std::string& transactionID) = 0;
 
   virtual SharedHandle<DHTMessage>
   createAnnouncePeerMessage(const SharedHandle<DHTNode>& remoteNode,

src/DHTMessageFactoryImpl.cc

@@ -314,23 +314,25 @@ DHTMessageFactoryImpl::createFindNodeMessage(const SharedHandle<DHTNode>& remote
 }
 
 SharedHandle<DHTMessage>
-DHTMessageFactoryImpl::createFindNodeReplyMessage(const SharedHandle<DHTNode>& remoteNode,
-                                                  const std::deque<SharedHandle<DHTNode> >& closestKNodes,
-                                                  const std::string& transactionID)
+DHTMessageFactoryImpl::createFindNodeReplyMessage
+(const SharedHandle<DHTNode>& remoteNode,
+ const std::vector<SharedHandle<DHTNode> >& closestKNodes,
+ const std::string& transactionID)
 {
-  SharedHandle<DHTFindNodeReplyMessage> m(new DHTFindNodeReplyMessage(_localNode, remoteNode, transactionID));
+  SharedHandle<DHTFindNodeReplyMessage> m
+    (new DHTFindNodeReplyMessage(_localNode, remoteNode, transactionID));
   m->setClosestKNodes(closestKNodes);
   setCommonProperty(m);
   return m;
 }
 
-std::deque<SharedHandle<DHTNode> >
+std::vector<SharedHandle<DHTNode> >
 DHTMessageFactoryImpl::extractNodes(const unsigned char* src, size_t length)
 {
   if(length%26 != 0) {
     throw DL_ABORT_EX("Nodes length is not multiple of 26");
   }
-  std::deque<SharedHandle<DHTNode> > nodes;
+  std::vector<SharedHandle<DHTNode> > nodes;
   for(size_t offset = 0; offset < length; offset += 26) {
     SharedHandle<DHTNode> node(new DHTNode(src+offset));
     std::pair<std::string, uint16_t> addr =
@@ -354,8 +356,8 @@ DHTMessageFactoryImpl::createFindNodeReplyMessage
   const BDE& nodesData =
     getString(getDictionary(dict, DHTResponseMessage::R),
               DHTFindNodeReplyMessage::NODES);
-  std::deque<SharedHandle<DHTNode> > nodes = extractNodes(nodesData.uc(),
-                                                          nodesData.s().size());
+  std::vector<SharedHandle<DHTNode> > nodes =
+    extractNodes(nodesData.uc(), nodesData.s().size());
   return createFindNodeReplyMessage(remoteNode, nodes, transactionID);
 }
 
@@ -383,18 +385,19 @@ DHTMessageFactoryImpl::createGetPeersReplyMessageWithNodes
   const BDE& rDict = getDictionary(dict, DHTResponseMessage::R);
   const BDE& nodesData = getString(rDict,
                                    DHTGetPeersReplyMessage::NODES);
-  std::deque<SharedHandle<DHTNode> > nodes = extractNodes(nodesData.uc(),
-                                                          nodesData.s().size());
+  std::vector<SharedHandle<DHTNode> > nodes =
+    extractNodes(nodesData.uc(), nodesData.s().size());
   const BDE& token = getString(rDict, DHTGetPeersReplyMessage::TOKEN);
   return createGetPeersReplyMessage(remoteNode, nodes, token.s(),
                                     transactionID);
 }
 
 SharedHandle<DHTMessage>
-DHTMessageFactoryImpl::createGetPeersReplyMessage(const SharedHandle<DHTNode>& remoteNode,
-                                                  const std::deque<SharedHandle<DHTNode> >& closestKNodes,
-                                                  const std::string& token,
-                                                  const std::string& transactionID)
+DHTMessageFactoryImpl::createGetPeersReplyMessage
+(const SharedHandle<DHTNode>& remoteNode,
+ const std::vector<SharedHandle<DHTNode> >& closestKNodes,
+ const std::string& token,
+ const std::string& transactionID)
 {
   SharedHandle<DHTGetPeersReplyMessage> m
     (new DHTGetPeersReplyMessage(_localNode, remoteNode, token, transactionID));
@@ -412,14 +415,14 @@ DHTMessageFactoryImpl::createGetPeersReplyMessageWithValues
   const BDE& rDict = getDictionary(dict, DHTResponseMessage::R);
   const BDE& valuesList = getList(rDict,
                                   DHTGetPeersReplyMessage::VALUES);
-  std::deque<SharedHandle<Peer> > peers;
+  std::vector<SharedHandle<Peer> > peers;
   for(BDE::List::const_iterator i = valuesList.listBegin();
       i != valuesList.listEnd(); ++i) {
     const BDE& data = *i;
     if(data.isString() && data.s().size() == 6) {
       std::pair<std::string, uint16_t> addr =
         bittorrent::unpackcompact(data.uc());
-      PeerHandle peer(new Peer(addr.first, addr.second));
+      SharedHandle<Peer> peer(new Peer(addr.first, addr.second));
       peers.push_back(peer);
     }
   }
@@ -429,10 +432,11 @@ DHTMessageFactoryImpl::createGetPeersReplyMessageWithValues
 }
 
 SharedHandle<DHTMessage>
-DHTMessageFactoryImpl::createGetPeersReplyMessage(const SharedHandle<DHTNode>& remoteNode,
-                                                  const std::deque<SharedHandle<Peer> >& values,
-                                                  const std::string& token,
-                                                  const std::string& transactionID)
+DHTMessageFactoryImpl::createGetPeersReplyMessage
+(const SharedHandle<DHTNode>& remoteNode,
+ const std::vector<SharedHandle<Peer> >& values,
+ const std::string& token,
+ const std::string& transactionID)
 {
   SharedHandle<DHTGetPeersReplyMessage> m(new DHTGetPeersReplyMessage(_localNode, remoteNode, token, transactionID));
   m->setValues(values);

src/DHTMessageFactoryImpl.h

@@ -72,7 +72,8 @@ private:
 
   void validatePort(const BDE& i) const;
 
-  std::deque<SharedHandle<DHTNode> > extractNodes(const unsigned char* src, size_t length);
+  std::vector<SharedHandle<DHTNode> >
+  extractNodes(const unsigned char* src, size_t length);
 
   void setCommonProperty(const SharedHandle<DHTAbstractMessage>& m);
 
@@ -111,9 +112,10 @@ public:
 
 
   virtual SharedHandle<DHTMessage>
-  createFindNodeReplyMessage(const SharedHandle<DHTNode>& remoteNode,
-                             const std::deque<SharedHandle<DHTNode> >& closestKNodes,
-                             const std::string& transactionID);
+  createFindNodeReplyMessage
+  (const SharedHandle<DHTNode>& remoteNode,
+   const std::vector<SharedHandle<DHTNode> >& closestKNodes,
+   const std::string& transactionID);
 
   virtual SharedHandle<DHTMessage>
   createGetPeersMessage(const SharedHandle<DHTNode>& remoteNode,
@@ -121,10 +123,11 @@ public:
                         const std::string& transactionID = A2STR::NIL);
 
   virtual SharedHandle<DHTMessage>
-  createGetPeersReplyMessage(const SharedHandle<DHTNode>& remoteNode,
-                             const std::deque<SharedHandle<DHTNode> >& closestKNodes,
-                             const std::string& token,
-                             const std::string& transactionID);
+  createGetPeersReplyMessage
+  (const SharedHandle<DHTNode>& remoteNode,
+   const std::vector<SharedHandle<DHTNode> >& closestKNodes,
+   const std::string& token,
+   const std::string& transactionID);
 
   SharedHandle<DHTMessage>
   createGetPeersReplyMessageWithNodes(const SharedHandle<DHTNode>& remoteNode,
@@ -132,10 +135,11 @@ public:
                                       const std::string& transactionID);
 
   virtual SharedHandle<DHTMessage>
-  createGetPeersReplyMessage(const SharedHandle<DHTNode>& remoteNode,
-                             const std::deque<SharedHandle<Peer> >& peers,
-                             const std::string& token,
-                             const std::string& transactionID);
+  createGetPeersReplyMessage
+  (const SharedHandle<DHTNode>& remoteNode,
+   const std::vector<SharedHandle<Peer> >& peers,
+   const std::string& token,
+   const std::string& transactionID);
 
   SharedHandle<DHTMessage>
   createGetPeersReplyMessageWithValues(const SharedHandle<DHTNode>& remoteNode,

src/DHTNodeLookupTask.cc

@@ -39,7 +39,6 @@
 #include "DHTNodeLookupEntry.h"
 #include "LogFactory.h"
 #include "util.h"
-#include <cassert>
 
 namespace aria2 {
 
@@ -48,13 +47,14 @@ DHTNodeLookupTask::DHTNodeLookupTask(const unsigned char* targetNodeID):
 {}
 
 void
-DHTNodeLookupTask::getNodesFromMessage(std::deque<SharedHandle<DHTNode> >& nodes,
-                                       const SharedHandle<DHTMessage>& message)
+DHTNodeLookupTask::getNodesFromMessage
+(std::vector<SharedHandle<DHTNode> >& nodes,
+ const SharedHandle<DHTMessage>& message)
 {
   SharedHandle<DHTFindNodeReplyMessage> m
     (dynamic_pointer_cast<DHTFindNodeReplyMessage>(message));
   if(!m.isNull()) {
-    const std::deque<SharedHandle<DHTNode> >& knodes = m->getClosestKNodes();
+    const std::vector<SharedHandle<DHTNode> >& knodes = m->getClosestKNodes();
     nodes.insert(nodes.end(), knodes.begin(), knodes.end());
   }
 }

src/DHTNodeLookupTask.h

@@ -43,7 +43,7 @@ class DHTNodeLookupTask:public DHTAbstractNodeLookupTask {
 public:
   DHTNodeLookupTask(const unsigned char* targetNodeID);
 
-  virtual void getNodesFromMessage(std::deque<SharedHandle<DHTNode> >& nodes,
+  virtual void getNodesFromMessage(std::vector<SharedHandle<DHTNode> >& nodes,
                                    const SharedHandle<DHTMessage>& message);
 
   virtual SharedHandle<DHTMessage> createMessage(const SharedHandle<DHTNode>& remoteNode);

src/DHTPeerAnnounceEntry.cc

@@ -50,7 +50,8 @@ DHTPeerAnnounceEntry::~DHTPeerAnnounceEntry() {}
 
 void DHTPeerAnnounceEntry::addPeerAddrEntry(const PeerAddrEntry& entry)
 {
-  std::deque<PeerAddrEntry>::iterator i = std::find(_peerAddrEntries.begin(), _peerAddrEntries.end(), entry);
+  std::vector<PeerAddrEntry>::iterator i =
+    std::find(_peerAddrEntries.begin(), _peerAddrEntries.end(), entry);
   if(i == _peerAddrEntries.end()) {
     _peerAddrEntries.push_back(entry);
   } else {
@@ -91,9 +92,10 @@ bool DHTPeerAnnounceEntry::empty() const
   return _peerAddrEntries.empty();
 }
 
-void DHTPeerAnnounceEntry::getPeers(std::deque<SharedHandle<Peer> >& peers) const
+void DHTPeerAnnounceEntry::getPeers
+(std::vector<SharedHandle<Peer> >& peers) const
 {
-  for(std::deque<PeerAddrEntry>::const_iterator i = _peerAddrEntries.begin();
+  for(std::vector<PeerAddrEntry>::const_iterator i = _peerAddrEntries.begin();
       i != _peerAddrEntries.end(); ++i) {
     SharedHandle<Peer> peer(new Peer((*i).getIPAddress(), (*i).getPort()));
     peers.push_back(peer);

src/DHTPeerAnnounceEntry.h

@@ -37,7 +37,7 @@
 
 #include "common.h"
 
-#include <deque>
+#include <vector>
 
 #include "SharedHandle.h"
 #include "DHTConstants.h"
@@ -52,7 +52,7 @@ class DHTPeerAnnounceEntry {
 private:
   unsigned char _infoHash[DHT_ID_LENGTH];
 
-  std::deque<PeerAddrEntry> _peerAddrEntries;
+  std::vector<PeerAddrEntry> _peerAddrEntries;
 
   Time _lastUpdated;
 public:
@@ -66,7 +66,7 @@ public:
 
   size_t countPeerAddrEntry() const;
 
-  const std::deque<PeerAddrEntry>& getPeerAddrEntries() const
+  const std::vector<PeerAddrEntry>& getPeerAddrEntries() const
   {
     return _peerAddrEntries;
   }
@@ -87,7 +87,7 @@ public:
     return _infoHash;
   }
 
-  void getPeers(std::deque<SharedHandle<Peer> >& peers) const;
+  void getPeers(std::vector<SharedHandle<Peer> >& peers) const;
 
 };
 

src/DHTPeerAnnounceStorage.cc

@@ -101,7 +101,7 @@ bool DHTPeerAnnounceStorage::contains(const unsigned char* infoHash) const
     std::binary_search(_entries.begin(), _entries.end(), entry, InfoHashLess());
 }
 
-void DHTPeerAnnounceStorage::getPeers(std::deque<SharedHandle<Peer> >& peers,
+void DHTPeerAnnounceStorage::getPeers(std::vector<SharedHandle<Peer> >& peers,
                                       const unsigned char* infoHash)
 {
   SharedHandle<DHTPeerAnnounceEntry> entry(new DHTPeerAnnounceEntry(infoHash));

src/DHTPeerAnnounceStorage.h

@@ -36,8 +36,11 @@
 #define _D_DHT_PEER_ANNOUNCE_STORAGE_H_
 
 #include "common.h"
-#include "SharedHandle.h"
+
 #include <deque>
+#include <vector>
+
+#include "SharedHandle.h"
 
 namespace aria2 {
 
@@ -68,7 +71,7 @@ public:
 
   bool contains(const unsigned char* infoHash) const;
 
-  void getPeers(std::deque<SharedHandle<Peer> >& peers,
+  void getPeers(std::vector<SharedHandle<Peer> >& peers,
                 const unsigned char* infoHash);
 
   // drop peer announce entry which is not updated in the past

src/DHTPeerLookupTask.cc

@@ -54,12 +54,14 @@ DHTPeerLookupTask::DHTPeerLookupTask
   DHTAbstractNodeLookupTask(bittorrent::getInfoHash(downloadContext)) {}
 
 void
-DHTPeerLookupTask::getNodesFromMessage(std::deque<SharedHandle<DHTNode> >& nodes,
-                                       const SharedHandle<DHTMessage>& message)
+DHTPeerLookupTask::getNodesFromMessage
+(std::vector<SharedHandle<DHTNode> >& nodes,
+ const SharedHandle<DHTMessage>& message)
 {
-  SharedHandle<DHTGetPeersReplyMessage> m(dynamic_pointer_cast<DHTGetPeersReplyMessage>(message));
+  SharedHandle<DHTGetPeersReplyMessage> m
+    (dynamic_pointer_cast<DHTGetPeersReplyMessage>(message));
   if(!m.isNull()) {
-    const std::deque<SharedHandle<DHTNode> >& knodes = m->getClosestKNodes();
+    const std::vector<SharedHandle<DHTNode> >& knodes = m->getClosestKNodes();
     nodes.insert(nodes.end(), knodes.begin(), knodes.end());
   }
 }

src/DHTPeerLookupTask.h

@@ -49,7 +49,7 @@ class DHTPeerLookupTask:public DHTAbstractNodeLookupTask {
 private:
   std::map<std::string, std::string> _tokenStorage;
 
-  std::deque<SharedHandle<Peer> > _peers;
+  std::vector<SharedHandle<Peer> > _peers;
 
   SharedHandle<PeerStorage> _peerStorage;
 
@@ -57,7 +57,7 @@ private:
 public:
   DHTPeerLookupTask(const SharedHandle<DownloadContext>& downloadContext);
 
-  virtual void getNodesFromMessage(std::deque<SharedHandle<DHTNode> >& nodes,
+  virtual void getNodesFromMessage(std::vector<SharedHandle<DHTNode> >& nodes,
                                    const SharedHandle<DHTMessage>& message);
   
   virtual void onReceivedInternal(const SharedHandle<DHTMessage>& message);
@@ -66,7 +66,7 @@ public:
 
   virtual void onFinish();
   
-  const std::deque<SharedHandle<Peer> >& getPeers() const
+  const std::vector<SharedHandle<Peer> >& getPeers() const
   {
     return _peers;
   }

src/DHTRoutingTable.cc

@@ -126,8 +126,9 @@ bool DHTRoutingTable::addNode(const SharedHandle<DHTNode>& node, bool good)
   return false;
 }
 
-void DHTRoutingTable::getClosestKNodes(std::deque<SharedHandle<DHTNode> >& nodes,
-                                       const unsigned char* key) const
+void DHTRoutingTable::getClosestKNodes
+(std::vector<SharedHandle<DHTNode> >& nodes,
+ const unsigned char* key) const
 {
   BNode::findClosestKNodes(nodes, _root, key);
 }
@@ -177,7 +178,8 @@ void DHTRoutingTable::moveBucketTail(const SharedHandle<DHTNode>& node)
   getBucketFor(node)->moveToTail(node);
 }
 
-void DHTRoutingTable::getBuckets(std::deque<SharedHandle<DHTBucket> >& buckets) const
+void DHTRoutingTable::getBuckets
+(std::vector<SharedHandle<DHTBucket> >& buckets) const
 {
   BNode::enumerateBucket(buckets, _root);
 }

src/DHTRoutingTable.h

@@ -36,9 +36,11 @@
 #define _D_DHT_ROUTING_TABLE_H_
 
 #include "common.h"
-#include "SharedHandle.h"
+
 #include <string>
-#include <deque>
+#include <vector>
+
+#include "SharedHandle.h"
 
 namespace aria2 {
 
@@ -73,7 +75,7 @@ public:
 
   bool addGoodNode(const SharedHandle<DHTNode>& node);
 
-  void getClosestKNodes(std::deque<SharedHandle<DHTNode> >& nodes,
+  void getClosestKNodes(std::vector<SharedHandle<DHTNode> >& nodes,
                         const unsigned char* key) const;
 
   size_t countBucket() const;
@@ -92,7 +94,7 @@ public:
 
   SharedHandle<DHTNode> getNode(const unsigned char* id, const std::string& ipaddr, uint16_t port) const;
   
-  void getBuckets(std::deque<SharedHandle<DHTBucket> >& buckets) const;
+  void getBuckets(std::vector<SharedHandle<DHTBucket> >& buckets) const;
 
   void setTaskQueue(const SharedHandle<DHTTaskQueue>& taskQueue);
 

src/DHTRoutingTableDeserializer.cc

@@ -157,7 +157,7 @@ void DHTRoutingTableDeserializer::deserialize(std::istream& in)
   readBytes(buf, buf.size(), in, 4);
   CHECK_STREAM(in, 4);
 
-  std::deque<SharedHandle<DHTNode> > nodes;
+  std::vector<SharedHandle<DHTNode> > nodes;
   // nodes
   for(size_t i = 0; i < numNodes; ++i) {
     // Currently, only IPv4 addresses are supported.

src/DHTRoutingTableDeserializer.h

@@ -36,10 +36,12 @@
 #define _D_DHT_ROUTING_TABLE_DESERIALIZER_H_
 
 #include "common.h"
+
+#include <vector>
+#include <iosfwd>
+
 #include "SharedHandle.h"
 #include "TimeA2.h"
-#include <deque>
-#include <iosfwd>
 
 namespace aria2 {
 
@@ -49,7 +51,7 @@ class DHTRoutingTableDeserializer {
 private:
   SharedHandle<DHTNode> _localNode;
 
-  std::deque<SharedHandle<DHTNode> > _nodes;
+  std::vector<SharedHandle<DHTNode> > _nodes;
 
   Time _serializedTime;
 public:
@@ -62,7 +64,7 @@ public:
     return _localNode;
   }
 
-  const std::deque<SharedHandle<DHTNode> >& getNodes() const
+  const std::vector<SharedHandle<DHTNode> >& getNodes() const
   {
     return _nodes;
   }

src/DHTRoutingTableSerializer.cc

@@ -53,12 +53,14 @@ DHTRoutingTableSerializer::DHTRoutingTableSerializer() {}
 
 DHTRoutingTableSerializer::~DHTRoutingTableSerializer() {}
 
-void DHTRoutingTableSerializer::setLocalNode(const SharedHandle<DHTNode>& localNode)
+void DHTRoutingTableSerializer::setLocalNode
+(const SharedHandle<DHTNode>& localNode)
 {
   _localNode = localNode;
 }
 
-void DHTRoutingTableSerializer::setNodes(const std::deque<SharedHandle<DHTNode> >& nodes)
+void DHTRoutingTableSerializer::setNodes
+(const std::vector<SharedHandle<DHTNode> >& nodes)
 {
   _nodes = nodes;
 }
@@ -99,7 +101,8 @@ void DHTRoutingTableSerializer::serialize(std::ostream& o)
   o.write(zero, 4);
 
   // nodes
-  for(std::deque<SharedHandle<DHTNode> >::const_iterator i = _nodes.begin(); i != _nodes.end(); ++i) {
+  for(std::vector<SharedHandle<DHTNode> >::const_iterator i = _nodes.begin();
+      i != _nodes.end(); ++i) {
     const SharedHandle<DHTNode>& node = *i;
     // Currently, only IPv4 address and IPv4-mapped address are saved.
     // 6bytes: write IP address + port in Compact IP-address/port info form.

src/DHTRoutingTableSerializer.h

@@ -36,10 +36,12 @@
 #define _D_DHT_ROUTING_TABLE_SERIALIZER_H_
 
 #include "common.h"
-#include "SharedHandle.h"
-#include <deque>
+
+#include <vector>
 #include <iosfwd>
 
+#include "SharedHandle.h"
+
 namespace aria2 {
 
 class DHTNode;
@@ -48,7 +50,7 @@ class DHTRoutingTableSerializer {
 private:
   SharedHandle<DHTNode> _localNode;
 
-  std::deque<SharedHandle<DHTNode> > _nodes;
+  std::vector<SharedHandle<DHTNode> > _nodes;
 public:
   DHTRoutingTableSerializer();
 
@@ -56,7 +58,7 @@ public:
 
   void setLocalNode(const SharedHandle<DHTNode>& localNode);
 
-  void setNodes(const std::deque<SharedHandle<DHTNode> >& nodes);
+  void setNodes(const std::vector<SharedHandle<DHTNode> >& nodes);
 
   void serialize(std::ostream& o);
 };

src/DHTSetup.cc

@@ -80,13 +80,13 @@ DHTSetup::DHTSetup():_logger(LogFactory::getInstance()) {}
 
 DHTSetup::~DHTSetup() {}
 
-void DHTSetup::setup(std::deque<Command*>& commands,
+void DHTSetup::setup(std::vector<Command*>& commands,
                      DownloadEngine* e, const Option* option)
 {
   if(_initialized) {
     return;
   }
-  std::deque<Command*> tempCommands;
+  std::vector<Command*> tempCommands;
   try {
     // load routing table and localnode id here
 
@@ -179,8 +179,10 @@ void DHTSetup::setup(std::deque<Command*>& commands,
     DHTRegistry::_messageFactory = factory;
 
     // add deserialized nodes to routing table
-    const std::deque<SharedHandle<DHTNode> >& desnodes = deserializer.getNodes();
-    for(std::deque<SharedHandle<DHTNode> >::const_iterator i = desnodes.begin(); i != desnodes.end(); ++i) {
+    const std::vector<SharedHandle<DHTNode> >& desnodes =
+      deserializer.getNodes();
+    for(std::vector<SharedHandle<DHTNode> >::const_iterator i =
+          desnodes.begin(); i != desnodes.end(); ++i) {
       routingTable->addNode(*i);
     }
     if(!desnodes.empty() && deserializer.getSerializedTime().elapsed(DHT_BUCKET_REFRESH_INTERVAL)) {
@@ -194,7 +196,7 @@ void DHTSetup::setup(std::deque<Command*>& commands,
       {
         std::pair<std::string, uint16_t> addr(option->get(PREF_DHT_ENTRY_POINT_HOST),
                                               option->getAsInt(PREF_DHT_ENTRY_POINT_PORT));
-        std::deque<std::pair<std::string, uint16_t> > entryPoints;
+        std::vector<std::pair<std::string, uint16_t> > entryPoints;
         entryPoints.push_back(addr);
         DHTEntryPointNameResolveCommand* command =
           new DHTEntryPointNameResolveCommand(e->newCUID(), e, entryPoints);

src/DHTSetup.h

@@ -36,7 +36,7 @@
 #define _D_DHT_SETUP_H_
 
 #include "common.h"
-#include <deque>
+#include <vector>
 
 namespace aria2 {
 class Logger;
@@ -55,7 +55,7 @@ public:
 
   ~DHTSetup();
 
-  void setup(std::deque<Command*>& commands,
+  void setup(std::vector<Command*>& commands,
              DownloadEngine* e, const Option* option);
 
   static bool initialized();

src/DefaultBtAnnounce.cc

@@ -274,7 +274,7 @@ DefaultBtAnnounce::processAnnounceResponse(const unsigned char* trackerResponse,
     logger->info(MSG_NO_PEER_LIST_RECEIVED);
   } else {
     if(!btRuntime->isHalt() && btRuntime->lessThanMinPeers()) {
-      std::deque<SharedHandle<Peer> > peers;
+      std::vector<SharedHandle<Peer> > peers;
       PeerListProcessor().extractPeer(peerData, std::back_inserter(peers));
       peerStorage->addPeer(peers);
     }

src/DefaultBtInteractive.cc

@@ -35,6 +35,7 @@
 #include "DefaultBtInteractive.h"
 
 #include <cstring>
+#include <vector>
 
 #include "prefs.h"
 #include "message.h"
@@ -226,7 +227,7 @@ void DefaultBtInteractive::decideChoking() {
 }
 
 void DefaultBtInteractive::checkHave() {
-  std::deque<size_t> indexes;
+  std::vector<size_t> indexes;
   _pieceStorage->getAdvertisedPieceIndexes(indexes, cuid, haveCheckPoint);
   haveCheckPoint.reset();
   if(indexes.size() >= 20) {
@@ -236,7 +237,7 @@ void DefaultBtInteractive::checkHave() {
       dispatcher->addMessageToQueue(messageFactory->createBitfieldMessage());
     }
   } else {
-    for(std::deque<size_t>::iterator itr = indexes.begin();
+    for(std::vector<size_t>::iterator itr = indexes.begin();
         itr != indexes.end(); ++itr) {
       dispatcher->addMessageToQueue(messageFactory->createHaveMessage(*itr));
     }
@@ -326,7 +327,7 @@ void DefaultBtInteractive::fillPiece(size_t maxMissingBlock) {
 
     if(peer->peerChoking()) {
       if(peer->isFastExtensionEnabled()) {
-        std::deque<size_t> excludedIndexes;
+        std::vector<size_t> excludedIndexes;
         btRequestFactory->getTargetPieceIndexes(excludedIndexes);
         while(numMissingBlock < maxMissingBlock) {
           SharedHandle<Piece> piece =
@@ -341,7 +342,7 @@ void DefaultBtInteractive::fillPiece(size_t maxMissingBlock) {
         }
       }
     } else {
-      std::deque<size_t> excludedIndexes;
+      std::vector<size_t> excludedIndexes;
       btRequestFactory->getTargetPieceIndexes(excludedIndexes);
       while(numMissingBlock < maxMissingBlock) {
         SharedHandle<Piece> piece =
@@ -364,7 +365,7 @@ void DefaultBtInteractive::addRequests() {
     _maxOutstandingRequest <= dispatcher->countOutstandingRequest() ?
     0 : _maxOutstandingRequest-dispatcher->countOutstandingRequest();
   if(reqNumToCreate > 0) {
-    BtMessages requests;
+    std::vector<SharedHandle<BtMessage> > requests;
     if(_pieceStorage->isEndGame()) {
       btRequestFactory->createRequestMessagesOnEndGame(requests,reqNumToCreate);
     } else {
@@ -437,7 +438,7 @@ void DefaultBtInteractive::addPeerExchangeMessage()
   if(_pexCheckPoint.elapsed(UTPexExtensionMessage::DEFAULT_INTERVAL)) {
     UTPexExtensionMessageHandle m
       (new UTPexExtensionMessage(peer->getExtensionMessageID("ut_pex")));
-    const Peers& peers = _peerStorage->getPeers();
+    const std::deque<SharedHandle<Peer> >& peers = _peerStorage->getPeers();
     {
       for(std::deque<SharedHandle<Peer> >::const_iterator i =
             peers.begin(); i != peers.end() && !m->freshPeersAreFull(); ++i) {
@@ -474,7 +475,7 @@ void DefaultBtInteractive::doInteractionProcessing() {
        _downloadContext->getTotalLength() > 0) {
       size_t num = _utMetadataRequestTracker->avail();
       if(num > 0) {
-        std::deque<SharedHandle<BtMessage> > requests;
+        std::vector<SharedHandle<BtMessage> > requests;
         _utMetadataRequestFactory->create(requests, num, _pieceStorage);
         dispatcher->addMessageToQueue(requests);
       }

src/DefaultBtMessageDispatcher.cc

@@ -75,15 +75,17 @@ void DefaultBtMessageDispatcher::addMessageToQueue(const BtMessageHandle& btMess
   messageQueue.push_back(btMessage);
 }
 
-void DefaultBtMessageDispatcher::addMessageToQueue(const BtMessages& btMessages)
+void DefaultBtMessageDispatcher::addMessageToQueue
+(const std::vector<SharedHandle<BtMessage> >& btMessages)
 {
-  for(BtMessages::const_iterator itr = btMessages.begin(); itr != btMessages.end(); itr++) {
+  for(std::vector<SharedHandle<BtMessage> >::const_iterator itr =
+        btMessages.begin(); itr != btMessages.end(); ++itr) {
     addMessageToQueue(*itr);
   }
 }
 
 void DefaultBtMessageDispatcher::sendMessages() {
-  BtMessages tempQueue;
+  std::vector<SharedHandle<BtMessage> > tempQueue;
   while(!messageQueue.empty()) {
     BtMessageHandle msg = messageQueue.front();
     messageQueue.pop_front();
@@ -121,7 +123,8 @@ void DefaultBtMessageDispatcher::doCancelSendingPieceAction(size_t index, uint32
 {
   BtCancelSendingPieceEvent event(index, begin, length);
 
-  BtMessages tempQueue = messageQueue;
+  std::vector<SharedHandle<BtMessage> > tempQueue
+    (messageQueue.begin(), messageQueue.end());
 
   forEachMemFunSH(tempQueue.begin(), tempQueue.end(),
                   &BtMessage::onCancelSendingPieceEvent, event);
@@ -129,7 +132,8 @@ void DefaultBtMessageDispatcher::doCancelSendingPieceAction(size_t index, uint32
 
 // Cancel sending piece message to peer.
 // TODO Is this method really necessary?
-void DefaultBtMessageDispatcher::doCancelSendingPieceAction(const PieceHandle& piece)
+void DefaultBtMessageDispatcher::doCancelSendingPieceAction
+(const SharedHandle<Piece>& piece)
 {
 }
 
@@ -158,7 +162,8 @@ public:
 };
 
 // localhost cancels outstanding download requests to the peer.
-void DefaultBtMessageDispatcher::doAbortOutstandingRequestAction(const PieceHandle& piece) {
+void DefaultBtMessageDispatcher::doAbortOutstandingRequestAction
+(const SharedHandle<Piece>& piece) {
   RequestSlot rs(piece->getIndex(), 0, 0, 0);
   std::deque<RequestSlot>::iterator first =
     std::lower_bound(requestSlots.begin(), requestSlots.end(), rs);
@@ -172,7 +177,8 @@ void DefaultBtMessageDispatcher::doAbortOutstandingRequestAction(const PieceHand
 
   BtAbortOutstandingRequestEvent event(piece);
 
-  BtMessages tempQueue = messageQueue;
+  std::vector<SharedHandle<BtMessage> > tempQueue
+    (messageQueue.begin(), messageQueue.end());
   forEachMemFunSH(tempQueue.begin(), tempQueue.end(),
                   &BtMessage::onAbortOutstandingRequestEvent, event);
 }
@@ -238,7 +244,8 @@ void DefaultBtMessageDispatcher::doChokingAction()
 {
   BtChokingEvent event;
 
-  BtMessages tempQueue = messageQueue;
+  std::vector<SharedHandle<BtMessage> > tempQueue
+    (messageQueue.begin(), messageQueue.end());
   forEachMemFunSH(tempQueue.begin(), tempQueue.end(),
                   &BtMessage::onChokingEvent, event);
 }
@@ -351,11 +358,6 @@ bool DefaultBtMessageDispatcher::isSendingInProgress()
   }
 }
 
-size_t DefaultBtMessageDispatcher::countOutstandingRequest()
-{
-  return requestSlots.size();
-}
-
 class BlockIndexLess {
 public:
   bool operator()(const RequestSlot& lhs, const RequestSlot& rhs) const

src/DefaultBtMessageDispatcher.h

@@ -36,6 +36,9 @@
 #define _D_DEFAULT_BT_MESSAGE_DISPATCHER_H_
 
 #include "BtMessageDispatcher.h"
+
+#include <deque>
+
 #include "a2time.h"
 
 namespace aria2 {
@@ -70,7 +73,8 @@ public:
   
   virtual void addMessageToQueue(const SharedHandle<BtMessage>& btMessage);
 
-  virtual void addMessageToQueue(const std::deque<SharedHandle<BtMessage> >& btMessages);
+  virtual void addMessageToQueue
+  (const std::vector<SharedHandle<BtMessage> >& btMessages);
 
   virtual void sendMessages();
 
@@ -92,8 +96,11 @@ public:
     return messageQueue.size();
   }
 
-  virtual size_t countOutstandingRequest();
-
+  virtual size_t countOutstandingRequest()
+  {
+    return requestSlots.size();
+  }
+  
   virtual bool isOutstandingRequest(size_t index, size_t blockIndex);
 
   virtual RequestSlot getOutstandingRequest(size_t index, uint32_t begin, size_t length);
@@ -109,7 +116,7 @@ public:
     return messageQueue;
   }
 
-  const RequestSlots& getRequestSlots() const
+  const std::deque<RequestSlot>& getRequestSlots() const
   {
     return requestSlots;
   }

src/DefaultBtMessageFactory.cc

@@ -278,7 +278,8 @@ DefaultBtMessageFactory::createHandshakeMessage(const unsigned char* infoHash,
 }
 
 BtMessageHandle
-DefaultBtMessageFactory::createRequestMessage(const PieceHandle& piece, size_t blockIndex)
+DefaultBtMessageFactory::createRequestMessage
+(const SharedHandle<Piece>& piece, size_t blockIndex)
 {
   BtRequestMessageHandle msg
     (new BtRequestMessage(piece->getIndex(),

src/DefaultBtMessageReceiver.cc

@@ -85,8 +85,7 @@ DefaultBtMessageReceiver::receiveHandshake(bool quickReply)
     return SharedHandle<BtHandshakeMessage>();
   }
   SharedHandle<BtHandshakeMessage> msg = messageFactory->createHandshakeMessage(data, dataLength);
-  std::deque<std::string> errors;
-  msg->validate(errors);
+  msg->validate();
   return msg;
 }
 
@@ -111,13 +110,8 @@ BtMessageHandle DefaultBtMessageReceiver::receiveMessage() {
     return SharedHandle<BtMessage>();
   }
   BtMessageHandle msg = messageFactory->createBtMessage(data, dataLength);
-  std::deque<std::string> errors;
-  if(msg->validate(errors)) {
-    return msg;
-  } else {
-    // TODO throw exception here based on errors;
-    return SharedHandle<BtMessage>();
-  }
+  msg->validate();
+  return msg;
 }
 
 void DefaultBtMessageReceiver::setDownloadContext

src/DefaultBtProgressInfoFile.cc

@@ -179,9 +179,10 @@ void DefaultBtProgressInfoFile::save()
     uint32_t numInFlightPieceNL = htonl(_pieceStorage->countInFlightPiece());
     o.write(reinterpret_cast<const char*>(&numInFlightPieceNL),
             sizeof(numInFlightPieceNL));
-    Pieces inFlightPieces;
+    std::vector<SharedHandle<Piece> > inFlightPieces;
     _pieceStorage->getInFlightPieces(inFlightPieces);
-    for(Pieces::const_iterator itr = inFlightPieces.begin();
+    for(std::vector<SharedHandle<Piece> >::const_iterator itr =
+          inFlightPieces.begin();
         itr != inFlightPieces.end(); ++itr) {
       uint32_t indexNL = htonl((*itr)->getIndex());
       o.write(reinterpret_cast<const char*>(&indexNL), sizeof(indexNL));
@@ -343,7 +344,7 @@ void DefaultBtProgressInfoFile::load()
     if(version >= 1) {
       numInFlightPiece = ntohl(numInFlightPiece);
     }
-    Pieces inFlightPieces;
+    std::vector<SharedHandle<Piece> > inFlightPieces;
     while(numInFlightPiece--) {
       uint32_t index;
       in.read(reinterpret_cast<char*>(&index), sizeof(index));
@@ -365,7 +366,7 @@ void DefaultBtProgressInfoFile::load()
         throw DL_ABORT_EX
           (StringFormat("piece length out of range: %u", length).str());
       }
-      PieceHandle piece(new Piece(index, length));
+      SharedHandle<Piece> piece(new Piece(index, length));
       uint32_t bitfieldLength;
       in.read(reinterpret_cast<char*>(&bitfieldLength),
               sizeof(bitfieldLength));

src/DefaultBtRequestFactory.cc

@@ -66,7 +66,7 @@ DefaultBtRequestFactory::~DefaultBtRequestFactory()
   }
 }
 
-void DefaultBtRequestFactory::addTargetPiece(const PieceHandle& piece)
+void DefaultBtRequestFactory::addTargetPiece(const SharedHandle<Piece>& piece)
 {
   pieces.push_back(piece);
 }
@@ -95,7 +95,7 @@ void DefaultBtRequestFactory::removeCompletedPiece() {
                pieces.end());
 }
 
-void DefaultBtRequestFactory::removeTargetPiece(const PieceHandle& piece) {
+void DefaultBtRequestFactory::removeTargetPiece(const SharedHandle<Piece>& piece) {
   pieces.erase(std::remove(pieces.begin(), pieces.end(), piece),
                pieces.end());
   dispatcher->doAbortOutstandingRequestAction(piece);
@@ -142,7 +142,8 @@ void DefaultBtRequestFactory::doChokedAction()
 }
 
 void DefaultBtRequestFactory::removeAllTargetPiece() {
-  for(Pieces::iterator itr = pieces.begin(); itr != pieces.end(); ++itr) {
+  for(std::deque<SharedHandle<Piece> >::iterator itr = pieces.begin();
+      itr != pieces.end(); ++itr) {
     dispatcher->doAbortOutstandingRequestAction(*itr);
     _pieceStorage->cancelPiece(*itr);
   }
@@ -150,7 +151,7 @@ void DefaultBtRequestFactory::removeAllTargetPiece() {
 }
 
 void DefaultBtRequestFactory::createRequestMessages
-(std::deque<SharedHandle<BtMessage> >& requests, size_t max)
+(std::vector<SharedHandle<BtMessage> >& requests, size_t max)
 {
   if(requests.size() >= max) {
     return;
@@ -158,7 +159,7 @@ void DefaultBtRequestFactory::createRequestMessages
   size_t getnum = max-requests.size();
   std::vector<size_t> blockIndexes;
   blockIndexes.reserve(getnum);
-  for(Pieces::iterator itr = pieces.begin();
+  for(std::deque<SharedHandle<Piece> >::iterator itr = pieces.begin();
       itr != pieces.end() && getnum; ++itr) {
     SharedHandle<Piece>& piece = *itr;
     if(piece->getMissingUnusedBlockIndex(blockIndexes, getnum)) {
@@ -181,17 +182,17 @@ void DefaultBtRequestFactory::createRequestMessages
 }
 
 void DefaultBtRequestFactory::createRequestMessagesOnEndGame
-(std::deque<SharedHandle<BtMessage> >& requests, size_t max)
+(std::vector<SharedHandle<BtMessage> >& requests, size_t max)
 {
-  for(Pieces::iterator itr = pieces.begin();
+  for(std::deque<SharedHandle<Piece> >::iterator itr = pieces.begin();
       itr != pieces.end() && requests.size() < max; ++itr) {
-    PieceHandle& piece = *itr;
+    SharedHandle<Piece>& piece = *itr;
     const size_t mislen = piece->getBitfieldLength();
     array_ptr<unsigned char> misbitfield(new unsigned char[mislen]);
 
     piece->getAllMissingBlockIndexes(misbitfield, mislen);
 
-    std::deque<size_t> missingBlockIndexes;
+    std::vector<size_t> missingBlockIndexes;
     size_t blockIndex = 0;
     for(size_t i = 0; i < mislen; ++i) {
       unsigned char bits = misbitfield[i];
@@ -204,7 +205,7 @@ void DefaultBtRequestFactory::createRequestMessagesOnEndGame
     }
     std::random_shuffle(missingBlockIndexes.begin(), missingBlockIndexes.end(),
                         *(SimpleRandomizer::getInstance().get()));
-    for(std::deque<size_t>::const_iterator bitr = missingBlockIndexes.begin();
+    for(std::vector<size_t>::const_iterator bitr = missingBlockIndexes.begin();
         bitr != missingBlockIndexes.end() && requests.size() < max; bitr++) {
       const size_t& blockIndex = *bitr;
       if(!dispatcher->isOutstandingRequest(piece->getIndex(),
@@ -247,7 +248,7 @@ size_t DefaultBtRequestFactory::countMissingBlock()
 }
 
 void DefaultBtRequestFactory::getTargetPieceIndexes
-(std::deque<size_t>& indexes) const
+(std::vector<size_t>& indexes) const
 {
   std::transform(pieces.begin(), pieces.end(), std::back_inserter(indexes),
                  mem_fun_sh(&Piece::getIndex));

src/DefaultBtRequestFactory.h

@@ -37,6 +37,8 @@
 
 #include "BtRequestFactory.h"
 
+#include <deque>
+
 namespace aria2 {
 
 class PieceStorage;
@@ -77,12 +79,12 @@ public:
   virtual void doChokedAction();
 
   virtual void createRequestMessages
-  (std::deque<SharedHandle<BtMessage> >& requests, size_t max);
+  (std::vector<SharedHandle<BtMessage> >& requests, size_t max);
 
   virtual void createRequestMessagesOnEndGame
-  (std::deque<SharedHandle<BtMessage> >& requests, size_t max);
+  (std::vector<SharedHandle<BtMessage> >& requests, size_t max);
 
-  virtual void getTargetPieceIndexes(std::deque<size_t>& indexes) const;
+  virtual void getTargetPieceIndexes(std::vector<size_t>& indexes) const;
 
   std::deque<SharedHandle<Piece> >& getTargetPieces()
   {

src/DefaultExtensionMessageFactory.cc

@@ -60,7 +60,7 @@ DefaultExtensionMessageFactory::DefaultExtensionMessageFactory():
   _logger(LogFactory::getInstance()) {}
 
 DefaultExtensionMessageFactory::DefaultExtensionMessageFactory
-(const PeerHandle& peer,
+(const SharedHandle<Peer>& peer,
  const SharedHandle<ExtensionMessageRegistry>& registry):
   _peer(peer),
   _registry(registry),
@@ -163,7 +163,7 @@ void DefaultExtensionMessageFactory::setPeerStorage
   _peerStorage = peerStorage;
 }
 
-void DefaultExtensionMessageFactory::setPeer(const PeerHandle& peer)
+void DefaultExtensionMessageFactory::setPeer(const SharedHandle<Peer>& peer)
 {
   _peer = peer;
 }

src/DefaultPeerStorage.cc

@@ -68,19 +68,20 @@ DefaultPeerStorage::~DefaultPeerStorage()
 
 class FindIdenticalPeer {
 private:
-  PeerHandle _peer;
+  SharedHandle<Peer> _peer;
 public:
-  FindIdenticalPeer(const PeerHandle& peer):_peer(peer) {}
+  FindIdenticalPeer(const SharedHandle<Peer>& peer):_peer(peer) {}
 
-  bool operator()(const PeerHandle& peer) const {
+  bool operator()(const SharedHandle<Peer>& peer) const {
     return (_peer == peer) ||
       ((_peer->ipaddr == peer->ipaddr) && (_peer->port == peer->port));
   }
 };
 
-bool DefaultPeerStorage::isPeerAlreadyAdded(const PeerHandle& peer)
+bool DefaultPeerStorage::isPeerAlreadyAdded(const SharedHandle<Peer>& peer)
 {
-  return std::find_if(peers.begin(), peers.end(), FindIdenticalPeer(peer)) != peers.end();
+  return std::find_if(peers.begin(), peers.end(),
+                      FindIdenticalPeer(peer)) != peers.end();
 }
 
 static size_t calculateMaxPeerListSize(const SharedHandle<BtRuntime>& btRuntime)
@@ -93,7 +94,7 @@ static size_t calculateMaxPeerListSize(const SharedHandle<BtRuntime>& btRuntime)
     btRuntime->getMaxPeers()+(btRuntime->getMaxPeers() >> 2);
 }
 
-bool DefaultPeerStorage::addPeer(const PeerHandle& peer) {
+bool DefaultPeerStorage::addPeer(const SharedHandle<Peer>& peer) {
   if(isPeerAlreadyAdded(peer)) {
     if(logger->debug()) {
       logger->debug("Adding %s:%u is rejected because it has been already"
@@ -109,10 +110,11 @@ bool DefaultPeerStorage::addPeer(const PeerHandle& peer) {
   return true;
 }
 
-void DefaultPeerStorage::addPeer(const Peers& peers) {
-  for(Peers::const_iterator itr = peers.begin();
+void DefaultPeerStorage::addPeer(const std::vector<SharedHandle<Peer> >& peers)
+{
+  for(std::vector<SharedHandle<Peer> >::const_iterator itr = peers.begin();
       itr != peers.end(); ++itr) {
-    const PeerHandle& peer = *itr;
+    const SharedHandle<Peer>& peer = *itr;
     if(addPeer(peer)) {
       if(logger->debug()) {
         logger->debug(MSG_ADDING_PEER, peer->ipaddr.c_str(), peer->port);
@@ -121,20 +123,21 @@ void DefaultPeerStorage::addPeer(const Peers& peers) {
   }  
 }
 
-const Peers& DefaultPeerStorage::getPeers() {
+const std::deque<SharedHandle<Peer> >& DefaultPeerStorage::getPeers()
+{
   return peers;
 }
 
 class FindFinePeer {
 public:
-  bool operator()(const PeerHandle& peer) const {
+  bool operator()(const SharedHandle<Peer>& peer) const {
     return peer->unused() && peer->isGood();
   }
 };
 
-PeerHandle DefaultPeerStorage::getUnusedPeer() {
-  Peers::const_iterator itr = std::find_if(peers.begin(), peers.end(),
-                                           FindFinePeer());
+SharedHandle<Peer> DefaultPeerStorage::getUnusedPeer() {
+  std::deque<SharedHandle<Peer> >::const_iterator itr =
+    std::find_if(peers.begin(), peers.end(), FindFinePeer());
   if(itr == peers.end()) {
     return SharedHandle<Peer>();
   } else {
@@ -147,17 +150,18 @@ private:
   std::string ipaddr;
   uint16_t port;
 public:
-  FindPeer(const std::string& ipaddr, uint16_t port):ipaddr(ipaddr), port(port) {}
+  FindPeer(const std::string& ipaddr, uint16_t port):
+    ipaddr(ipaddr), port(port) {}
 
-  bool operator()(const PeerHandle& peer) const {
+  bool operator()(const SharedHandle<Peer>& peer) const {
     return ipaddr == peer->ipaddr && port == peer->port;
   }
 };
 
-PeerHandle DefaultPeerStorage::getPeer(const std::string& ipaddr,
-                                       uint16_t port) const {
-  Peers::const_iterator itr = std::find_if(peers.begin(), peers.end(),
-                                           FindPeer(ipaddr, port));
+SharedHandle<Peer> DefaultPeerStorage::getPeer(const std::string& ipaddr,
+                                               uint16_t port) const {
+  std::deque<SharedHandle<Peer> >::const_iterator itr =
+    std::find_if(peers.begin(), peers.end(), FindPeer(ipaddr, port));
   if(itr == peers.end()) {
     return SharedHandle<Peer>();
   } else {
@@ -175,9 +179,9 @@ bool DefaultPeerStorage::isPeerAvailable() {
 
 class CollectActivePeer {
 private:
-  std::deque<SharedHandle<Peer> >& _activePeers;
+  std::vector<SharedHandle<Peer> >& _activePeers;
 public:
-  CollectActivePeer(std::deque<SharedHandle<Peer> >& activePeers):
+  CollectActivePeer(std::vector<SharedHandle<Peer> >& activePeers):
     _activePeers(activePeers) {}
 
   void operator()(const SharedHandle<Peer>& peer)
@@ -188,7 +192,8 @@ public:
   }
 };
 
-void DefaultPeerStorage::getActivePeers(std::deque<SharedHandle<Peer> >& activePeers)
+void DefaultPeerStorage::getActivePeers
+(std::vector<SharedHandle<Peer> >& activePeers)
 {
   std::for_each(peers.begin(), peers.end(), CollectActivePeer(activePeers));
 }
@@ -214,12 +219,12 @@ TransferStat DefaultPeerStorage::calculateStat()
     }
     _lastTransferStatMapUpdated.reset();
     _peerTransferStatMap.clear();
-    std::deque<SharedHandle<Peer> > activePeers;
+    std::vector<SharedHandle<Peer> > activePeers;
     getActivePeers(activePeers);
     struct timeval now;
     gettimeofday(&now, 0);
-    for(std::deque<SharedHandle<Peer> >::const_iterator i = activePeers.begin();
-        i != activePeers.end(); ++i) {
+    for(std::vector<SharedHandle<Peer> >::const_iterator i =
+          activePeers.begin(); i != activePeers.end(); ++i) {
       TransferStat s;
       s.downloadSpeed = (*i)->calculateDownloadSpeed(now);
       s.uploadSpeed = (*i)->calculateUploadSpeed(now);
@@ -261,10 +266,10 @@ TransferStat DefaultPeerStorage::getTransferStatFor
 }
 
 void DefaultPeerStorage::deleteUnusedPeer(size_t delSize) {
-  Peers temp;
-  for(Peers::reverse_iterator itr = peers.rbegin();
+  std::deque<SharedHandle<Peer> > temp;
+  for(std::deque<SharedHandle<Peer> >::reverse_iterator itr = peers.rbegin();
       itr != peers.rend(); ++itr) {
-    const PeerHandle& p = *itr;
+    const SharedHandle<Peer>& p = *itr;
     if(p->unused() && delSize > 0) {
       onErasingPeer(p);
       delSize--;
@@ -293,9 +298,10 @@ void DefaultPeerStorage::onReturningPeer(const SharedHandle<Peer>& peer)
   }
 }
 
-void DefaultPeerStorage::returnPeer(const PeerHandle& peer)
+void DefaultPeerStorage::returnPeer(const SharedHandle<Peer>& peer)
 {
-  Peers::iterator itr = std::find(peers.begin(), peers.end(), peer);
+  std::deque<SharedHandle<Peer> >::iterator itr =
+    std::find(peers.begin(), peers.end(), peer);
   if(itr == peers.end()) {
     if(logger->debug()) {
       logger->debug("Cannot find peer %s:%u in PeerStorage.",
@@ -321,7 +327,7 @@ bool DefaultPeerStorage::chokeRoundIntervalElapsed()
 
 void DefaultPeerStorage::executeChoke()
 {
-  std::deque<SharedHandle<Peer> > activePeers;
+  std::vector<SharedHandle<Peer> > activePeers;
   getActivePeers(activePeers);
   if(_pieceStorage->downloadFinished()) {
     return _seederStateChoke->executeChoke(activePeers);

src/DefaultPeerStorage.h

@@ -83,13 +83,13 @@ public:
 
   SharedHandle<Peer> getPeer(const std::string& ipaddr, uint16_t port) const;
 
-  virtual void addPeer(const std::deque<SharedHandle<Peer> >& peers);
+  virtual void addPeer(const std::vector<SharedHandle<Peer> >& peers);
 
   virtual const std::deque<SharedHandle<Peer> >& getPeers();
 
   virtual bool isPeerAvailable();
 
-  virtual void getActivePeers(std::deque<SharedHandle<Peer> >& peers);
+  virtual void getActivePeers(std::vector<SharedHandle<Peer> >& peers);
 
   virtual TransferStat calculateStat();
 

src/DefaultPieceStorage.cc

@@ -105,11 +105,11 @@ bool DefaultPieceStorage::getMissingPieceIndex(size_t& index,
   }
 }
 
-PieceHandle DefaultPieceStorage::checkOutPiece(size_t index)
+SharedHandle<Piece> DefaultPieceStorage::checkOutPiece(size_t index)
 {
   bitfieldMan->setUseBit(index);
 
-  PieceHandle piece = findUsedPiece(index);
+  SharedHandle<Piece> piece = findUsedPiece(index);
   if(piece.isNull()) {
     piece.reset(new Piece(index, bitfieldMan->getBlockLength(index)));
 
@@ -130,9 +130,9 @@ PieceHandle DefaultPieceStorage::checkOutPiece(size_t index)
  * Newly instantiated piece is not added to usedPieces.
  * Because it is waste of memory and there is no chance to use them later.
  */
-PieceHandle DefaultPieceStorage::getPiece(size_t index)
+SharedHandle<Piece> DefaultPieceStorage::getPiece(size_t index)
 {
-  PieceHandle piece;
+  SharedHandle<Piece> piece;
   if(0 <= index && index <= bitfieldMan->getMaxIndex()) {
     piece = findUsedPiece(index);
     if(piece.isNull()) {
@@ -145,7 +145,7 @@ PieceHandle DefaultPieceStorage::getPiece(size_t index)
   return piece;
 }
 
-void DefaultPieceStorage::addUsedPiece(const PieceHandle& piece)
+void DefaultPieceStorage::addUsedPiece(const SharedHandle<Piece>& piece)
 {
   std::deque<SharedHandle<Piece> >::iterator i =
     std::lower_bound(usedPieces.begin(), usedPieces.end(), piece);
@@ -156,7 +156,7 @@ void DefaultPieceStorage::addUsedPiece(const PieceHandle& piece)
   }
 }
 
-PieceHandle DefaultPieceStorage::findUsedPiece(size_t index) const
+SharedHandle<Piece> DefaultPieceStorage::findUsedPiece(size_t index) const
 {
   SharedHandle<Piece> p(new Piece());
   p->setIndex(index);
@@ -190,13 +190,14 @@ SharedHandle<Piece> DefaultPieceStorage::getMissingPiece
 
 #ifdef ENABLE_BITTORRENT
 
-bool DefaultPieceStorage::hasMissingPiece(const PeerHandle& peer)
+bool DefaultPieceStorage::hasMissingPiece(const SharedHandle<Peer>& peer)
 {
   return bitfieldMan->hasMissingPiece(peer->getBitfield(),
                                       peer->getBitfieldLength());
 }
 
-PieceHandle DefaultPieceStorage::getMissingPiece(const SharedHandle<Peer>& peer)
+SharedHandle<Piece>
+DefaultPieceStorage::getMissingPiece(const SharedHandle<Peer>& peer)
 {
   return getMissingPiece(peer->getBitfield(), peer->getBitfieldLength());
 }
@@ -204,7 +205,7 @@ PieceHandle DefaultPieceStorage::getMissingPiece(const SharedHandle<Peer>& peer)
 void DefaultPieceStorage::createFastIndexBitfield
 (BitfieldMan& bitfield, const SharedHandle<Peer>& peer)
 {
-  for(std::deque<size_t>::const_iterator itr =
+  for(std::vector<size_t>::const_iterator itr =
         peer->getPeerAllowedIndexSet().begin();
       itr != peer->getPeerAllowedIndexSet().end(); ++itr) {
     if(!bitfieldMan->isBitSet(*itr) && peer->hasPiece(*itr)) {
@@ -213,7 +214,7 @@ void DefaultPieceStorage::createFastIndexBitfield
   }
 }
 
-PieceHandle DefaultPieceStorage::getMissingFastPiece
+SharedHandle<Piece> DefaultPieceStorage::getMissingFastPiece
 (const SharedHandle<Peer>& peer)
 {
   if(peer->isFastExtensionEnabled() && peer->countPeerAllowedIndexSet() > 0) {
@@ -227,16 +228,14 @@ PieceHandle DefaultPieceStorage::getMissingFastPiece
 }
 
 static void unsetExcludedIndexes(BitfieldMan& bitfield,
-                                 const std::deque<size_t>& excludedIndexes)
+                                 const std::vector<size_t>& excludedIndexes)
 {
-  for(std::deque<size_t>::const_iterator i = excludedIndexes.begin();
-      i != excludedIndexes.end(); ++i) {
-    bitfield.unsetBit(*i);
-  }
+  std::for_each(excludedIndexes.begin(), excludedIndexes.end(),
+                std::bind1st(std::mem_fun(&BitfieldMan::unsetBit), &bitfield));
 }
 
 SharedHandle<Piece> DefaultPieceStorage::getMissingPiece
-(const SharedHandle<Peer>& peer, const std::deque<size_t>& excludedIndexes)
+(const SharedHandle<Peer>& peer, const std::vector<size_t>& excludedIndexes)
 {
   BitfieldMan tempBitfield(bitfieldMan->getBlockLength(),
                            bitfieldMan->getTotalLength());
@@ -246,7 +245,7 @@ SharedHandle<Piece> DefaultPieceStorage::getMissingPiece
 }
 
 SharedHandle<Piece> DefaultPieceStorage::getMissingFastPiece
-(const SharedHandle<Peer>& peer, const std::deque<size_t>& excludedIndexes)
+(const SharedHandle<Peer>& peer, const std::vector<size_t>& excludedIndexes)
 {
   if(peer->isFastExtensionEnabled() && peer->countPeerAllowedIndexSet() > 0) {
     BitfieldMan tempBitfield(bitfieldMan->getBlockLength(),
@@ -267,7 +266,7 @@ bool DefaultPieceStorage::hasMissingUnusedPiece()
   return bitfieldMan->getFirstMissingUnusedIndex(index);
 }
 
-PieceHandle DefaultPieceStorage::getSparseMissingUnusedPiece
+SharedHandle<Piece> DefaultPieceStorage::getSparseMissingUnusedPiece
 (const unsigned char* ignoreBitfield, size_t length)
 {
   size_t index;
@@ -278,7 +277,7 @@ PieceHandle DefaultPieceStorage::getSparseMissingUnusedPiece
   }
 }
 
-PieceHandle DefaultPieceStorage::getMissingPiece(size_t index)
+SharedHandle<Piece> DefaultPieceStorage::getMissingPiece(size_t index)
 {
   if(hasPiece(index) || isPieceUsed(index)) {
     return SharedHandle<Piece>();
@@ -287,7 +286,7 @@ PieceHandle DefaultPieceStorage::getMissingPiece(size_t index)
   }
 }
 
-void DefaultPieceStorage::deleteUsedPiece(const PieceHandle& piece)
+void DefaultPieceStorage::deleteUsedPiece(const SharedHandle<Piece>& piece)
 {
   if(piece.isNull()) {
     return;
@@ -319,7 +318,7 @@ void DefaultPieceStorage::deleteUsedPiece(const PieceHandle& piece)
 //   size_t deleted = 0;
 //   for(Pieces::iterator itr = usedPieces.begin();
 //       itr != usedPieces.end() && deleted < delNum;) {
-//     PieceHandle& piece = *itr;
+//     SharedHandle<Piece>& piece = *itr;
 //     if(!bitfieldMan->isUseBitSet(piece->getIndex()) &&
 //        piece->countCompleteBlock() <= piece->countBlock()*(fillRate/100.0)) {
 //       logger->info(MSG_DELETING_USED_PIECE,
@@ -335,7 +334,7 @@ void DefaultPieceStorage::deleteUsedPiece(const PieceHandle& piece)
 //   return deleted;
 // }
 
-void DefaultPieceStorage::completePiece(const PieceHandle& piece)
+void DefaultPieceStorage::completePiece(const SharedHandle<Piece>& piece)
 {
   if(piece.isNull()) {
     return;
@@ -369,7 +368,7 @@ bool DefaultPieceStorage::isSelectiveDownloadingMode()
 }
 
 // not unittested
-void DefaultPieceStorage::cancelPiece(const PieceHandle& piece)
+void DefaultPieceStorage::cancelPiece(const SharedHandle<Piece>& piece)
 {
   if(piece.isNull()) {
     return;
@@ -541,12 +540,13 @@ void DefaultPieceStorage::advertisePiece(int32_t cuid, size_t index)
 }
 
 void
-DefaultPieceStorage::getAdvertisedPieceIndexes(std::deque<size_t>& indexes,
+DefaultPieceStorage::getAdvertisedPieceIndexes(std::vector<size_t>& indexes,
                                                int32_t myCuid,
                                                const Time& lastCheckTime)
 {
-  for(Haves::const_iterator itr = haves.begin(); itr != haves.end(); itr++) {
-    const Haves::value_type& have = *itr;
+  for(std::deque<HaveEntry>::const_iterator itr = haves.begin();
+      itr != haves.end(); ++itr) {
+    const HaveEntry& have = *itr;
     if(have.getCuid() == myCuid) {
       continue;
     }
@@ -575,7 +575,7 @@ public:
   
 void DefaultPieceStorage::removeAdvertisedPiece(time_t elapsed)
 {
-  Haves::iterator itr =
+  std::deque<HaveEntry>::iterator itr =
     std::find_if(haves.begin(), haves.end(), FindElapsedHave(elapsed));
   if(itr != haves.end()) {
     if(logger->debug()) {
@@ -601,7 +601,8 @@ void DefaultPieceStorage::markPiecesDone(uint64_t length)
     }
     size_t r = (length%bitfieldMan->getBlockLength())/Piece::BLOCK_LENGTH;
     if(r > 0) {
-      PieceHandle p(new Piece(numPiece, bitfieldMan->getBlockLength(numPiece)));
+      SharedHandle<Piece> p
+        (new Piece(numPiece, bitfieldMan->getBlockLength(numPiece)));
       
       for(size_t i = 0; i < r; ++i) {
         p->completeBlock(i);
@@ -623,7 +624,8 @@ void DefaultPieceStorage::markPieceMissing(size_t index)
   bitfieldMan->unsetBit(index);
 }
 
-void DefaultPieceStorage::addInFlightPiece(const Pieces& pieces)
+void DefaultPieceStorage::addInFlightPiece
+(const std::vector<SharedHandle<Piece> >& pieces)
 {
   usedPieces.insert(usedPieces.end(), pieces.begin(), pieces.end());
   std::sort(usedPieces.begin(), usedPieces.end());
@@ -634,7 +636,8 @@ size_t DefaultPieceStorage::countInFlightPiece()
   return usedPieces.size();
 }
 
-void DefaultPieceStorage::getInFlightPieces(std::deque<SharedHandle<Piece> >& pieces)
+void DefaultPieceStorage::getInFlightPieces
+(std::vector<SharedHandle<Piece> >& pieces)
 {
   pieces.insert(pieces.end(), usedPieces.begin(), usedPieces.end());
 }

src/DefaultPieceStorage.h

@@ -37,6 +37,8 @@
 
 #include "PieceStorage.h"
 
+#include <deque>
+
 namespace aria2 {
 
 class DownloadContext;
@@ -67,8 +69,6 @@ public:
   const Time& getRegisteredTime() const { return registeredTime; }
 };
 
-typedef std::deque<HaveEntry> Haves;
-
 class DefaultPieceStorage : public PieceStorage {
 private:
   SharedHandle<DownloadContext> downloadContext;
@@ -80,7 +80,7 @@ private:
   size_t endGamePieceNum;
   Logger* logger;
   const Option* option;
-  Haves haves;
+  std::deque<HaveEntry> haves;
 
   SharedHandle<PieceStatMan> _pieceStatMan;
 
@@ -126,10 +126,10 @@ public:
   virtual SharedHandle<Piece> getMissingFastPiece(const SharedHandle<Peer>& peer);
 
   virtual SharedHandle<Piece> getMissingPiece
-  (const SharedHandle<Peer>& peer, const std::deque<size_t>& excludedIndexes);
+  (const SharedHandle<Peer>& peer, const std::vector<size_t>& excludedIndexes);
 
   virtual SharedHandle<Piece> getMissingFastPiece
-  (const SharedHandle<Peer>& peer, const std::deque<size_t>& excludedIndexes);
+  (const SharedHandle<Peer>& peer, const std::vector<size_t>& excludedIndexes);
 
 #endif // ENABLE_BITTORRENT
 
@@ -194,7 +194,7 @@ public:
   virtual void advertisePiece(int32_t cuid, size_t index);
 
   virtual void
-  getAdvertisedPieceIndexes(std::deque<size_t>& indexes,
+  getAdvertisedPieceIndexes(std::vector<size_t>& indexes,
                             int32_t myCuid, const Time& lastCheckTime);
 
   virtual void removeAdvertisedPiece(time_t elapsed);
@@ -205,11 +205,13 @@ public:
 
   virtual void markPieceMissing(size_t index);
 
-  virtual void addInFlightPiece(const std::deque<SharedHandle<Piece> >& pieces);
+  virtual void addInFlightPiece
+  (const std::vector<SharedHandle<Piece> >& pieces);
 
   virtual size_t countInFlightPiece();
 
-  virtual void getInFlightPieces(std::deque<SharedHandle<Piece> >& pieces);
+  virtual void getInFlightPieces
+  (std::vector<SharedHandle<Piece> >& pieces);
 
   virtual void addPieceStats(size_t index);
 

src/DownloadCommand.cc

@@ -67,7 +67,7 @@ namespace aria2 {
 static const size_t BUFSIZE = 16*1024;
 
 DownloadCommand::DownloadCommand(int cuid,
-                                 const RequestHandle& req,
+                                 const SharedHandle<Request>& req,
                                  const SharedHandle<FileEntry>& fileEntry,
                                  RequestGroup* requestGroup,
                                  DownloadEngine* e,
@@ -112,7 +112,7 @@ bool DownloadCommand::executeInternal() {
     return false;
   }
   setReadCheckSocket(socket);
-  SegmentHandle segment = _segments.front();
+  SharedHandle<Segment> segment = _segments.front();
 
   size_t bufSize;
   if(segment->getLength() > 0) {
@@ -279,7 +279,8 @@ bool DownloadCommand::prepareForNextSegment() {
       }
     }
 #ifdef ENABLE_MESSAGE_DIGEST
-    CheckIntegrityEntryHandle entry(new ChecksumCheckIntegrityEntry(_requestGroup));
+    SharedHandle<CheckIntegrityEntry> entry
+      (new ChecksumCheckIntegrityEntry(_requestGroup));
     if(entry->isValidationReady()) {
       entry->initValidator();
       // TODO do we need cuttrailinggarbage here?
@@ -293,11 +294,11 @@ bool DownloadCommand::prepareForNextSegment() {
     // The number of segments should be 1 in order to pass through the next
     // segment.
     if(_segments.size() == 1) {
-      SegmentHandle tempSegment = _segments.front();
+      SharedHandle<Segment> tempSegment = _segments.front();
       if(!tempSegment->complete()) {
         return prepareForRetry(0);
       }
-      SegmentHandle nextSegment =
+      SharedHandle<Segment> nextSegment =
         _requestGroup->getSegmentMan()->getSegment(cuid,
                                                    tempSegment->getIndex()+1);
       if(!nextSegment.isNull() && nextSegment->getWrittenLength() == 0) {

src/DownloadContext.cc

@@ -120,7 +120,7 @@ void DownloadContext::setFilePathWithIndex
 
 void DownloadContext::setFileFilter(IntSequence seq)
 {
-  std::deque<int32_t> fileIndexes = seq.flush();
+  std::vector<int32_t> fileIndexes = seq.flush();
   std::sort(fileIndexes.begin(), fileIndexes.end());
   fileIndexes.erase(std::unique(fileIndexes.begin(), fileIndexes.end()),
                     fileIndexes.end());

src/DownloadEngine.cc

@@ -237,7 +237,7 @@ void DownloadEngine::setStatCalc(const StatCalcHandle& statCalc)
   _statCalc = statCalc;
 }
 
-void DownloadEngine::addCommand(const Commands& commands)
+void DownloadEngine::addCommand(const std::vector<Command*>& commands)
 {
   this->commands.insert(this->commands.end(), commands.begin(), commands.end());
 }
@@ -398,10 +398,10 @@ DownloadEngine::popPooledSocket(std::map<std::string, std::string>& options,
 
 SharedHandle<SocketCore>
 DownloadEngine::popPooledSocket
-(const std::deque<std::string>& ipaddrs, uint16_t port)
+(const std::vector<std::string>& ipaddrs, uint16_t port)
 {
   SharedHandle<SocketCore> s;
-  for(std::deque<std::string>::const_iterator i = ipaddrs.begin();
+  for(std::vector<std::string>::const_iterator i = ipaddrs.begin();
       i != ipaddrs.end(); ++i) {
     s = popPooledSocket(*i, port);
     if(!s.isNull()) {
@@ -414,10 +414,10 @@ DownloadEngine::popPooledSocket
 SharedHandle<SocketCore>
 DownloadEngine::popPooledSocket
 (std::map<std::string, std::string>& options,
- const std::deque<std::string>& ipaddrs, uint16_t port)
+ const std::vector<std::string>& ipaddrs, uint16_t port)
 {
   SharedHandle<SocketCore> s;
-  for(std::deque<std::string>::const_iterator i = ipaddrs.begin();
+  for(std::vector<std::string>::const_iterator i = ipaddrs.begin();
       i != ipaddrs.end(); ++i) {
     s = popPooledSocket(options, *i, port);
     if(!s.isNull()) {

src/DownloadEngine.h

@@ -40,6 +40,7 @@
 #include <string>
 #include <deque>
 #include <map>
+#include <vector>
 
 #include "SharedHandle.h"
 #include "a2netcompat.h"
@@ -184,7 +185,7 @@ public:
                                Command* command);
 #endif // ENABLE_ASYNC_DNS
 
-  void addCommand(const std::deque<Command*>& commands);
+  void addCommand(const std::vector<Command*>& commands);
 
   void setStatCalc(const SharedHandle<StatCalc>& statCalc);
 
@@ -228,12 +229,12 @@ public:
    uint16_t port);
 
   SharedHandle<SocketCore>
-  popPooledSocket(const std::deque<std::string>& ipaddrs, uint16_t port);
+  popPooledSocket(const std::vector<std::string>& ipaddrs, uint16_t port);
 
   SharedHandle<SocketCore>
   popPooledSocket
   (std::map<std::string, std::string>& options,
-   const std::deque<std::string>& ipaddrs,
+   const std::vector<std::string>& ipaddrs,
    uint16_t port);
 
   const SharedHandle<CookieStorage>& getCookieStorage() const