Handlers.hh

Go to the documentation of this file.

#ifndef HANDLERS_HH
#define HANDLERS_HH
 
#include <boost/filesystem/path.hpp>
#include <boost/program_options.hpp>
#include <string>
#include <vector>
 
#include "casm/casm_io/container/stream_io.hh"
#include "casm/global/definitions.hh"
#include "casm/global/enum.hh"
 
namespace CASM {
namespace Completer {
class ArgHandler {
 public:
  enum ARG_TYPE {
    VOID,
    PATH,
    COMMAND,
    SCELNAME,
    QUERY,
    OPERATOR,
    CONFIGNAME,
    COORDTYPE,
    DBTYPE,
    ENUMMETHOD,
    CONFIGTYPE,
    CALCTYPE,
    BSET,
    CLEX,
    REF,
    ECI,
    PROPERTY,
    DOF,
    INFOMETHOD
  };
 
  static ARG_TYPE determine_type(const po::option_description &boost_option);
 
  static std::string path();
 
  static std::string command();
 
  static std::string supercell();
 
  static std::string query();
 
  static std::string operation();
 
  static std::string configname();
 
  static std::string coordtype();
 
  static std::string dbtype();
 
  static std::string enummethod();
 
  static std::string configtype();
 
  static std::string calctype();
 
  static std::string bset();
 
  static std::string clex();
 
  static std::string ref();
 
  static std::string eci();
 
  static std::string property();
 
  static std::string dof();
 
  static std::string infomethod();
 
  static void void_to_bash(std::vector<std::string> &arguments);
 
  static void path_to_bash(std::vector<std::string> &arguments);
 
  static void command_to_bash(std::vector<std::string> &arguments);
 
  static void scelname_to_bash(std::vector<std::string> &arguments);
 
  static void configname_to_bash(std::vector<std::string> &arguments);
 
  static void query_to_bash(std::vector<std::string> &arguments);
 
  static void operator_to_bash(std::vector<std::string> &arguments);
 
  static void dbtype_to_bash(std::vector<std::string> &arguments);
 
  static void enummethod_to_bash(std::vector<std::string> &arguments);
 
  static void configtype_to_bash(std::vector<std::string> &arguments);
 
  static void calctype_to_bash(std::vector<std::string> &arguments);
 
  static void bset_to_bash(std::vector<std::string> &arguments);
 
  static void clex_to_bash(std::vector<std::string> &arguments);
 
  static void ref_to_bash(std::vector<std::string> &arguments);
 
  static void eci_to_bash(std::vector<std::string> &arguments);
 
  static void property_to_bash(std::vector<std::string> &arguments);
 
  static void dof_to_bash(std::vector<std::string> &arguments);
 
  static void infomethod_to_bash(std::vector<std::string> &arguments);
 
 private:
  static const std::vector<std::pair<std::string, ARG_TYPE> > m_argument_table;
};
 
class OptionHandlerBase {
 public:
  OptionHandlerBase(const std::string &init_option_tag);
 
  OptionHandlerBase(const std::string &init_option_tag,
                    const std::string &init_descriptor);
 
  po::variables_map &vm();
 
  const po::variables_map &vm() const;
 
  const po::options_description &desc();
 
  const po::options_description &desc() const;
 
  const std::string &tag() const;
 
 protected:
  std::string m_tag;
 
  mutable po::options_description m_desc;
 
  po::variables_map m_vm;
 
  virtual void initialize() = 0;
 
  //-------------------------------------------------------------------------------------//
 
  void add_selection_suboption(const fs::path &_default = "MASTER");
 
  void add_selection_no_default_suboption();
 
  void add_configlist_suboption(const fs::path &_default = "MASTER");
 
  fs::path m_selection_path;
 
  const fs::path &selection_path() const;
 
  //----------------------------//
 
  void add_selections_suboption(const fs::path &_default = "MASTER");
 
  void add_configlists_suboption(const fs::path &_default = "MASTER");
 
  std::vector<fs::path> m_selection_paths;
 
  const std::vector<fs::path> &selection_paths() const;
 
  //-------------------------------------------------------------------------------------//
 
  void add_prim_path_suboption(const fs::path &_default = "");
 
  fs::path m_prim_path;
 
  const fs::path &prim_path() const;
 
  //-------------------------------------------------------------------------------------//
 
  void add_file_path_suboption(const fs::path &_default = "");
 
  fs::path m_file_path;
 
  const fs::path &file_path() const;
 
  //-------------------------------------------------------------------------------------//
 
