namespace boost {
-template<typename Directed = directedS, typename VertexProperty = void,
- typename EdgeProperty = void, typename GraphProperty = no_property,
+template<typename Directed = directedS, typename VertexProperty = no_property,
+ typename EdgeProperty = no_property, typename GraphProperty = no_property,
typename Vertex = std::size_t, typename EdgeIndex = Vertex>
class compressed_sparse_row_graph
{
diff --git a/doc/dijkstra_shortest_paths.html b/doc/dijkstra_shortest_paths.html
index 4ed19711..369e78a0 100644
--- a/doc/dijkstra_shortest_paths.html
+++ b/doc/dijkstra_shortest_paths.html
@@ -330,7 +330,9 @@ IN: distance_inf(D inf)
The inf object must be the greatest value of any D object.
That is, compare(d, inf) == true for any d != inf.
- The type D is the value type of the DistanceMap.
+ The type D is the value type of the DistanceMap. Edges
+ are assumed to have a weight less than (using distance_compare for
+ comparison) this value.
Default: std::numeric_limits<D>::max()
Python: Unsupported parameter.
diff --git a/doc/dijkstra_shortest_paths_no_color_map.html b/doc/dijkstra_shortest_paths_no_color_map.html
index e1cc1c8e..b65d333f 100644
--- a/doc/dijkstra_shortest_paths_no_color_map.html
+++ b/doc/dijkstra_shortest_paths_no_color_map.html
@@ -69,7 +69,7 @@ Algorithms for some background to the shortest-path problem.
- dijkstra_shortest_paths_no_color_map differs from the original dijkstra_shortest_paths algorithm by not using a color map to identify vertices as discovered or undiscovered. Instead, this is done with the distance map: a vertex u such that distance_compare(distance_map[u], distance_infinity) == false is considered to be undiscovered.
+ dijkstra_shortest_paths_no_color_map differs from the original dijkstra_shortest_paths algorithm by not using a color map to identify vertices as discovered or undiscovered. Instead, this is done with the distance map: a vertex u such that distance_compare(distance_map[u], distance_infinity) == false is considered to be undiscovered. Note that this means that edges with infinite weight will not work correctly in this algorithm.
@@ -116,10 +116,6 @@ indicated by the labels on the right.
DIJKSTRA(G, s, w)
- for each vertex u in V (This loop is not run in dijkstra_shortest_paths_no_color_map_no_init)
- d[u] := infinity
- p[u] := u
- end for
d[s] := 0
INSERT(Q, s)
while (Q != Ø)
@@ -141,10 +137,6 @@ DIJKSTRA(G, s, w)
-initialize vertex u
-
-
-
discover vertex s
@@ -293,7 +285,9 @@ IN: distance_inf(D distance_infinity)
The distance_infinity object must be the greatest value of any D object.
That is, distance_compare(d, distance_infinity) == true for any d != distance_infinity.
- The type D is the value type of the DistanceMap.
+ The type D is the value type of the DistanceMap. All edges
+ are assumed to have weight less than (by distance_compare) this
+ value.
Default: std::numeric_limits<D>::max()
diff --git a/doc/grid_graph.html b/doc/grid_graph.html
index 100c97ec..0a2fea5d 100644
--- a/doc/grid_graph.html
+++ b/doc/grid_graph.html
@@ -81,13 +81,13 @@
-
- Dimensions - Number of dimensions in the graph, must be greater than 2
+ Dimensions - Number of dimensions in the graph
-
- VertexIndex - Type used for vertex indices, defaults to std::size_t
+ VertexIndex - Type used for vertex indices, defaults to std::size_t
-
- EdgeIndex - Type used for edge indices, defaults to the same type as VertexIndex
+ EdgeIndex - Type used for edge indices, defaults to the same type as VertexIndex
diff --git a/doc/gursoy_atun_layout.html b/doc/gursoy_atun_layout.html
index 52482a36..db61443e 100644
--- a/doc/gursoy_atun_layout.html
+++ b/doc/gursoy_atun_layout.html
@@ -161,7 +161,8 @@ IN: double learning_constant_final
IN: VertexIndexMap vertex_index_map
This maps each vertex to an integer in the range [0,
- num_vertices(g)).
+ num_vertices(g)). This is only necessary when no
+ displacement map is provided.
The type VertexIndexMap must be a model of Readable Property
Map. The value type of the map must be an integer type. The
@@ -176,9 +177,7 @@ IN: VertexIndexMap vertex_index_map
IN: EdgeWeightMap weight
- This maps each edge to an weight.
- num_vertices(g)). This is only necessary when no
- displacement map is provided.
+ This maps each edge to a weight.
The type EdgeWeightMap must be a model of Readable Property
Map. The value type of the map must be an floating-point type
@@ -221,7 +220,7 @@ Equivalent to the non-named vertex_index_map parameter.
Default: get(vertex_index, g)
Note: if you use this default, make sure your graph has
an internal vertex_index property. For example,
- adjacenty_list with VertexList=listS does
+ adjacency_list with VertexList=listS does
not have an internal vertex_index property.
diff --git a/doc/sorted_erdos_renyi_gen.html b/doc/sorted_erdos_renyi_gen.html
index 55273fa2..b61242a5 100644
--- a/doc/sorted_erdos_renyi_gen.html
+++ b/doc/sorted_erdos_renyi_gen.html
@@ -63,7 +63,7 @@ graphs, suitable for initializing an adjacency_list or other graph
structure with iterator-based initialization. An Erdös-Renyi
graph G = (n, p) is a graph with n vertices
-that. The probability of having an edge (u, v) in G
+such that the probability of having an edge (u, v) in G
is p for any vertices u and v. Typically,
there are no self-loops, but the generator can optionally introduce
self-loops with probability p.
@@ -93,7 +93,7 @@ sorted_erdos_renyi_iterator(RandomGenerator& gen, vertices_size_type n,
Constructs an Erdös-Renyi generator iterator that creates a
graph with n vertices and a given probability of the
total number of edges that a simple graph may have.
-probability. Random vertices and edges are selected using the
+Random vertices and edges are selected using the
random number generator gen. Self-loops are permitted only when
allow_self_loops is true.
diff --git a/example/Jamfile.v2 b/example/Jamfile.v2
index 8a0c2c7d..5d4dc7f0 100644
--- a/example/Jamfile.v2
+++ b/example/Jamfile.v2
@@ -35,9 +35,11 @@ exe bfs-example : bfs-example.cpp ;
exe bfs-example2 : bfs-example2.cpp ;
exe dfs-example : dfs-example.cpp ;
exe adjacency_list_io : adjacency_list_io.cpp ;
-exe strong_components : strong_components.cpp ../build//boost_graph ;
-exe strong-components : strong-components.cpp ;
exe undirected_adjacency_list : undirected_adjacency_list.cpp ;
exe directed_graph : directed_graph.cpp ;
exe undirected_graph : undirected_graph.cpp ;
exe two_graphs_common_spanning_trees : two_graphs_common_spanning_trees.cpp ;
+exe strong_components : strong_components.cpp ../build//boost_graph ;
+exe strong-components : strong-components.cpp ;
+exe subgraph : subgraph.cpp ;
+exe subgraph_properties : subgraph_properties.cpp ;
diff --git a/example/subgraph_properties.cpp b/example/subgraph_properties.cpp
index 7de21cec..613d53a3 100644
--- a/example/subgraph_properties.cpp
+++ b/example/subgraph_properties.cpp
@@ -69,20 +69,20 @@ int main(int,char*[])
std::cout << std::endl << "After initializing properties for G1:" << std::endl;
std::cout << " Global and local properties for vertex G0[C]..." << std::endl;
- std::cout << " G0[C]= " << boost::get(vertex_name, G0, C) << std::endl;// prints: "G0[C]= C"
- std::cout << " G1[A1]= " << boost::get(vertex_name, G1, A1) << std::endl;// prints: "G1[A1]= A1"
+ std::cout << " G0[C]= " << boost::get(vertex_name, G0, vertex(C, G0)) << std::endl;// prints: "G0[C]= C"
+ std::cout << " G1[A1]= " << boost::get(vertex_name, G1, vertex(A1, G1)) << std::endl;// prints: "G1[A1]= A1"
name1[B1] = "B1";
std::cout << " Global and local properties for vertex G0[E]..." << std::endl;
- std::cout << " G0[E]= " << boost::get(vertex_name, G0, E) << std::endl;// prints: "G0[E]= E"
- std::cout << " G1[B1]= " << boost::get(vertex_name, G1, B1) << std::endl;// prints: "G1[B1]= B1"
+ std::cout << " G0[E]= " << boost::get(vertex_name, G0, vertex(E, G0)) << std::endl;// prints: "G0[E]= E"
+ std::cout << " G1[B1]= " << boost::get(vertex_name, G1, vertex(B1, G1)) << std::endl;// prints: "G1[B1]= B1"
name1[C1] = "C1";
std::cout << " Global and local properties for vertex G0[F]..." << std::endl;
- std::cout << " G0[F]= " << boost::get(vertex_name, G0, F) << std::endl;// prints: "G0[F]= F"
- std::cout << " G1[C1]= " << boost::get(vertex_name, G1, C1) << std::endl;// prints: "G1[C1]= C1"
+ std::cout << " G0[F]= " << boost::get(vertex_name, G0, vertex(F, G0)) << std::endl;// prints: "G0[F]= F"
+ std::cout << " G1[C1]= " << boost::get(vertex_name, G1, vertex(C1, G1)) << std::endl;// prints: "G1[C1]= C1"
Graph& G2 = G0.create_subgraph();
enum { A2, B2 }; // for conveniently refering to vertices in G2
@@ -95,15 +95,15 @@ int main(int,char*[])
std::cout << std::endl << std::endl << "After initializing properties for G2:" << std::endl;
std::cout << " Global and local properties for vertex G0[A]" << std::endl;
- std::cout << " G0[A]= " << boost::get(vertex_name, G0, A) << std::endl;// prints: "G0[A]= A"
- std::cout << " G2[A2]= " << boost::get(vertex_name, G2, A2) << std::endl;// prints: "G2[A2]= A2"
+ std::cout << " G0[A]= " << boost::get(vertex_name, G0, vertex(A, G0)) << std::endl;// prints: "G0[A]= A"
+ std::cout << " G2[A2]= " << boost::get(vertex_name, G2, vertex(A2, G2)) << std::endl;// prints: "G2[A2]= A2"
name2[B2] = "B2";
std::cout << " Global and local properties for vertex G0[C]..." << std::endl;
- std::cout << " G0[C]= " << boost::get(vertex_name, G0, C) << std::endl;// prints: "G0[C]= C"
- std::cout << " G1[A1]= " << boost::get(vertex_name, G1, A1) << std::endl;// prints: "G1[A1]= A1"
- std::cout << " G2[B2]= " << boost::get(vertex_name, G2, B2) << std::endl;// prints: "G2[B2]= B2"
+ std::cout << " G0[C]= " << boost::get(vertex_name, G0, vertex(C, G0)) << std::endl;// prints: "G0[C]= C"
+ std::cout << " G1[A1]= " << boost::get(vertex_name, G1, vertex(A1, G1)) << std::endl;// prints: "G1[A1]= A1"
+ std::cout << " G2[B2]= " << boost::get(vertex_name, G2, vertex(B2, G2)) << std::endl;// prints: "G2[B2]= B2"
return 0;
}
diff --git a/include/boost/graph/astar_search.hpp b/include/boost/graph/astar_search.hpp
index 132dca02..38224a98 100644
--- a/include/boost/graph/astar_search.hpp
+++ b/include/boost/graph/astar_search.hpp
@@ -370,8 +370,8 @@ namespace boost {
detail::make_property_map_from_arg_pack_gen(D())(g, arg_pack),
detail::make_property_map_from_arg_pack_gen(D())(g, arg_pack),
detail::override_const_property(arg_pack, _weight_map, g, edge_weight),
- detail::override_const_property(arg_pack, _vertex_index_map, g, vertex_index),
detail::make_color_map_from_arg_pack(g, arg_pack),
+ detail::override_const_property(arg_pack, _vertex_index_map, g, vertex_index),
arg_pack[_distance_compare | std::less()],
arg_pack[_distance_combine | closed_plus(inf)],
inf,
diff --git a/include/boost/graph/compressed_sparse_row_graph.hpp b/include/boost/graph/compressed_sparse_row_graph.hpp
index 59e8bb4a..42e2419a 100644
--- a/include/boost/graph/compressed_sparse_row_graph.hpp
+++ b/include/boost/graph/compressed_sparse_row_graph.hpp
@@ -136,7 +136,7 @@ namespace detail {
typedef boost::iterator_facade, T, std::random_access_iterator_tag, const T&> base_type;
T saved_value;
const T& dereference() const {return saved_value;}
- bool equal(default_construct_iterator i) const {return true;}
+ bool equal(default_construct_iterator /*i*/) const {return true;}
void increment() {}
void decrement() {}
void advance(typename base_type::difference_type) {}
diff --git a/include/boost/graph/core_numbers.hpp b/include/boost/graph/core_numbers.hpp
index 3db59c72..33764c4f 100644
--- a/include/boost/graph/core_numbers.hpp
+++ b/include/boost/graph/core_numbers.hpp
@@ -11,8 +11,7 @@
#ifndef BOOST_GRAPH_CORE_NUMBERS_HPP
#define BOOST_GRAPH_CORE_NUMBERS_HPP
-#include
-#include
+#include
#include
#include
#include
@@ -159,7 +158,8 @@ namespace boost {
if (get(c,u) > v_cn) {
// remove the edge
put(c,u,get(c,u)-get(wm,*oi));
- Q.update(u);
+ if (Q.contains(u))
+ Q.update(u);
}
}
vis.finish_vertex(v,g);
@@ -175,13 +175,14 @@ namespace boost {
{
typedef typename property_traits::value_type D;
typedef std::less Cmp;
- typedef indirect_cmp IndirectCmp;
- IndirectCmp icmp(c, Cmp());
// build the mutable queue
typedef typename graph_traits::vertex_descriptor vertex;
- typedef mutable_queue, IndirectCmp,
- IndexMap> MutableQueue;
- MutableQueue Q(num_vertices(g), icmp, im);
+ std::vector index_in_heap_data(num_vertices(g));
+ typedef iterator_property_map::iterator, IndexMap>
+ index_in_heap_map_type;
+ index_in_heap_map_type index_in_heap_map(index_in_heap_data.begin(), im);
+ typedef d_ary_heap_indirect MutableQueue;
+ MutableQueue Q(c, index_in_heap_map, Cmp());
typename graph_traits::vertex_iterator vi,vi_end;
for (boost::tie(vi,vi_end) = vertices(g); vi!=vi_end; ++vi) {
Q.push(*vi);
diff --git a/include/boost/graph/detail/d_ary_heap.hpp b/include/boost/graph/detail/d_ary_heap.hpp
index ba58647a..2d921926 100644
--- a/include/boost/graph/detail/d_ary_heap.hpp
+++ b/include/boost/graph/detail/d_ary_heap.hpp
@@ -20,6 +20,11 @@
#include
#include
+// WARNING: it is not safe to copy a d_ary_heap_indirect and then modify one of
+// the copies. The class is required to be copyable so it can be passed around
+// (without move support from C++11), but it deep-copies the heap contents yet
+// shallow-copies the index_in_heap_map.
+
namespace boost {
// Swap two elements in a property map without assuming they model
diff --git a/include/boost/graph/detail/indexed_properties.hpp b/include/boost/graph/detail/indexed_properties.hpp
index e1f874b2..4494625c 100644
--- a/include/boost/graph/detail/indexed_properties.hpp
+++ b/include/boost/graph/detail/indexed_properties.hpp
@@ -253,7 +253,7 @@ class indexed_edge_properties
typedef secret const_edge_map_type;
secret operator[](secret) { return secret(); }
- void write_by_index(std::size_t idx, const no_property& prop) {}
+ void write_by_index(std::size_t /*idx*/, const no_property& /*prop*/) {}
edge_map_type get_edge_bundle(const IndexMap& = IndexMap()) const {
return edge_map_type();
@@ -270,7 +270,7 @@ class indexed_edge_properties
public:
void push_back(const edge_push_back_type&) { }
- void move_range(std::size_t src_begin, std::size_t src_end, std::size_t dest_begin) {}
+ void move_range(std::size_t /*src_begin*/, std::size_t /*src_end*/, std::size_t /*dest_begin*/) {}
typedef dummy_no_property_iterator iterator;
iterator begin() {return dummy_no_property_iterator();}
diff --git a/include/boost/graph/detail/set_adaptor.hpp b/include/boost/graph/detail/set_adaptor.hpp
index 90a64a2c..33acc07e 100644
--- a/include/boost/graph/detail/set_adaptor.hpp
+++ b/include/boost/graph/detail/set_adaptor.hpp
@@ -111,7 +111,7 @@ namespace boost {
// Shit, can't implement this without knowing the size of the
// universe.
template
- void set_compliment(const std::set& x,
+ void set_compliment(const std::set& /*x*/,
std::set& z)
{
z.clear();
diff --git a/include/boost/graph/filtered_graph.hpp b/include/boost/graph/filtered_graph.hpp
index 66cead60..74fea461 100644
--- a/include/boost/graph/filtered_graph.hpp
+++ b/include/boost/graph/filtered_graph.hpp
@@ -195,7 +195,6 @@ namespace boost {
typedef filtered_graph_tag graph_tag;
-#ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES
// Bundled properties support
template
typename graph::detail::bundled_result::type&
@@ -206,11 +205,10 @@ namespace boost {
typename graph::detail::bundled_result::type const&
operator[](Descriptor x) const
{ return this->m_g[x]; }
-#endif // BOOST_GRAPH_NO_BUNDLED_PROPERTIES
static vertex_descriptor null_vertex()
{
- return Graph::null_vertex();
+ return Traits::null_vertex();
}
//private:
@@ -222,26 +220,21 @@ namespace boost {
template
- struct vertex_property_type > {
- typedef typename vertex_property_type::type type;
- };
+ struct vertex_property_type >:
+ vertex_property_type {};
template
- struct edge_property_type > {
- typedef typename edge_property_type::type type;
- };
+ struct edge_property_type >:
+ edge_property_type {};
template
- struct graph_property_type > {
- typedef typename graph_property_type::type type;
- };
+ struct graph_property_type >:
+ graph_property_type {};
-
-#ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES
template
struct vertex_bundle_type >
@@ -256,7 +249,6 @@ namespace boost {
struct graph_bundle_type >
: graph_bundle_type { };
-#endif // BOOST_GRAPH_NO_BUNDLED_PROPERTIES
//===========================================================================
// Non-member functions for the Filtered Edge Graph
diff --git a/include/boost/graph/grid_graph.hpp b/include/boost/graph/grid_graph.hpp
index 7bb37324..9a09fca3 100644
--- a/include/boost/graph/grid_graph.hpp
+++ b/include/boost/graph/grid_graph.hpp
@@ -30,11 +30,6 @@
#define BOOST_GRID_GRAPH_TYPE \
grid_graph
-#define BOOST_GRID_GRAPH_TYPE_MEM typename BOOST_GRID_GRAPH_TYPE::
-
-#define BOOST_GRID_GRAPH_TYPE_TD(mem) \
- typedef typename BOOST_GRID_GRAPH_TYPE::mem mem
-
#define BOOST_GRID_GRAPH_TRAITS_T \
typename graph_traits
@@ -68,6 +63,13 @@ namespace boost {
return (m_graph->index_of(key));
}
+ friend inline Index
+ get(const grid_graph_index_map& index_map,
+ const typename grid_graph_index_map::key_type& key)
+ {
+ return (index_map[key]);
+ }
+
protected:
const Graph* m_graph;
};
@@ -106,6 +108,13 @@ namespace boost {
value_type operator[](const key_type& key) const {
return (value_type(key.second, key.first));
}
+
+ friend inline Descriptor
+ get(const grid_graph_reverse_edge_map& rev_map,
+ const typename grid_graph_reverse_edge_map::key_type& key)
+ {
+ return (rev_map[key]);
+ }
};
template
@@ -442,7 +451,7 @@ namespace boost {
vertex_descriptor vertex_at
(vertices_size_type vertex_index) const {
- array vertex;
+ boost::array vertex;
vertices_size_type index_divider = 1;
for (std::size_t dimension_index = 0;
@@ -532,6 +541,8 @@ namespace boost {
vertex_descriptor source_vertex = source(edge, *this);
vertex_descriptor target_vertex = target(edge, *this);
+ BOOST_ASSERT (source_vertex != target_vertex);
+
// Determine the dimension where the source and target vertices
// differ (should only be one if this is a valid edge).
std::size_t different_dimension_index = 0;
@@ -732,13 +743,12 @@ namespace boost {
// VertexListGraph
//================
- template
- friend inline std::pair
- vertices(const BOOST_GRID_GRAPH_TYPE& graph) {
- BOOST_GRID_GRAPH_TYPE_TD(vertex_iterator);
- BOOST_GRID_GRAPH_TYPE_TD(vertex_function);
- BOOST_GRID_GRAPH_TYPE_TD(vertex_index_iterator);
+ friend inline std::pair
+ vertices(const type& graph) {
+ typedef typename type::vertex_iterator vertex_iterator;
+ typedef typename type::vertex_function vertex_function;
+ typedef typename type::vertex_index_iterator vertex_index_iterator;
return (std::make_pair
(vertex_iterator(vertex_index_iterator(0),
@@ -747,16 +757,14 @@ namespace boost {
vertex_function(&graph))));
}
- template
- friend inline BOOST_GRID_GRAPH_TYPE_MEM vertices_size_type
- num_vertices(const BOOST_GRID_GRAPH_TYPE& graph) {
+ friend inline typename type::vertices_size_type
+ num_vertices(const type& graph) {
return (graph.num_vertices());
}
- template
- friend inline BOOST_GRID_GRAPH_TYPE_MEM vertex_descriptor
- vertex(BOOST_GRID_GRAPH_TYPE_MEM vertices_size_type vertex_index,
- const BOOST_GRID_GRAPH_TYPE& graph) {
+ friend inline typename type::vertex_descriptor
+ vertex(typename type::vertices_size_type vertex_index,
+ const type& graph) {
return (graph.vertex_at(vertex_index));
}
@@ -765,14 +773,13 @@ namespace boost {
// IncidenceGraph
//===============
- template
- friend inline std::pair
- out_edges(BOOST_GRID_GRAPH_TYPE_MEM vertex_descriptor vertex,
- const BOOST_GRID_GRAPH_TYPE& graph) {
- BOOST_GRID_GRAPH_TYPE_TD(degree_iterator);
- BOOST_GRID_GRAPH_TYPE_TD(out_edge_function);
- BOOST_GRID_GRAPH_TYPE_TD(out_edge_iterator);
+ friend inline std::pair
+ out_edges(typename type::vertex_descriptor vertex,
+ const type& graph) {
+ typedef typename type::degree_iterator degree_iterator;
+ typedef typename type::out_edge_function out_edge_function;
+ typedef typename type::out_edge_iterator out_edge_iterator;
return (std::make_pair
(out_edge_iterator(degree_iterator(0),
@@ -781,19 +788,17 @@ namespace boost {
out_edge_function(vertex, &graph))));
}
- template
- friend inline BOOST_GRID_GRAPH_TYPE_MEM degree_size_type
+ friend inline typename type::degree_size_type
out_degree
- (BOOST_GRID_GRAPH_TYPE_MEM vertex_descriptor vertex,
- const BOOST_GRID_GRAPH_TYPE& graph) {
+ (typename type::vertex_descriptor vertex,
+ const type& graph) {
return (graph.out_degree(vertex));
}
- template
- friend inline BOOST_GRID_GRAPH_TYPE_MEM edge_descriptor
- out_edge_at(BOOST_GRID_GRAPH_TYPE_MEM vertex_descriptor vertex,
- BOOST_GRID_GRAPH_TYPE_MEM degree_size_type out_edge_index,
- const BOOST_GRID_GRAPH_TYPE& graph) {
+ friend inline typename type::edge_descriptor
+ out_edge_at(typename type::vertex_descriptor vertex,
+ typename type::degree_size_type out_edge_index,
+ const type& graph) {
return (graph.out_edge_at(vertex, out_edge_index));
}
@@ -801,14 +806,13 @@ namespace boost {
// AdjacencyGraph
//===============
- template
- friend typename std::pair
- adjacent_vertices (BOOST_GRID_GRAPH_TYPE_MEM vertex_descriptor vertex,
- const BOOST_GRID_GRAPH_TYPE& graph) {
- BOOST_GRID_GRAPH_TYPE_TD(degree_iterator);
- BOOST_GRID_GRAPH_TYPE_TD(adjacent_vertex_function);
- BOOST_GRID_GRAPH_TYPE_TD(adjacency_iterator);
+ friend typename std::pair
+ adjacent_vertices (typename type::vertex_descriptor vertex,
+ const type& graph) {
+ typedef typename type::degree_iterator degree_iterator;
+ typedef typename type::adjacent_vertex_function adjacent_vertex_function;
+ typedef typename type::adjacency_iterator adjacency_iterator;
return (std::make_pair
(adjacency_iterator(degree_iterator(0),
@@ -821,26 +825,23 @@ namespace boost {
// EdgeListGraph
//==============
- template
- friend inline BOOST_GRID_GRAPH_TYPE_MEM edges_size_type
- num_edges(const BOOST_GRID_GRAPH_TYPE& graph) {
+ friend inline typename type::edges_size_type
+ num_edges(const type& graph) {
return (graph.num_edges());
}
- template
- friend inline BOOST_GRID_GRAPH_TYPE_MEM edge_descriptor
- edge_at(BOOST_GRID_GRAPH_TYPE_MEM edges_size_type edge_index,
- const BOOST_GRID_GRAPH_TYPE& graph) {
+ friend inline typename type::edge_descriptor
+ edge_at(typename type::edges_size_type edge_index,
+ const type& graph) {
return (graph.edge_at(edge_index));
}
- template
- friend inline std::pair
- edges(const BOOST_GRID_GRAPH_TYPE& graph) {
- BOOST_GRID_GRAPH_TYPE_TD(edge_index_iterator);
- BOOST_GRID_GRAPH_TYPE_TD(edge_function);
- BOOST_GRID_GRAPH_TYPE_TD(edge_iterator);
+ friend inline std::pair
+ edges(const type& graph) {
+ typedef typename type::edge_index_iterator edge_index_iterator;
+ typedef typename type::edge_function edge_function;
+ typedef typename type::edge_iterator edge_iterator;
return (std::make_pair
(edge_iterator(edge_index_iterator(0),
@@ -853,14 +854,13 @@ namespace boost {
// BiDirectionalGraph
//===================
- template
- friend inline std::pair
- in_edges(BOOST_GRID_GRAPH_TYPE_MEM vertex_descriptor vertex,
- const BOOST_GRID_GRAPH_TYPE& graph) {
- BOOST_GRID_GRAPH_TYPE_TD(in_edge_function);
- BOOST_GRID_GRAPH_TYPE_TD(degree_iterator);
- BOOST_GRID_GRAPH_TYPE_TD(in_edge_iterator);
+ friend inline std::pair
+ in_edges(typename type::vertex_descriptor vertex,
+ const type& graph) {
+ typedef typename type::in_edge_function in_edge_function;
+ typedef typename type::degree_iterator degree_iterator;
+ typedef typename type::in_edge_iterator in_edge_iterator;
return (std::make_pair
(in_edge_iterator(degree_iterator(0),
@@ -869,25 +869,22 @@ namespace boost {
in_edge_function(vertex, &graph))));
}
- template
- friend inline BOOST_GRID_GRAPH_TYPE_MEM degree_size_type
- in_degree (BOOST_GRID_GRAPH_TYPE_MEM vertex_descriptor vertex,
- const BOOST_GRID_GRAPH_TYPE& graph) {
+ friend inline typename type::degree_size_type
+ in_degree (typename type::vertex_descriptor vertex,
+ const type& graph) {
return (graph.in_degree(vertex));
}
- template
- friend inline BOOST_GRID_GRAPH_TYPE_MEM degree_size_type
- degree (BOOST_GRID_GRAPH_TYPE_MEM vertex_descriptor vertex,
- const BOOST_GRID_GRAPH_TYPE& graph) {
+ friend inline typename type::degree_size_type
+ degree (typename type::vertex_descriptor vertex,
+ const type& graph) {
return (graph.out_degree(vertex) * 2);
}
- template
- friend inline BOOST_GRID_GRAPH_TYPE_MEM edge_descriptor
- in_edge_at(BOOST_GRID_GRAPH_TYPE_MEM vertex_descriptor vertex,
- BOOST_GRID_GRAPH_TYPE_MEM degree_size_type in_edge_index,
- const BOOST_GRID_GRAPH_TYPE& graph) {
+ friend inline typename type::edge_descriptor
+ in_edge_at(typename type::vertex_descriptor vertex,
+ typename type::degree_size_type in_edge_index,
+ const type& graph) {
return (graph.in_edge_at(vertex, in_edge_index));
}
@@ -896,21 +893,20 @@ namespace boost {
// Adjacency Matrix
//==================
- template
- friend std::pair
- edge (BOOST_GRID_GRAPH_TYPE_MEM vertex_descriptor source_vertex,
- BOOST_GRID_GRAPH_TYPE_MEM vertex_descriptor destination_vertex,
- const BOOST_GRID_GRAPH_TYPE& graph) {
+ friend std::pair
+ edge (typename type::vertex_descriptor source_vertex,
+ typename type::vertex_descriptor destination_vertex,
+ const type& graph) {
- std::pair edge_exists =
+ std::pair edge_exists =
std::make_pair(std::make_pair(source_vertex, destination_vertex), false);
for (std::size_t dimension_index = 0;
dimension_index < Dimensions;
++dimension_index) {
- BOOST_GRID_GRAPH_TYPE_MEM vertices_size_type dim_difference = 0;
- BOOST_GRID_GRAPH_TYPE_MEM vertices_size_type
+ typename type::vertices_size_type dim_difference = 0;
+ typename type::vertices_size_type
source_dim = source_vertex[dimension_index],
dest_dim = destination_vertex[dimension_index];
@@ -957,77 +953,54 @@ namespace boost {
// Index Property Map Functions
//=============================
- template
- friend inline BOOST_GRID_GRAPH_TYPE_MEM vertices_size_type
+ friend inline typename type::vertices_size_type
get(vertex_index_t,
- const BOOST_GRID_GRAPH_TYPE& graph,
- BOOST_GRID_GRAPH_TYPE_MEM vertex_descriptor vertex) {
+ const type& graph,
+ typename type::vertex_descriptor vertex) {
return (graph.index_of(vertex));
}
- template
- friend inline BOOST_GRID_GRAPH_TYPE_MEM edges_size_type
+ friend inline typename type::edges_size_type
get(edge_index_t,
- const BOOST_GRID_GRAPH_TYPE& graph,
- BOOST_GRID_GRAPH_TYPE_MEM edge_descriptor edge) {
+ const type& graph,
+ typename type::edge_descriptor edge) {
return (graph.index_of(edge));
}
- template
friend inline grid_graph_index_map<
- BOOST_GRID_GRAPH_TYPE,
- BOOST_GRID_GRAPH_TYPE_MEM vertex_descriptor,
- BOOST_GRID_GRAPH_TYPE_MEM vertices_size_type>
- get(vertex_index_t, const BOOST_GRID_GRAPH_TYPE& graph) {
+ type,
+ typename type::vertex_descriptor,
+ typename type::vertices_size_type>
+ get(vertex_index_t, const type& graph) {
return (grid_graph_index_map<
- BOOST_GRID_GRAPH_TYPE,
- BOOST_GRID_GRAPH_TYPE_MEM vertex_descriptor,
- BOOST_GRID_GRAPH_TYPE_MEM vertices_size_type>(graph));
+ type,
+ typename type::vertex_descriptor,
+ typename type::vertices_size_type>(graph));
}
- template
friend inline grid_graph_index_map<
- BOOST_GRID_GRAPH_TYPE,
- BOOST_GRID_GRAPH_TYPE_MEM edge_descriptor,
- BOOST_GRID_GRAPH_TYPE_MEM edges_size_type>
- get(edge_index_t, const BOOST_GRID_GRAPH_TYPE& graph) {
+ type,
+ typename type::edge_descriptor,
+ typename type::edges_size_type>
+ get(edge_index_t, const type& graph) {
return (grid_graph_index_map<
- BOOST_GRID_GRAPH_TYPE,
- BOOST_GRID_GRAPH_TYPE_MEM edge_descriptor,
- BOOST_GRID_GRAPH_TYPE_MEM edges_size_type>(graph));
+ type,
+ typename type::edge_descriptor,
+ typename type::edges_size_type>(graph));
}
- template
friend inline grid_graph_reverse_edge_map<
- BOOST_GRID_GRAPH_TYPE_MEM edge_descriptor>
- get(edge_reverse_t, const BOOST_GRID_GRAPH_TYPE& graph) {
+ typename type::edge_descriptor>
+ get(edge_reverse_t, const type& graph) {
return (grid_graph_reverse_edge_map<
- BOOST_GRID_GRAPH_TYPE_MEM edge_descriptor>());
+ typename type::edge_descriptor>());
}
- template
- friend inline Index
- get(const grid_graph_index_map& index_map,
- const typename grid_graph_index_map::key_type& key)
- {
- return (index_map[key]);
- }
-
template
friend struct grid_graph_index_map;
- template
- friend inline Descriptor
- get(const grid_graph_reverse_edge_map& rev_map,
- const typename grid_graph_reverse_edge_map::key_type& key)
- {
- return (rev_map[key]);
- }
-
template
friend struct grid_graph_reverse_edge_map;
@@ -1036,8 +1009,6 @@ namespace boost {
} // namespace boost
#undef BOOST_GRID_GRAPH_TYPE
-#undef BOOST_GRID_GRAPH_TYPE_TD
-#undef BOOST_GRID_GRAPH_TYPE_MEM
#undef BOOST_GRID_GRAPH_TEMPLATE_PARAMS
#undef BOOST_GRID_GRAPH_TRAITS_T
diff --git a/include/boost/graph/labeled_graph.hpp b/include/boost/graph/labeled_graph.hpp
index e1a2f7c2..67505d25 100644
--- a/include/boost/graph/labeled_graph.hpp
+++ b/include/boost/graph/labeled_graph.hpp
@@ -196,7 +196,7 @@ namespace graph_detail {
{
// If the element is already occupied, then we probably don't want to
// overwrite it.
- if(c[l] == Graph::null_vertex()) return false;
+ if(c[l] == graph_traits::null_vertex()) return false;
c[l] = v;
return true;
}
@@ -411,7 +411,7 @@ public:
/** Return a null descriptor */
static vertex_descriptor null_vertex()
- { return graph_type::null_vertex(); }
+ { return graph_traits::null_vertex(); }
private:
graph_type _graph;
@@ -525,7 +525,7 @@ public:
#endif
static vertex_descriptor null_vertex()
- { return graph_type::null_vertex(); }
+ { return graph_traits::null_vertex(); }
private:
graph_type* _graph;
diff --git a/include/boost/graph/named_function_params.hpp b/include/boost/graph/named_function_params.hpp
index 32dd5802..94314a69 100644
--- a/include/boost/graph/named_function_params.hpp
+++ b/include/boost/graph/named_function_params.hpp
@@ -432,13 +432,13 @@ BOOST_BGL_DECLARE_NAMED_PARAMS
template
struct override_property_t {
typedef ArgType result_type;
- result_type operator()(const Graph& g, const typename boost::add_reference::type a) const {return a;}
+ result_type operator()(const Graph&, const typename boost::add_reference::type a) const {return a;}
};
template
struct override_property_t {
typedef typename boost::property_map::type result_type;
- result_type operator()(const Graph& g, const ArgType& a) const {return get(Prop(), g);}
+ result_type operator()(const Graph& g, const ArgType&) const {return get(Prop(), g);}
};
template
@@ -455,7 +455,7 @@ BOOST_BGL_DECLARE_NAMED_PARAMS
template
typename override_property_result::type
- override_property(const ArgPack& ap, const boost::parameter::keyword& t, const Graph& g, Prop prop) {
+ override_property(const ArgPack& ap, const boost::parameter::keyword& t, const Graph& g, Prop) {
return override_property_t<
typename boost::parameter::value_type::type,
Prop,
@@ -633,7 +633,7 @@ BOOST_BGL_DECLARE_NAMED_PARAMS
typedef Q priority_queue_type;
static priority_queue_type
- make_queue(const Graph& g, const ArgPack& ap, KeyT defaultKey, const Q& q) {
+ make_queue(const Graph&, const ArgPack&, KeyT, const Q& q) {
return q;
}
};
@@ -645,7 +645,7 @@ BOOST_BGL_DECLARE_NAMED_PARAMS
typedef boost::d_ary_heap_indirect::helper::map_type, Compare> priority_queue_type;
static priority_queue_type
- make_queue(const Graph& g, const ArgPack& ap, KeyT defaultKey, const Q& q) {
+ make_queue(const Graph& g, const ArgPack& ap, KeyT defaultKey, const Q&) {
return priority_queue_type(
map_maker::make_map(g, ap, defaultKey),
map_maker::make_map(g, ap, typename boost::property_traits::value_type(-1))
diff --git a/include/boost/graph/named_graph.hpp b/include/boost/graph/named_graph.hpp
index f49c0970..77e1a22f 100644
--- a/include/boost/graph/named_graph.hpp
+++ b/include/boost/graph/named_graph.hpp
@@ -105,7 +105,7 @@ public:
typedef vertex_name_type argument_type;
typedef VertexProperty result_type;
- VertexProperty operator()(const vertex_name_type& name)
+ VertexProperty operator()(const vertex_name_type&)
{
boost::throw_exception(std::runtime_error("add_vertex: "
"unable to create a vertex from its name"));
diff --git a/include/boost/graph/properties.hpp b/include/boost/graph/properties.hpp
index 6b5ade97..5cc926bc 100644
--- a/include/boost/graph/properties.hpp
+++ b/include/boost/graph/properties.hpp
@@ -21,7 +21,7 @@
#include
#include
-#include
+#include
#include
#include
#include
@@ -149,13 +149,13 @@ namespace boost {
template
struct property_kind_from_graph {
typedef typename boost::mpl::if_<
- boost::is_same::type>,
+ boost::is_base_of::type>,
vertex_property_tag,
typename boost::mpl::if_<
- boost::is_same::type>,
+ boost::is_base_of::type>,
edge_property_tag,
typename boost::mpl::if_<
- boost::is_same::type>,
+ boost::is_base_of::type>,
graph_property_tag,
void>::type>::type>::type type;
};
diff --git a/include/boost/graph/relax.hpp b/include/boost/graph/relax.hpp
index 46857960..e3866df4 100644
--- a/include/boost/graph/relax.hpp
+++ b/include/boost/graph/relax.hpp
@@ -49,20 +49,30 @@ namespace boost {
Vertex u = source(e, g), v = target(e, g);
typedef typename property_traits::value_type D;
typedef typename property_traits::value_type W;
- D d_u = get(d, u), d_v = get(d, v);
- W w_e = get(w, e);
+ const D d_u = get(d, u);
+ const D d_v = get(d, v);
+ const W& w_e = get(w, e);
- // The redundant gets in the return statements are to ensure that extra
- // floating-point precision in x87 registers does not lead to relax()
- // returning true when the distance did not actually change.
+ // The seemingly redundant comparisons after the distance puts are to
+ // ensure that extra floating-point precision in x87 registers does not
+ // lead to relax() returning true when the distance did not actually
+ // change.
if ( compare(combine(d_u, w_e), d_v) ) {
put(d, v, combine(d_u, w_e));
- put(p, v, u);
- return compare(get(d, v), d_v);
+ if (compare(get(d, v), d_v)) {
+ put(p, v, u);
+ return true;
+ } else {
+ return false;
+ }
} else if (is_undirected && compare(combine(d_v, w_e), d_u)) {
put(d, u, combine(d_v, w_e));
- put(p, u, v);
- return compare(get(d, u), d_u);
+ if (compare(get(d, u), d_u)) {
+ put(p, u, v);
+ return true;
+ } else {
+ return false;
+ }
} else
return false;
}
diff --git a/include/boost/graph/reverse_graph.hpp b/include/boost/graph/reverse_graph.hpp
index 96fc32d3..bea975ab 100644
--- a/include/boost/graph/reverse_graph.hpp
+++ b/include/boost/graph/reverse_graph.hpp
@@ -460,7 +460,7 @@ template
typename enable_if,
detail::underlying_edge_desc_map_type::edge_descriptor> >::type
get(edge_underlying_t,
- G& g)
+ G&)
{
return detail::underlying_edge_desc_map_type::edge_descriptor>();
}
@@ -468,7 +468,7 @@ get(edge_underlying_t,
template
typename enable_if, typename graph_traits::edge_descriptor>::type
get(edge_underlying_t,
- G& g,
+ G&,
const typename graph_traits::edge_descriptor& k)
{
return k.underlying_descx;
@@ -477,7 +477,7 @@ get(edge_underlying_t,
template
typename enable_if, detail::underlying_edge_desc_map_type::edge_descriptor> >::type
get(edge_underlying_t,
- const G& g)
+ const G&)
{
return detail::underlying_edge_desc_map_type::edge_descriptor>();
}
@@ -485,7 +485,7 @@ get(edge_underlying_t,
template
typename enable_if, typename graph_traits::edge_descriptor>::type
get(edge_underlying_t,
- const G& g,
+ const G&,
const typename graph_traits::edge_descriptor& k)
{
return k.underlying_descx;
diff --git a/include/boost/graph/undirected_graph.hpp b/include/boost/graph/undirected_graph.hpp
index adcc86e5..738a5c95 100644
--- a/include/boost/graph/undirected_graph.hpp
+++ b/include/boost/graph/undirected_graph.hpp
@@ -10,11 +10,6 @@
#include
#include
-// NOTE: The retag_property_list is used to "normalize" a proeprty such that
-// any non-property conforming parameter is wrapped in a vertex_bundle
-// property. For example (with bad syntax) retag> -> property,
-// but retag -> property.
-
namespace boost
{
struct undirected_graph_tag { };
diff --git a/include/boost/graph/visitors.hpp b/include/boost/graph/visitors.hpp
index f986c96c..d10e140c 100644
--- a/include/boost/graph/visitors.hpp
+++ b/include/boost/graph/visitors.hpp
@@ -269,7 +269,7 @@ namespace boost {
{}
template
- void operator() (VertexOrEdge v, const Graph& g)
+ void operator() (VertexOrEdge v, const Graph&)
{
put (property_map_, v, value_);
}
@@ -292,7 +292,7 @@ namespace boost {
inline property_put
put_property (PropertyMap property_map,
typename property_traits ::value_type value,
- EventTag tag)
+ EventTag)
{
return property_put (property_map, value);
}
diff --git a/include/boost/pending/indirect_cmp.hpp b/include/boost/pending/indirect_cmp.hpp
index 638625ce..14ee5314 100644
--- a/include/boost/pending/indirect_cmp.hpp
+++ b/include/boost/pending/indirect_cmp.hpp
@@ -33,14 +33,15 @@ namespace boost {
typedef typename boost::property_traits::key_type K;
typedef K first_argument_type;
typedef K second_argument_type;
- typedef T result_type;
+ typedef bool result_type;
inline indirect_cmp(const ReadablePropertyMap& df, const Compare& c = Compare())
: d(df), cmp(c) { }
template
inline bool
operator()(const A& u, const B& v) const {
- T du = get(d, u), dv = get(d, v);
+ const T& du = get(d, u);
+ const T& dv = get(d, v);
return cmp(du, dv);
}
protected:
diff --git a/include/boost/pending/property.hpp b/include/boost/pending/property.hpp
index 93ebffbf..3053908d 100644
--- a/include/boost/pending/property.hpp
+++ b/include/boost/pending/property.hpp
@@ -11,6 +11,7 @@
#include
#include
#include
+#include
namespace boost {
@@ -53,8 +54,8 @@ namespace boost {
enum graph_bundle_t {graph_bundle};
// Code to look up one property in a property list:
- template
- struct lookup_one_property_internal {BOOST_STATIC_CONSTANT(bool, found = false);};
+ template
+ struct lookup_one_property_internal {BOOST_STATIC_CONSTANT(bool, found = false); typedef void type;};
// Special-case properties (vertex_all, edge_all, graph_all)
#define BGL_ALL_PROP(tag) \
@@ -93,8 +94,14 @@ namespace boost {
private: \
typedef lookup_one_property_internal base_type; \
public: \
- static typename base_type::type& lookup(property& p, BOOST_JOIN(kind, _bundle_t)) {return base_type::lookup(p.m_base, BOOST_JOIN(kind, _bundle_t)());} \
- static const typename base_type::type& lookup(const property& p, BOOST_JOIN(kind, _bundle_t)) {return base_type::lookup(p.m_base, BOOST_JOIN(kind, _bundle_t)());} \
+ template \
+ static typename lazy_enable_if_c<(base_type::found && (is_same::value)), \
+ add_reference >::type \
+ lookup(property& p, BundleTag) {return base_type::lookup(p.m_base, BOOST_JOIN(kind, _bundle_t)());} \
+ template \
+ static typename lazy_enable_if_c<(base_type::found && (is_same::value)), \
+ add_reference >::type \
+ lookup(const property& p, BundleTag) {return base_type::lookup(p.m_base, BOOST_JOIN(kind, _bundle_t)());} \
}; \
BGL_DO_ONE_BUNDLE_TYPE(vertex)
@@ -122,12 +129,14 @@ namespace boost {
typedef lookup_one_property_internal base_type;
public:
template
- static typename enable_if >, typename base_type::type&>::type
+ static typename lazy_enable_if >,
+ add_reference >::type
lookup(PL& prop, const PropName& tag) {
return base_type::lookup(prop.m_base, tag);
}
template
- static typename enable_if >, const typename base_type::type&>::type
+ static typename lazy_enable_if >,
+ add_reference >::type
lookup(const PL& prop, const PropName& tag) {
return base_type::lookup(prop.m_base, tag);
}
@@ -135,12 +144,12 @@ namespace boost {
// Pointer-to-member access to bundled properties
#ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES
- template
- struct lookup_one_property_internal {
+ template
+ struct lookup_one_property_internal >::type> {
BOOST_STATIC_CONSTANT(bool, found = true);
typedef R type;
- static R& lookup(T& x, R T::*ptr) {return x.*ptr;}
- static const R& lookup(const T& x, R T::*ptr) {return x.*ptr;}
+ static R& lookup(T& x, R TMaybeBase::*ptr) {return x.*ptr;}
+ static const R& lookup(const T& x, R TMaybeBase::*ptr) {return x.*ptr;}
};
#endif
@@ -153,7 +162,8 @@ namespace boost {
BOOST_STATIC_CONSTANT(bool, found = (lookup_one_property_internal::found));
typedef const typename lookup_one_property_internal::type type;
template
- static typename enable_if, const typename lookup_one_property_internal::type&>::type
+ static typename lazy_enable_if,
+ add_reference::type> >::type
lookup(const U& p, Tag tag) {
return lookup_one_property_internal::lookup(p, tag);
}
@@ -199,58 +209,6 @@ namespace boost {
: mpl::bool_::value>
{ };
- /** @internal @name Retag Property List
- * This metafunction is used internally to normalize a property if it is
- * actually modeling a property. Specifically this is used in Boost.Graph
- * to map user-provided classes into bundled properties.
- */
- //@{
- // One base case of the recursive form (see below). This matches any
- // retag request that does not include a property<...> or no_property as
- // the FinalType. This is used for generating bundles in Boost.Graph.
- template
- struct retag_property_list
- {
- typedef property type;
- typedef FinalType retagged;
- };
-
- // Recursively retag the nested property list.
- template
- struct retag_property_list >
- {
- private:
- typedef retag_property_list next;
-
- public:
- typedef property type;
- typedef typename next::retagged retagged;
- };
-
- // This base case will correctly deduce the final property type if the
- // retagged property is given in property form. This should not hide
- // the base case below.
- // NOTE: This addresses a problem of layering bundled properties in the BGL
- // where multiple retaggings will fail to deduce the correct retagged
- // type.
- template
- struct retag_property_list >
- {
- public:
- typedef property type;
- typedef FinalType retagged;
- };
-
- // A final base case of the retag_property_list, this will terminate a
- // properly structured list.
- template
- struct retag_property_list
- {
- typedef no_property type;
- typedef no_property retagged;
- };
- //@}
-
template
class lookup_one_property_f;
diff --git a/test/grid_graph_cc.cpp b/test/grid_graph_cc.cpp
index a9e1c808..d49de7c3 100644
--- a/test/grid_graph_cc.cpp
+++ b/test/grid_graph_cc.cpp
@@ -12,14 +12,13 @@
#include
#include
-#define DIMENSIONS 3
using namespace boost;
-int main (int, char*[]) {
-
- typedef grid_graph Graph;
- typedef graph_traits::vertex_descriptor Vertex;
- typedef graph_traits::edge_descriptor Edge;
+template
+void check() {
+ typedef grid_graph Graph;
+ typedef typename graph_traits::vertex_descriptor Vertex;
+ typedef typename graph_traits::edge_descriptor Edge;
BOOST_CONCEPT_ASSERT((BidirectionalGraphConcept ));
BOOST_CONCEPT_ASSERT((VertexListGraphConcept ));
@@ -29,6 +28,14 @@ int main (int, char*[]) {
BOOST_CONCEPT_ASSERT((AdjacencyMatrixConcept ));
BOOST_CONCEPT_ASSERT((ReadablePropertyGraphConcept ));
BOOST_CONCEPT_ASSERT((ReadablePropertyGraphConcept ));
+}
+
+int main (int, char*[]) {
+ check<0>();
+ check<1>();
+ check<2>();
+ check<3>();
+ check<4>();
return (0);
}
diff --git a/test/grid_graph_test.cpp b/test/grid_graph_test.cpp
index 3cd665bd..d88e68d2 100644
--- a/test/grid_graph_test.cpp
+++ b/test/grid_graph_test.cpp
@@ -17,8 +17,6 @@
#include
#include
-#define DIMENSIONS 3
-
using namespace boost;
// Function that prints a vertex to std::cout
@@ -28,11 +26,11 @@ void print_vertex(Vertex vertex_to_print) {
std::cout << "(";
for (std::size_t dimension_index = 0;
- dimension_index < DIMENSIONS;
+ dimension_index < vertex_to_print.size();
++dimension_index) {
std::cout << vertex_to_print[dimension_index];
- if (dimension_index != (DIMENSIONS - 1)) {
+ if (dimension_index != (vertex_to_print.size() - 1)) {
std::cout << ", ";
}
}
@@ -40,31 +38,23 @@ void print_vertex(Vertex vertex_to_print) {
std::cout << ")";
}
-int test_main(int argc, char* argv[]) {
+template
+void do_test(minstd_rand& generator) {
+ typedef grid_graph Graph;
+ typedef typename graph_traits::vertices_size_type vertices_size_type;
+ typedef typename graph_traits::edges_size_type edges_size_type;
- std::size_t random_seed = time(0);
+ typedef typename graph_traits::vertex_descriptor vertex_descriptor;
+ typedef typename graph_traits::edge_descriptor edge_descriptor;
- if (argc > 1) {
- random_seed = lexical_cast(argv[1]);
- }
-
- minstd_rand generator(random_seed);
-
- typedef grid_graph Graph;
- typedef graph_traits::vertices_size_type vertices_size_type;
- typedef graph_traits::edges_size_type edges_size_type;
-
- typedef graph_traits::vertex_descriptor vertex_descriptor;
- typedef graph_traits::edge_descriptor edge_descriptor;
-
- std::cout << "Dimensions: " << DIMENSIONS << ", lengths: ";
+ std::cout << "Dimensions: " << Dims << ", lengths: ";
// Randomly generate the dimension lengths (3-10) and wrapping
- array lengths;
- array wrapped;
+ boost::array lengths;
+ boost::array wrapped;
- for (int dimension_index = 0;
- dimension_index < DIMENSIONS;
+ for (unsigned int dimension_index = 0;
+ dimension_index < Dims;
++dimension_index) {
lengths[dimension_index] = 3 + (generator() % 8);
wrapped[dimension_index] = ((generator() % 2) == 0);
@@ -78,8 +68,8 @@ int test_main(int argc, char* argv[]) {
Graph graph(lengths, wrapped);
// Verify dimension lengths and wrapping
- for (int dimension_index = 0;
- dimension_index < DIMENSIONS;
+ for (unsigned int dimension_index = 0;
+ dimension_index < Dims;
++dimension_index) {
BOOST_REQUIRE(graph.length(dimension_index) == lengths[dimension_index]);
BOOST_REQUIRE(graph.wrapped(dimension_index) == wrapped[dimension_index]);
@@ -107,8 +97,8 @@ int test_main(int argc, char* argv[]) {
vertices_size_type current_index =
get(boost::vertex_index, graph, current_vertex);
- for (int dimension_index = 0;
- dimension_index < DIMENSIONS;
+ for (unsigned int dimension_index = 0;
+ dimension_index < Dims;
++dimension_index) {
BOOST_REQUIRE(/*(current_vertex[dimension_index] >= 0) && */ // Always true
(current_vertex[dimension_index] < lengths[dimension_index]));
@@ -205,6 +195,23 @@ int test_main(int argc, char* argv[]) {
}
BOOST_REQUIRE(edge_count == num_edges(graph));
+}
+
+int test_main(int argc, char* argv[]) {
+
+ std::size_t random_seed = time(0);
+
+ if (argc > 1) {
+ random_seed = lexical_cast(argv[1]);
+ }
+
+ minstd_rand generator(random_seed);
+
+ do_test<0>(generator);
+ do_test<1>(generator);
+ do_test<2>(generator);
+ do_test<3>(generator);
+ do_test<4>(generator);
return (0);
}