runEnvironment.hpp

#ifndef ABLATELIBRARY_RUNENVIRONMENT_HPP
#define ABLATELIBRARY_RUNENVIRONMENT_HPP
#include <filesystem>
#include <functional>
#include <memory>
#include <parameters/mapParameters.hpp>
#include <regex>
#include <string>
#include "parameters/parameters.hpp"
 
namespace ablate::environment {
class RunEnvironment {
   private:
    inline static int DefaultGlobalArgc = 0;
 
    inline static char** DefaultGlobalArgs = nullptr;
 
    inline static int* GlobalArgc = &DefaultGlobalArgc;
 
    inline static char*** GlobalArgs = &DefaultGlobalArgs;
 
    std::filesystem::path outputDirectory;
 
    const std::string title;
 
    // default empty runEnvironment
    explicit RunEnvironment();
 
    static const inline std::regex OutputDirectoryVariable = std::regex("\\$OutputDirectory");
 
    struct FinalizeFunction {
        std::string name;
        std::function<void()> function;
    };
 
    inline static std::vector<FinalizeFunction> finalizeFunctions;
 
   public:
    explicit RunEnvironment(const parameters::Parameters&, const std::filesystem::path& inputPath = {});
    ~RunEnvironment() = default;
 
    // force RunEnvironment to be a singleton
    RunEnvironment(RunEnvironment& other) = delete;
    void operator=(const RunEnvironment&) = delete;
 
    // create an empty run env
    static void Setup();
 
    // static access methods
    static void Setup(const parameters::Parameters&, const std::filesystem::path& inputPath = {});
    inline static const RunEnvironment& Get() {
        if (!runEnvironment) {
            runEnvironment.reset(new RunEnvironment());
        }
        return *runEnvironment;
    }
 
    [[nodiscard]] inline const std::filesystem::path& GetOutputDirectory() const { return outputDirectory; }
 
    void ExpandVariables(std::string& value) const;
 
    static void Initialize(int* argc, char*** args);
 
    static void RegisterCleanUpFunction(const std::string& name, std::function<void()>);
 
    static void Finalize();
 
    static inline int* GetArgCount() { return GlobalArgc; }
 
    static inline char*** GetArgs() { return GlobalArgs; }
 
    static std::string_view GetVersion();
 
    class Parameters : public parameters::MapParameters {
       public:
        inline Parameters& OutputDirectory(const std::filesystem::path& path) {
            Insert("directory", path.string());
            return *this;
        }
 
        inline Parameters& TagDirectory(bool tag) {
            Insert("tagDirectory", tag);
            return *this;
        }
        inline Parameters& Title(std::string simulationTitle) {
            Insert("title", simulationTitle);
            return *this;
        }
    };
 
   private:
    inline static std::unique_ptr<RunEnvironment> runEnvironment = std::unique_ptr<RunEnvironment>();
};
}  // namespace ablate::environment
 
#endif  // ABLATELIBRARY_RUNENVIRONMENT_HPP