use std-algorithms instead of manual loops to avoid overflow warning

Reported-By: gcc
Understandable: no
Git-Dch: Ignore

diff --git a/apt-pkg/acquire-worker.cc b/apt-pkg/acquire-worker.cc
index 889768030f61ac576ae943fc21ed870d56ac5587..45ee6dde3eecdf4fb35ecab2c3352e64ff0f8080 100644 (file)
--- a/apt-pkg/acquire-worker.cc
+++ b/apt-pkg/acquire-worker.cc
@@ -254,8 +254,8 @@ bool pkgAcquire::Worker::RunMessages()
            ItemDone();
 
            // Change the status so that it can be dequeued
            ItemDone();
 
            // Change the status so that it can be dequeued

-           for (pkgAcquire::Queue::QItem::owner_iterator O = Itm->Owners.begin(); O != Itm->Owners.end(); ++O)
-              (*O)->Status = pkgAcquire::Item::StatIdle;
+           for (auto const &O: Itm->Owners)
+              O->Status = pkgAcquire::Item::StatIdle;

            // Mark the item as done (taking care of all queues)
            // and then put it in the main queue again
            std::vector<Item*> const ItmOwners = Itm->Owners;
            // Mark the item as done (taking care of all queues)
            // and then put it in the main queue again
            std::vector<Item*> const ItmOwners = Itm->Owners;

diff --git a/apt-pkg/acquire.cc b/apt-pkg/acquire.cc
index 6a800002e3de7ba8a6c4a2b1b3a50e3bc0af2472..a74f1c2f648697cef952f91a70a580313d827d06 100644 (file)
--- a/apt-pkg/acquire.cc
+++ b/apt-pkg/acquire.cc
@@ -24,6 +24,7 @@
 #include <apt-pkg/fileutl.h>
 
 #include <algorithm>
 #include <apt-pkg/fileutl.h>
 
 #include <algorithm>

+#include <numeric>

 #include <string>
 #include <vector>
 #include <iostream>
 #include <string>
 #include <vector>
 #include <iostream>


@@ -658,10 +659,10 @@ bool pkgAcquire::Clean(string Dir)
 /* This is the total number of bytes needed */
 APT_PURE unsigned long long pkgAcquire::TotalNeeded()
 {
 /* This is the total number of bytes needed */
 APT_PURE unsigned long long pkgAcquire::TotalNeeded()
 {

-   unsigned long long Total = 0;
-   for (ItemCIterator I = ItemsBegin(); I != ItemsEnd(); ++I)
-      Total += (*I)->FileSize;
-   return Total;
+   return std::accumulate(ItemsBegin(), ItemsEnd(), 0,
+      [](unsigned long long const T, Item const * const I) {
+        return T + I->FileSize;
+   });

 }
                                                                        /*}}}*/
 // Acquire::FetchNeeded - Number of bytes needed to get                        /*{{{*/
 }
                                                                        /*}}}*/
 // Acquire::FetchNeeded - Number of bytes needed to get                        /*{{{*/


@@ -669,11 +670,13 @@ APT_PURE unsigned long long pkgAcquire::TotalNeeded()
 /* This is the number of bytes that is not local */
 APT_PURE unsigned long long pkgAcquire::FetchNeeded()
 {
 /* This is the number of bytes that is not local */
 APT_PURE unsigned long long pkgAcquire::FetchNeeded()
 {

-   unsigned long long Total = 0;
-   for (ItemCIterator I = ItemsBegin(); I != ItemsEnd(); ++I)
-      if ((*I)->Local == false)
-        Total += (*I)->FileSize;
-   return Total;
+   return std::accumulate(ItemsBegin(), ItemsEnd(), 0,
+      [](unsigned long long const T, Item const * const I) {
+        if (I->Local == false)
+           return T + I->FileSize;
+        else
+           return T;
+   });

 }
                                                                        /*}}}*/
 // Acquire::PartialPresent - Number of partial bytes we already have   /*{{{*/
 }
                                                                        /*}}}*/
 // Acquire::PartialPresent - Number of partial bytes we already have   /*{{{*/


@@ -681,11 +684,13 @@ APT_PURE unsigned long long pkgAcquire::FetchNeeded()
 /* This is the number of bytes that is not local */
 APT_PURE unsigned long long pkgAcquire::PartialPresent()
 {
 /* This is the number of bytes that is not local */
 APT_PURE unsigned long long pkgAcquire::PartialPresent()
 {

-  unsigned long long Total = 0;
-   for (ItemCIterator I = ItemsBegin(); I != ItemsEnd(); ++I)
-      if ((*I)->Local == false)
-        Total += (*I)->PartialSize;
-   return Total;
+   return std::accumulate(ItemsBegin(), ItemsEnd(), 0,
+      [](unsigned long long const T, Item const * const I) {
+        if (I->Local == false)
+           return T + I->PartialSize;
+        else
+           return T;
+   });

 }
                                                                        /*}}}*/
 // Acquire::UriBegin - Start iterator for the uri list                 /*{{{*/
 }
                                                                        /*}}}*/
 // Acquire::UriBegin - Start iterator for the uri list                 /*{{{*/


@@ -909,8 +914,8 @@ bool pkgAcquire::Queue::Cycle()
         return true;
 
       I->Worker = Workers;
         return true;
 
       I->Worker = Workers;

-      for (QItem::owner_iterator O = I->Owners.begin(); O != I->Owners.end(); ++O)
-        (*O)->Status = pkgAcquire::Item::StatFetching;
+      for (auto const &O: I->Owners)
+        O->Status = pkgAcquire::Item::StatFetching;

       PipeDepth++;
       if (Workers->QueueItem(I) == false)
         return false;
       PipeDepth++;
       if (Workers->QueueItem(I) == false)
         return false;


@@ -962,11 +967,11 @@ HashStringList pkgAcquire::Queue::QItem::GetExpectedHashes() const        /*{{{*/
 APT_PURE unsigned long long pkgAcquire::Queue::QItem::GetMaximumSize() const   /*{{{*/
 {
    unsigned long long Maximum = std::numeric_limits<unsigned long long>::max();
 APT_PURE unsigned long long pkgAcquire::Queue::QItem::GetMaximumSize() const   /*{{{*/
 {
    unsigned long long Maximum = std::numeric_limits<unsigned long long>::max();

-   for (pkgAcquire::Queue::QItem::owner_iterator O = Owners.begin(); O != Owners.end(); ++O)
+   for (auto const &O: Owners)

    {
    {

-      if ((*O)->FileSize == 0)
+      if (O->FileSize == 0)

         continue;
         continue;

-      Maximum = std::min(Maximum, (*O)->FileSize);
+      Maximum = std::min(Maximum, O->FileSize);

    }
    if (Maximum == std::numeric_limits<unsigned long long>::max())
       return 0;
    }
    if (Maximum == std::numeric_limits<unsigned long long>::max())
       return 0;