add factor registerer

README.md

@@ -4,6 +4,7 @@ Oh-My-LOAM is a ROS-free implementation of LOAM (J. Zhang and S. Singh. LOAM: Li
 
 Comparing with A-LOAM, this implementation has following features:
 
+- it's ROS-free
 - it's more readable and easier to understand/modify
 
 # Dependences

common/registerer/registerer.h

@@ -5,15 +5,65 @@
 #include <string>
 
 #include "common/log/log.h"
-#include "common/macro/macros.h"
+
+namespace common {
 
 template <typename BaseClass>
 class AbstractFactory {
+ public:
   virtual ~AbstractFactory() = default;
-  virtual std::shared_ptr<BaseClass> Create() = 0;
+  virtual BaseClass *Create() = 0;
 };
 
 template <typename BaseClass, typename DerivedClass>
-class ConcreteFactory {
+class ConcreteFactory : public AbstractFactory<BaseClass> {
-  virtual std::shared_ptr<BaseClass> Create() = 0;
+ public:
-};
+  BaseClass *Create() override {
+    return new DerivedClass;
+  }
+};
+
+template <typename BaseClass>
+inline auto &GetFactoryMap() {
+  static std::map<std::string, std::shared_ptr<AbstractFactory<BaseClass>>> map;
+  return map;
+}
+
+template <typename BaseClass>
+class Registerer {
+ public:
+  template <typename DerivedClass>
+  static void Register(const std::string &derived_class_name) {
+    static_assert(std::is_base_of<BaseClass, DerivedClass>::value, "");
+    auto &factory_map = GetFactoryMap<BaseClass>();
+    if (factory_map.find(derived_class_name) != factory_map.end()) {
+      return;
+    }
+    factory_map[derived_class_name].reset(
+        new ConcreteFactory<BaseClass, DerivedClass>);
+  }
+
+  static BaseClass *NewInstance(const std::string &derived_class_name) {
+    auto &factory_map = GetFactoryMap<BaseClass>();
+    auto iter = factory_map.find(derived_class_name);
+    if (iter == factory_map.end()) {
+      AFATAL << "Class not registered: " << derived_class_name << ".";
+      return nullptr;
+    }
+    return iter->second->Create();
+  }
+
+  static bool IsRegistered(const std::string &derived_class_name) {
+    auto &factory_map = GetFactoryMap<BaseClass>();
+    return factory_map.find(derived_class_name) != factory_map.end();
+  }
+};
+
+}  // namespace common
+
+#define REGISTER_CLASS(base_class, derived_class)                              \
+  namespace {                                                                  \
+  __attribute__((constructor)) void Register##derived_class() {                \
+    ::common::Registerer<base_class>::Register<derived_class>(#derived_class); \
+  }                                                                            \
+  }  // namespace

oh_my_loam/configs/config.yaml

@@ -1,5 +1,5 @@
 # global configs
-lidar: VPL16
+lidar: VLP16
 log_to_file: false
 log_path: /data/log/oh_my_loam
 vis: true

oh_my_loam/extractor/extractor_VLP16.cc

@@ -1,6 +1,7 @@
 #include "extractor_VLP16.h"
 
 #include "common/math/math_utils.h"
+#include "common/registerer/registerer.h"
 
 namespace oh_my_loam {
 
@@ -10,4 +11,6 @@ int ExtractorVLP16::GetScanID(const common::Point &pt) const {
   return static_cast<int>(std::round(theta / 2.0) + 1.e-5);
 };
 
+REGISTER_CLASS(Extractor, ExtractorVLP16)
+
 }  // namespace oh_my_loam

oh_my_loam/oh_my_loam.cc

@@ -2,9 +2,8 @@
 
 #include <vector>
 
-#include "common/common.h"
 #include "common/pcl/pcl_utils.h"
-#include "oh_my_loam/extractor/extractor_VLP16.h"
+#include "common/registerer/registerer.h"
 
 namespace oh_my_loam {
 
@@ -15,7 +14,8 @@ const double kPointMinDist = 0.5;
 bool OhMyLoam::Init() {
   config_ = common::YAMLConfig::Instance()->config();
   is_vis_ = config_["vis"].as<bool>();
-  extractor_.reset(new ExtractorVLP16);
+  extractor_.reset(common::Registerer<Extractor>::NewInstance(
+      "Extractor" + config_["lidar"].as<std::string>()));
   if (!extractor_->Init()) {
     AERROR << "Failed to initialize extractor";
     return false;