SequenceManager.h

Go to the documentation of this file.

 
// SPDX-License-Identifier: LGPL-2.1-or-later
 
#ifndef TASKOLIB_SEQUENCEMANAGER_H_
#define TASKOLIB_SEQUENCEMANAGER_H_
 
#include <filesystem>
#include <string>
#include <vector>
 
#include <gul14/optional.h>
#include <gul14/string_view.h>
#include <libgit4cpp/Repository.h>
 
#include "taskolib/Sequence.h"
#include "taskolib/UniqueId.h"
 
namespace task {
 
class SequenceManager
{
public:
    struct SequenceOnDisk
    {
        std::filesystem::path path;
 
        SequenceName name; 
        UniqueId unique_id; 
 
        friend bool operator==(const SequenceOnDisk& a, const SequenceOnDisk& b) noexcept
        {
            return a.unique_id == b.unique_id && a.name == b.name && a.path == b.path;
        }
 
        friend bool operator!=(const SequenceOnDisk& a, const SequenceOnDisk& b) noexcept
        {
            return !(a == b);
        }
    };
 
    explicit SequenceManager(std::filesystem::path path);
 
    Sequence copy_sequence(UniqueId original_uid, const SequenceName& new_name);
 
    Sequence create_sequence(gul14::string_view label = "", SequenceName name = SequenceName{});
 
    std::filesystem::path get_path() const { return path_; }
 
    Sequence import_sequence(const std::filesystem::path& path);
 
    std::vector<SequenceOnDisk> list_sequences() const;
 
    Sequence load_sequence(UniqueId uid) const;
 
    Sequence
    load_sequence(UniqueId uid, const std::vector<SequenceOnDisk>& sequences) const;
 
    Sequence load_sequence(std::filesystem::path folder) const;
 
    static gul14::optional<SequenceOnDisk>
    parse_folder_name(const std::filesystem::path& folder);
 
    void remove_sequence(UniqueId unique_id);
 
    void rename_sequence(UniqueId unique_id, const SequenceName& new_name);
 
    void rename_sequence(Sequence& sequence, const SequenceName& new_name);
 
    bool store_sequence(const Sequence& sequence);
 
private:
    std::filesystem::path path_;
 
    git::Repository git_repo_;
 
    static UniqueId create_unique_id(const std::vector<SequenceOnDisk>& sequences);
 
    Sequence load_sequence(const SequenceOnDisk& seq_on_disk) const;
 
    template <typename T>
    bool perform_commit(std::string message, T action, std::string extra_dir = "")
    {
        auto commit_body = std::string{ };
        try {
            git_repo_.reset(0);
            if constexpr (std::is_same<decltype(action()), void>::value)
                action();
            else {
                auto path = action();
                commit_body = stage_files_in_directory(path);
                message += path;
            }
            if (not extra_dir.empty())
                commit_body = stage_files_in_directory(extra_dir);
            if (commit_body.empty())
                return false;
            git_repo_.commit(gul14::cat(message, "\n", commit_body));
        }
        catch (std::exception const& e) {
            try {
                git_repo_.reset(0);
            }
            catch (...) {}
            throw e;
        }
        return true;
    }
 
    std::string stage_files_in_directory(const std::string& directory);
 
    std::string stage_files(const std::string& glob);
 
    static SequenceOnDisk find_sequence_on_disk(UniqueId uid,
        const std::vector<SequenceOnDisk>& sequences);
 
    static SequenceName make_sequence_name_from_label(gul14::string_view label);
 
    std::string write_sequence_to_disk(const Sequence& sequence);
};
 
} // namespace task
 
#endif
 
// vi:ts=4:sw=4:sts=4:et