added IndexedList container type

modules/planning/common/BUILD

@@ -16,14 +16,19 @@ cc_library(
 )
 
 cc_library(
-    name = "object_table",
-    srcs = [
-        "object_table.cc",
+    name = "indexed_list",
+    hdrs = [
+        "indexed_list.h",
     ],
+)
+
+cc_library(
+    name = "object_table",
     hdrs = [
         "object_table.h",
     ],
     deps = [
+        ":indexed_list",
         ":obstacle",
         ":planning_gflags",
     ],

modules/planning/common/object_table.cc → modules/planning/common/indexed_list.h

@@ -15,38 +15,42 @@
  *****************************************************************************/
 
 /**
- * @file object_table.cc
+ * @file indexed_list.h
  **/
 
-#include "modules/planning/common/object_table.h"
+#ifndef MODULES_PLANNING_COMMON_INDEXED_LIST_H_
+#define MODULES_PLANNING_COMMON_INDEXED_LIST_H_
 
 #include <memory>
-#include <utility>
-
-#include "modules/common/log.h"
+#include <unordered_map>
+#include <vector>
 
 namespace apollo {
 namespace planning {
 
-Obstacle* ObjectTable::get_obstacle(const uint32_t id) {
-  return get_obstacle(std::to_string(id));
-}
-
-Obstacle* ObjectTable::get_obstacle(const std::string& id) {
-  auto iter = _obstacle_cache.find(id);
-  if (iter != _obstacle_cache.end()) {
-    return iter->second.get();
-  } else {
-    AERROR << "Failed to find object " << id;
-    return nullptr;
+template <typename I, typename T>
+class IndexedList {
+ public:
+  void Add(const I id, std::unique_ptr<T> ptr) {
+    _object_list.push_back(ptr.get());
+    _object_dict[id] = std::move(ptr);
+  }
+  T* Find(const I id) {
+    auto iter = _object_dict.find(id);
+    if (iter == _object_dict.end()) {
+      return nullptr;
+    } else {
+      return iter->second.get();
+    }
   }
-}
+  const std::vector<T*>& Items() const { return _object_list; }
 
-void ObjectTable::add_obstacle(const Obstacle& obstacle) {
-  auto ptr = std::unique_ptr<Obstacle>();
-  *ptr = obstacle;
-  _obstacle_cache[ptr->Id()] = std::move(ptr);
-}
+ private:
+  std::vector<const T*> _object_list;
+  std::unordered_map<I, std::unique_ptr<T>> _object_dict;
+};
 
 }  // namespace planning
 }  // namespace apollo
+
+#endif  // MODULES_PLANNING_COMMON_INDEXED_LIST_H

modules/planning/common/object_table.h

@@ -25,22 +25,14 @@
 #include <string>
 #include <unordered_map>
 
+#include "modules/planning/common/indexed_list.h"
 #include "modules/planning/common/obstacle.h"
 #include "modules/planning/common/planning_gflags.h"
 
 namespace apollo {
 namespace planning {
 
-class ObjectTable {
- public:
-  ObjectTable() = default;
-  Obstacle* get_obstacle(const uint32_t id);
-  Obstacle* get_obstacle(const std::string& id);
-  void add_obstacle(const Obstacle& obstacle);
-
- private:
-  std::unordered_map<std::string, std::unique_ptr<Obstacle>> _obstacle_cache;
-};
+using ObjectTable = IndexedList<uint32_t, Obstacle>;
 
 }  // namespace planning
 }  // namespace apollo

modules/planning/optimizer/dp_st_speed/dp_st_graph.cc

@@ -300,8 +300,7 @@ Status DpStGraph::get_object_decision(const StGraphData& st_graph_data,
     CHECK_EQ(boundary_it->points().size(), 4);
 
     Obstacle* object_ptr =
-        DataCenter::instance()->mutable_object_table()->get_obstacle(
-            boundary_it->id());
+        DataCenter::instance()->mutable_object_table()->Find(boundary_it->id());
     if (!object_ptr) {
       AERROR << "Failed to find object " << boundary_it->id();
       return Status(ErrorCode::PLANNING_ERROR,