sjef.h

Go to the documentation of this file.

#ifndef SJEF_SJEF_H
#define SJEF_SJEF_H
#ifdef __APPLE__
#if (__DARWIN_C_LEVEL < __DARWIN_C_FULL) && (!defined(__STDC_VERSION__) || __STDC_VERSION__ < 201112L) &&              \
    (!defined(__cplusplus) || __cplusplus < 201703L)
#include <boost/align/aligned_alloc.hpp>
using boost::alignment::aligned_alloc;
#endif
#endif
#include <filesystem>
#include <iostream>
#include <map>
#include <memory>
#include <mutex>
#include <ostream>
#include <set>
#include <sjef/util/Logger.h>
#include <string>
#include <thread>
#include <vector>
 
namespace pugi {
class xpath_node_set; 
}
namespace sjef {
namespace util {
class Job;
class Locker; 
} // namespace util
class Backend; 
using util::Locker;
using util::Logger;
struct pugi_xml_document; 
static constexpr int recentMax = 128;
enum status : int { unknown = 0, running = 1, waiting = 2, completed = 3, unevaluated = 4, killed = 5, failed = 6 };
using mapstringstring_t = std::map<std::string, std::string>;
 
class Project {
private:
  std::string m_project_suffix;
  std::filesystem::path m_filename; 
  std::vector<std::filesystem::path> m_reserved_files = std::vector<std::filesystem::path>{
      sjef::Project::s_propertyFile}; 
  std::unique_ptr<pugi_xml_document> m_properties;
  mapstringstring_t m_suffixes; 
  std::map<std::string, Backend> m_backends;
 
  std::unique_ptr<pugi_xml_document> m_backend_doc;
  // put the flag into a container to deal conveniently with std:atomic_flag's
  // lack of move constructor
  struct unmovables_container {
    std::mutex m_property_set_mutex;
  };
  mutable unmovables_container m_unmovables;
  mutable std::string m_backend; 
  mutable std::string m_xml_cached;
  static const std::string s_propertyFile;
  std::shared_ptr<Locker> m_locker;
  mutable Logger m_warn{std::cerr, Logger::Levels::warning, {"sjef:: Error: ", "sjef:: Warning: ", "sjef:: Note:"}};
  mutable Logger m_trace{std::cout, Logger::Levels::quiet};
  friend class util::Job;
  mutable std::unique_ptr<util::Job> m_job;
 
public:
  explicit Project(const std::filesystem::path& filename, bool construct = true, const std::string& default_suffix = "",
                   const mapstringstring_t& suffixes = {{"inp", "inp"}, {"out", "out"}, {"xml", "xml"}});
  //  explicit Project(const std::string& filename, bool construct = true, const std::string& default_suffix = "",
  //                   const mapstringstring_t& suffixes = {{"inp", "inp"}, {"out", "out"}, {"xml", "xml"}}) :
  //                   Project(std::filesystem::path(filename),construct,default_suffix,suffixes) {}
  Project(const Project& source) = delete;
  Project(const Project&& source) = delete;
  virtual ~Project();
  bool copy(const std::filesystem::path& destination_filename, bool force = false, bool keep_hash = false,
            bool slave = false, int keep_run_directories = std::numeric_limits<int>::max(), bool history = true);
  bool move(const std::filesystem::path& destination_filename, bool force = false, bool history = true);
  bool trash();
  static void erase(const std::filesystem::path& filename, const std::string& default_suffix = "");
  bool import_file(const std::filesystem::path& file, bool overwrite = false);
  bool import_file(const std::vector<std::string>& files, bool overwrite = false) {
    bool result = true;
    for (const auto& file : files)
      result &= import_file(file, overwrite);
    return result;
  }
  bool export_file(const std::filesystem::path& file, bool overwrite = false);
  bool export_file(const std::vector<std::string>& files, bool overwrite = false) {
    bool result = true;
    for (const auto& file : files)
      result &= export_file(file, overwrite);
    return result;
  }
  void set_warnings(const Logger::Levels level = Logger::Levels::warning, std::ostream& stream = std::cerr,
                    std::vector<std::string> preambles = {"sjef:: Error: ", "sjef:: Warning: ", "sjef:: Note:"}) {
    m_warn = Logger{stream, level, std::move(preambles)};
  }
  void set_verbosity(int verbosity, std::ostream& stream = std::cout) { m_trace = Logger(stream, verbosity); }
 
  bool run(int verbosity = 0, bool force = false, bool wait = false, const std::string& options="");
  bool run(const std::string& name, int verbosity = 0, bool force = false, bool wait = false, const std::string& options="") {
    change_backend(name);
    return run(verbosity, force, wait);
  }
 
  sjef::status status() const;
  std::string status_message(int verbosity = 0) const;
  void wait(unsigned int maximum_microseconds = 10000) const;
  void kill(int verbosity = 0);
  bool run_needed(int verbosity = 0) const;
  std::string input_from_output(bool sync = true) const;
  int local_pid_from_output() const;
  void refresh_backends();
  sjef::status status_from_output() const;
  void rewrite_input_file(const std::string& input_file_name, const std::string& old_name);
  void custom_initialisation();
  void custom_run_preface();
  std::string xml(int run = 0, bool sync = true) const;
  std::string file_contents(const std::string& suffix = "", const std::string& name = "", int run = 0,
                            bool sync = true) const;
 
