Class GraphMixin

include/core/graph.h:46–125

 */
template<class _Index, class ..._Attributes>
class GraphMixin {
public:
    typedef _Index Index;
    typedef std::tuple<Index, float, _Attributes...> VertexEdge;
    typedef std::tuple<Index, Index, float, _Attributes...> Edge;

    std::vector<std::vector<VertexEdge>> vertex_edges;
    std::vector<Edge> edges;
    std::vector<float> vertex_weights, edge_weights;
    std::vector<size_t> flat_offsets;

    Index num_vertex;
    size_t num_edge;

#define USING_GRAPH_MIXIN(type) \
    using typename type::VertexEdge; \
    using typename type::Edge; \
    using type::vertex_edges; \
    using type::edges; \
    using type::vertex_weights; \
    using type::edge_weights; \
    using type::num_vertex; \
    using type::num_edge; \
    using type::info

    GraphMixin() = default;
    GraphMixin(const GraphMixin &) = delete;
    GraphMixin &operator=(const GraphMixin &) = delete;

    /** Clear the graph and free CPU memory */
    virtual void clear() {
        num_vertex = 0;
        num_edge = 0;
        decltype(vertex_edges)().swap(vertex_edges);
        decltype(edges)().swap(edges);
        decltype(vertex_weights)().swap(vertex_weights);
        decltype(edge_weights)().swap(edge_weights);
        decltype(flat_offsets)().swap(flat_offsets);
    }

    /** Flatten the adjacency list to an edge list */
    virtual void flatten() {
        if (!edges.empty())
            return;

        size_t offset = 0;
        flat_offsets.resize(num_vertex);
        for (Index u = 0; u < num_vertex; u++) {
            for (auto &&vertex_edge : vertex_edges[u]) {
                edges.push_back(std::tuple_cat(std::tie(u), vertex_edge));
                edge_weights.push_back(std::get<1>(vertex_edge));
            }
            flat_offsets[u] = offset;
            offset += vertex_edges[u].size();
        }
    }

    virtual inline std::string name() const {