Graph.hpp

Go to the documentation of this file.

#ifndef RAIIGRAPH_GRAPH_HPP 
#define RAIIGRAPH_GRAPH_HPP
 
#include "igraph.h"
#include "Vector.hpp"
#include "error.hpp"
 
namespace raiigraph {
 
class Graph {
private:
    void setup(igraph_int_t num_vertices, igraph_bool_t directed) {
        check_code(igraph_empty(&my_graph, num_vertices, directed));
    }
 
public:
    Graph(igraph_int_t num_vertices = 0, igraph_bool_t directed = false) {
        setup(num_vertices, directed);
    }
 
    Graph(const IntVector& edges, igraph_int_t num_vertices, igraph_bool_t directed) : Graph(edges.get(), num_vertices, directed) {} 
 
    Graph(const igraph_vector_int_t* edges, igraph_int_t num_vertices, igraph_bool_t directed) { 
        check_code(igraph_create(&my_graph, edges, num_vertices, directed));
    }
 
    Graph(igraph_t&& graph) : my_graph(std::move(graph)) {}
 
public:
    Graph(const Graph& other) {
        check_code(igraph_copy(&my_graph, &(other.my_graph)));
    }
 
    Graph& operator=(const Graph& other) {
        if (this != &other) {
            check_code(igraph_copy(&my_graph, &(other.my_graph)));
        }
        return *this;
    }
 
    Graph(Graph&& other) {
        setup(0, false);
        std::swap(my_graph, other.my_graph);
    }    
 
    Graph& operator=(Graph&& other) {
        if (this != &other) {
            std::swap(my_graph, other.my_graph);
        }
        return *this;
    }
 
    ~Graph() {
        igraph_destroy(&my_graph);
    }
 
public:
    igraph_int_t vcount() const {
        return igraph_vcount(&my_graph);
    }
 
    igraph_int_t ecount() const {
        return igraph_ecount(&my_graph);
    }
 
    IntVector get_edgelist(igraph_bool_t by_col = false) const {
        IntVector out(ecount());
        check_code(igraph_get_edgelist(&my_graph, out.get(), by_col));
        return out;
    }
 
public:
    igraph_bool_t is_directed() const {
        return igraph_is_directed(&my_graph);
    }
 
    igraph_bool_t is_connected(igraph_connectedness_t mode = IGRAPH_WEAK) const {
        igraph_bool_t res;
        check_code(igraph_is_connected(&my_graph, &res, mode));
        return res;
    }
 
    igraph_bool_t is_simple(igraph_bool_t directed) const {
        igraph_bool_t res;
        check_code(igraph_is_simple(&my_graph, &res, directed));
        return res;
    }
 
    igraph_bool_t has_loop() const {
        igraph_bool_t res;
        check_code(igraph_has_loop(&my_graph, &res));
        return res;
    }
 
    igraph_bool_t has_multiple() const {
        igraph_bool_t res;
        check_code(igraph_has_multiple(&my_graph, &res));
        return res;
    }
 
    igraph_bool_t has_mutual(igraph_bool_t loops = false) const {
        igraph_bool_t res;
        check_code(igraph_has_mutual(&my_graph, &res, loops));
        return res;
    }
 
    bool is_tree(igraph_neimode_t mode = IGRAPH_ALL) const {
        igraph_bool_t res;
        check_code(igraph_is_tree(&my_graph, &res, NULL, mode));
        return res;
    }
 
    bool is_forest(igraph_neimode_t mode = IGRAPH_ALL) const {
        igraph_bool_t res;
        check_code(igraph_is_forest(&my_graph, &res, NULL, mode));
        return res;
    }
 
    bool is_dag() const {
        igraph_bool_t res;
        check_code(igraph_is_dag(&my_graph, &res));
        return res;
    }
 
    bool is_acyclic() const {
        igraph_bool_t res;
        check_code(igraph_is_acyclic(&my_graph, &res));
        return res;
    }
 
public:
    operator igraph_t*() {
        return &my_graph;
    }
 
    operator const igraph_t*() const {
        return &my_graph;
    }
 
    igraph_t* get() {
        return &my_graph;
    }
 
    const igraph_t* get() const {
        return &my_graph;
    }
 
private:
    igraph_t my_graph;
};
 
}
 
#endif