  void clean(int keep_run_directories = 1);
 
  void property_set(const std::string& property, const std::string& value);
  void property_set(const mapstringstring_t& properties);
  std::string property_get(const std::string& property) const;
  mapstringstring_t property_get(const std::vector<std::string>& properties) const;
  void property_delete(const std::string& property);
  void property_delete(const std::vector<std::string>& properties);
  std::vector<std::string> property_names() const;
  std::filesystem::path filename(std::string suffix = "", const std::string& name = "", int run = -1) const;
  std::string filename_string(std::string suffix = "", const std::string& name = "", int run = -1) const;
  std::string run_directory_basename(int run = 0) const;
  std::filesystem::path run_directory(int run = 0) const;
  int run_verify(int run) const;
  using run_list_t = std::vector<std::string>;
  run_list_t run_list() const;
  std::filesystem::path run_directory_new();
  void run_delete(int run);
  std::string name() const;
  static int recent_find(const std::string& suffix, const std::filesystem::path& filename);
  int recent_find(const std::filesystem::path& filename) const;
  static std::string recent(const std::string& suffix, int number = 1);
  std::string recent(int number = 1) const;
  void change_backend(std::string backend = std::string{""}, bool force = false);
 
  const std::map<std::string, Backend>& backends() const { return m_backends; }
  std::map<std::string, Backend>& backends() { return m_backends; }
 
private:
  Backend default_backend();
  void throw_if_backend_invalid(std::string backend = "") const;
  std::string get_project_suffix(const std::filesystem::path& filename, const std::string& default_suffix) const;
  static void recent_edit(const std::filesystem::path& add, const std::filesystem::path& remove = "");
  mutable std::filesystem::file_time_type m_property_file_modification_time;
  mutable std::map<std::string, std::filesystem::file_time_type, std::less<>> m_input_file_modification_time;
  std::set<std::string, std::less<>> m_run_directory_ignore;
  void property_delete_locked(const std::string& property);
  void check_property_file_locked() const;
  void check_property_file() const;
  void save_property_file_locked() const;
  void save_property_file() const;
  void load_property_file_locked() const;
  bool properties_last_written_by_me(bool removeFile = false) const;
  bool check_backends(const std::string& suffix) const;
 
public:
  std::filesystem::path propertyFile() const;
  const std::string backend_cache() const;
 
private:
  std::string cache(const Backend& backend) const;
  void force_file_names(const std::string& oldname);
  static void backend_watcher(sjef::Project& project_, int min_wait_milliseconds, int max_wait_milliseconds = 0,
                              int poll_milliseconds = 1);
  void shutdown_backend_watcher();
  std::string referenced_file_contents(const std::string& line) const;
 
public:
  static const std::vector<std::string> suffix_keys;
  /*
   */
  size_t project_hash();
  size_t input_hash() const;
 
  std::string backend_get(const std::string& backend, const std::string& key) const;
 
  std::string backend_parameter_expand(const std::string& backend, std::string templ = "") const;
 
  mapstringstring_t backend_parameters(const std::string& backend, bool doc = false) const;
 
  void backend_parameter_set(const std::string& backend, const std::string& name, const std::string& value) {
    property_set("Backend/" + backend + "/" + name, value);
  }
 
  void backend_parameter_delete(const std::string& backend, const std::string& name) {
    property_delete("Backend/" + backend + "/" + name);
  }
 
  std::string backend_parameter_get(const std::string& backend, const std::string& name) const {
    auto p = property_get("Backend/" + backend + "/" + name);
    if (p.find("!") == std::string::npos)
      return p;
    return p.substr(0, p.find("!"));
  }
 
  std::string backend_parameter_documentation(const std::string& backend, const std::string& name) const {
    auto ps = backend_parameters(backend, true);
    if (ps.count(name) == 0)
      return "";
    return ps.at(name);
  }
 
  std::string backend_parameter_default(const std::string& backend, const std::string& name) const {
    auto ps = backend_parameters(backend, false);
    if (ps.count(name) == 0)
      return "";
    return ps.at(name);
  }
 
  std::vector<std::string> backend_names() const;
 
  void add_backend(const std::string& name, const mapstringstring_t& fields);
 
  void delete_backend(const std::string& name);
 
  bool check_backend(const std::string& name) const;
 
  bool check_all_backends() const;
 
  void take_run_files(int run = 0, const std::string& fromname = "", const std::string& toname = "") const;
 
  void set_current_run(unsigned int run = 0);
 
  unsigned int current_run() const;
 
  pugi::xpath_node_set select_nodes(const std::string& xpath_query, int run = 0) const;
  std::vector<std::string> xpath_search(const std::string& xpath_query, const std::string& attribute = "",
                                        int run = 0) const;
 
  std::vector<std::string> xpath_xml(const std::string& xpath_query, int run = 0) const;
};
 
bool check_backends(const std::string& suffix);
 
std::filesystem::path expand_path(const std::filesystem::path& path, const std::string& suffix = "");
 
std::string xmlRepair(const std::string& source, const mapstringstring_t& injections = {});
 
std::string version() noexcept;
 
class runtime_error : public std::runtime_error {
  using std::runtime_error::runtime_error;
};
 
} // namespace sjef
 
#endif // SJEF_SJEF_H