GpsTrackPoint declaration

map/gps_track_container.cpp

@@ -29,7 +29,7 @@ void GpsTrackContainer::SetDuration(hours duration)
   RemoveOldPoints(removed);
 
   if (m_callback && !removed.empty())
-    m_callback(vector<df::GpsTrackPoint>(), move(removed));
+    m_callback(vector<GpsTrackPoint>(), move(removed));
 }
 
 hours GpsTrackContainer::GetDuration() const
@@ -49,7 +49,7 @@ void GpsTrackContainer::SetMaxSize(size_t maxSize)
   RemoveOldPoints(removed);
 
   if (m_callback && !removed.empty())
-    m_callback(vector<df::GpsTrackPoint>(), move(removed));
+    m_callback(vector<GpsTrackPoint>(), move(removed));
 }
 
 size_t GpsTrackContainer::GetMaxSize() const
@@ -68,7 +68,7 @@ void GpsTrackContainer::SetCallback(TGpsTrackDiffCallback callback, bool sendAll
   if (!m_callback || !sendAll || m_points.empty())
     return;
 
-  vector<df::GpsTrackPoint> added;
+  vector<GpsTrackPoint> added;
   CopyPoints(added);
 
   m_callback(move(added), vector<uint32_t>());
@@ -86,15 +86,16 @@ uint32_t GpsTrackContainer::AddPoint(m2::PointD const & point, double speedMPS,
     return kInvalidId;
   }
 
-  df::GpsTrackPoint gtp;
+  GpsTrackPoint gtp;
   gtp.m_timestamp = timestamp;
   gtp.m_point = point;
   gtp.m_speedMPS = speedMPS;
-  gtp.m_id = ++m_counter;
+  gtp.m_id = m_counter;
 
   m_points.push_back(gtp);
+  ++m_counter;
 
-  vector<df::GpsTrackPoint> added;
+  vector<GpsTrackPoint> added;
   added.emplace_back(gtp);
 
   vector<uint32_t> removed;
@@ -106,7 +107,7 @@ uint32_t GpsTrackContainer::AddPoint(m2::PointD const & point, double speedMPS,
   return gtp.m_id;
 }
 
-void GpsTrackContainer::GetPoints(vector<df::GpsTrackPoint> & points) const
+void GpsTrackContainer::GetPoints(vector<GpsTrackPoint> & points) const
 {
   lock_guard<mutex> lg(m_guard);
 
@@ -122,15 +123,15 @@ void GpsTrackContainer::Clear()
   if (m_callback)
   {
     removed.reserve(m_points.size());
-    for_each(m_points.begin(), m_points.end(), [&](df::GpsTrackPoint const & pt){ removed.emplace_back(pt.m_id); });
+    for_each(m_points.begin(), m_points.end(), [&](GpsTrackPoint const & pt){ removed.emplace_back(pt.m_id); });
   }
 
   // We do not use 'clear' because it does not guarantee memory cleaning,
   // Instead, we use move from an empty queue
-  m_points = deque<df::GpsTrackPoint>();
+  m_points = deque<GpsTrackPoint>();
 
   if (m_callback && !removed.empty())
-    m_callback(vector<df::GpsTrackPoint>(), move(removed));
+    m_callback(vector<GpsTrackPoint>(), move(removed));
 }
 
 void GpsTrackContainer::RemoveOldPoints(vector<uint32_t> & removedIds)
@@ -144,11 +145,11 @@ void GpsTrackContainer::RemoveOldPoints(vector<uint32_t> & removedIds)
 
   if (m_points.front().m_timestamp < lowerBorder)
   {
-    df::GpsTrackPoint pt;
+    GpsTrackPoint pt;
     pt.m_timestamp = lowerBorder;
 
     auto const itr = lower_bound(m_points.begin(), m_points.end(), pt,
-                                 [](df::GpsTrackPoint const & a, df::GpsTrackPoint const & b) -> bool
+                                 [](GpsTrackPoint const & a, GpsTrackPoint const & b) -> bool
     {
         return a.m_timestamp < b.m_timestamp;
     });
@@ -175,9 +176,9 @@ void GpsTrackContainer::RemoveOldPoints(vector<uint32_t> & removedIds)
   }
 }
 
-void GpsTrackContainer::CopyPoints(vector<df::GpsTrackPoint> & points) const
+void GpsTrackContainer::CopyPoints(vector<GpsTrackPoint> & points) const
 {
   // Must be called under m_guard lock
 
-  points = vector<df::GpsTrackPoint>(m_points.begin(), m_points.end());
+  points = vector<GpsTrackPoint>(m_points.begin(), m_points.end());
 }

map/gps_track_container.hpp

@@ -1,5 +1,9 @@
 #pragma once
 
+// NOTE!
+// Temporary, to avoid cyclic dependencies between map and drape projects,
+// we declared GpsTrackPoint in the drape project.
+// Ideally, drape must use declaration GpsTrackPoint, instead of declaring it there.
 #include "drape_frontend/gps_track_point.hpp"
 
 #include "std/chrono.hpp"
@@ -10,6 +14,24 @@
 class GpsTrackContainer final
 {
 public:
+  using GpsTrackPoint = df::GpsTrackPoint;
+  // See note above
+  /*
+  struct GpsTrackPoint
+  {
+    // Timestamp of the point, seconds from 1st Jan 1970
+    double m_timestamp;
+
+    // Point in the Mercator projection
+    m2::PointD m_point;
+
+    // Speed in the point, M/S
+    double m_speedMPS;
+
+    // Unique identifier of the point
+    uint32_t m_id;
+  };
+  */
 
   static uint32_t constexpr kInvalidId = numeric_limits<uint32_t>::max();
 
@@ -17,7 +39,7 @@ public:
   /// @param toAdd - collection of points to add.
   /// @param toRemove - collection of point indices to remove.
   /// @note Calling of a GpsTrackContainer's function from the callback causes deadlock.
-  using TGpsTrackDiffCallback = std::function<void(vector<df::GpsTrackPoint> && toAdd, vector<uint32_t> && toRemove)>;
+  using TGpsTrackDiffCallback = std::function<void(vector<GpsTrackPoint> && toAdd, vector<uint32_t> && toRemove)>;
 
   GpsTrackContainer();
 
@@ -56,7 +78,7 @@ public:
 
   /// Returns points snapshot from the container.
   /// @param points - output for collection of points.
-  void GetPoints(vector<df::GpsTrackPoint> & points) const;
+  void GetPoints(vector<GpsTrackPoint> & points) const;
 
   /// Clears collection of point in the track.
   /// @note Callback is called with 'toRemove' points, if need.
@@ -64,7 +86,7 @@ public:
 
 private:
   void RemoveOldPoints(vector<uint32_t> & removedIds);
-  void CopyPoints(vector<df::GpsTrackPoint> & points) const;
+  void CopyPoints(vector<GpsTrackPoint> & points) const;
 
   mutable mutex m_guard;
 
@@ -78,7 +100,7 @@ private:
 
   // Collection of points, by nature is asc. sorted by m_timestamp.
   // Max size of m_points is adjusted by m_trackDuration and m_maxSize.
-  deque<df::GpsTrackPoint> m_points;
+  deque<GpsTrackPoint> m_points;
 
   // Simple counter which is used to generate point unique ids.
   uint32_t m_counter;