Updated container names from string to adapter config message type

modules/prediction/conf/adapter.conf

 config {
   type: PERCEPTION_OBSTACLES 
   mode: RECEIVE_ONLY
-  message_history_limit: 10
+  message_history_limit: 1
 }
 config {
   type: LOCALIZATION

modules/prediction/container/BUILD

@@ -9,6 +9,7 @@ cc_library(
     deps = [
         "//modules/common:macro",
         "//modules/common:log",
+        "//modules/common/adapters/proto:adapter_config_proto",
         "//modules/prediction/container/obstacles:obstacles_container",
         "//modules/prediction/container/pose:pose_container",
         "@glog//:glog",

modules/prediction/container/container_manager.cc

@@ -23,6 +23,8 @@
 namespace apollo {
 namespace prediction {
 
+using ::apollo::common::adapter::AdapterConfig;
+
 ContainerManager::ContainerManager() {
   RegisterContainers();
 }
@@ -32,32 +34,34 @@ ContainerManager::~ContainerManager() {
 }
 
 void ContainerManager::RegisterContainers() {
-  RegisterContainer("PerceptionObstacles");
-  RegisterContainer("Pose");
+  RegisterContainer(AdapterConfig::PERCEPTION_OBSTACLES);
+  RegisterContainer(AdapterConfig::LOCALIZATION);
 }
 
-Container* ContainerManager::GetContainer(const std::string& name) {
-  if (containers_.find(name) != containers_.end()) {
-    return containers_[name].get();
+Container* ContainerManager::GetContainer(
+    const ::apollo::common::adapter::AdapterConfig::MessageType &type) {
+  if (containers_.find(type) != containers_.end()) {
+    return containers_[type].get();
   } else {
     return nullptr;
   }
 }
 
 std::unique_ptr<Container> ContainerManager::CreateContainer(
-    const std::string& name) {
+    const ::apollo::common::adapter::AdapterConfig::MessageType &type) {
   std::unique_ptr<Container> container_ptr(nullptr);
-  if (name == "PerceptionObstacles") {
+  if (type == AdapterConfig::PERCEPTION_OBSTACLES) {
     container_ptr.reset(new ObstaclesContainer());
-  } else if (name == "Pose") {
+  } else if (type == AdapterConfig::LOCALIZATION) {
     container_ptr.reset(new PoseContainer());
   }
   return container_ptr;
 }
 
-void ContainerManager::RegisterContainer(const std::string& name) {
-  containers_[name] = CreateContainer(name);
-  ADEBUG << "Container [" << name << "] is registered.";
+void ContainerManager::RegisterContainer(
+    const ::apollo::common::adapter::AdapterConfig::MessageType &type) {
+  containers_[type] = CreateContainer(type);
+  ADEBUG << "Container [" << type << "] is registered.";
 }
 
 }  // namespace prediction

modules/prediction/container/container_manager.h

@@ -22,11 +22,12 @@
 #ifndef MODULES_PREDICTION_CONTAINER_CONTAINER_MANAGER_H_
 #define MODULES_PREDICTION_CONTAINER_CONTAINER_MANAGER_H_
 
-#include <unordered_map>
+#include <map>
 #include <string>
 #include <memory>
 
 #include "modules/prediction/container/container.h"
+#include "modules/common/adapters/proto/adapter_config.pb.h"
 #include "modules/common/macro.h"
 
 /**
@@ -45,24 +46,27 @@ class ContainerManager {
 
   /**
    * @brief Get mutable container
-   * @param Name of the container
+   * @param Type of the container
    * @return Pointer to the container given the name
    */
-  Container* GetContainer(const std::string& name);
+  Container* GetContainer(
+      const ::apollo::common::adapter::AdapterConfig::MessageType &type);
 
  private:
   /**
    * @breif Register a container
-   * @param Container name
+   * @param Container type
    */
-  void RegisterContainer(const std::string& name);
+  void RegisterContainer(
+      const ::apollo::common::adapter::AdapterConfig::MessageType &type);
 
   /**
    * @brief Create a container
-   * @param Container name
+   * @param Container type
    * @return Container pointer
    */
-  std::unique_ptr<Container> CreateContainer(const std::string& name);
+  std::unique_ptr<Container> CreateContainer(
+      const ::apollo::common::adapter::AdapterConfig::MessageType &type);
 
   /**
    * @brief Register all containers
@@ -70,7 +74,8 @@ class ContainerManager {
   void RegisterContainers();
 
  private:
-  std::unordered_map<std::string, std::unique_ptr<Container>> containers_;
+  std::map<::apollo::common::adapter::AdapterConfig::MessageType,
+    std::unique_ptr<Container>> containers_;
 
   DECLARE_SINGLETON(ContainerManager)
 };

modules/prediction/evaluator/evaluator_manager.cc

@@ -26,6 +26,7 @@ namespace prediction {
 
 using ::apollo::perception::PerceptionObstacles;
 using ::apollo::perception::PerceptionObstacle;
+using ::apollo::common::adapter::AdapterConfig;
 
 EvaluatorManager::EvaluatorManager() {
   RegisterEvaluators();
@@ -48,7 +49,8 @@ void EvaluatorManager::Run(
     const ::apollo::perception::PerceptionObstacles& perception_obstacles) {
   AINFO << "Start run evaluator manager";
   ObstaclesContainer *container = dynamic_cast<ObstaclesContainer*>(
-      ContainerManager::instance()->GetContainer("PerceptionObstacles"));
+      ContainerManager::instance()->GetContainer(
+      AdapterConfig::PERCEPTION_OBSTACLES));
   CHECK_NOTNULL(container);
   AINFO << "Start for loop";
 

modules/prediction/prediction.cc

@@ -33,21 +33,24 @@ namespace prediction {
 using ::apollo::perception::PerceptionObstacles;
 using ::apollo::localization::LocalizationEstimate;
 using ::apollo::common::adapter::AdapterManager;
+using ::apollo::common::adapter::AdapterConfig;
 using ::apollo::common::Status;
 using ::apollo::common::ErrorCode;
 
-std::string Prediction::Name() const { return FLAGS_prediction_module_name; }
+std::string Prediction::Name() const {
+  return FLAGS_prediction_module_name;
+}
 
 Status Prediction::Init() {
   // Load prediction conf
-  conf_.Clear();
+  prediction_conf_.Clear();
   if (!::apollo::common::util::GetProtoFromFile(FLAGS_prediction_conf_file,
-                                                &conf_)) {
+                                                &prediction_conf_)) {
     return OnError("Unable to load prediction conf file: " +
                    FLAGS_prediction_conf_file);
   } else {
     ADEBUG << "Config file is loaded into: "
-           << conf_.ShortDebugString();
+           << prediction_conf_.ShortDebugString();
   }
 
   // Initialize the adapters
@@ -74,7 +77,8 @@ void Prediction::Stop() {}
 void Prediction::OnPerception(const PerceptionObstacles &perception_obstacles) {
   auto localization_adapter = AdapterManager::GetLocalization();
   ObstaclesContainer* obstacles_container = dynamic_cast<ObstaclesContainer*>(
-      ContainerManager::instance()->GetContainer("PerceptionObstacles"));
+      ContainerManager::instance()->GetContainer(
+      AdapterConfig::PERCEPTION_OBSTACLES));
   if (localization_adapter->Empty()) {
     ADEBUG << "No localization message.";
   } else {
@@ -84,7 +88,8 @@ void Prediction::OnPerception(const PerceptionObstacles &perception_obstacles) {
            << localization.ShortDebugString()
            << "].";
     PoseContainer* pose_container = dynamic_cast<PoseContainer*>(
-        ContainerManager::instance()->GetContainer("Pose"));
+        ContainerManager::instance()->GetContainer(
+        AdapterConfig::LOCALIZATION));
     pose_container->Insert(localization);
     obstacles_container->InsertPerceptionObstacle(
         *(pose_container->ToPerceptionObstacle()),

modules/prediction/prediction.h

@@ -73,7 +73,7 @@ class Prediction : public apollo::common::ApolloApp {
       const perception::PerceptionObstacles &perception_obstacles);
 
  private:
-  PredictionConf conf_;
+  PredictionConf prediction_conf_;
 };
 
 }  // namespace prediction

modules/prediction/predictor/predictor_manager.cc

@@ -29,6 +29,7 @@ namespace prediction {
 
 using ::apollo::perception::PerceptionObstacles;
 using ::apollo::perception::PerceptionObstacle;
+using ::apollo::common::adapter::AdapterConfig;
 
 PredictorManager::PredictorManager() {
   RegisterPredictors();
@@ -53,7 +54,8 @@ void PredictorManager::Run(
     const PerceptionObstacles& perception_obstacles) {
   prediction_obstacles_.Clear();
   ObstaclesContainer *container = dynamic_cast<ObstaclesContainer*>(
-      ContainerManager::instance()->GetContainer("PerceptionObstacles"));
+      ContainerManager::instance()->GetContainer(
+      AdapterConfig::PERCEPTION_OBSTACLES));
   CHECK_NOTNULL(container);
 
   Predictor *predictor = nullptr;