cleanup

tools/replay/route.cc

@@ -21,6 +21,7 @@ RouteIdentifier Route::parseRoute(const std::string &str) {
   if (std::regex_match(str, match, pattern)) {
     identifier.dongle_id = match[2].str();
     identifier.timestamp = match[3].str();
+    identifier.date_time = strToTime(identifier.timestamp);
     identifier.str = identifier.dongle_id + "|" + identifier.timestamp;
 
     const auto separator = match[5].str();
@@ -43,33 +44,35 @@ RouteIdentifier Route::parseRoute(const std::string &str) {
 }
 
 bool Route::load() {
-  return auto_source_ ? loadFromAutoSource() : loadFromCommaApi();
-}
-
-bool Route::loadFromCommaApi() {
   route_ = parseRoute(route_string_);
   if (route_.str.empty() || (data_dir_.empty() && route_.dongle_id.empty())) {
     rInfo("invalid route format");
     return false;
   }
-  date_time_ = strToTime(route_.timestamp);
 
-  bool load_success = data_dir_.empty() ? loadFromServer() : loadFromLocal();
+  if (!loadSegments()) {
-  if (!load_success) {
+    rInfo("Failed to load segments");
-    rInfo("Failed to load route from %s", data_dir_.empty() ? "server" : "local");
     return false;
   }
 
-  if (route_.begin_segment == -1) route_.begin_segment = segments_.rbegin()->first;
+  return true;
-  if (route_.end_segment == -1) route_.end_segment = segments_.rbegin()->first;
+}
-  for (auto it = segments_.begin(); it != segments_.end(); /**/) {
+
-    if (it->first < route_.begin_segment || it->first > route_.end_segment) {
+bool Route::loadSegments() {
-      it = segments_.erase(it);
+  if (!auto_source_) {
-    } else {
+    bool ret = data_dir_.empty() ? loadFromServer() : loadFromLocal();
-      ++it;
+    if (ret) {
+      // Trim segments
+      if (route_.begin_segment > 0) {
+        segments_.erase(segments_.begin(), segments_.lower_bound(route_.begin_segment));
+      }
+      if (route_.end_segment >= 0) {
+        segments_.erase(segments_.upper_bound(route_.end_segment), segments_.end());
+      }
     }
+    return !segments_.empty();
   }
-  return true;
+  return loadFromAutoSource();
 }
 
 bool Route::loadFromAutoSource() {
@@ -86,21 +89,6 @@ bool Route::loadFromAutoSource() {
   for (int i = 0; i < log_files.size(); ++i) {
     addFileToSegment(i, log_files[i]);
   }
-  static const std::regex pattern(R"(([a-z0-9]{16})\|(\d{4}-\d{2}-\d{2}--\d{2}-\d{2}-\d{2}))");
-  std::smatch matches;
-  if (std::regex_search(route_string_, matches, pattern)) {
-    route_.str = matches[0];
-    route_.dongle_id = matches[1];
-    route_.timestamp = matches[2];
-    date_time_ = strToTime(route_.timestamp);
-  } else {
-    route_.dongle_id = route_string_;
-    route_.timestamp = route_string_;
-    route_.str = route_string_;
-  }
-  route_.begin_segment = 0;
-  route_.end_segment = log_files.size() - 1;
-
   return !segments_.empty();
 }
 

tools/replay/route.h

@@ -24,6 +24,7 @@ enum class RouteLoadError {
 struct RouteIdentifier {
   std::string dongle_id;
   std::string timestamp;
+  std::time_t date_time;
   int begin_segment = 0;
   int end_segment = -1;
   std::string str;
@@ -44,7 +45,7 @@ public:
   bool load();
   RouteLoadError lastError() const { return err_; }
   inline const std::string &name() const { return route_.str; }
-  inline const std::time_t datetime() const { return date_time_; }
+  inline const std::time_t datetime() const { return route_.date_time; }
   inline const std::string &dir() const { return data_dir_; }
   inline const RouteIdentifier &identifier() const { return route_; }
   inline const std::map<int, SegmentFile> &segments() const { return segments_; }
@@ -52,17 +53,16 @@ public:
   static RouteIdentifier parseRoute(const std::string &str);
 
 protected:
+  bool loadSegments();
   bool loadFromAutoSource();
-  bool loadFromCommaApi();
   bool loadFromLocal();
   bool loadFromServer(int retries = 3);
   bool loadFromJson(const std::string &json);
   void addFileToSegment(int seg_num, const std::string &file);
-  std::time_t strToTime(const std::string &timestamp);
+  static std::time_t strToTime(const std::string &timestamp);
   RouteIdentifier route_ = {};
   std::string data_dir_;
   std::map<int, SegmentFile> segments_;
-  std::time_t date_time_;
   RouteLoadError err_ = RouteLoadError::None;
   bool auto_source_ = false;
   std::string route_string_;