nx2bgl.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/graph_traits.hpp>
#include <boost/graph/graph_utility.hpp>
 
namespace py {
 
    template <typename Graph> class VertexView : public Graph {
      public:
        explicit VertexView(Graph&& gra) noexcept : Graph{std::move(gra)} {}
 
        [[nodiscard]] auto begin() const {
            // auto [v_iter, v_end] = boost::vertices(*this);
            // return v_iter;
            return boost::vertices(*this).first;
        }
 
        [[nodiscard]] auto end() const {
            // auto [v_iter, v_end] = boost::vertices(*this);
            // return v_end;
            return boost::vertices(*this).second;
        }
 
        [[nodiscard]] auto cbegin() const {
            // auto [v_iter, v_end] = boost::vertices(*this);
            // return v_iter;
            return boost::vertices(*this).first;
        }
 
        [[nodiscard]] auto cend() const {
            // auto [v_iter, v_end] = boost::vertices(*this);
            // return v_end;
            return boost::vertices(*this).second;
        }
    };
 
    template <typename Graph> class EdgeView {
      private:
        const Graph& gra;
 
      public:
        explicit EdgeView(const Graph& gra) : gra{gra} {}
 
        [[nodiscard]] auto begin() const {
            // auto [e_iter, e_end] = boost::edges(_gra);
            // return e_iter;
            return boost::edges(this->gra).first;
        }
 
        [[nodiscard]] auto end() const {
            // auto [e_iter, e_end] = boost::edges(_gra);
            // return e_end;
            return boost::edges(this->gra).second;
        }
 
        [[nodiscard]] auto cbegin() const {
            // auto [e_iter, e_end] = boost::edges(_gra);
            // return e_iter;
            return boost::edges(this->gra).first;
        }
 
        [[nodiscard]] auto cend() const {
            // auto [e_iter, e_end] = boost::edges(_gra);
            // return e_end;
            return boost::edges(this->gra).second;
        }
    };
 
    template <typename Vertex, typename Graph> class AtlasView {
      private:
        Vertex _v;
        const Graph& gra;
 
      public:
        AtlasView(Vertex v, const Graph& gra) : _v{v}, gra{gra} {}
 
        auto begin() const {
            // auto [e_iter, e_end] = boost::out_edges(_v, _gra);
            // return e_iter;
            return boost::out_edges(this->_v, this->gra).first;
        }
 
        auto end() const {
            // auto [e_iter, e_end] = boost::out_edges(_v, _gra);
            // return e_end;
            return boost::out_edges(this->_v, this->gra).second;
        }
 
        auto cbegin() const {
            // auto [e_iter, e_end] = boost::out_edges(_v, _gra);
            // return e_iter;
            return boost::out_edges(this->_v, this->gra).first;
        }
 
        auto cend() const {
            // auto [e_iter, e_end] = boost::out_edges(_v, _gra);
            // return e_end;
            return boost::out_edges(this->_v, this->gra).second;
        }
    };
 
    template <typename Graph> class GrAdaptor : public VertexView<Graph> {
      public:
        using Vertex = typename boost::graph_traits<Graph>::vertex_descriptor;
        using node_t = Vertex;
        using edge_t = typename boost::graph_traits<Graph>::edge_descriptor;
 
        // using edge_wt_t = decltype( boost::get(boost::edge_weight,
        // std::declval<Graph>()) );
 
        GrAdaptor() = delete;
 
        explicit GrAdaptor(Graph&& gra) noexcept : VertexView<Graph>{std::move(gra)} {}
 
        // GrAdaptor(const GrAdaptor&) = delete;            // don't copy
        // GrAdaptor& operator=(const GrAdaptor&) = delete; // don't assign
        // GrAdaptor(GrAdaptor&&) noexcept = default;                // don't copy
 
        [[nodiscard]] auto number_of_nodes() const { return boost::num_vertices(*this); }
 
        [[nodiscard]] auto number_of_edges() const { return boost::num_edges(*this); }
 
        [[nodiscard]] auto edges() const -> EdgeView<Graph> { return EdgeView<Graph>(*this); }
 
        [[nodiscard]] auto neighbors(Vertex v) const -> AtlasView<Vertex, Graph> {
            return AtlasView<Vertex, Graph>(v, *this);
        }
 
        auto add_edge(int u, int v) {
            return boost::add_edge(static_cast<Vertex>(u), static_cast<Vertex>(v), *this);
        }
 
        static auto null_vertex() -> Vertex { return boost::graph_traits<Graph>::null_vertex(); }
 
        template <typename Edge> auto source(const Edge& e) const -> Vertex {
            return boost::source(e, *this);
        }
 
        template <typename Edge> auto target(const Edge& e) const -> Vertex {
            return boost::target(e, *this);
        }
 
        template <typename Edge> [[nodiscard]] auto end_points(const Edge& e) const {
            auto s = boost::source(e, *this);
            auto t = boost::target(e, *this);
            return std::make_pair(s, t);
        }
    };
 
}  // namespace py