Use std::shuffle, instead of std::random_shuffle

src/AnnounceList.cc

@@ -222,8 +222,8 @@ void AnnounceList::moveToCompletedAllowedTier() {
 void AnnounceList::shuffle() {
   for (const auto& tier: tiers_) {
     auto& urls = tier->urls;
-    std::random_shuffle(std::begin(urls), std::end(urls),
+    std::shuffle(std::begin(urls), std::end(urls),
-                        *SimpleRandomizer::getInstance());
+                 *SimpleRandomizer::getInstance());
   }
 }
 

src/BtDependency.cc

@@ -120,8 +120,8 @@ bool BtDependency::resolve()
         context->getFileEntries();
       for (auto &fe : fileEntries) {
         auto &uri = fe->getRemainingUris();
-        std::random_shuffle(std::begin(uri), std::end(uri),
+        std::shuffle(std::begin(uri), std::end(uri),
-                            *SimpleRandomizer::getInstance());
+                     *SimpleRandomizer::getInstance());
       }
       const std::vector<std::shared_ptr<FileEntry> >& dependantFileEntries =
         dependant_->getDownloadContext()->getFileEntries();

src/BtLeecherStateChoke.cc

@@ -152,8 +152,7 @@ void BtLeecherStateChoke::plannedOptimisticUnchoke
   auto i = std::partition(peerEntries.begin(), peerEntries.end(),
                           PeerFilter(true, true));
   if(i != peerEntries.begin()) {
-    std::random_shuffle(peerEntries.begin(), i,
+    std::shuffle(peerEntries.begin(), i, *SimpleRandomizer::getInstance());
-                        *SimpleRandomizer::getInstance());
     (*peerEntries.begin()).enableOptUnchoking();
     A2_LOG_INFO(fmt("POU: %s",
                     (*peerEntries.begin()).getPeer()->getIPAddress().c_str()));
@@ -183,8 +182,7 @@ void BtLeecherStateChoke::regularUnchoke(std::vector<PeerEntry>& peerEntries)
     }
   }
   if(fastOptUnchoker) {
-    std::random_shuffle(peerIter, peerEntries.end(),
+    std::shuffle(peerIter, peerEntries.end(), *SimpleRandomizer::getInstance());
-                        *SimpleRandomizer::getInstance());
     for (auto& p : peerEntries) {
       if(p.getPeer()->peerInterested()) {
         p.enableOptUnchoking();

src/BtSeederStateChoke.cc

@@ -141,8 +141,7 @@ void BtSeederStateChoke::unchoke
     std::for_each(peers.begin(), peers.end(),
                   std::mem_fn(&PeerEntry::disableOptUnchoking));
     if(r != peers.end()) {
-      std::random_shuffle(r, peers.end(),
+      std::shuffle(r, peers.end(), *SimpleRandomizer::getInstance());
-                          *SimpleRandomizer::getInstance());
       (*r).getPeer()->optUnchoking(true);
       A2_LOG_INFO(fmt("POU: %s", (*r).getPeer()->getIPAddress().c_str()));
     }

src/DHTConnectionImpl.cc

@@ -61,8 +61,7 @@ bool DHTConnectionImpl::bind
   while(sgl.hasNext()) {
     ports.push_back(sgl.next());
   }
-  std::random_shuffle(ports.begin(), ports.end(),
+  std::shuffle(ports.begin(), ports.end(), *SimpleRandomizer::getInstance());
-                      *SimpleRandomizer::getInstance());
   for (const auto& p : ports) {
     port = p;
     if(bind(port, addr)) {

src/DefaultBtRequestFactory.cc

@@ -211,9 +211,8 @@ DefaultBtRequestFactory::createRequestMessagesOnEndGame(size_t max)
         }
       }
     }
-    std::random_shuffle(std::begin(missingBlockIndexes),
+    std::shuffle(std::begin(missingBlockIndexes), std::end(missingBlockIndexes),
-                        std::end(missingBlockIndexes),
+                 *SimpleRandomizer::getInstance());
-                        *SimpleRandomizer::getInstance());
     for(auto bitr = std::begin(missingBlockIndexes),
           eoi2 = std::end(missingBlockIndexes);
         bitr != eoi2 && requests.size() < max; ++bitr) {

src/DefaultPieceStorage.cc

@@ -67,6 +67,7 @@
 #include "Notifier.h"
 #include "WrDiskCache.h"
 #include "RequestGroup.h"
+#include "SimpleRandomizer.h"
 #ifdef ENABLE_BITTORRENT
 # include "bittorrent_helper.h"
 #endif // ENABLE_BITTORRENT
@@ -201,7 +202,8 @@ void DefaultPieceStorage::getMissingPiece
         indexes.push_back(i);
       }
     }
-    std::random_shuffle(indexes.begin(), indexes.end());
+    std::shuffle(indexes.begin(), indexes.end(),
+                 *SimpleRandomizer::getInstance());
     for(std::vector<size_t>::const_iterator i = indexes.begin(),
           eoi = indexes.end(); i != eoi && misBlock < minMissingBlocks; ++i) {
       std::shared_ptr<Piece> piece = checkOutPiece(*i, cuid);

src/MetalinkEntry.cc

@@ -98,8 +98,8 @@ public:
 } // namespace
 
 void MetalinkEntry::reorderResourcesByPriority() {
-  std::random_shuffle(std::begin(resources), std::end(resources),
+  std::shuffle(std::begin(resources), std::end(resources),
-                      *SimpleRandomizer::getInstance());
+               *SimpleRandomizer::getInstance());
   std::sort(std::begin(resources), std::end(resources),
             PriorityHigher<std::unique_ptr<MetalinkResource>>{});
 }

src/PeerListenCommand.cc

@@ -70,8 +70,7 @@ bool PeerListenCommand::bindPort(uint16_t& port, SegList<int>& sgl)
   while(sgl.hasNext()) {
     ports.push_back(sgl.next());
   }
-  std::random_shuffle(ports.begin(), ports.end(),
+  std::shuffle(ports.begin(), ports.end(), *SimpleRandomizer::getInstance());
-                      *SimpleRandomizer::getInstance());
   const int ipv = (family_ == AF_INET) ? 4 : 6;
   for(std::vector<uint16_t>::const_iterator i = ports.begin(),
         eoi = ports.end(); i != eoi; ++i) {

src/PieceStatMan.cc

@@ -51,8 +51,8 @@ PieceStatMan::PieceStatMan(size_t pieceNum, bool randomShuffle):
   }
   // we need some randomness in ordering.
   if(randomShuffle) {
-    std::random_shuffle(order_.begin(), order_.end(),
+    std::shuffle(order_.begin(), order_.end(),
-                        *SimpleRandomizer::getInstance());
+                 *SimpleRandomizer::getInstance());
   }
 }
 

src/RequestGroup.cc

@@ -565,8 +565,8 @@ void RequestGroup::initPieceStorage()
                                         downloadContext_->getFileEntries(),
                                         downloadContext_->getPieceLength());
         if (!result.empty()) {
-          std::random_shuffle(std::begin(result), std::end(result),
+          std::shuffle(std::begin(result), std::end(result),
-                              *SimpleRandomizer::getInstance());
+                       *SimpleRandomizer::getInstance());
           auto priSelector = make_unique<PriorityPieceSelector>
             (ps->popPieceSelector());
           priSelector->setPriorityPiece(std::begin(result), std::end(result));

src/download_helper.cc

@@ -200,8 +200,8 @@ createBtRequestGroup(const std::string& metaInfoUri,
                              metaInfoUri.empty() ? "default" : metaInfoUri);
   for (auto &fe : dctx->getFileEntries()) {
     auto &uris = fe->getRemainingUris();
-    std::random_shuffle(std::begin(uris), std::end(uris),
+    std::shuffle(std::begin(uris), std::end(uris),
-                        *SimpleRandomizer::getInstance());
+                 *SimpleRandomizer::getInstance());
   }
   if(metaInfoUri.empty()) {
     rg->setMetadataInfo(createMetadataInfoDataOnly());