digraphs.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cassert>
#include <py2cpp/py2cpp.hpp>
#include <type_traits>
#include <utility>
#include <vector>
#include <xnetwork/classes/coreviews.hpp>  // import AtlasView, AdjacencyView
#include <xnetwork/classes/graph.hpp>
#include <xnetwork/classes/reportviews.hpp>  // import NodeView, EdgeView, DegreeView
 
// #if __cplusplus > 201703L
// #include <cppcoro/generator.hpp>
// #endif
 
namespace xnetwork {
 
    template <typename nodeview_t, typename adjlist_t = py::dict<Value_type<nodeview_t>, int>,
              typename adjlist_outer_dict_factory = py::dict<Value_type<nodeview_t>, adjlist_t>>
    class DiGraphS : public Graph<nodeview_t, adjlist_t, adjlist_outer_dict_factory> {
        using _Base = Graph<nodeview_t, adjlist_t, adjlist_outer_dict_factory>;
 
      public:
        using Node = typename _Base::Node;  // luk
        using edge_t = std::pair<Node, Node>;
        // using graph_attr_dict_factory = typename _Base::graph_attr_dict_factory;
        // using adjlist_outer_dict_factory =
        //     typename _Base::adjlist_outer_dict_factory;
        using key_type = typename _Base::key_type;
        using value_type = typename _Base::value_type;
 
      public:
        // adjlist_outer_dict_factory &_adj; // successor
 
        explicit DiGraphS(const nodeview_t& Nodes) : _Base{Nodes} {}
 
        explicit DiGraphS(uint32_t num_nodes) : _Base{num_nodes} {}
 
        auto adj() const {
            using T = decltype(this->_adj);
            return AdjacencyView<T>(this->_adj);
        }
 
        auto succ() const {
            using T = decltype(this->_adj);
            return AdjacencyView<T>(this->_adj);
        }
 
        template <typename U = key_type> auto add_edge(const Node& node_u, const Node& node_v) ->
            typename std::enable_if<std::is_same<U, value_type>::value>::type {
            this->_adj[node_u].insert(node_v);
        }
 
        template <typename U = key_type> auto add_edge(const Node& node_u, const Node& node_v) ->
            typename std::enable_if<!std::is_same<U, value_type>::value>::type {
            using T = typename adjlist_t::mapped_type;
            auto data = this->_adj[node_u].get(node_v, T{});
            this->_adj[node_u][node_v] = data;
        }
 
        template <typename T> auto add_edge(const Node& node_u, const Node& node_v, const T& data) {
            this->_adj[node_u][node_v] = data;
        }
 
        template <typename C1, typename C2> auto add_edges_from(const C1& edges, const C2& data) {
            auto N = edges.size();
            for (auto idx = 0U; idx != N; ++idx) {
                const auto& e = edges[idx];
                this->add_edge(e.first, e.second, data[idx]);
            }
        }
 
        auto has_successor(const Node& node_u, const Node& node_v) const -> bool {
            return this->_node.contains(node_u) && this->_adj.at(node_u).contains(node_v);
        }
 
        auto successors(const Node& node) -> auto& { return this->_adj[node]; }
 
        auto successors(const Node& node) const -> const auto& { return this->_adj[node]; }
 
        auto degree(const Node& node) const { return this->_adj[node].size(); }
 
        auto number_of_edges() const -> size_t {
            size_t n_edges = 0;
            for (const auto& node : this->_node) {
                n_edges += this->_adj.at(node).size();
            }
            return n_edges;  // No division needed since it's a directed graph
        }
 
        auto clear() {
            this->_adj.clear();
            // this->_pred.clear()
            // this->_node.clear();
            this->graph.clear();
        }
 
        auto is_multigraph() const { return false; }
 
        auto is_directed() const { return true; }
    };
 
    using SimpleDiGraphS = DiGraphS<decltype(py::range<uint32_t>(uint32_t{})),
                                    py::dict<uint32_t, int>, std::vector<py::dict<uint32_t, int>>>;
 
    // template <typename nodeview_t,
    //           typename adjlist_t> DiGraphS(int )
    // -> DiGraphS<decltype(py::range<int>(1)), py::set<int>>;
 
}  // namespace xnetwork