  void add_configlist_nodefault_suboption();
 
  //----------------------------//
 
  void add_configlists_nodefault_suboption();
 
  //-------------------------------------------------------------------------------------//
 
  void add_configtype_suboption(std::string _default,
                                std::set<std::string> _configtype_opts);
 
  std::string m_configtype;
 
  std::set<std::string> m_configtype_opts;
 
  std::string configtype() const;
 
  std::set<std::string> configtype_opts() const;
 
  //-------------------------------------------------------------------------------------//
 
  void add_db_type_suboption(std::string _default,
                             std::set<std::string> _configtype_opts);
 
  std::string m_db_type;
 
  std::set<std::string> m_db_type_opts;
 
  std::string db_type() const;
 
  std::set<std::string> db_type_opts() const;
 
  //-------------------------------------------------------------------------------------//
 
  void add_help_suboption();
 
  //-------------------------------------------------------------------------------------//
 
  void add_general_help_suboption();
 
  std::vector<std::string> m_help_opt_vec;
 
  const std::vector<std::string> &help_opt_vec() const;
 
  //-------------------------------------------------------------------------------------//
 
  void add_verbosity_suboption();
 
  std::string m_verbosity_str;
 
  const std::string &verbosity_str() const;
 
  int verbosity() const;
 
  //-------------------------------------------------------------------------------------//
 
  void add_input_suboption(bool required = true);
 
  std::string m_input_str;
 
  std::string input_str() const;
 
  //-------------------------------------------------------------------------------------//
 
  void add_settings_suboption(bool required = true);
 
  fs::path m_settings_path;
 
  const fs::path settings_path() const;
 
  //-------------------------------------------------------------------------------------//
 
  void add_output_suboption();
 
  void add_output_suboption(const fs::path &_default);
 
  fs::path m_output_path;
 
  const fs::path output_path() const;
 
  //-------------------------------------------------------------------------------------//
 
  void add_gzip_suboption();
 
  bool m_gzip_flag;
 
  bool gzip_flag() const;
 
  //-------------------------------------------------------------------------------------//
 
  void add_scelname_suboption();
 
  std::string m_supercell_str;
 
  const std::string &supercell_str() const;
 
  //----------------------------//
 
  void add_scelnames_suboption();
 
  std::vector<std::string> m_supercell_strs;
 
  const std::vector<std::string> &supercell_strs() const;
 
  //-------------------------------------------------------------------------------------//
 
  void add_configname_suboption();
 
  std::string m_config_str;
 
  const std::string &config_str() const;
 
  //----------------------------//
 
  void add_confignames_suboption();
 
  std::vector<std::string> m_config_strs;
 
  const std::vector<std::string> &config_strs() const;
 
  //----------------------------//
 
  void add_names_suboption();
 
  std::vector<std::string> m_name_strs;
 
  const std::vector<std::string> &name_strs() const;
 
  //-------------------------------------------------------------------------------------//
 
  void add_coordtype_suboption();
 
  std::string m_coordtype_str;
 
  const std::string &coordtype_str() const;
 
  COORD_TYPE coordtype_enum() const;
 
  //-------------------------------------------------------------------------------------//
 
  void add_dofs_suboption();
 
  std::vector<std::string> m_dof_strs;
 
  const std::vector<std::string> &dof_strs() const;
 
  //-------------------------------------------------------------------------------------//
 
  void add_dry_run_suboption(std::string msg = default_dry_run_msg());
 
  static std::string default_dry_run_msg();
 
  bool dry_run() const;
 
  //-------------------------------------------------------------------------------------//
 
  // Add more general suboption adding routines here//
};
 
class MonteOption : public OptionHandlerBase {
 public:
  using OptionHandlerBase::settings_path;
  using OptionHandlerBase::verbosity_str;
 
  MonteOption();
 
  Index condition_index() const;
 
 private:
  void initialize() override;
 
  Index m_condition_index;
};
 
//*****************************************************************************************************//
 
class RunOption : public OptionHandlerBase {
 public:
  using OptionHandlerBase::selection_path;
 
  RunOption();
 
  const std::string &exec_str() const;
 
 private:
  void initialize() override;
 
  std::string m_exec_str;
};
 
//*****************************************************************************************************//
 
class BsetOption : public OptionHandlerBase {
 public:
  BsetOption();
 
  using OptionHandlerBase::coordtype_enum;
 
 private:
  void initialize() override;
};
 
//*****************************************************************************************************//
 
class CompositionOption : public OptionHandlerBase {
 public:
  CompositionOption();
 
