Config.h

#pragma once
 
#include <iosfwd>
#include <string>
#include <string_view>
 
#include "delpi/util/OptionValue.hpp"
 
namespace delpi {
 
#define DELPI_PARAMETER(param_name, type, default_value, help)                             \
 public:                                                                                   \
    \
  OptionValue<type> &m_##param_name() { return param_name##_; }                            \
 \
  [[nodiscard]] const type &param_name() const { return param_name##_.get(); }             \
  static constexpr type default_##param_name{default_value};                               \
  static constexpr const char *const help_##param_name{help};                              \
                                                                                           \
 private:                                                                                  \
  OptionValue<type> param_name##_{default_value};

class Config {
 public:
  enum class LpSolver {
    SOPLEX,   
    QSOPTEX,  
    DELPI,    
  };

  enum class Format {
    AUTO,  
    MPS,   
    LP,    
  };

  enum class LpMode {
    AUTO = 0,                       
    PURE_PRECISION_BOOSTING = 1,    
    PURE_ITERATIVE_REFINEMENT = 2,  
    HYBRID = 3,                     
  };

  Config() = default;
  explicit Config(std::string filename);
  explicit Config(bool read_from_stdin);
  explicit Config(Format format);
 
 public:
  static constexpr std::string_view help_filename{"Input file name"};

  [[nodiscard]] const std::string &filename() const { return filename_.get(); }
  [[nodiscard]] std::string filename_extension() const;
  OptionValue<std::string> &m_filename() { return filename_; }
  [[nodiscard]] LpMode actual_lp_mode() const;
  [[nodiscard]] Format actual_format() const;
 
 private:
  OptionValue<std::string> filename_{""};
 
  DELPI_PARAMETER(continuous_output, bool, false,
                  "Continuous output.\n"
                  "\t\tIf a delta-optimal solution with actual_delta > delta is found, output it and continue")
  DELPI_PARAMETER(csv, bool, false, "Produce CSV output. Must also specify --with-timings to get the time stats")
  DELPI_PARAMETER(debug_parsing, bool, false, "Debug parsing")
  DELPI_PARAMETER(delta, double, 0, "Delta used by the LP solver solver")
  DELPI_PARAMETER(format, Format, delpi::Config::Format::AUTO,
                  "Input file format\n"
                  "\t\tOne of: auto (1), mps (2)")
  DELPI_PARAMETER(lp_mode, LpMode, delpi::Config::LpMode::AUTO,
                  "LP mode used by the LP solver.\n"
                  "\t\tNot all solvers may support all modes\n"
                  "\t\tOne of: auto (1), pure-precision-boosting (2), pure-iterative-refinement (3), hybrid (4)")
  DELPI_PARAMETER(lp_solver, LpSolver, delpi::Config::LpSolver::SOPLEX,
                  "Underlying LP solver used by the theory solver.\n"
                  "\t\tOne of: soplex (1), qsoptex (2)")
  DELPI_PARAMETER(number_of_jobs, unsigned int, 1u, "Number of jobs")
  DELPI_PARAMETER(skip_optimise, bool, false,
                  "Whether to skip the objective function, turning the optimisation in a feasibility problem. "
                  "Only affects the MPS format")
  DELPI_PARAMETER(dry_run, bool, false, "Whether to stop the program before running any optimization algorithm")
  DELPI_PARAMETER(produce_models, bool, false,
                  "Produce models, showing a valid assignment.\n"
                  "\t\tOnly applicable if the problem is feasible")
  DELPI_PARAMETER(random_seed, unsigned int, 0u,
                  "Set the random seed. 0 means that the seed will be generated on the fly")
  DELPI_PARAMETER(read_from_stdin, bool, false, "Read the input from the standard input")
  DELPI_PARAMETER(silent, bool, false, "Silent mode. Nothing will be printed on the standard output")
  DELPI_PARAMETER(
      timeout, unsigned int, 0,
      "Timeout in milliseconds for the main routine, without accounting for input parsing. 0 means no timeout")
  DELPI_PARAMETER(verbose_delpi, int, 2, "Verbosity level for delpi. In the range [0, 5]")
  DELPI_PARAMETER(verbose_simplex, int, 0, "Verbosity level for simplex. In the range [0, 5]")
  DELPI_PARAMETER(verify, bool, false,
                  "If the input produces a feasible output, verify the assignment against the input")
  DELPI_PARAMETER(with_timings, bool, false, "Report timings alongside results")
};
 
std::ostream &operator<<(std::ostream &os, const Config &config);
std::ostream &operator<<(std::ostream &os, const Config::LpSolver &lp_solver);
std::ostream &operator<<(std::ostream &os, const Config::Format &format);
std::ostream &operator<<(std::ostream &os, const Config::LpMode &mode);
 
}  // namespace delpi
 
#ifdef DELPI_INCLUDE_FMT
 
#include "delpi/util/logging.h"
 
OSTREAM_FORMATTER(delpi::Config);
OSTREAM_FORMATTER(delpi::Config::LpSolver);
OSTREAM_FORMATTER(delpi::Config::Format);
OSTREAM_FORMATTER(delpi::Config::LpMode);
 
#endif