Program Listing for File nx2bgl.hpp

↰ Return to documentation for file (py2cpp/nx2bgl.hpp)

#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