Complete.cc

Go to the documentation of this file.

#ifndef COMPLETE_CC
#define COMPLETE_CC
 
#include "casm/completer/Complete.hh"
 
#include "casm/casm_io/dataformatter/DataFormatter.hh"
#include "casm/clex/Configuration.hh"
 
namespace CASM {
namespace Completer {
typedef ArgHandler::ARG_TYPE ARG_TYPE;
 
std::string strip_argument(const std::string &raw_input) {
  std::string stripped = raw_input;
 
  if (stripped[0] == '-') {
    stripped.erase(stripped.begin() + 1, stripped.end());
  }
 
  if (stripped[0] == '-') {
    stripped.erase(stripped.begin() + 1, stripped.end());
  }
 
  return stripped;
}
 
//*****************************************************************************************************//
 
namespace Suboption_impl {
std::string pull_short(const po::option_description &single_boost_option) {
  std::string possible_short;
  possible_short = single_boost_option.canonical_display_name(
      po::command_line_style::allow_dash_for_short);
  if (possible_short.size() > 2 || possible_short[0] != '-' ||
      possible_short[1] == '-') {
    return "-_";
  } else {
    return possible_short;
  }
}
 
std::string pull_long(const po::option_description &single_boost_option) {
  return single_boost_option.canonical_display_name(
      po::command_line_style::allow_long);
}
}  // namespace Suboption_impl
 
Suboption::Suboption(const std::string &init_longname, std::string init_short,
                     ARG_TYPE init_expected_types)
    : m_long(init_longname),
      m_short(init_short),
      m_expected_arg(init_expected_types) {
  _sanity_throw();
}
 
Suboption::Suboption(const po::option_description &init_boost_option)
    : m_long(Suboption_impl::pull_long(init_boost_option)),
      m_short(Suboption_impl::pull_short(init_boost_option)),
      m_expected_arg(ArgHandler::determine_type(init_boost_option)) {
  _sanity_throw();
}
 
void Suboption::_sanity_throw() const {
  if (m_long.size() < 3 || m_short.size() != 2) {
    throw std::runtime_error(
        "--long option must be at least 3 characters long and -s(hort) must be "
        "exactly 2!");
  }
  if (m_long[0] != '-' || m_long[1] != '-' || m_short[0] != '-') {
    throw std::runtime_error(
        "Suboption --long and -s(hort) tags must include leading '-' "
        "characters!");
  }
}
 
std::string Suboption::long_tag() const { return m_long; }
 
std::string Suboption::short_tag() const { return m_short; }
 
bool Suboption::matches(const std::string &test_tag) const {
  if (test_tag.size() == 2) {
    return (test_tag == m_short);
  }
 
  else {
    return (test_tag == m_long);
  }
 
  throw std::runtime_error(
      "The impossible has occurred. Stepped through an if/else block and hit "
      "neither");
}
 
ARG_TYPE Suboption::argument_type() const { return m_expected_arg; }
 
//***************************************************************************************************//
 
Option::Option(const std::string &init_tag,
               const std::vector<Suboption> &init_allowed_subopts)
    : m_tag(init_tag), m_avail_suboptions(init_allowed_subopts) {}
 
Option::Option(const std::string &init_tag,
               const po::options_description &init_premade_descs)
    : m_tag(init_tag) {
  m_avail_suboptions.reserve(init_premade_descs.options().size());
 
  for (auto it = init_premade_descs.options().begin();
       it != init_premade_descs.options().end(); ++it) {
    m_avail_suboptions.push_back(Suboption(**it));
  }
}
 
std::string Option::tag() const { return m_tag; }
 
std::vector<std::string> Option::probe_suboptions() const {
  std::vector<std::string> suboption_tag_list;
  for (auto it = m_avail_suboptions.begin(); it != m_avail_suboptions.end();
       ++it) {
    suboption_tag_list.push_back(it->long_tag());
  }
 
  return suboption_tag_list;
}
 
ARG_TYPE Option::probe_argument_type(const std::string &suboption_tag) const {
  for (auto it = m_avail_suboptions.begin(); it != m_avail_suboptions.end();
       ++it) {
    if (it->matches(suboption_tag)) {
      return it->argument_type();
    }
  }
 
  return ARG_TYPE::VOID;
}
 
bool Option::matches(const std::string &test_tag) const {
  return (test_tag == m_tag);
}
 
//***************************************************************************************************//
 
Engine::Engine(const std::vector<Option> &init_options)
    : m_avail_options(init_options) {}
 
std::vector<std::string> Engine::probe_options() const {
  std::vector<std::string> option_list;
  for (auto it = m_avail_options.begin(); it != m_avail_options.end(); ++it) {
    option_list.push_back(it->tag());
  }
 
  return option_list;
}
 
std::vector<std::string> Engine::probe_suboptions(
    const std::string &option_tag) const {
  for (auto it = m_avail_options.begin(); it != m_avail_options.end(); ++it) {
    if (it->matches(option_tag)) {
      return it->probe_suboptions();
    }
  }
 
  // as fallback, show files/dirs
  return std::vector<std::string>({"BASH_COMP_PATH"});
}
 
std::vector<std::string> Engine::probe_arguments(
    const std::string &option_tag, const std::string &suboption_tag) const {
  std::vector<std::string> arguments;
 
  ARG_TYPE required_arg = _probe_argument_type(option_tag, suboption_tag);
 
  switch (required_arg) {
    case ARG_TYPE::VOID:
      ArgHandler::void_to_bash(arguments);
      break;
 
    case ARG_TYPE::PATH:
      ArgHandler::path_to_bash(arguments);
      break;
 
    case ARG_TYPE::COMMAND:
      ArgHandler::command_to_bash(arguments);
      break;
 
    case ARG_TYPE::SCELNAME:
      // Add supercell names from PrimClex pointer somehow
      ArgHandler::scelname_to_bash(arguments);
      break;
 
    case ARG_TYPE::QUERY:
      ArgHandler::query_to_bash(arguments);
      break;
 
    case ARG_TYPE::OPERATOR:
      ArgHandler::operator_to_bash(arguments);
      break;
 
    case ARG_TYPE::CONFIGNAME:
      ArgHandler::configname_to_bash(arguments);
      break;
 
    case ARG_TYPE::COORDTYPE:
      // ArgHandler::coord_mode_to_bash();
      break;
 
    case ARG_TYPE::DBTYPE:
      ArgHandler::dbtype_to_bash(arguments);
      break;
 
    case ARG_TYPE::ENUMMETHOD:
      ArgHandler::enummethod_to_bash(arguments);
      break;
 
    case ARG_TYPE::CONFIGTYPE:
      ArgHandler::configtype_to_bash(arguments);
      break;
 
    case ARG_TYPE::CALCTYPE:
      ArgHandler::calctype_to_bash(arguments);
      break;
 
    case ARG_TYPE::BSET:
      ArgHandler::bset_to_bash(arguments);
      break;
 
    case ARG_TYPE::CLEX:
      ArgHandler::clex_to_bash(arguments);
      break;
 
    case ARG_TYPE::REF:
      ArgHandler::ref_to_bash(arguments);
      break;
 
    case ARG_TYPE::ECI:
      ArgHandler::eci_to_bash(arguments);
      break;
 
    case ARG_TYPE::PROPERTY:
      ArgHandler::property_to_bash(arguments);
      break;
 
    case ARG_TYPE::INFOMETHOD:
      ArgHandler::infomethod_to_bash(arguments);
      break;
 
    default:
      break;
  }
 
  // as fallback, show files/dirs
  if (!arguments.size()) {
    arguments.push_back("BASH_COMP_PATH");
  }
 
  return arguments;
}
 
ARG_TYPE Engine::_probe_argument_type(const std::string &option_tag,
                                      const std::string &suboption_tag) const {
  for (auto it = m_avail_options.begin(); it != m_avail_options.end(); ++it) {
    if (it->matches(option_tag)) {
      return it->probe_argument_type(suboption_tag);
    }
  }
 
  return ARG_TYPE::VOID;
}
 
void Engine::push_back(const Option &new_option) {
  m_avail_options.push_back(new_option);
  return;
}
}  // namespace Completer
}  // namespace CASM
 
#endif