From d0d15608a0d4c3825f462d08b6dd2685b17c07be Mon Sep 17 00:00:00 2001 From: Jeremy Siek Date: Tue, 6 Apr 2004 03:00:24 +0000 Subject: [PATCH] added note [SVN r2108] --- include/boost/graph/digraph.hpp | 127 ++++++++++++++++++++++++++++---- 1 file changed, 113 insertions(+), 14 deletions(-) diff --git a/include/boost/graph/digraph.hpp b/include/boost/graph/digraph.hpp index aa8b1bdf..e71feb77 100644 --- a/include/boost/graph/digraph.hpp +++ b/include/boost/graph/digraph.hpp @@ -1,9 +1,16 @@ +// Copyright Jeremy Siek 2004 + +// This file was an experiment to try supporting operator-> to access +// vertex and edge properties from a vertex or descriptor. The +// experiment was abandoned because of const issues. + #ifndef BOOST_GRAPH_DIGRAPH_HPP #define BOOST_GRAPH_DIGRAPH_HPP #include #include #include +#include namespace boost { @@ -11,27 +18,48 @@ namespace boost { class digraph { public: - class vertex_descriptor { + template + class vertex_desc { public: - vertex_descriptor(std::size_t i, Vertex* prop) - : m_property(prop) { } - Vertex* operator->() const { return m_property; } + vertex_desc() { } + template + vertex_desc(const vertex_desc& u) : m_index(u.m_index), m_property(u.m_property) { } + vertex_desc(std::size_t i, V* prop) + : m_index(i), m_property(prop) { } + bool operator==(const vertex_descriptor& u) const + { return m_property == u.m_property; } + bool operator!=(const vertex_descriptor& u) const + { return m_property != u.m_property; } + V* operator->() const { return m_property; } std::size_t index() const { return m_index; } - // or perhaps operator std::size_t() const { return m_index; } private: std::size_t m_index; - Vertex* m_property; + V* m_property; }; - class edge_descriptor { + typedef vertex_desc vertex_descriptor; + typedef vertex_desc const_vertex_descriptor; + + template + class edge_desc { public: - edge_descriptor(std::size_t u, std::size_t v, Edge* prop) + edge_desc() { } + template + edge_desc(const edge_desc& e) : m_source(e.m_source), m_target(e.m_target), m_property(e.m_property) { } + edge_desc(std::size_t u, std::size_t v, E* prop) : m_source(u), m_target(v), m_property(prop) { } - Edge* operator->() const { return m_property; } + bool operator==(const edge_descriptor& e) const + { return m_property == e.m_property; } + bool operator!=(const edge_descriptor& e) const + { return m_property != e.m_property; } + E* operator->() const { return m_property; } std::size_t m_source; std::size_t m_target; - Edge* m_property; + E* m_property; }; + typedef edge_desc edge_descriptor; + typedef edge_desc const_edge_descriptor; + //private: would be private if friends worked -JGS struct edge_info { edge_info(const Edge& e) : m_property(e) { } @@ -48,15 +76,47 @@ namespace boost { class out_edge_iterator : public iterator_adaptor::const_iterator, - edge_descriptor, edge_descriptor> + edge_descriptor, use_default, edge_descriptor> { + typedef iterator_adaptor::const_iterator, + edge_descriptor, use_default, edge_descriptor> super_t; public: + out_edge_iterator(typename std::list::const_iterator i, std::size_t src) + : super_t(i), m_src(src) { } edge_descriptor operator*() const { - return edge_descriptor(m_src, base()->m_target, &base()->m_property); + return edge_descriptor(m_src, base()->m_target, const_cast(&base()->m_property)); } private: std::size_t m_src; }; + class adjacency_iterator + : public iterator_adaptor::const_iterator, + vertex_descriptor, use_default, vertex_descriptor> + { + typedef iterator_adaptor::const_iterator, + vertex_descriptor, use_default, vertex_descriptor> super_t; + public: + adjacency_iterator(typename std::list::const_iterator i, std::size_t src, typename std::vector::const_iterator verts) + : super_t(i), m_src(src), m_verts(verts) { } + vertex_descriptor operator*() const { + return vertex_descriptor(base()->m_target, const_cast(&m_verts[base()->m_target].m_property)); + } + private: + std::size_t m_src; + typename std::vector::const_iterator m_verts; + }; + typedef void in_edge_iterator; + typedef void vertex_iterator; + typedef void edge_iterator; + typedef directed_tag directed_category; + typedef allow_parallel_edge_tag edge_parallel_category; + struct traversal_category : public incidence_graph_tag, adjacency_graph_tag { }; + typedef std::size_t vertices_size_type; + typedef std::size_t edges_size_type; + typedef std::size_t degree_size_type; std::vector m_adj_list; }; @@ -72,7 +132,25 @@ namespace boost { typedef typename digraph::vertex_descriptor VD; return VD(i, &g.m_adj_list.back().m_property); } - + + template + typename digraph::vertex_descriptor + source(typename digraph::edge_descriptor e, + const digraph& g) + { + typedef typename digraph::vertex_descriptor VD; + return VD(e.m_source, const_cast(&g.m_adj_list[e.m_source].m_property)); + } + + template + typename digraph::vertex_descriptor + target(typename digraph::edge_descriptor e, + const digraph& g) + { + typedef typename digraph::vertex_descriptor VD; + return VD(e.m_target, const_cast(&g.m_adj_list[e.m_target].m_property)); + } + template std::pair::edge_descriptor, bool> edge(typename digraph::vertex_descriptor u, @@ -93,9 +171,30 @@ namespace boost { out_edges(typename digraph::vertex_descriptor u, const digraph& g) { - + typedef typename digraph::out_edge_iterator OEI; + OEI first(g.m_adj_list[u].m_out_edges.begin(), u), + last(g.m_adj_list[u].m_out_edges.end(), u); + return std::make_pair(first, last); + } + template + std::size_t + out_degree(typename digraph::vertex_descriptor u, + const digraph& g) + { + return g.m_adj_list[u].m_out_edges.size(); } + template + std::pair::adjacency_iterator, + typename digraph::adjacency_iterator> + adjacent_vertices(typename digraph::vertex_descriptor u, + const digraph& g) + { + typedef typename digraph::adjacency_iterator AI; + AI first(g.m_adj_list[u].m_out_edges.begin(), u, g.m_adj_list.begin()), + last(g.m_adj_list[u].m_out_edges.end(), u, g.m_adj_list.begin()); + return std::make_pair(first, last); + } } // namespace boost