insfile_reader.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2020 W. Traylor <wolfgang.traylor@senckenberg.de>
//
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#ifndef FAUNA_INSFILE_READER_H
#define FAUNA_INSFILE_READER_H
 
#include <list>
#include "cpptoml.h"
#include "parameters.h"
 
namespace Fauna {
// Forward declarations
class Hft;
 
// Repeat typedef from hft.h
typedef std::vector<std::shared_ptr<const Hft>> HftList;
 
class ambiguous_param_type : public std::runtime_error {
 public:
 
  ambiguous_param_type(const std::string& key, const std::string& hft,
                       const std::string& value1, const std::string& value2)
      : std::runtime_error(
            "Parameter '" + key + +"' " +
            (hft == "" ? "of HFT '" + hft + "' " : "") +
            "is ambiguous: there is '" + value1 + "' or '" + value2 + "'. " +
            "The reason might be that the parameter can take two different "
            "types and has then been defined twice."){};
};
 
class bad_array_size : public std::runtime_error {
 public:
 
  bad_array_size(const std::string& key, const unsigned int given_size,
                 const std::string& expected_size)
      : std::runtime_error("Array parameter '" + key + "' has " +
                           std::to_string(given_size) + "'elements," +
                           " but required are: " + expected_size){};
};
 
class invalid_option : public std::runtime_error {
 public:
 
  invalid_option(const std::string& key, const std::string& value,
                 const std::set<std::string>& valid_options)
      : runtime_error(construct_message(key, value, valid_options)){};
 
 
  invalid_option(const Hft& hft, const std::string& key,
                 const std::string& value,
                 const std::set<std::string>& valid_options)
      : runtime_error(construct_message(key, value, valid_options)){};
 
 private:
  std::string construct_message(const std::string& key,
                                const std::string& value,
                                const std::set<std::string>& valid_options);
};
 
struct missing_parameter : public std::runtime_error {
 
  missing_parameter(const std::string& key)
      : runtime_error("Missing mandatory parameter: \"" + key + '"'){};
};
 
struct missing_hft_parameter : public std::runtime_error {
 
  missing_hft_parameter(const std::string& hft_name, const std::string& key)
      : runtime_error("Missing mandatory parameter \"" + key + "\" in HFT \"" +
                      hft_name + "\"."){};
};
 
struct missing_group : public std::runtime_error {
 
  missing_group(const std::string& hft_name, const std::string& group_name)
      : std::runtime_error("Cannot find group with name \"" + group_name +
                           "\". " + "Required by HFT \"" + hft_name + "\"."){};
};
 
 
struct param_out_of_range : public std::runtime_error {
 
  param_out_of_range(const std::string& key, const std::string& value,
                     const std::string& allowed_interval)
      : std::runtime_error("The parameter \"" + key + "\" " +
                           "is out of range. The specified value is " + value +
                           ", which lies outside of the interval " +
                           allowed_interval + "."){};
};
 
struct unknown_parameters : public std::runtime_error {
 
  unknown_parameters(const std::list<std::string> elements)
      : runtime_error("Unknown parameters encountered:\n" +
                      concatenate_elements(elements)){};
 
  static std::string concatenate_elements(
      const std::list<std::string> elements) {
    std::ostringstream str;
    for (const auto& i : elements) str << i << "\n";
    return str.str();
  }
};
 
struct wrong_param_type : public std::runtime_error {
 
  wrong_param_type(const std::string& key, const std::string& type_expected,
                   const std::string& type_found)
      : std::runtime_error("The parameter \"" + key + "\" " +
                           "is of a wrong type. I found type " + type_found +
                           ", but expected " + type_expected + "."){};
};
 
class InsfileReader {
 public:
 
  InsfileReader(const std::string filename);
 
  const HftList& get_hfts() const { return hfts; };
 
  const Parameters& get_params() const { return params; };
 
 private:
 
  std::shared_ptr<cpptoml::table> get_group_table(
      const std::string& group_name) const;
 
  enum class GetValueOpt {
    RemoveKey,
    KeepKey
  };
 
 
  template <class T>
  std::shared_ptr<T> get_value(
      const std::shared_ptr<cpptoml::table>& table, const std::string& key,
      const GetValueOpt opt = GetValueOpt::RemoveKey) const;
 
 
  template <class T>
  std::shared_ptr<std::vector<T>> get_value_array(
      const std::shared_ptr<cpptoml::table>& table, const std::string& key,
      const GetValueOpt opt = GetValueOpt::RemoveKey) const;
 
 
  template <class Expected>
  void check_wrong_type(std::shared_ptr<cpptoml::table> table,
                        const std::string& key) const;
 
 
  template <class T>
  std::shared_ptr<T> find_hft_parameter(
      const std::shared_ptr<cpptoml::table>& hft_table, const std::string& key,
      const bool mandatory);
 
 
  template <class T>
  std::shared_ptr<std::vector<T>> find_hft_array_parameter(
      const std::shared_ptr<cpptoml::table>& hft_table, const std::string& key,
      const bool mandatory);
 
 
  std::list<std::string> get_all_keys(std::shared_ptr<cpptoml::table> table);
 
  void read_table_forage();
 
  void read_table_output();
 
  void read_table_output_text_tables();
 
  void read_table_simulation();
 
 
  void remove_qualified_key(std::shared_ptr<cpptoml::table> table,
                            const std::string key) const;
 
 
  Hft read_hft(const std::shared_ptr<cpptoml::table>& table);
 
  std::shared_ptr<cpptoml::table> ins;
 
 
  std::set<std::string> hft_keys_parsed;
 
  Parameters params;
  HftList hfts;
};
}  // namespace Fauna
 
#endif  // FAUNA_INSFILE_READER_H