parser.h

// Copyright (C) 2020  Philipp Basler, Margarete Mühlleitner and Jonas Müller
// SPDX-FileCopyrightText: 2021 Philipp Basler, Margarete Mühlleitner and Jonas
// Müller
//
// SPDX-License-Identifier: GPL-3.0-or-later
 
#ifndef PARSER_H
#define PARSER_H
 
#include <BSMPT/models/IncludeAllModels.h>
#include <optional>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace BSMPT
{
 
class parserException : public std::exception
{
public:
  virtual const char *what() const noexcept;
  parserException(const std::string &msg);
 
private:
  std::string message;
};
 
class parser
{
public:
  parser();
  parser(const bool &enable_column_output);
  void enable_minimizer_options();
  void add_argument_only_display(const std::string &argument,
                                 const std::string &description,
                                 const std::string &default_val);
  void add_argument(const std::string &argument, bool required);
  void add_argument(const std::string &argument,
                    const std::string &description,
                    bool required);
  void add_argument(const std::string &argument,
                    const std::string &description,
                    const std::string &default_val,
                    bool required);
  void add_subtext(const std::string &subtext);
  void add_input(const std::vector<std::string> &input);
  void print_help() const;
  template <typename T = std::string>
  T get_value(const std::string &argument) const
  {
    auto value = get_value_as_string(argument);
    if constexpr (std::is_same<T, std::string>::value)
    {
      return value;
    }
    else if constexpr (std::is_same<T, int>::value)
    {
      return std::stoi(value);
    }
    else if constexpr (std::is_same<T, unsigned int>::value)
    {
      return std::stoul(value);
    }
    else if constexpr (std::is_same<T, double>::value)
    {
      return std::stod(value);
    }
    else if constexpr (std::is_same<T, bool>::value)
    {
      auto lower = to_lower(value);
      return lower == "true";
    }
    else
    {
      return static_cast<T>(value);
    }
  }
 
  bool all_required_set() const;
  void check_required_parameters() const;
  void set_help_header(const std::string &header);
 
private:
  struct Options
  {
    std::string argument;
    std::string description;
    std::optional<std::string> value;
    std::string default_val = "";
  };
  struct KeyValue
  {
    std::string key;
    std::string value;
    KeyValue() = default;
    KeyValue(const std::string &Key, const std::string &Value)
        : key{Key}
        , value{Value}
    {
    }
  };
 
  std::vector<std::pair<std::string, Options>> mOrderedArguments;
  std::unordered_map<std::string, Options> mRequiredArguments;
  std::unordered_map<std::string, Options> mOptionalArguments;
 
  bool extra_column_output = false;
 
  std::string get_value_as_string(const std::string &argument) const;
  void add_json_input(const std::string &filename);
  void add_input(const std::vector<KeyValue> &input);
  std::string to_lower(const std::string &input) const;
 
  KeyValue get_key_value(const std::string &input);
  std::string mHeader;
 
  mutable bool mHelpAlreadyPrinted{false};
};
} // namespace BSMPT
#endif // PARSER_H