ValidatorFactory.h

Go to the documentation of this file.

#pragma once
#include <lanelet2_core/utility/Utilities.h>

#include <functional>
#include <regex>

#include "lanelet2_validation/BasicValidator.h"

namespace lanelet {
namespace validation {

using Regexes = std::vector<std::regex>;

template <typename ValidatorT>
using ValidatorWithName = std::pair<std::string, std::unique_ptr<ValidatorT>>;

template <typename ValidatorT>
using ValidatorsWithName = std::vector<ValidatorWithName<ValidatorT>>;

class ValidatorFactory {
 public:
  template <typename ValidatorT>
  using CreationFcn = std::function<ValidatorT*()>;
  static ValidatorFactory& instance();

  ValidatorsWithName<MapValidator> createMapValidators(const Regexes& regexes);
  ValidatorsWithName<TrafficRuleValidator> createTrafficRuleValidators(const Regexes& regexes);
  ValidatorsWithName<RoutingGraphValidator> createRoutingGraphValidators(const Regexes& regexes);

  std::vector<std::string> availableValidators(const Regexes& regexes = {});

  template <typename ValidatorT>
  friend class RegisterMapValidator;

  template <typename ValidatorT>
  friend class RegisterTrafficRuleValidator;

  template <typename ValidatorT>
  friend class RegisterRoutingGraphValidator;

 private:
  void registerMapValidator(const std::string& name, const CreationFcn<MapValidator>& creator);
  void registerTrafficRuleValidator(const std::string& name, const CreationFcn<TrafficRuleValidator>& creator);
  void registerRoutingGraphValidator(const std::string& name, const CreationFcn<RoutingGraphValidator>& creator);

  ValidatorFactory() = default;
  std::map<std::string, CreationFcn<MapValidator>> mapValidatorRegistry_;
  std::map<std::string, CreationFcn<TrafficRuleValidator>> trafficRuleValidatorRegistry_;
  std::map<std::string, CreationFcn<RoutingGraphValidator>> routingGraphValidatorRegistry_;
};

template <class T>
class RegisterMapValidator {
 public:
  RegisterMapValidator() {
    static_assert(!utils::strequal(T::name(), ""), "You did not overload the name() function!");
    ValidatorFactory::instance().registerMapValidator(T::name(), []() { return new T(); });
  }
};

template <class T>
class RegisterTrafficRuleValidator {
 public:
  RegisterTrafficRuleValidator() {
    static_assert(!utils::strequal(T::name(), ""), "You did not overload the name() function!");
    ValidatorFactory::instance().registerTrafficRuleValidator(T::name(), []() { return new T(); });
  }
};

template <class T>
class RegisterRoutingGraphValidator {
 public:
  RegisterRoutingGraphValidator() {
    static_assert(!utils::strequal(T::name(), ""), "You did not overload the name() function!");
    ValidatorFactory::instance().registerRoutingGraphValidator(T::name(), []() { return new T(); });
  }
};
}  // namespace validation
}  // namespace lanelet