Database: Switch the natural order from newest inclusion to oldest

The inclusion database for the user always starts with the most recent
entry. It is now the same way in the code as well.

src/Database.cpp

@@ -39,14 +39,17 @@ Database::iterator::iterator (files_iterator fbegin, files_iterator fend) :
           files_it(fbegin),
           files_end(fend)
 {
-    if (files_end != files_it) {
+    if (files_end != files_it)
+    {
       auto &lines = files_it->allLines ();
-      lines_it = lines.begin ();
+      lines_it = lines.rbegin ();
-      lines_end = lines.end ();
+      lines_end = lines.rend ();
       while ((lines_it == lines_end) && (files_it != files_end))
+      {
         ++files_it;
       }
     }
+}
 
 ////////////////////////////////////////////////////////////////////////////////
 Database::iterator& Database::iterator::operator++()
@@ -66,8 +69,8 @@ Database::iterator& Database::iterator::operator++()
         if (files_it != files_end)
         {
           auto& lines = files_it->allLines ();
-          lines_it = lines.begin ();
+          lines_it = lines.rbegin ();
-          lines_end = lines.end ();
+          lines_end = lines.rend ();
         }
       }
     }
@@ -114,12 +117,14 @@ Database::reverse_iterator::reverse_iterator (files_iterator fbegin,
 {
     if (files_end != files_it)
     {
-      lines_it = files_it->allLines ().rbegin ();
+      lines_it = files_it->allLines ().begin ();
-      lines_end = files_it->allLines ().rend ();
+      lines_end = files_it->allLines ().end ();
       while ((lines_it == lines_end) && (files_it != files_end))
+      {
         ++files_it;
       }
     }
+}
 
 ////////////////////////////////////////////////////////////////////////////////
 Database::reverse_iterator& Database::reverse_iterator::operator++()
@@ -138,8 +143,8 @@ Database::reverse_iterator& Database::reverse_iterator::operator++()
         ++files_it;
         if (files_it != files_end)
         {
-          lines_it = files_it->allLines ().rbegin ();
+          lines_it = files_it->allLines ().begin ();
-          lines_end = files_it->allLines ().rend ();
+          lines_end = files_it->allLines ().end ();
         }
       }
     }
@@ -187,13 +192,18 @@ Database::iterator Database::begin ()
     initializeDatafiles ();
   }
 
-  return iterator(_files.begin (), _files.end ());
+  return iterator (_files.rbegin (), _files.rend ());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 Database::iterator Database::end ()
 {
-  return iterator (_files.end (), _files.end ());
+  if (_files.empty ())
+  {
+    initializeDatafiles ();
+  }
+
+  return iterator (_files.rend (), _files.rend ());
 }
 
 
@@ -205,7 +215,7 @@ Database::reverse_iterator Database::rbegin ()
     initializeDatafiles ();
   }
 
-  return reverse_iterator (_files.rbegin (), _files.rend ());
+  return reverse_iterator(_files.begin (), _files.end ());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -216,7 +226,7 @@ Database::reverse_iterator Database::rend ()
     initializeDatafiles ();
   }
 
-  return reverse_iterator (_files.rend (), _files.rend ());
+  return reverse_iterator (_files.end (), _files.end ());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -251,15 +261,16 @@ std::vector <std::string> Database::files () const
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// Walk backwards through the files until an interval is found.
+// Return most recent line from database 
-std::string Database::lastLine ()
+std::string Database::firstLine ()
 {
-  auto it = rbegin ();
+  for (auto& line : *this)
-  auto end = rend ();
+  {
-
+    if (! line.empty ())
-  while (it != end)
+    {
-    if (! it->empty ())
+      return line;
-      return *it;
+    }
+  }
 
   return "";
 }
@@ -424,8 +435,8 @@ void Database::initializeTagDatabase ()
 
   if (!File::read (_location + "/tags.data", content))
   {
-    auto it = rbegin ();
+    auto it = Database::begin ();
-    auto end = rend ();
+    auto end = Database::end ();
     
     if (it == end)
       return;

src/Database.h

@@ -44,8 +44,8 @@ public:
   {
   private:
     friend class Database;
-    typedef std::vector <Datafile>::iterator files_iterator;
+    typedef std::vector <Datafile>::reverse_iterator files_iterator;
-    typedef std::vector <std::string>::const_iterator lines_iterator;
+    typedef std::vector <std::string>::const_reverse_iterator lines_iterator;
     typedef std::string value_type;
 
     files_iterator files_it;
@@ -70,8 +70,8 @@ public:
   {
   private:
     friend class Database;
-    typedef std::vector <Datafile>::reverse_iterator files_iterator;
+    typedef std::vector <Datafile>::iterator files_iterator;
-    typedef std::vector <std::string>::const_reverse_iterator lines_iterator;
+    typedef std::vector <std::string>::const_iterator lines_iterator;
     typedef std::string value_type;
 
     files_iterator files_it;
@@ -98,7 +98,7 @@ public:
   void commit ();
   std::vector <std::string> files () const;
 
-  std::string lastLine ();
+  std::string firstLine ();
 
   void addInterval (const Interval&, bool verbose);
   void deleteInterval (const Interval&);

src/data.cpp

@@ -315,10 +315,11 @@ std::vector <Range> getAllExclusions (
 std::vector <Interval> getAllInclusions (Database& database)
 {
   std::vector <Interval> all;
-  for (auto& line : database)
+  auto it = database.rbegin ();
+  auto end = database.rend ();
+  for ( ;it != end; ++it)
   {
-    Interval i = IntervalFactory::fromSerialization (line);
+    all.push_back (IntervalFactory::fromSerialization (*it));
-    all.push_back (i);
   }
 
   return all;
@@ -572,8 +573,8 @@ std::vector <Interval> getTracked (
   // Avoid assigning a zero-width range - leave it unstarted instead.
   if (! filter.is_started ())
   {
-    auto begin = database.begin ();
+    auto begin = database.rbegin ();
-    auto end = database.end ();
+    auto end = database.rend ();
     if (begin != end) 
     {
       filter.start = IntervalFactory::fromSerialization (*begin).start;
@@ -588,11 +589,9 @@ std::vector <Interval> getTracked (
   int id_skip = 0;
   std::deque <Interval> intervals;
 
-  auto it = database.rbegin ();
+  for (auto& line : database)
-  auto end = database.rend ();
-  for (; it != end; ++it)
   {
-    Interval interval = IntervalFactory::fromSerialization(*it);
+    Interval interval = IntervalFactory::fromSerialization(line);
 
     // Since we are moving backwards, and the intervals are in sorted order,
     // if the filter is after the interval, we know there will be no more
@@ -668,9 +667,9 @@ std::vector <Range> getUntracked (
 Interval getLatestInterval (Database& database)
 {
   Interval i;
-  auto lastLine = database.lastLine ();
+  auto firstLine = database.firstLine ();
-  if (! lastLine.empty ())
+  if (! firstLine.empty ())
-    i = IntervalFactory::fromSerialization (lastLine);
+    i = IntervalFactory::fromSerialization (firstLine);
 
   return i;
 }

src/helper.cpp

@@ -87,11 +87,9 @@ std::string intervalSummarize (
     // acceptable definition of "the current task".
     time_t total_recorded = 0;
 
-    auto i = database.rbegin ();
+    for (auto& line : database)
-    auto end = database.rend ();
-    for (; i != end; ++i)
     {
-      Interval current = IntervalFactory::fromSerialization (*i);
+      Interval current = IntervalFactory::fromSerialization (line);
       if (interval.tags () == current.tags ())
         total_recorded += current.total ();
       else