  const std::string &axis_choice_str() const;
 
 private:
  void initialize() override;
 
  std::string m_axis_choice_str;
};
 
//*****************************************************************************************************//
 
class RefOption : public OptionHandlerBase {
 public:
  using OptionHandlerBase::config_str;
  using OptionHandlerBase::supercell_str;
 
  RefOption();
 
  const std::string &set_str() const;
 
 private:
  void initialize() override;
 
  std::string m_set_str;
};
 
//*****************************************************************************************************//
 
class FilesOption : public OptionHandlerBase {
 public:
  using OptionHandlerBase::gzip_flag;
  using OptionHandlerBase::output_path;
 
  FilesOption();
 
  const std::vector<std::string> &calc_vec() const;
 
  const std::string &settings_str() const;
 
 private:
  void initialize() override;
 
  std::vector<std::string> m_calc_vec;
 
  std::string m_settings_str;
};
 
//*****************************************************************************************************//
 
class FormatOption : public OptionHandlerBase {
 public:
  FormatOption();
 
 private:
  void initialize() override;
};
 
//*****************************************************************************************************//
 
class InitOption : public OptionHandlerBase {
 public:
  InitOption();
 
  using OptionHandlerBase::file_path;
 
  using OptionHandlerBase::prim_path;
 
  using OptionHandlerBase::selection_path;
 
  using OptionHandlerBase::config_strs;
 
  using OptionHandlerBase::dof_strs;
 
  using OptionHandlerBase::coordtype_enum;
 
 private:
  void initialize() override;
};
 
//*****************************************************************************************************//
 
class PerturbOption : public OptionHandlerBase {
 public:
  using OptionHandlerBase::selection_path;
 
  PerturbOption();
 
  const fs::path &cspecs_path() const;
 
 private:
  void initialize() override;
 
  fs::path m_cspecs_path;
};
 
//*****************************************************************************************************//
 
class SettingsOption : public OptionHandlerBase {
 public:
  SettingsOption();
 
  const std::string &input_str() const;
 
  const std::vector<std::string> &input_vec() const;
 
 private:
  void initialize() override;
 
  std::string m_input_str;
 
  std::vector<std::string> m_input_vec;
};
 
//*****************************************************************************************************//
 
class StatusOption : public OptionHandlerBase {
 public:
  StatusOption();
 
 private:
  void initialize() override;
};
 
//*****************************************************************************************************//
 
class SuperOption : public OptionHandlerBase {
 public:
  using OptionHandlerBase::config_strs;
  using OptionHandlerBase::coordtype_enum;
  using OptionHandlerBase::selection_paths;
  using OptionHandlerBase::supercell_strs;
 
  SuperOption();
 
  const std::vector<fs::path> &transf_mat_paths() const;
 
  const fs::path &struct_path() const;
 
  const std::string &unit_scel_str() const;
 
  Index min_vol() const;
 
  double tolerance() const;
 
 private:
  void initialize() override;
 
  std::vector<fs::path> m_transf_mat_paths;
 
  fs::path m_struct_path;
 
  std::string m_unit_scel_str;
 
  Index m_min_vol;
 
  double m_tolerance;
};
 
//*****************************************************************************************************//
 
class ViewOption : public OptionHandlerBase {
 public:
  using OptionHandlerBase::config_strs;
  using OptionHandlerBase::configtype;
  using OptionHandlerBase::configtype_opts;
  using OptionHandlerBase::selection_path;
 
  ViewOption();
  int m_images;
 
 private:
  void initialize() override;
};
 
class EnumOptionBase : public OptionHandlerBase {
 public:
  EnumOptionBase(std::string const &_name)
      : OptionHandlerBase(_name), m_all_existing(false) {}
 
  using OptionHandlerBase::config_strs;
  using OptionHandlerBase::coordtype_enum;
  using OptionHandlerBase::input_str;
  using OptionHandlerBase::settings_path;
  using OptionHandlerBase::supercell_strs;
 
  virtual ~EnumOptionBase() {}
 
  int min_volume() const { return m_min_volume; }
 
  int max_volume() const { return m_max_volume; }
 
  bool all_existing() const { return m_all_existing; }
 
 protected:
  int m_min_volume;
  int m_max_volume;
  bool m_all_existing;
 
 private:
  virtual void initialize() override {}
};
 
//*****************************************************************************************************//
 
class SymOption : public EnumOptionBase {
 public:
  using OptionHandlerBase::coordtype_enum;
  using OptionHandlerBase::coordtype_str;
  using OptionHandlerBase::dof_strs;
  using OptionHandlerBase::selection_path;
 
