casm_functions.hh

Go to the documentation of this file.

#ifndef CASM_FUNCTIONS_HH
#define CASM_FUNCTIONS_HH
 
#include <boost/filesystem/path.hpp>
 
#include "casm/app/CLIParse.hh"
#include "casm/app/errors.hh"
#include "casm/global/definitions.hh"
#include "casm/misc/cloneable_ptr.hh"
#include "casm/misc/unique_cloneable_map.hh"
 
namespace CASM {
 
void print_splash(std::ostream &out);
 
class PrimClex;
class jsonParser;
 
struct CommandArgs : public CLIParse {
  CommandArgs(int _argc, char *_argv[], PrimClex *_primclex = nullptr,
              fs::path _root = fs::path());
 
  CommandArgs(std::string _args, PrimClex *_primclex = nullptr,
              fs::path _root = fs::path());
 
  CommandArgs(const CommandArgs &other) = delete;
  CommandArgs(CommandArgs &&other) = delete;
  CommandArgs &operator=(const CommandArgs &) = delete;
  CommandArgs &operator=(CommandArgs &&) = delete;
 
  ~CommandArgs();
 
  PrimClex *primclex;
 
  fs::path root;
 
  bool is_help;
 
  // if LOG should be written
  bool write_log;
 
  // which casm sub-command ('init', 'enum', etc.)
  std::string command;
 
 private:
  void _init();
};
 
typedef std::function<int(const CommandArgs &)> Command;
typedef std::map<std::string, Command> CommandMap;
 
CommandMap &command_map();
 
int casm_api(const CommandArgs &args);
 
PrimClex &make_primclex_if_not(const CommandArgs &args,
                               std::unique_ptr<PrimClex> &uniq_primclex);
 
std::ostream &make_ostream_if(bool output, std::ostream &sout,
                              std::unique_ptr<std::ostream> &fout,
                              fs::path out_path, bool gzip);
 
int help_command(const CommandArgs &args);
 
int version_command(const CommandArgs &args);
 
template <typename OptionType>
class InterfaceBase;
 
template <typename OptionType>
using InterfaceMap =
    notstd::unique_cloneable_map<std::string, InterfaceBase<OptionType> >;
 
template <typename OptionType>
class InterfaceBase {
 public:
  InterfaceBase() {}
 
  virtual ~InterfaceBase() {}
 
  virtual std::string help() const = 0;
 
  virtual std::string name() const = 0;
 
  virtual int run(PrimClex const &primclex,
                  jsonParser const &json_options) const = 0;
 
  std::unique_ptr<InterfaceBase> clone() const {
    return std::unique_ptr<InterfaceBase>(this->_clone());
  }
 
 private:
  virtual InterfaceBase *_clone() const = 0;
};
 
template <typename OptionType>
std::unique_ptr<InterfaceMap<OptionType> > make_interface_map() {
  return notstd::make_unique<InterfaceMap<OptionType> >(
      [](const InterfaceBase<OptionType> &e) -> std::string {
        return e.name();
      },
      [](const InterfaceBase<OptionType> &e)
          -> notstd::cloneable_ptr<InterfaceBase<OptionType> > {
        return notstd::clone(e);
      });
}
 
}  // namespace CASM
 
#endif