loader.h

Go to the documentation of this file.

 
#pragma once
 
#include <neograph/api.h>
#include <neograph/graph/types.h>
#include <mutex>
#include <unordered_map>
#include <optional>
#include <string>
#include <vector>
 
namespace neograph::graph {
 
class GraphNode;
 
class NEOGRAPH_API ReducerRegistry {
public:
    static ReducerRegistry& instance();
 
    void register_reducer(const std::string& name, ReducerFn fn);
 
    ReducerFn get(const std::string& name) const;
 
    std::vector<std::string> names() const;
 
private:
    friend class GraphRegistry;
    mutable std::mutex mutex_;
    ReducerRegistry();
    std::unordered_map<std::string, ReducerFn> registry_;
};
 
struct ConditionSpec {
    std::vector<std::string> labels;
    bool open = false;
};
 
class NEOGRAPH_API ConditionRegistry {
public:
    static ConditionRegistry& instance();
 
    void register_condition(const std::string& name, ConditionFn fn);
 
    void register_condition(const std::string& name, ConditionFn fn,
                            ConditionSpec spec);
 
    ConditionFn get(const std::string& name) const;
 
    std::optional<ConditionSpec> condition_spec(const std::string& name) const;
 
    std::vector<std::string> names() const;
 
private:
    friend class GraphRegistry;
    mutable std::mutex mutex_;
    ConditionRegistry();
    std::unordered_map<std::string, ConditionFn> registry_;
    std::unordered_map<std::string, ConditionSpec> specs_;
};
 
using NodeFactoryFn = std::function<std::unique_ptr<GraphNode>(
    const std::string& name,
    const json& config,
    const NodeContext& ctx)>;
 
class NEOGRAPH_API NodeFactory {
public:
    static NodeFactory& instance();
 
    void register_type(const std::string& type, NodeFactoryFn fn);
 
    void register_type(const std::string& type, NodeFactoryFn fn,
                       json config_schema);
 
    void register_type(const std::string& type, NodeFactoryFn fn,
                       json config_schema, json effects);
 
    json node_effects(const std::string& type) const;
 
    std::unique_ptr<GraphNode> create(const std::string& type,
                                       const std::string& name,
                                       const json& config,
                                       const NodeContext& ctx) const;
 
    std::vector<std::string> registered_types() const;
 
    json config_schema(const std::string& type) const;
 
    json export_schema() const;
 
private:
    friend class GraphRegistry;
    mutable std::mutex mutex_;
    NodeFactory();
    std::unordered_map<std::string, NodeFactoryFn> registry_;
    std::unordered_map<std::string, json> schemas_;
    std::unordered_map<std::string, json> effects_;
};
 
} // namespace neograph::graph