graph.h

Go to the documentation of this file.

#ifndef FPMAS_GRAPH_API_H
#define FPMAS_GRAPH_API_H
 
#include <unordered_map>
#include "fpmas/api/graph/node.h"
#include "fpmas/api/graph/id.h"
#include "fpmas/api/utils/callback.h"
 
namespace fpmas { namespace api { namespace graph {
        template<typename NodeType, typename EdgeType>
            class Graph {
                static_assert(std::is_base_of<typename NodeType::EdgeType, EdgeType>::value,
                        "NodeType::EdgeType must be a base of EdgeType.");
                static_assert(std::is_base_of<typename EdgeType::NodeType, NodeType>::value,
                        "EdgeType::NodeType must be a base of NodeType.");
                public:
                typedef typename NodeType::IdType NodeIdType;
                typedef typename EdgeType::IdType EdgeIdType;
 
                typedef fpmas::api::graph::IdHash<typename NodeType::IdType> NodeIdHash;
                typedef fpmas::api::graph::IdHash<typename EdgeType::IdType> EdgeIdHash;
 
                typedef std::unordered_map<
                    NodeIdType, NodeType*, NodeIdHash
                    > NodeMap;
                typedef std::unordered_map<
                    EdgeIdType, EdgeType*, EdgeIdHash
                    > EdgeMap;
 
                public:
                virtual void insert(NodeType* node) = 0;
 
                virtual void insert(EdgeType* edge) = 0;
 
                
                virtual void erase(NodeType* node) = 0;
 
                virtual void erase(EdgeType* edge) = 0;
 
                virtual void addCallOnInsertNode(api::utils::Callback<NodeType*>* callback) = 0;
 
                virtual std::vector<api::utils::Callback<NodeType*>*> onInsertNodeCallbacks() const = 0;
 
                virtual void addCallOnEraseNode(api::utils::Callback<NodeType*>* callback) = 0;
 
                virtual std::vector<api::utils::Callback<NodeType*>*> onEraseNodeCallbacks() const = 0;
 
                virtual void addCallOnInsertEdge(api::utils::Callback<EdgeType*>* callback) = 0;
 
                virtual std::vector<api::utils::Callback<EdgeType*>*> onInsertEdgeCallbacks() const = 0;
 
                virtual void addCallOnEraseEdge(api::utils::Callback<EdgeType*>* callback) = 0;
 
                virtual std::vector<api::utils::Callback<EdgeType*>*> onEraseEdgeCallbacks() const = 0;
 
                // Node getters
                virtual NodeType* getNode(NodeIdType id) = 0;
                virtual const NodeType* getNode(NodeIdType id) const = 0;
                virtual const NodeMap& getNodes() const = 0;
 
                // Edge getters
                virtual EdgeType* getEdge(EdgeIdType id) = 0;
                virtual const EdgeType* getEdge(EdgeIdType) const = 0;
                virtual const EdgeMap& getEdges() const = 0;
 
                virtual void clear() = 0;
 
                virtual ~Graph() {}
            };
    }}
}
#endif