shared.hpp

#pragma once
 
 
#include <filesystem>
#include <set>
#include <sys/inotify.h>
#include <random>
#include <fcntl.h>
#include <csignal>
#include <exec.hpp>
 
#ifdef PROFILE
#include <map>
#endif
 
#include "third_party/thread-pool/include/BS_thread_pool.hpp"
 
namespace shared {
 
  // The thread pool
  extern BS::thread_pool<BS::tp::wait_deadlock_checks> pool;
 
  // Environment variables
  extern const std::string runtime, config, cache, data, home, session, nobody, real;
 
  extern std::filesystem::path data_dir, app_data;
 
  // Our inotify watch
  extern int inotify;
 
  // Definitions.
  using set = std::set<std::string>;
  using vector = std::vector<std::string>;
  using list = std::initializer_list<std::string_view>;
 

  class TemporaryDirectory {
    private:
      static std::random_device dev;
      static std::mt19937 prng;
      static std::uniform_int_distribution<uint64_t> rand;
 
      // The path, and the name
      std::string path;
      std::string name;

      void generate(const std::string_view& parent, const std::string_view& prefix, const std::string_view& suffix) {
        path.reserve(parent.length() + prefix.length() + suffix.length() + 17);
        path.append(parent); if (!parent.ends_with('/')) path += '/';
 
        std::stringstream name_stream;
        if (!prefix.empty()) name_stream << prefix << '-';
        name_stream << std::hex << rand(prng);
        if (!suffix.empty()) name_stream << '-' << suffix;
        name = name_stream.str();
        path += name;
      }
 
    public:

    TemporaryDirectory(
        const std::string& parent = std::filesystem::temp_directory_path(),
        const std::string_view& prefix = "", const std::string_view& suffix = "",
        const bool& defer = false
    ) {
      do {
        generate(parent, prefix, suffix);
      } while (std::filesystem::is_directory(path));
      if (!defer) create();
    }
 
    // Obliterate the directory.
    ~TemporaryDirectory() {std::filesystem::remove_all(path);}

    const std::string& get_path() const {return path;}

    void create() const {std::filesystem::create_directories(path);}

    std::string sub(const std::string& name, const bool& dir = false) const {
      const auto new_path = path + "/" + name;
      if (dir) std::filesystem::create_directories(new_path);
      return new_path;
    }

    const std::string& get_name() const {return name;}
  };

  void log(const list& msg, const std::string& level="log");
 

  template <class T = list> void extend(vector& dest, T source);
  template <class T = list> void extend(set& dest, T source);
  void extend(set& dest, set source);
 

  template <class T = vector> std::string join(const T& list, const char& joiner =  ' ');
 

  template <typename T = char> std::string strip(const std::string_view& in, const T& to_strip);
 

  template <typename T = char> std::string trim(const std::string& in, const T& to_strip);
 

  set wildcard(const std::string_view& pattern, const std::string_view& path, const list& args = {});
 

  std::string escape(const std::string& in);
 

  void share(vector& command, const std::string_view& path, const std::string& mode = "ro-bind");
 

  void merge(set& command, set path);
 

  void genv(vector& command, const std::string_view& env);
 

  void inotify_wait(const int& wd, const std::string_view& name = "");
 

  std::string hash(const std::string_view& in);

  template <class T, class A, class L = list, class ...Args> void single_batch(const A& fun, T& accum, const L& mem, Args&&... args) {
    for (const auto& val : mem) fun(accum, val, args...);
  }

  template <class T, class A, class L = list, class ...Args> void batch(const A& fun, T& accum, const L& mem, Args&&... args) {
    std::vector<std::future<T>> futures; futures.reserve(mem.size());
    for (auto& val : mem) {
      futures.emplace_back(pool.submit_task([val = std::move(val), &fun, &args...]() {return container::init<T>(fun, val, args...);}));
    }
    for (auto& future : futures) extend(accum, future.get());
  }
 

  void extend(vector& dest, const std::initializer_list<const list>& source);
 
 
  // Profiling stuff :)
  #ifdef PROFILE
  extern std::map<std::string, uint_fast32_t> time_slice;
 
  template <typename T> inline void profile(const std::string& name, T func) {
    auto begin = std::chrono::high_resolution_clock::now();
    func();
    auto duration = duration_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::now() - begin).count();
    time_slice["total"] += duration;
    time_slice[name] = duration;
    log({name, ":", std::to_string(duration), "us"});
  }
  #else
    #define profile(name, func) func();
  #endif
}