OGDFGraphWrapper.h

Go to the documentation of this file.

 
#pragma once
 
#ifdef OGDF_INCLUDE_CGAL
 
#   include <ogdf/basic/Graph.h>
#   include <ogdf/fileformats/GraphIO.h>
#   include <ogdf/geometric/cr_min/datastructure/Iterators.h>
#   include <ogdf/geometric/cr_min/datastructure/OGDFVector.h>
#   include <ogdf/geometric/cr_min/graph/ogdf_iterator.h>
#   include <ogdf/geometric/cr_min/tools/ogdf/Universal.h>
 
#   include <algorithm>
#   include <iostream>
#   include <map>
#   include <vector>
 
namespace ogdf {
namespace internal {
namespace gcm {
namespace graph {
 
class OGDFGraphWrapper {
public:
    using Node = node;
    using Edge = edge;
    using AdjEntry = adjEntry;
 
protected:
    std::shared_ptr<Graph> self_generated_graph;
    const Graph& graph;
 
    static void id_sg_handle_node(Node, Node) { }
 
    static void id_sg_handle_edge(Edge, Edge) { }
 
 
public:
    OGDFGraphWrapper() : self_generated_graph(new Graph()), graph(*self_generated_graph) {
        /*nothing to do*/
    }
 
    OGDFGraphWrapper(const Graph& _graph) : self_generated_graph(nullptr), graph(_graph) {
        /*nothing to do*/
    }
 
    ~OGDFGraphWrapper() { }
 
    inline const Graph& get_graph() { return graph; }
 
    inline const Graph& get_ogdf_graph() { return graph; }
 
    inline size_t number_of_nodes() const { return graph.numberOfNodes(); }
 
    inline size_t number_of_edges() const { return graph.numberOfEdges(); }
 
    inline size_t max_node_index() const { return graph.maxNodeIndex(); }
 
    inline size_t max_edge_index() const { return graph.maxEdgeIndex(); }
 
    inline Node get_node(unsigned int i) const {
        for (auto w : nodes()) {
            if (w->index() == (int)i) {
                return w;
            }
        }
        return nullptr;
    }
 
    inline Edge search_edge(Node v, Node w) const {
        if (v->degree() < w->degree()) {
            for (auto e : edges(v)) {
                if (e->opposite(v) == w) {
                    return e;
                }
            }
            return nullptr;
        } else {
            for (auto e : edges(w)) {
                if (e->opposite(w) == v) {
                    return e;
                }
            }
            return nullptr;
        }
    }
 
    inline bool are_adjacent(Node v, Node w) const { return search_edge(v, w) != nullptr; }
 
    inline datastructure::IteratorRange<NodeIterator> nodes() const {
        if (number_of_nodes() > 0) {
            return datastructure::IteratorRange<NodeIterator>(NodeIterator(graph.firstNode()),
                    NodeIterator(graph.lastNode()->succ()));
        } else {
            return datastructure::IteratorRange<NodeIterator>(Node(0), Node(0));
        }
    }
 
    inline datastructure::IteratorRange<EdgeIterator> edges() const {
        if (number_of_edges() > 0) {
            return datastructure::IteratorRange<EdgeIterator>(EdgeIterator(graph.firstEdge()),
                    EdgeIterator(graph.lastEdge()->succ()));
        } else {
            return datastructure::IteratorRange<EdgeIterator>(Edge(0), Edge(0));
        }
    }
 
    inline datastructure::IteratorRange<IncidentEdgeIterator> edges(const Node w) const {
        if (w->degree() == 0) {
            return datastructure::IteratorRange<IncidentEdgeIterator>(
                    IncidentEdgeIterator(adjEntry(0)), IncidentEdgeIterator(adjEntry(0)));
        } else {
            return datastructure::IteratorRange<IncidentEdgeIterator>(
                    IncidentEdgeIterator(w->firstAdj()), IncidentEdgeIterator(w->lastAdj()->succ()));
        }
    }
 
    inline datastructure::IteratorRange<AdjEntryIterator> adj(const Node w) const {
        if (w->degree() == 0) {
            return datastructure::IteratorRange<AdjEntryIterator>(AdjEntryIterator(adjEntry(0)),
                    AdjEntryIterator(adjEntry(0)));
        } else {
            return datastructure::IteratorRange<AdjEntryIterator>(AdjEntryIterator(w->firstAdj()),
                    AdjEntryIterator(w->lastAdj()->succ()));
        }
    }
 
    inline datastructure::IteratorRange<AdjacentNodeIterator> neighbors(const Node w) const {
        if (w->degree() == 0) {
            return datastructure::IteratorRange<AdjacentNodeIterator>(
                    AdjacentNodeIterator(adjEntry(0)), AdjacentNodeIterator(adjEntry(0)));
 
        } else {
            return datastructure::IteratorRange<AdjacentNodeIterator>(
                    AdjacentNodeIterator(w->firstAdj()), AdjacentNodeIterator(w->lastAdj()->succ()));
        }
    }
};
 
}
}
}
}
 
 
#endif