ConfigReader.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Deutsches Elektronen-Synchrotron DESY, MSK, ChimeraTK Project <chimeratk-support@desy.de>
// SPDX-License-Identifier: LGPL-3.0-or-later
#pragma once
 
#include "ApplicationModule.h"
#include "ArrayAccessor.h"
#include "ScalarAccessor.h"
 
#include <ChimeraTK/SupportedUserTypes.h>
 
#include <map>
#include <unordered_map>
#include <utility>
 
namespace ChimeraTK {
 
  struct FunctorFill;
  struct ArrayFunctorFill;
  struct FunctorSetValues;
  struct FunctorSetValuesArray;
  class ModuleTree;
 
  class ConfigReader : public ApplicationModule {
   public:
    ConfigReader(ModuleGroup* owner, const std::string& name, const std::string& fileName,
        const std::unordered_set<std::string>& tags = {});
    ~ConfigReader() override;
 
    void mainLoop() override {}
    void prepare() override;
 
    template<typename T>
    const T& get(std::string variableName) const;
 
    template<typename T>
    const T& get(std::string variableName, const T& defaultValue) const;
 
    std::list<std::string> getModules(const std::string& path = {}) const;
 
   protected:
    void construct(const std::string& fileName);
 
    std::string _fileName;
 
    std::unique_ptr<ModuleTree> _moduleTree;
 
    void parsingError(const std::string& message) noexcept;
 
    template<typename T>
    struct Var {
      Var(Module* owner, const std::string& name, T theValue)
      : accessor(owner, name, "unknown", "Configuration variable"), value(std::move(theValue)) {}
 
      Var() = default;
 
      ScalarOutput<T> accessor;
      T value{};
    };
 
    template<typename T>
    struct Array {
      Array(Module* owner, const std::string& name, const std::vector<T>& theValue)
      : accessor(owner, name, "unknown", theValue.size(), "Configuration array"), value(theValue) {}
 
      Array() = default;
 
      ArrayOutput<T> accessor;
      std::vector<T> value;
    };
 
    template<typename T>
    void createVar(const std::string& name, const std::string& value);
 
    template<typename T>
    void createArray(const std::string& name, const std::map<size_t, std::string>& values);
 
    [[nodiscard]] bool checkVariable(std::string const& name, std::string const& type) const;
 
    [[nodiscard]] bool checkArray(std::string const& name, std::string const& type) const;
 
    template<typename T>
    using MapOfVar = std::unordered_map<std::string, Var<T>>;
 
    ChimeraTK::TemplateUserTypeMapNoVoid<MapOfVar> _variableMap;
 
    template<typename T>
    using MapOfArray = std::unordered_map<std::string, Array<T>>;
 
    ChimeraTK::TemplateUserTypeMapNoVoid<MapOfArray> _arrayMap;
 
    ChimeraTK::SingleTypeUserTypeMapNoVoid<const char*> _typeMap{"int8", "uint8", "int16", "uint16", "int32", "uint32",
        "int64", "uint64", "float", "double", "string", "boolean"};
 
    template<typename T>
    std::optional<const T*> getImpl(const std::string& variableName, T*) const;
 
    template<typename T>
    std::optional<const std::vector<T>*> getImpl(const std::string& variableName, std::vector<T>*) const;
 
    friend struct FunctorFill;
    friend struct ArrayFunctorFill;
    friend struct FunctorSetValues;
    friend struct FunctorSetValuesArray;
    friend struct FunctorGetTypeForName;
  };
 
  /********************************************************************************************************************/
  /********************************************************************************************************************/
 
  template<typename T>
  const T& ConfigReader::get(std::string variableName, const T& defaultValue) const {
    if(variableName.starts_with("/")) {
      variableName = variableName.substr(1);
    }
    auto result = getImpl(variableName, static_cast<T*>(nullptr));
    return *(result.value_or(&defaultValue));
  }
 
  /********************************************************************************************************************/
  /********************************************************************************************************************/
 
  template<typename T>
  const T& ConfigReader::get(std::string variableName) const {
    if(variableName.starts_with("/")) {
      variableName = variableName.substr(1);
    }
    auto result = getImpl(variableName, static_cast<T*>(nullptr));
    if(!result.has_value()) {
      auto msg = "ConfigReader: Cannot find configuration variable of the name '" + variableName +
          "' in the config file '" + _fileName + "'.";
      std::cerr << msg << std::endl;
      throw(ChimeraTK::logic_error(msg));
    }
    return *(result.value());
  }
 
  /********************************************************************************************************************/
  /********************************************************************************************************************/
 
  template<typename T>
  std::optional<const T*> ConfigReader::getImpl(const std::string& variableName, T*) const {
    bool exists = checkVariable(variableName, boost::fusion::at_key<T>(_typeMap));
    if(!exists) {
      return {};
    }
    return &(boost::fusion::at_key<T>(_variableMap.table).at(variableName).value);
  }
 
  /********************************************************************************************************************/
  /********************************************************************************************************************/
 
  template<typename T>
  std::optional<const std::vector<T>*> ConfigReader::getImpl(const std::string& variableName, std::vector<T>*) const {
    bool exists = checkArray(variableName, boost::fusion::at_key<T>(_typeMap));
    if(!exists) {
      return {};
    }
    return &(boost::fusion::at_key<T>(_arrayMap.table).at(variableName).value);
  }
 
} // namespace ChimeraTK