:github_url: https://github.com/svenevs/exhale-companion


.. _program_listing_file_py2cpp_nx2bgl.hpp:

Program Listing for File nx2bgl.hpp
===================================

|exhale_lsh| :ref:`Return to documentation for file <file_py2cpp_nx2bgl.hpp>` (``py2cpp/nx2bgl.hpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #pragma once
   
   #include <boost/graph/adjacency_list.hpp>
   #include <boost/graph/graph_traits.hpp>
   #include <boost/graph/graph_utility.hpp>
   #include <type_traits>
   
   namespace xn {
   
   template <typename Graph> class VertexView : public Graph {
     public:
       explicit VertexView(Graph &&G) noexcept : Graph{std::forward<Graph>(G)} {}
   
       [[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 &G;
   
     public:
       explicit EdgeView(const Graph &G) : G{G} {}
   
       [[nodiscard]] auto begin() const {
           // auto [e_iter, e_end] = boost::edges(_G);
           // return e_iter;
           return boost::edges(this->G).first;
       }
   
       [[nodiscard]] auto end() const {
           // auto [e_iter, e_end] = boost::edges(_G);
           // return e_end;
           return boost::edges(this->G).second;
       }
   
       [[nodiscard]] auto cbegin() const {
           // auto [e_iter, e_end] = boost::edges(_G);
           // return e_iter;
           return boost::edges(this->G).first;
       }
   
       [[nodiscard]] auto cend() const {
           // auto [e_iter, e_end] = boost::edges(_G);
           // return e_end;
           return boost::edges(this->G).second;
       }
   };
   
   template <typename Vertex, typename Graph> class AtlasView {
     private:
       Vertex _v;
       const Graph &G;
   
     public:
       AtlasView(Vertex v, const Graph &G) : _v{v}, G{G} {}
   
       auto begin() const {
           // auto [e_iter, e_end] = boost::out_edges(_v, _G);
           // return e_iter;
           return boost::out_edges(this->_v, this->G).first;
       }
   
       auto end() const {
           // auto [e_iter, e_end] = boost::out_edges(_v, _G);
           // return e_end;
           return boost::out_edges(this->_v, this->G).second;
       }
   
       auto cbegin() const {
           // auto [e_iter, e_end] = boost::out_edges(_v, _G);
           // return e_iter;
           return boost::out_edges(this->_v, this->G).first;
       }
   
       auto cend() const {
           // auto [e_iter, e_end] = boost::out_edges(_v, _G);
           // return e_end;
           return boost::out_edges(this->_v, this->G).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 &&G) noexcept
           : VertexView<Graph>{std::forward<Graph>(G)} {}
   
       // 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(u, 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 xn