  SymOption();
 
  bool wedges() const { return m_wedges; }
 
  double tol() const { return m_tol; }
 
  fs::path poscar_path() const { return m_poscar_path; }
 
 private:
  bool m_wedges;
  double m_tol;
  fs::path m_poscar_path;
 
  void initialize() override;
};
 
class EnumOption : public EnumOptionBase {
 public:
  EnumOption();
 
  using OptionHandlerBase::dry_run;
  using OptionHandlerBase::verbosity_str;
 
  const std::vector<std::string> &desc_vec() const { return m_desc_vec; }
 
  std::string method() const { return m_method; }
 
  const std::string &filter_str() const { return m_filter_str; }
 
 private:
  void initialize() override;
 
  std::vector<std::string> m_desc_vec;
 
  std::string m_method;
  std::string m_filter_str;
};
 
//*****************************************************************************************************//
 
class InfoOption : public OptionHandlerBase {
 public:
  using OptionHandlerBase::input_str;
  using OptionHandlerBase::settings_path;
 
  InfoOption();
 
  const std::vector<std::string> &desc_vec() const { return m_desc_vec; }
 
  std::string method() const { return m_method; }
 
 private:
  void initialize() override;
 
  std::vector<std::string> m_desc_vec;
  std::string m_method;
};
 
//*****************************************************************************************************//
 
class QueryOption : public OptionHandlerBase {
 public:
  using OptionHandlerBase::db_type;
  using OptionHandlerBase::db_type_opts;
  using OptionHandlerBase::gzip_flag;
  using OptionHandlerBase::help_opt_vec;
  using OptionHandlerBase::output_path;
  using OptionHandlerBase::selection_path;
 
  QueryOption();
 
  bool verbatim_flag() const;
 
  const std::vector<std::string> &columns_vec() const;
 
  const std::vector<std::string> &new_alias_vec() const;
 
 private:
  void initialize() override;
 
  std::vector<std::string> m_columns_vec;
 
  std::vector<std::string> m_new_alias_vec;
};
//*****************************************************************************************************//
 
class ImportOption : public OptionHandlerBase {
 public:
  using OptionHandlerBase::configtype;
  using OptionHandlerBase::configtype_opts;
  using OptionHandlerBase::input_str;
  using OptionHandlerBase::settings_path;
 
  ImportOption();
 
  const std::vector<fs::path> &pos_vec() const;
 
  const fs::path &batch_path() const;
 
 private:
  void initialize() override;
 
  std::vector<fs::path> m_pos_vec;
 
  fs::path m_batch_path;
};
//*****************************************************************************************************//
 
class SelectOption : public OptionHandlerBase {
 public:
  using OptionHandlerBase::db_type;
  using OptionHandlerBase::db_type_opts;
  using OptionHandlerBase::help_opt_vec;
  using OptionHandlerBase::output_path;
  using OptionHandlerBase::selection_paths;
 
  SelectOption();
 
  const std::vector<std::string> &criteria_vec() const;
 
 private:
  void initialize() override;
 
  // vector necessary to allow --set/--set-on/--set-off with or without an
  // argument
  std::vector<std::string> m_criteria_vec;
};
//*****************************************************************************************************//
 
class RmOption : public OptionHandlerBase {
 public:
  using OptionHandlerBase::db_type;
  using OptionHandlerBase::db_type_opts;
  using OptionHandlerBase::dry_run;
  using OptionHandlerBase::name_strs;
  using OptionHandlerBase::selection_path;
 
  RmOption();
 
  bool force() const;
 
  bool data() const;
 
 private:
  void initialize() override;
};
 
//*****************************************************************************************************//
 
class UpdateOption : public OptionHandlerBase {
 public:
  using OptionHandlerBase::configtype;
  using OptionHandlerBase::configtype_opts;
  using OptionHandlerBase::input_str;
  using OptionHandlerBase::selection_path;
  using OptionHandlerBase::settings_path;
 
  UpdateOption();
 
  double vol_tolerance() const;
 
  double lattice_weight() const;
 
  double min_va_frac() const;
 
  double max_va_frac() const;
 
 private:
  void initialize() override;
 
  double m_vol_tolerance;
 
  double m_lattice_weight;  // TODO: Push to base? Other commands use this
 
  double m_min_va_frac;
 
  double m_max_va_frac;
};
 
//*****************************************************************************************************//
 
}  // namespace Completer
}  // namespace CASM
 
#endif