Handlers.hh

Go to the documentation of this file.

#ifndef HANDLERS_HH
#define HANDLERS_HH

#include <string>
#include <vector>
#include <boost/program_options.hpp>
#include "casm/CASM_global_definitions.hh"

namespace CASM {
  namespace Completer {
    class ArgHandler {
    public:

      enum ARG_TYPE {VOID, PATH, COMMAND, SCELNAME, QUERY, OPERATOR, CONFIGNAME, COORDTYPE};

      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 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 query_to_bash(std::vector<std::string> &arguments);

      static void operator_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 std::string &tag() const;


    protected:

      std::string m_tag;

      po::options_description m_desc;

      po::variables_map m_vm;

      virtual void initialize() = 0;

      //-------------------------------------------------------------------------------------//

      void add_configlist_suboption(const fs::path &_default = "MASTER");

      fs::path m_selection_path;

      const fs::path &selection_path() const;

      //----------------------------//

      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_configlist_nodefault_suboption();

      //----------------------------//

      void add_configlists_nodefault_suboption();

      //-------------------------------------------------------------------------------------//

      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;

      //-------------------------------------------------------------------------------------//

      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();

      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_coordtype_suboption();

      std::string m_coordtype_str;

      const std::string &coordtype_str() const;

      COORD_TYPE coordtype_enum() const;

      //-------------------------------------------------------------------------------------//

      //Add more general suboption adding routines here//
    };

    class MonteOption : public OptionHandlerBase {


    public:

      using OptionHandlerBase::verbosity_str;
      using OptionHandlerBase::settings_path;

      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 QueryOption : public OptionHandlerBase {

    public:

      using OptionHandlerBase::selection_path;
      using OptionHandlerBase::output_path;
      using OptionHandlerBase::gzip_flag;
      using OptionHandlerBase::help_opt_vec;

      QueryOption();

      const std::vector<std::string> &columns_vec() const;

      const std::vector<std::string> &new_alias_vec() const;

      bool json_flag() const;

      bool verbatim_flag() const;

      bool no_header_flag() const;

    private:

      void initialize() override;

      std::vector<std::string> m_columns_vec;

      std::vector<std::string> m_new_alias_vec;

      bool m_json_flag;

      bool m_verbatim_flag;

      bool m_no_header_flag;

    };

    //*****************************************************************************************************//

    class BsetOption : public OptionHandlerBase {

    public:

      BsetOption();

    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::supercell_str;
      using OptionHandlerBase::config_str;

      RefOption();

      const std::string &set_str() const;

    private:

      void initialize() override;

      std::string m_set_str;

    };

    //*****************************************************************************************************//

    class FilesOption : public OptionHandlerBase {

    public:

      using OptionHandlerBase::output_path;
      using OptionHandlerBase::gzip_flag;

      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 ImportOption : public OptionHandlerBase {

    public:

      ImportOption();

      double vol_tolerance() const;

      double lattice_weight() const;

      double min_va_frac() const;

      double max_va_frac() const;

      const std::vector<fs::path> &pos_vec() const;

      const fs::path &batch_path() const;


    private:

      void initialize() override;

      double m_vol_tolerance;

      double m_lattice_weight;

      double m_min_va_frac;

      double m_max_va_frac;

      std::vector<fs::path> m_pos_vec;

      fs::path m_batch_path;

    };

    //*****************************************************************************************************//

    class InitOption : public OptionHandlerBase {

    public:

      InitOption();

    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 SelectOption : public OptionHandlerBase {

    public:

      using OptionHandlerBase::help_opt_vec;
      using OptionHandlerBase::selection_paths;
      using OptionHandlerBase::output_path;

      SelectOption();

      const std::vector<std::string> &criteria_vec() const;

    private:

      void initialize() override;

      std::vector<std::string> m_criteria_vec;


    };

    //*****************************************************************************************************//

    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::coordtype_enum;
      using OptionHandlerBase::supercell_strs;
      using OptionHandlerBase::config_strs;
      using OptionHandlerBase::selection_paths;

      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 SymOption : public OptionHandlerBase {

    public:

      using OptionHandlerBase::coordtype_enum;

      SymOption();

    private:

      void initialize() override;

    };

    //*****************************************************************************************************//

    class RmOption : public OptionHandlerBase {

    public:

      using OptionHandlerBase::selection_path;
      using OptionHandlerBase::config_strs;
      using OptionHandlerBase::supercell_strs;

      RmOption();

      bool force() const;

      bool dry_run() const;

    private:

      void initialize() override;

    };

    //*****************************************************************************************************//

    class UpdateOption : public OptionHandlerBase {

    public:

      using OptionHandlerBase::coordtype_enum;

      using OptionHandlerBase::selection_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;

    };

    //*****************************************************************************************************//

    class ViewOption : public OptionHandlerBase {

    public:

      using OptionHandlerBase::config_strs;
      using OptionHandlerBase::selection_path;

      ViewOption();

    private:

      void initialize() override;

    };

    //*****************************************************************************************************//

    class EnumOption : public OptionHandlerBase {

    public:

      EnumOption();

      using OptionHandlerBase::settings_path;
      using OptionHandlerBase::input_str;
      using OptionHandlerBase::supercell_strs;

      const std::vector<std::string> &desc_vec() const {
        return m_desc_vec;
      }

      std::string method() const {
        return m_method;
      }

      int min_volume() const {
        return m_min_volume;
      }

      int max_volume() const {
        return m_max_volume;
      }

      bool all_existing() const {
        return m_all_existing;
      }

      const std::vector<std::string> &filter_strs() const {
        return m_filter_strs;
      }

    private:

      void initialize() override;

      std::vector<std::string> m_desc_vec;

      std::string m_method;
      int m_min_volume;
      int m_max_volume;
      bool m_all_existing;
      std::vector<std::string> m_filter_strs;

    };

    //*****************************************************************************************************//

  }
}


#endif