AnnounceList, AnnounceTier: Code cleanup using C++11 features

src/AnnounceList.cc

@@ -45,13 +45,13 @@ namespace aria2 {
 AnnounceList::AnnounceList():currentTrackerInitialized_(false) {}
 
 AnnounceList::AnnounceList
-(const std::vector<std::vector<std::string> >& announceList):
+(const std::vector<std::vector<std::string>>& announceList):
   currentTrackerInitialized_(false) {
   reconfigure(announceList);
 }
 
 AnnounceList::AnnounceList
-(const std::deque<std::shared_ptr<AnnounceTier> >& announceTiers):
+(const std::deque<std::shared_ptr<AnnounceTier>>& announceTiers):
   tiers_(announceTiers), currentTrackerInitialized_(false)  {
   resetIterator();
 }
@@ -59,31 +59,31 @@ AnnounceList::AnnounceList
 AnnounceList::~AnnounceList() {}
 
 void AnnounceList::reconfigure
-(const std::vector<std::vector<std::string> >& announceList)
+(const std::vector<std::vector<std::string>>& announceList)
 {
   for (const auto& vec: announceList) {
     if(vec.empty()) {
       continue;
     }
-    std::deque<std::string> urls(vec.begin(), vec.end());
+
-    std::shared_ptr<AnnounceTier> tier(new AnnounceTier(urls));
+    std::deque<std::string> uris(std::begin(vec), std::end(vec));
-    tiers_.push_back(tier);
+    auto tier =
+      std::make_shared<AnnounceTier>(std::move(uris));
+    tiers_.push_back(std::move(tier));
   }
   resetIterator();
 }
 
 void AnnounceList::reconfigure(const std::string& url) {
-  std::deque<std::string> urls;
+  std::deque<std::string> urls{ url };
-  urls.push_back(url);
+  tiers_.push_back(std::make_shared<AnnounceTier>(std::move(urls)));
-  std::shared_ptr<AnnounceTier> tier(new AnnounceTier(urls));
-  tiers_.push_back(tier);
   resetIterator();
 }
 
 void AnnounceList::resetIterator() {
-  currentTier_ = tiers_.begin();
+  currentTier_ = std::begin(tiers_);
-  if(currentTier_ != tiers_.end() && (*currentTier_)->urls.size()) {
+  if(currentTier_ != std::end(tiers_) && (*currentTier_)->urls.size()) {
-    currentTracker_ = (*currentTier_)->urls.begin();
+    currentTracker_ = std::begin((*currentTier_)->urls);
     currentTrackerInitialized_ = true;
   } else {
     currentTrackerInitialized_ = false;
@@ -101,25 +101,25 @@ std::string AnnounceList::getAnnounce() const {
 void AnnounceList::announceSuccess() {
   if(currentTrackerInitialized_) {
     (*currentTier_)->nextEvent();
-    std::string url = *currentTracker_;
+    auto url = *currentTracker_;
     (*currentTier_)->urls.erase(currentTracker_);
-    (*currentTier_)->urls.push_front(url);
+    (*currentTier_)->urls.push_front(std::move(url));
-    currentTier_ = tiers_.begin();
+    currentTier_ = std::begin(tiers_);
-    currentTracker_ = (*currentTier_)->urls.begin();
+    currentTracker_ = std::begin((*currentTier_)->urls);
   }
 }
 
 void AnnounceList::announceFailure() {
   if(currentTrackerInitialized_) {
     ++currentTracker_;
-    if(currentTracker_ == (*currentTier_)->urls.end()) {
+    if(currentTracker_ == std::end((*currentTier_)->urls)) {
       // force next event
       (*currentTier_)->nextEventIfAfterStarted();
       ++currentTier_;
-      if(currentTier_ == tiers_.end()) {
+      if(currentTier_ == std::end(tiers_)) {
         currentTrackerInitialized_ = false;
       } else {
-        currentTracker_ = (*currentTier_)->urls.begin();
+        currentTracker_ = std::begin((*currentTier_)->urls);
       }
     }
   }
@@ -190,46 +190,46 @@ public:
 } // namespace
 
 size_t AnnounceList::countStoppedAllowedTier() const {
-  return count_if(tiers_.begin(), tiers_.end(), FindStoppedAllowedTier());
+  return count_if(std::begin(tiers_), std::end(tiers_),
+                  FindStoppedAllowedTier());
 }
 
 size_t AnnounceList::countCompletedAllowedTier() const {
-  return count_if(tiers_.begin(), tiers_.end(), FindCompletedAllowedTier());
+  return count_if(std::begin(tiers_), std::end(tiers_),
+                  FindCompletedAllowedTier());
 }
 
 void AnnounceList::setCurrentTier
-(const std::deque<std::shared_ptr<AnnounceTier> >::iterator& itr) {
+(std::deque<std::shared_ptr<AnnounceTier>>::iterator itr) {
-  if(itr != tiers_.end()) {
+  if(itr != std::end(tiers_)) {
-    currentTier_ = itr;
+    currentTier_ = std::move(itr);
-    currentTracker_ = (*currentTier_)->urls.begin();
+    currentTracker_ = std::begin((*currentTier_)->urls);
   }
 }
 
 void AnnounceList::moveToStoppedAllowedTier() {
-  auto itr = find_wrap_if(tiers_.begin(), tiers_.end(), currentTier_,
+  auto itr = find_wrap_if(std::begin(tiers_), std::end(tiers_), currentTier_,
                           FindStoppedAllowedTier());
-  setCurrentTier(itr);
+  setCurrentTier(std::move(itr));
 }
 
 void AnnounceList::moveToCompletedAllowedTier() {
-  auto itr =
+  auto itr = find_wrap_if(std::begin(tiers_), std::end(tiers_), currentTier_,
-    find_wrap_if(tiers_.begin(), tiers_.end(),
-                 currentTier_,
                           FindCompletedAllowedTier());
-  setCurrentTier(itr);
+  setCurrentTier(std::move(itr));
 }
 
 void AnnounceList::shuffle() {
   for (const auto& tier: tiers_) {
     auto& urls = tier->urls;
-    std::random_shuffle(urls.begin(), urls.end(),
+    std::random_shuffle(std::begin(urls), std::end(urls),
                         *SimpleRandomizer::getInstance());
   }
 }
 
 bool AnnounceList::allTiersFailed() const
 {
-  return currentTier_ == tiers_.end();
+  return currentTier_ == std::end(tiers_);
 }
 
 void AnnounceList::resetTier()
@@ -241,18 +241,18 @@ bool AnnounceList::currentTierAcceptsStoppedEvent() const
 {
   if(currentTrackerInitialized_) {
     return FindStoppedAllowedTier()(*currentTier_);
-  } else {
-    return false;
   }
+
+  return false;
 }
 
 bool AnnounceList::currentTierAcceptsCompletedEvent() const
 {
   if(currentTrackerInitialized_) {
     return FindCompletedAllowedTier()(*currentTier_);
-  } else {
-    return false;
   }
+
+  return false;
 }
 
 size_t AnnounceList::countTier() const

src/AnnounceList.h

@@ -50,25 +50,25 @@ namespace aria2 {
 class AnnounceList {
 public:
 private:
-  std::deque<std::shared_ptr<AnnounceTier> > tiers_;
+  std::deque<std::shared_ptr<AnnounceTier>> tiers_;
-  std::deque<std::shared_ptr<AnnounceTier> >::iterator currentTier_;
+  std::deque<std::shared_ptr<AnnounceTier>>::iterator currentTier_;
   std::deque<std::string>::iterator currentTracker_;
   bool currentTrackerInitialized_;
 
   void resetIterator();
   void setCurrentTier
-  (const std::deque<std::shared_ptr<AnnounceTier> >::iterator& itr);
+  (std::deque<std::shared_ptr<AnnounceTier>>::iterator itr);
 public:
   AnnounceList();
-  AnnounceList(const std::vector<std::vector<std::string> >& announceList);
+  AnnounceList(const std::vector<std::vector<std::string>>& announceList);
-  AnnounceList(const std::deque<std::shared_ptr<AnnounceTier> >& tiers);
+  AnnounceList(const std::deque<std::shared_ptr<AnnounceTier>>& tiers);
   ~AnnounceList();
 
   // Don't allow copying
-  AnnounceList(const AnnounceList&);
+  AnnounceList(const AnnounceList&) = delete;
-  AnnounceList& operator=(const AnnounceList&);
+  AnnounceList& operator=(const AnnounceList&) = delete;
 
-  void reconfigure(const std::vector<std::vector<std::string> >& announceList);
+  void reconfigure(const std::vector<std::vector<std::string>>& announceList);
   void reconfigure(const std::string& url);
 
   size_t countTier() const;

src/AnnounceTier.cc

@@ -36,8 +36,8 @@
 
 namespace aria2 {
 
-AnnounceTier::AnnounceTier(const std::deque<std::string>& urls)
+AnnounceTier::AnnounceTier(std::deque<std::string> urls)
-  : event(STARTED), urls(urls)
+  : event(STARTED), urls(std::move(urls))
 {}
 
 AnnounceTier::~AnnounceTier() {}

src/AnnounceTier.h

@@ -57,13 +57,13 @@ public:
   AnnounceEvent event;
   std::deque<std::string> urls;
 
-  AnnounceTier(const std::deque<std::string>& urls);
+  AnnounceTier(std::deque<std::string> urls);
 
   ~AnnounceTier();
 
   // Don't allow copying
-  AnnounceTier(const AnnounceTier&);
+  AnnounceTier(const AnnounceTier&) = delete;
-  AnnounceTier& operator=(const AnnounceTier&);
+  AnnounceTier& operator=(const AnnounceTier&) = delete;
 
   void nextEvent();