Factory.h

Go to the documentation of this file.

#pragma once
#include <lanelet2_core/utility/Utilities.h>
 
#include <cstring>
#include <functional>
#include <map>
#include <string>
 
#include "lanelet2_io/Configuration.h"
#include "lanelet2_io/Projection.h"
#include "lanelet2_io/io_handlers/Parser.h"
#include "lanelet2_io/io_handlers/Writer.h"
 
namespace lanelet {
namespace io_handlers {
class ParserFactory {  // NOLINT
 public:
  using ParserCreationFcn = std::function<Parser*(const Projector&, const io::Configuration&)>;
 
  static ParserFactory& instance();
 
  static Parser::Ptr create(const std::string& parserName, const Projector& projector,
                            const io::Configuration& config = io::Configuration());
 
  static Parser::Ptr createFromExtension(const std::string& extension, const Projector& projector,
                                         const io::Configuration& config = io::Configuration());
 
  static std::vector<std::string> availableParsers();
 
  static std::vector<std::string> availableExtensions();
 
  template <typename T>
  friend class RegisterParser;
 
 private:
  void registerParser(const std::string& strategy, const std::string& extension,
                      const ParserCreationFcn& factoryFunction);
 
  ParserFactory() = default;
  std::map<std::string, ParserCreationFcn> registry_;
  std::map<std::string, ParserCreationFcn> extensionRegistry_;
};
 
class WriterFactory {  // NOLINT
 public:
  using WriterCreationFcn = std::function<Writer*(const Projector&, const io::Configuration&)>;
 
  static WriterFactory& instance();
 
  static Writer::Ptr create(const std::string& writerName, const Projector& projector,
                            const io::Configuration& config = io::Configuration());
 
  static Writer::Ptr createFromExtension(const std::string& extension, const Projector& projector,
                                         const io::Configuration& config = io::Configuration());
 
  static std::vector<std::string> availableWriters();
 
  static std::vector<std::string> availableExtensions();
 
  template <typename T>
  friend class RegisterWriter;
 
 private:
  void registerWriter(const std::string& strategy, const std::string& extension,
                      const WriterCreationFcn& factoryFunction);
 
  WriterFactory() = default;
  std::map<std::string, WriterCreationFcn> registry_;
  std::map<std::string, WriterCreationFcn> extensionRegistry_;
};
 
template <class T>
class RegisterWriter {
 public:
  RegisterWriter() {
    static_assert(!utils::strequal(T::name(), ""), "You did not overload the name() function!");
    WriterFactory::instance().registerWriter(
        T::name(), T::extension(), [](const Projector& projector, const io::Configuration& config) -> Writer* {
          return new T(projector, config);
        });
  }
};
 
template <class T>
class RegisterParser {
 public:
  RegisterParser() {
    static_assert(!utils::strequal(T::name(), ""), "You did not overload the name() function!");
    ParserFactory::instance().registerParser(
        T::name(), T::extension(), [](const Projector& projector, const io::Configuration& config) -> Parser* {
          return new T(projector, config);
        });
  }
};
}  // namespace io_handlers
}  // namespace lanelet