Graph.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
#include <memory>
#include <unordered_map>
#include <vector>
 
#include "smgl/Node.hpp"
#include "smgl/Uuid.hpp"
#include "smgl/filesystem.hpp"
 
namespace smgl
{
 
// Pre-declare for Graphviz
class GraphStyle;
 
enum class CacheType {
    Adjacent = 0,
    Subdirectory
};
 
class Graph : public UniquelyIdentifiable
{
public:
    constexpr static std::uint32_t Version{1};
 
    enum class State { Idle, Updating, Error };
 
    auto operator[](const Uuid& uuid) const -> Node::Pointer;
 
    void insertNode(const Node::Pointer& n);
 
    template <typename NodeType, typename... Args>
    auto insertNode(Args... args) -> std::shared_ptr<NodeType>;
 
    template <typename N, typename... Ns>
    void insertNodes(N& n0, Ns&&... nodes);
 
    void removeNode(const Node::Pointer& n);
 
    auto size() const -> std::size_t;
 
    auto state() const -> State;
 
    auto cacheFile() const -> filesystem::path;
 
    void setCacheFile(const filesystem::path& p);
 
    auto cacheType() const -> CacheType;
 
    void setCacheType(CacheType t);
 
    auto cacheDir() const -> filesystem::path;
 
    auto cacheEnabled() const -> bool;
 
    void setEnableCache(bool enable);
 
    void setProjectMetadata(const Metadata& m);
 
    auto projectMetadata() const -> const Metadata&;
 
    auto projectMetadata() -> Metadata&;
 
    auto update() -> State;
 
    static auto Serialize(const Graph& g) -> Metadata;
 
    static auto Save(
        const filesystem::path& path, const Graph& g, bool writeCache = false)
        -> void;
 
    static auto Load(const filesystem::path& path) -> Graph;
 
    static auto CheckRegistration(const filesystem::path& path)
        -> std::vector<std::string>;
 
    static auto CheckRegistration(const Graph& g) -> std::vector<std::string>;
 
    static auto Schedule(const Graph& g) -> std::vector<Node::Pointer>;
 
private:
    filesystem::path cacheFile_;
    CacheType cacheType_{CacheType::Subdirectory};
    bool cache_enabled_{false};
    std::unordered_map<Uuid, Node::Pointer> nodes_;
    State state_{State::Idle};
    Metadata extraMetadata_;
 
    static auto Serialize(
        const Graph& g, bool useCache, const filesystem::path& cacheDir)
        -> Metadata;
 
    friend auto WriteDotFile(
        const filesystem::path& path, const Graph& g, const GraphStyle& style)
        -> void;
};
 
}  // namespace smgl
 
#include "smgl/GraphImpl.hpp"