engine.h

#ifndef CAPIO_CL_ENGINE_H
#define CAPIO_CL_ENGINE_H
#include <vector>
 
#include "capiocl.hpp"
#include "capiocl/monitor.h"
#include "capiocl/serializer.h"

namespace capiocl::engine {
class Engine final {
    friend class serializer::Serializer;
    bool store_all_in_memory = false;

    configuration::CapioClConfiguration configuration;

    monitor::Monitor monitor;

    std::string node_name;

    std::string workflow_name;
 
    // LCOV_EXCL_START
    struct CapioCLEntry final {
        std::vector<std::string> producers;
        std::vector<std::string> consumers;
        std::vector<std::filesystem::path> file_dependencies;
        std::string commit_rule            = commitRules::ON_TERMINATION;
        std::string fire_rule              = fireRules::UPDATE;
        long directory_children_count      = 0;
        long commit_on_close_count         = 0;
        bool enable_directory_count_update = true; // whether to update or not directory item count
        bool store_in_memory               = false;
        bool permanent                     = false;
        bool excluded                      = false;
        bool is_file                       = true;
    };
 
    // LCOV_EXCL_STOP

    mutable std::unordered_map<std::string, CapioCLEntry> _capio_cl_entries;

    static std::string truncateLastN(const std::string &str, const std::size_t n) {
        if (str.length() > n) {
            return "[..] " + str.substr(str.length() - n);
        }
        return str;
    }

    void _newFile(const std::filesystem::path &path) const;

    void compute_directory_entry_count(const std::filesystem::path &path) const;
 
  public:
    explicit Engine(bool use_default_settings = true);

    void print() const;

    bool contains(const std::filesystem::path &file) const;

    size_t size() const;

    void add(std::filesystem::path &path, std::vector<std::string> &producers,
             std::vector<std::string> &consumers, const std::string &commit_rule,
             const std::string &fire_rule, bool permanent, bool exclude,
             std::vector<std::filesystem::path> &dependencies);

    void addProducer(const std::filesystem::path &path, std::string &producer);

    void addConsumer(const std::filesystem::path &path, std::string &consumer);

    void addFileDependency(const std::filesystem::path &path,
                           std::filesystem::path &file_dependency);

    void newFile(const std::filesystem::path &path);

    void remove(const std::filesystem::path &path) const;

    void setCommitRule(const std::filesystem::path &path, const std::string &commit_rule);

    void setFireRule(const std::filesystem::path &path, const std::string &fire_rule);

    void setPermanent(const std::filesystem::path &path, bool value);

    void setExclude(const std::filesystem::path &path, bool value);

    void setDirectory(const std::filesystem::path &path);

    void setFile(const std::filesystem::path &path);

    void setCommitedCloseNumber(const std::filesystem::path &path, long num);

 
    void setDirectoryFileCount(const std::filesystem::path &path, long num);

    void setFileDeps(const std::filesystem::path &path,
                     const std::vector<std::filesystem::path> &dependencies);

    void setStoreFileInMemory(const std::filesystem::path &path);

    void setAllStoreInMemory();

    void setStoreFileInFileSystem(const std::filesystem::path &path);

    void setWorkflowName(const std::string &name);

    long getDirectoryFileCount(const std::filesystem::path &path) const;

    std::string getCommitRule(const std::filesystem::path &path) const;

    std::string getFireRule(const std::filesystem::path &path) const;

    std::vector<std::string> getProducers(const std::filesystem::path &path) const;

    std::vector<std::string> getConsumers(const std::filesystem::path &path) const;

    long getCommitCloseCount(const std::filesystem::path::iterator::reference &path) const;

    std::vector<std::filesystem::path>
    getCommitOnFileDependencies(const std::filesystem::path &path) const;

    std::vector<std::string> getFileToStoreInMemory() const;

    std::set<std::string> getHomeNode(const std::filesystem::path &path) const;

    void setHomeNode(const std::filesystem::path &path) const;

    const std::string &getWorkflowName() const;

    bool isProducer(const std::filesystem::path &path, const std::string &app_name) const;

    bool isConsumer(const std::filesystem::path &path, const std::string &app_name) const;

    bool isFirable(const std::filesystem::path &path) const;

    bool isFile(const std::filesystem::path &path) const;

    bool isExcluded(const std::filesystem::path &path) const;

    bool isDirectory(const std::filesystem::path &path) const;

    bool isStoredInMemory(const std::filesystem::path &path) const;

    bool isPermanent(const std::filesystem::path &path) const;

    bool isCommitted(const std::filesystem::path &path) const;

    void setCommitted(const std::filesystem::path &path) const;

    std::vector<std::string> getPaths() const;

    bool operator==(const Engine &other) const;

    void loadConfiguration(const std::string &path);

    void useDefaultConfiguration();
};
 
} // namespace capiocl::engine
 
#endif // CAPIO_CL_ENGINE_H