|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r63244 - in trunk: boost/graph boost/graph/detail boost/graph/distributed boost/graph/distributed/adjlist boost/graph/planar_detail libs/graph/example libs/graph/src libs/graph/test libs/graph_parallel/test
From: jewillco_at_[hidden]
Date: 2010-06-22 14:03:01
Author: jewillco
Date: 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
New Revision: 63244
URL: http://svn.boost.org/trac/boost/changeset/63244
Log:
Added boost:: to all uses of tie() to disambiguate from std version
Text files modified:
trunk/boost/graph/adj_list_serialize.hpp | 2
trunk/boost/graph/adjacency_matrix.hpp | 10 +++---
trunk/boost/graph/astar_search.hpp | 2
trunk/boost/graph/bandwidth.hpp | 6 ++--
trunk/boost/graph/bellman_ford_shortest_paths.hpp | 6 ++--
trunk/boost/graph/betweenness_centrality.hpp | 10 +++---
trunk/boost/graph/bipartite.hpp | 2
trunk/boost/graph/boykov_kolmogorov_max_flow.hpp | 24 +++++++++---------
trunk/boost/graph/bron_kerbosch_all_cliques.hpp | 2
trunk/boost/graph/clustering_coefficient.hpp | 8 +++---
trunk/boost/graph/copy.hpp | 40 +++++++++++++++---------------
trunk/boost/graph/core_numbers.hpp | 18 ++++++------
trunk/boost/graph/create_condensation_graph.hpp | 6 ++--
trunk/boost/graph/cuthill_mckee_ordering.hpp | 2
trunk/boost/graph/dag_shortest_paths.hpp | 4 +-
trunk/boost/graph/depth_first_search.hpp | 12 ++++----
trunk/boost/graph/detail/compressed_sparse_row_struct.hpp | 2
trunk/boost/graph/detail/sparse_ordering.hpp | 2
trunk/boost/graph/dijkstra_shortest_paths.hpp | 2
trunk/boost/graph/directed_graph.hpp | 6 ++--
trunk/boost/graph/distributed/adjacency_list.hpp | 12 ++++----
trunk/boost/graph/distributed/adjlist/redistribute.hpp | 6 ++--
trunk/boost/graph/distributed/betweenness_centrality.hpp | 4 +-
trunk/boost/graph/distributed/connected_components.hpp | 2
trunk/boost/graph/distributed/connected_components_parallel_search.hpp | 2
trunk/boost/graph/distributed/crauser_et_al_shortest_paths.hpp | 2
trunk/boost/graph/distributed/dehne_gotz_min_spanning_tree.hpp | 6 ++--
trunk/boost/graph/distributed/depth_first_search.hpp | 4 +-
trunk/boost/graph/distributed/eager_dijkstra_shortest_paths.hpp | 2
trunk/boost/graph/distributed/graphviz.hpp | 4 +-
trunk/boost/graph/distributed/page_rank.hpp | 2
trunk/boost/graph/distributed/rmat_graph_generator.hpp | 2
trunk/boost/graph/distributed/strong_components.hpp | 28 ++++++++++----------
trunk/boost/graph/dominator_tree.hpp | 16 ++++++------
trunk/boost/graph/eccentricity.hpp | 6 ++--
trunk/boost/graph/edge_connectivity.hpp | 20 +++++++-------
trunk/boost/graph/edmonds_karp_max_flow.hpp | 6 ++--
trunk/boost/graph/filtered_graph.hpp | 20 +++++++-------
trunk/boost/graph/floyd_warshall_shortest.hpp | 18 ++++++------
trunk/boost/graph/fruchterman_reingold.hpp | 8 +++---
trunk/boost/graph/graph_stats.hpp | 2
trunk/boost/graph/graph_utility.hpp | 40 +++++++++++++++---------------
trunk/boost/graph/graphml.hpp | 4 +-
trunk/boost/graph/graphviz.hpp | 10 +++---
trunk/boost/graph/howard_cycle_ratio.hpp | 14 +++++-----
trunk/boost/graph/incremental_components.hpp | 4 +-
trunk/boost/graph/johnson_all_pairs_shortest.hpp | 24 +++++++++---------
trunk/boost/graph/king_ordering.hpp | 4 +-
trunk/boost/graph/kolmogorov_max_flow.hpp | 24 +++++++++---------
trunk/boost/graph/leda_graph.hpp | 8 +++---
trunk/boost/graph/make_connected.hpp | 2
trunk/boost/graph/max_cardinality_matching.hpp | 30 +++++++++++-----------
trunk/boost/graph/mcgregor_common_subgraphs.hpp | 4 +-
trunk/boost/graph/metric_tsp_approx.hpp | 2
trunk/boost/graph/minimum_degree_ordering.hpp | 16 ++++++------
trunk/boost/graph/neighbor_bfs.hpp | 6 ++--
trunk/boost/graph/page_rank.hpp | 2
trunk/boost/graph/planar_detail/boyer_myrvold_impl.hpp | 52 ++++++++++++++++++++--------------------
trunk/boost/graph/profile.hpp | 2
trunk/boost/graph/push_relabel_max_flow.hpp | 42 ++++++++++++++++----------------
trunk/boost/graph/r_c_shortest_paths.hpp | 2
trunk/boost/graph/random.hpp | 6 ++--
trunk/boost/graph/read_dimacs.hpp | 4 +-
trunk/boost/graph/reverse_graph.hpp | 2
trunk/boost/graph/rmat_graph_generator.hpp | 10 +++---
trunk/boost/graph/sequential_vertex_coloring.hpp | 4 +-
trunk/boost/graph/sloan_ordering.hpp | 12 ++++----
trunk/boost/graph/strong_components.hpp | 10 +++---
trunk/boost/graph/subgraph.hpp | 20 +++++++-------
trunk/boost/graph/transitive_closure.hpp | 30 +++++++++++-----------
trunk/boost/graph/transitive_reduction.hpp | 2
trunk/boost/graph/tree_traits.hpp | 2
trunk/boost/graph/undirected_dfs.hpp | 12 ++++----
trunk/boost/graph/undirected_graph.hpp | 6 ++--
trunk/boost/graph/wavefront.hpp | 10 +++---
trunk/libs/graph/example/accum-compile-times.cpp | 4 +-
trunk/libs/graph/example/astar-cities.cpp | 4 +-
trunk/libs/graph/example/bellman-example.cpp | 4 +-
trunk/libs/graph/example/bfs-example2.cpp | 2
trunk/libs/graph/example/bfs-name-printer.cpp | 14 +++++-----
trunk/libs/graph/example/biconnected_components.cpp | 2
trunk/libs/graph/example/bipartite_example.cpp | 2
trunk/libs/graph/example/boost_web_graph.cpp | 14 +++++-----
trunk/libs/graph/example/boykov_kolmogorov-eg.cpp | 4 +-
trunk/libs/graph/example/cc-internet.cpp | 2
trunk/libs/graph/example/copy-example.cpp | 2
trunk/libs/graph/example/cycle-file-dep.cpp | 8 +++---
trunk/libs/graph/example/cycle-file-dep2.cpp | 8 +++---
trunk/libs/graph/example/cycle_ratio_example.cpp | 2
trunk/libs/graph/example/dag_shortest_paths.cpp | 2
trunk/libs/graph/example/dfs-parenthesis.cpp | 2
trunk/libs/graph/example/dijkstra-example-listS.cpp | 12 ++++----
trunk/libs/graph/example/dijkstra-example.cpp | 6 ++--
trunk/libs/graph/example/dijkstra-no-color-map-example.cpp | 6 ++--
trunk/libs/graph/example/eccentricity.cpp | 4 +-
trunk/libs/graph/example/edge-connectivity.cpp | 16 ++++++------
trunk/libs/graph/example/edge-function.cpp | 8 +++---
trunk/libs/graph/example/edge_property.cpp | 4 +-
trunk/libs/graph/example/edmonds-karp-eg.cpp | 4 +-
trunk/libs/graph/example/family-tree-eg.cpp | 4 +-
trunk/libs/graph/example/file_dependencies.cpp | 6 ++--
trunk/libs/graph/example/filtered-copy-example.cpp | 2
trunk/libs/graph/example/filtered_graph_edge_range.cpp | 4 +-
trunk/libs/graph/example/fr_layout.cpp | 2
trunk/libs/graph/example/gerdemann.cpp | 4 +-
trunk/libs/graph/example/graph-property-iter-eg.cpp | 4 +-
trunk/libs/graph/example/in_edges.cpp | 4 +-
trunk/libs/graph/example/isomorphism.cpp | 4 +-
trunk/libs/graph/example/johnson-eg.cpp | 2
trunk/libs/graph/example/kevin-bacon.cpp | 8 +++---
trunk/libs/graph/example/kevin-bacon2.cpp | 4 +-
trunk/libs/graph/example/knights-tour.cpp | 20 +++++++-------
trunk/libs/graph/example/kruskal-example.cpp | 4 +-
trunk/libs/graph/example/kruskal-telephone.cpp | 2
trunk/libs/graph/example/leda-graph-eg.cpp | 2
trunk/libs/graph/example/loops_dfs.cpp | 8 +++---
trunk/libs/graph/example/max_flow.cpp | 4 +-
trunk/libs/graph/example/min_max_paths.cpp | 6 ++--
trunk/libs/graph/example/modify_graph.cpp | 26 ++++++++++----------
trunk/libs/graph/example/ordered_out_edges.cpp | 4 +-
trunk/libs/graph/example/ospf-example.cpp | 6 ++--
trunk/libs/graph/example/parallel-compile-time.cpp | 22 ++++++++--------
trunk/libs/graph/example/prim-example.cpp | 2
trunk/libs/graph/example/prim-telephone.cpp | 2
trunk/libs/graph/example/print-adjacent-vertices.cpp | 4 +-
trunk/libs/graph/example/print-edges.cpp | 2
trunk/libs/graph/example/print-in-edges.cpp | 4 +-
trunk/libs/graph/example/print-out-edges.cpp | 4 +-
trunk/libs/graph/example/push-relabel-eg.cpp | 4 +-
trunk/libs/graph/example/quick-tour.cpp | 16 ++++++------
trunk/libs/graph/example/quick_tour.cpp | 10 +++---
trunk/libs/graph/example/reachable-loop-head.cpp | 6 ++--
trunk/libs/graph/example/reachable-loop-tail.cpp | 4 +-
trunk/libs/graph/example/read_write_dimacs-eg.cpp | 4 +-
trunk/libs/graph/example/remove_edge_if_bidir.cpp | 2
trunk/libs/graph/example/remove_edge_if_undir.cpp | 2
trunk/libs/graph/example/roget_components.cpp | 6 ++--
trunk/libs/graph/example/scc.cpp | 2
trunk/libs/graph/example/subgraph.cpp | 2
trunk/libs/graph/example/tiernan_girth_circumference.cpp | 2
trunk/libs/graph/example/topo-sort-file-dep.cpp | 8 +++---
trunk/libs/graph/example/topo-sort-file-dep2.cpp | 8 +++---
trunk/libs/graph/example/transpose-example.cpp | 4 +-
trunk/libs/graph/example/undirected.cpp | 12 ++++----
trunk/libs/graph/src/graphml.cpp | 2
trunk/libs/graph/test/astar_search_test.cpp | 4 +-
trunk/libs/graph/test/betweenness_centrality_test.cpp | 18 ++++++------
trunk/libs/graph/test/biconnected_components_test.cpp | 4 +-
trunk/libs/graph/test/bidir_remove_edge.cpp | 4 +-
trunk/libs/graph/test/bidir_vec_remove_edge.cpp | 2
trunk/libs/graph/test/boykov_kolmogorov_max_flow_test.cpp | 28 ++++++++++----------
trunk/libs/graph/test/cycle_ratio_tests.cpp | 2
trunk/libs/graph/test/dijkstra_heap_performance.cpp | 2
trunk/libs/graph/test/dominator_tree_test.cpp | 6 ++--
trunk/libs/graph/test/graphml_test.cpp | 4 +-
trunk/libs/graph/test/index_graph.cpp | 2
trunk/libs/graph/test/layout_test.cpp | 18 ++++++------
trunk/libs/graph/test/matching_test.cpp | 16 ++++++------
trunk/libs/graph/test/max_flow_test.cpp | 4 +-
trunk/libs/graph/test/metric_tsp_approx.cpp | 4 +-
trunk/libs/graph/test/property_iter.cpp | 4 +-
trunk/libs/graph/test/random_matching_test.cpp | 8 +++---
trunk/libs/graph/test/subgraph.cpp | 2
trunk/libs/graph/test/subgraph_bundled.cpp | 2
trunk/libs/graph/test/transitive_closure_test.cpp | 10 +++---
trunk/libs/graph_parallel/test/adjlist_build_test.cpp | 8 +++---
trunk/libs/graph_parallel/test/adjlist_redist_test.cpp | 2
trunk/libs/graph_parallel/test/distributed_adjacency_list_test.cpp | 8 +++---
trunk/libs/graph_parallel/test/distributed_betweenness_centrality_test.cpp | 4 +-
169 files changed, 663 insertions(+), 663 deletions(-)
Modified: trunk/boost/graph/adj_list_serialize.hpp
==============================================================================
--- trunk/boost/graph/adj_list_serialize.hpp (original)
+++ trunk/boost/graph/adj_list_serialize.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -92,7 +92,7 @@
ar >> BOOST_SERIALIZATION_NVP(u);
ar >> BOOST_SERIALIZATION_NVP(v);
Edge e; bool inserted;
- tie(e,inserted) = add_edge(verts[u], verts[v], graph);
+ boost::tie(e,inserted) = add_edge(verts[u], verts[v], graph);
ar >> serialization::make_nvp("edge_property", get(edge_all_t(), graph, e) );
}
}
Modified: trunk/boost/graph/adjacency_matrix.hpp
==============================================================================
--- trunk/boost/graph/adjacency_matrix.hpp (original)
+++ trunk/boost/graph/adjacency_matrix.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -766,7 +766,7 @@
{
typename adjacency_matrix<D,VP,EP,GP,A>::degree_size_type n = 0;
typename adjacency_matrix<D,VP,EP,GP,A>::out_edge_iterator f, l;
- for (tie(f, l) = out_edges(u, g); f != l; ++f)
+ for (boost::tie(f, l) = out_edges(u, g); f != l; ++f)
++n;
return n;
}
@@ -848,7 +848,7 @@
{
typename adjacency_matrix<D,VP,EP,GP,A>::degree_size_type n = 0;
typename adjacency_matrix<D,VP,EP,GP,A>::in_edge_iterator f, l;
- for (tie(f, l) = in_edges(u, g); f != l; ++f)
+ for (boost::tie(f, l) = in_edges(u, g); f != l; ++f)
++n;
return n;
}
@@ -1017,9 +1017,9 @@
{
typename adjacency_matrix<directedS,VP,EP,GP,A>::vertex_iterator
vi, vi_end;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
remove_edge(u, *vi, g);
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
remove_edge(*vi, u, g);
}
@@ -1032,7 +1032,7 @@
{
typename adjacency_matrix<undirectedS,VP,EP,GP,A>::vertex_iterator
vi, vi_end;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
remove_edge(u, *vi, g);
}
Modified: trunk/boost/graph/astar_search.hpp
==============================================================================
--- trunk/boost/graph/astar_search.hpp (original)
+++ trunk/boost/graph/astar_search.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -284,7 +284,7 @@
typedef typename property_traits<ColorMap>::value_type ColorValue;
typedef color_traits<ColorValue> Color;
typename graph_traits<VertexListGraph>::vertex_iterator ui, ui_end;
- for (tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui) {
+ for (boost::tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui) {
put(color, *ui, Color::white());
put(distance, *ui, inf);
put(cost, *ui, inf);
Modified: trunk/boost/graph/bandwidth.hpp
==============================================================================
--- trunk/boost/graph/bandwidth.hpp (original)
+++ trunk/boost/graph/bandwidth.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -24,7 +24,7 @@
typedef typename graph_traits<Graph>::vertices_size_type size_type;
size_type b = 0;
typename graph_traits<Graph>::out_edge_iterator e, end;
- for (tie(e, end) = out_edges(i, g); e != end; ++e) {
+ for (boost::tie(e, end) = out_edges(i, g); e != end; ++e) {
int f_i = get(index, i);
int f_j = get(index, target(*e, g));
using namespace std; // to call abs() unqualified
@@ -49,7 +49,7 @@
BOOST_USING_STD_MAX();
typename graph_traits<Graph>::vertices_size_type b = 0;
typename graph_traits<Graph>::vertex_iterator i, end;
- for (tie(i, end) = vertices(g); i != end; ++i)
+ for (boost::tie(i, end) = vertices(g); i != end; ++i)
b = max BOOST_PREVENT_MACRO_SUBSTITUTION (b, ith_bandwidth(*i, g, index));
return b;
}
@@ -69,7 +69,7 @@
typedef typename detail::numeric_traits<size_type>::difference_type diff_t;
size_type sum = 0;
typename graph_traits<Graph>::edge_iterator i, end;
- for (tie(i, end) = edges(g); i != end; ++i) {
+ for (boost::tie(i, end) = edges(g); i != end; ++i) {
diff_t f_u = get(index_map, source(*i, g));
diff_t f_v = get(index_map, target(*i, g));
using namespace std; // to call abs() unqualified
Modified: trunk/boost/graph/bellman_ford_shortest_paths.hpp
==============================================================================
--- trunk/boost/graph/bellman_ford_shortest_paths.hpp (original)
+++ trunk/boost/graph/bellman_ford_shortest_paths.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -108,7 +108,7 @@
for (Size k = 0; k < N; ++k) {
bool at_least_one_edge_relaxed = false;
- for (tie(i, end) = edges(g); i != end; ++i) {
+ for (boost::tie(i, end) = edges(g); i != end; ++i) {
v.examine_edge(*i, g);
if (relax(*i, g, weight, pred, distance, combine, compare)) {
at_least_one_edge_relaxed = true;
@@ -120,7 +120,7 @@
break;
}
- for (tie(i, end) = edges(g); i != end; ++i)
+ for (boost::tie(i, end) = edges(g); i != end; ++i)
if (compare(combine(get(distance, source(*i, g)), get(weight, *i)),
get(distance, target(*i,g))))
{
@@ -148,7 +148,7 @@
bellman_visitor<> null_vis;
typedef typename property_traits<WeightMap>::value_type weight_type;
typename graph_traits<VertexAndEdgeListGraph>::vertex_iterator v, v_end;
- for (tie(v, v_end) = vertices(g); v != v_end; ++v) {
+ for (boost::tie(v, v_end) = vertices(g); v != v_end; ++v) {
put(distance, *v, (std::numeric_limits<weight_type>::max)());
put(pred, *v, *v);
}
Modified: trunk/boost/graph/betweenness_centrality.hpp
==============================================================================
--- trunk/boost/graph/betweenness_centrality.hpp (original)
+++ trunk/boost/graph/betweenness_centrality.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -305,10 +305,10 @@
std::stack<vertex_descriptor> ordered_vertices;
vertex_iterator s, s_end;
- for (tie(s, s_end) = vertices(g); s != s_end; ++s) {
+ for (boost::tie(s, s_end) = vertices(g); s != s_end; ++s) {
// Initialize for this iteration
vertex_iterator w, w_end;
- for (tie(w, w_end) = vertices(g); w != w_end; ++w) {
+ for (boost::tie(w, w_end) = vertices(g); w != w_end; ++w) {
incoming[*w].clear();
put(path_count, *w, 0);
put(dependency, *w, 0);
@@ -581,7 +581,7 @@
typename graph_traits<Graph>::vertices_size_type n = num_vertices(g);
centrality_type factor = centrality_type(2)/centrality_type(n*n - 3*n + 2);
vertex_iterator v, v_end;
- for (tie(v, v_end) = vertices(g); v != v_end; ++v) {
+ for (boost::tie(v, v_end) = vertices(g); v != v_end; ++v) {
put(centrality, *v, factor * get(centrality, *v));
}
}
@@ -602,13 +602,13 @@
// Find max centrality
centrality_type max_centrality(0);
vertex_iterator v, v_end;
- for (tie(v, v_end) = vertices(g); v != v_end; ++v) {
+ for (boost::tie(v, v_end) = vertices(g); v != v_end; ++v) {
max_centrality = (max)(max_centrality, get(centrality, *v));
}
// Compute central point dominance
centrality_type sum(0);
- for (tie(v, v_end) = vertices(g); v != v_end; ++v) {
+ for (boost::tie(v, v_end) = vertices(g); v != v_end; ++v) {
sum += (max_centrality - get(centrality, *v));
}
return sum/(n-1);
Modified: trunk/boost/graph/bipartite.hpp
==============================================================================
--- trunk/boost/graph/bipartite.hpp (original)
+++ trunk/boost/graph/bipartite.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -291,7 +291,7 @@
predecessor_recorder_t predecessor_recorder (predecessor_map);
/// Initialize predecessor map
- for (tie (vertex_iter, vertex_end) = vertices (graph); vertex_iter != vertex_end; ++vertex_iter)
+ for (boost::tie (vertex_iter, vertex_end) = vertices (graph); vertex_iter != vertex_end; ++vertex_iter)
{
put (predecessor_map, *vertex_iter, *vertex_iter);
}
Modified: trunk/boost/graph/boykov_kolmogorov_max_flow.hpp
==============================================================================
--- trunk/boost/graph/boykov_kolmogorov_max_flow.hpp (original)
+++ trunk/boost/graph/boykov_kolmogorov_max_flow.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -118,13 +118,13 @@
m_last_grow_vertex(graph_traits<Graph>::null_vertex()){
// initialize the color-map with gray-values
vertex_iterator vi, v_end;
- for(tie(vi, v_end) = vertices(m_g); vi != v_end; ++vi){
+ for(boost::tie(vi, v_end) = vertices(m_g); vi != v_end; ++vi){
set_tree(*vi, tColorTraits::gray());
}
// Initialize flow to zero which means initializing
// the residual capacity equal to the capacity
edge_iterator ei, e_end;
- for(tie(ei, e_end) = edges(m_g); ei != e_end; ++ei) {
+ for(boost::tie(ei, e_end) = edges(m_g); ei != e_end; ++ei) {
m_res_cap_map[*ei] = m_cap_map[*ei];
assert(m_rev_edge_map[m_rev_edge_map[*ei]] == *ei); //check if the reverse edge map is build up properly
}
@@ -142,7 +142,7 @@
while(true){
bool path_found;
edge_descriptor connecting_edge;
- tie(connecting_edge, path_found) = grow(); //find a path from source to sink
+ boost::tie(connecting_edge, path_found) = grow(); //find a path from source to sink
if(!path_found){
//we're finished, no more paths were found
break;
@@ -164,7 +164,7 @@
// connects but shouldn't have an impact on other maxflow problems
// (this is done in grow() anyway)
out_edge_iterator ei, e_end;
- for(tie(ei, e_end) = out_edges(m_source, m_g); ei != e_end; ++ei){
+ for(boost::tie(ei, e_end) = out_edges(m_source, m_g); ei != e_end; ++ei){
edge_descriptor from_source = *ei;
vertex_descriptor current_node = target(from_source, m_g);
if(current_node == m_sink){
@@ -175,7 +175,7 @@
}
edge_descriptor to_sink;
bool is_there;
- tie(to_sink, is_there) = lookup_edge(current_node, m_sink, m_g);
+ boost::tie(to_sink, is_there) = lookup_edge(current_node, m_sink, m_g);
if(is_there){
tEdgeVal cap_from_source = m_res_cap_map[from_source];
tEdgeVal cap_to_sink = m_res_cap_map[to_sink];
@@ -215,7 +215,7 @@
add_active_node(current_node);
}
}
- for(tie(ei, e_end) = out_edges(m_sink, m_g); ei != e_end; ++ei){
+ for(boost::tie(ei, e_end) = out_edges(m_sink, m_g); ei != e_end; ++ei){
edge_descriptor to_sink = m_rev_edge_map[*ei];
vertex_descriptor current_node = source(to_sink, m_g);
if(m_res_cap_map[to_sink]){
@@ -248,7 +248,7 @@
out_edge_iterator ei, e_end;
if(current_node != m_last_grow_vertex){
m_last_grow_vertex = current_node;
- tie(m_last_grow_edge_it, m_last_grow_edge_end) = out_edges(current_node, m_g);
+ boost::tie(m_last_grow_edge_it, m_last_grow_edge_end) = out_edges(current_node, m_g);
}
for(; m_last_grow_edge_it != m_last_grow_edge_end; ++m_last_grow_edge_it) {
edge_descriptor out_edge = *m_last_grow_edge_it;
@@ -282,7 +282,7 @@
out_edge_iterator ei, e_end;
if(current_node != m_last_grow_vertex){
m_last_grow_vertex = current_node;
- tie(m_last_grow_edge_it, m_last_grow_edge_end) = out_edges(current_node, m_g);
+ boost::tie(m_last_grow_edge_it, m_last_grow_edge_end) = out_edges(current_node, m_g);
}
for(; m_last_grow_edge_it != m_last_grow_edge_end; ++m_last_grow_edge_it){
edge_descriptor in_edge = m_rev_edge_map[*m_last_grow_edge_it];
@@ -419,7 +419,7 @@
tDistanceVal min_distance = (std::numeric_limits<tDistanceVal>::max)();
edge_descriptor new_parent_edge;
out_edge_iterator ei, e_end;
- for(tie(ei, e_end) = out_edges(current_node, m_g); ei != e_end; ++ei){
+ for(boost::tie(ei, e_end) = out_edges(current_node, m_g); ei != e_end; ++ei){
const edge_descriptor in_edge = m_rev_edge_map[*ei];
assert(target(in_edge, m_g) == current_node); //we should be the target of this edge
if(m_res_cap_map[in_edge] > 0){
@@ -438,7 +438,7 @@
m_time_map[current_node] = m_time;
} else{
m_time_map[current_node] = 0;
- for(tie(ei, e_end) = out_edges(current_node, m_g); ei != e_end; ++ei){
+ for(boost::tie(ei, e_end) = out_edges(current_node, m_g); ei != e_end; ++ei){
edge_descriptor in_edge = m_rev_edge_map[*ei];
vertex_descriptor other_node = source(in_edge, m_g);
if(get_tree(other_node) == tColorTraits::black() && has_parent(other_node)){
@@ -462,7 +462,7 @@
out_edge_iterator ei, e_end;
edge_descriptor new_parent_edge;
tDistanceVal min_distance = (std::numeric_limits<tDistanceVal>::max)();
- for(tie(ei, e_end) = out_edges(current_node, m_g); ei != e_end; ++ei){
+ for(boost::tie(ei, e_end) = out_edges(current_node, m_g); ei != e_end; ++ei){
const edge_descriptor out_edge = *ei;
if(m_res_cap_map[out_edge] > 0){
const vertex_descriptor other_node = target(out_edge, m_g);
@@ -479,7 +479,7 @@
m_time_map[current_node] = m_time;
} else{
m_time_map[current_node] = 0;
- for(tie(ei, e_end) = out_edges(current_node, m_g); ei != e_end; ++ei){
+ for(boost::tie(ei, e_end) = out_edges(current_node, m_g); ei != e_end; ++ei){
const edge_descriptor out_edge = *ei;
const vertex_descriptor other_node = target(out_edge, m_g);
if(get_tree(other_node) == tColorTraits::white() && has_parent(other_node)){
Modified: trunk/boost/graph/bron_kerbosch_all_cliques.hpp
==============================================================================
--- trunk/boost/graph/bron_kerbosch_all_cliques.hpp (original)
+++ trunk/boost/graph/bron_kerbosch_all_cliques.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -280,7 +280,7 @@
// constant inserts and removals at the end and also a constant size.
VertexIterator i, end;
- tie(i, end) = vertices(g);
+ boost::tie(i, end) = vertices(g);
VertexSet cands(i, end); // start with all vertices as candidates
VertexSet nots; // start with no vertices visited
Modified: trunk/boost/graph/clustering_coefficient.hpp
==============================================================================
--- trunk/boost/graph/clustering_coefficient.hpp (original)
+++ trunk/boost/graph/clustering_coefficient.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -72,7 +72,7 @@
// for things like this (num_neighbors() would be great).
AdjacencyIterator i, end;
- tie(i, end) = adjacent_vertices(v, g);
+ boost::tie(i, end) = adjacent_vertices(v, g);
std::size_t k = std::distance(i, end);
return detail::possible_edges(g, k, Directed());
}
@@ -92,7 +92,7 @@
Degree count(0);
AdjacencyIterator i, j, end;
- for(tie(i, end) = adjacent_vertices(v, g); i != end; ++i) {
+ for(boost::tie(i, end) = adjacent_vertices(v, g); i != end; ++i) {
for(j = boost::next(i); j != end; ++j) {
count += detail::count_edges(g, *i, *j, Directed());
}
@@ -127,7 +127,7 @@
Coefficient sum(0);
VertexIterator i, end;
- for(tie(i, end) = vertices(g); i != end; ++i) {
+ for(boost::tie(i, end) = vertices(g); i != end; ++i) {
Coefficient cc = clustering_coefficient<Coefficient>(g, *i);
put(cm, *i, cc);
sum += cc;
@@ -147,7 +147,7 @@
Coefficient cc(0);
VertexIterator i, end;
- for(tie(i, end) = vertices(g); i != end; ++i) {
+ for(boost::tie(i, end) = vertices(g); i != end; ++i) {
cc += get(cm, *i);
}
return cc / Coefficient(num_vertices(g));
Modified: trunk/boost/graph/copy.hpp
==============================================================================
--- trunk/boost/graph/copy.hpp (original)
+++ trunk/boost/graph/copy.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -113,19 +113,19 @@
Orig2CopyVertexIndexMap orig2copy, IndexMap)
{
typename graph_traits<Graph>::vertex_iterator vi, vi_end;
- for (tie(vi, vi_end) = vertices(g_in); vi != vi_end; ++vi) {
+ for (boost::tie(vi, vi_end) = vertices(g_in); vi != vi_end; ++vi) {
typename graph_traits<MutableGraph>::vertex_descriptor
new_v = add_vertex(g_out);
put(orig2copy, *vi, new_v);
copy_vertex(*vi, new_v);
}
typename graph_traits<Graph>::edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = edges(g_in); ei != ei_end; ++ei) {
+ for (boost::tie(ei, ei_end) = edges(g_in); ei != ei_end; ++ei) {
typename graph_traits<MutableGraph>::edge_descriptor new_e;
bool inserted;
- tie(new_e, inserted) = add_edge(get(orig2copy, source(*ei, g_in)),
- get(orig2copy, target(*ei, g_in)),
- g_out);
+ boost::tie(new_e, inserted) = add_edge(get(orig2copy, source(*ei, g_in)),
+ get(orig2copy, target(*ei, g_in)),
+ g_out);
copy_edge(*ei, new_e);
}
}
@@ -142,20 +142,20 @@
Orig2CopyVertexIndexMap orig2copy, IndexMap)
{
typename graph_traits<Graph>::vertex_iterator vi, vi_end;
- for (tie(vi, vi_end) = vertices(g_in); vi != vi_end; ++vi) {
+ for (boost::tie(vi, vi_end) = vertices(g_in); vi != vi_end; ++vi) {
typename graph_traits<MutableGraph>::vertex_descriptor
new_v = add_vertex(g_out);
put(orig2copy, *vi, new_v);
copy_vertex(*vi, new_v);
}
- for (tie(vi, vi_end) = vertices(g_in); vi != vi_end; ++vi) {
+ for (boost::tie(vi, vi_end) = vertices(g_in); vi != vi_end; ++vi) {
typename graph_traits<Graph>::out_edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = out_edges(*vi, g_in); ei != ei_end; ++ei) {
+ for (boost::tie(ei, ei_end) = out_edges(*vi, g_in); ei != ei_end; ++ei) {
typename graph_traits<MutableGraph>::edge_descriptor new_e;
bool inserted;
- tie(new_e, inserted) = add_edge(get(orig2copy, source(*ei, g_in)),
- get(orig2copy, target(*ei, g_in)),
- g_out);
+ boost::tie(new_e, inserted) = add_edge(get(orig2copy, source(*ei, g_in)),
+ get(orig2copy, target(*ei, g_in)),
+ g_out);
copy_edge(*ei, new_e);
}
}
@@ -177,21 +177,21 @@
std::vector<default_color_type>
color(num_vertices(g_in), Color::white());
typename graph_traits<Graph>::vertex_iterator vi, vi_end;
- for (tie(vi, vi_end) = vertices(g_in); vi != vi_end; ++vi) {
+ for (boost::tie(vi, vi_end) = vertices(g_in); vi != vi_end; ++vi) {
typename graph_traits<MutableGraph>::vertex_descriptor
new_v = add_vertex(g_out);
put(orig2copy, *vi, new_v);
copy_vertex(*vi, new_v);
}
- for (tie(vi, vi_end) = vertices(g_in); vi != vi_end; ++vi) {
+ for (boost::tie(vi, vi_end) = vertices(g_in); vi != vi_end; ++vi) {
typename graph_traits<Graph>::out_edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = out_edges(*vi, g_in); ei != ei_end; ++ei) {
+ for (boost::tie(ei, ei_end) = out_edges(*vi, g_in); ei != ei_end; ++ei) {
typename graph_traits<MutableGraph>::edge_descriptor new_e;
bool inserted;
if (color[get(index_map, target(*ei, g_in))] == Color::white()) {
- tie(new_e, inserted) = add_edge(get(orig2copy, source(*ei,g_in)),
- get(orig2copy, target(*ei,g_in)),
- g_out);
+ boost::tie(new_e, inserted) = add_edge(get(orig2copy, source(*ei,g_in)),
+ get(orig2copy, target(*ei,g_in)),
+ g_out);
copy_edge(*ei, new_e);
}
}
@@ -361,9 +361,9 @@
void examine_edge(Edge e, const Graph& g_in) const {
typename graph_traits<NewGraph>::edge_descriptor new_e;
bool inserted;
- tie(new_e, inserted) = add_edge(get(orig2copy, source(e, g_in)),
- get(orig2copy, target(e, g_in)),
- g_out);
+ boost::tie(new_e, inserted) = add_edge(get(orig2copy, source(e, g_in)),
+ get(orig2copy, target(e, g_in)),
+ g_out);
copy_edge(e, new_e);
}
private:
Modified: trunk/boost/graph/core_numbers.hpp
==============================================================================
--- trunk/boost/graph/core_numbers.hpp (original)
+++ trunk/boost/graph/core_numbers.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -122,11 +122,11 @@
{
typename graph_traits<Graph>::vertex_iterator vi,vi_end;
typename graph_traits<Graph>::out_edge_iterator ei,ei_end;
- for (tie(vi,vi_end) = vertices(g); vi!=vi_end; ++vi) {
+ for (boost::tie(vi,vi_end) = vertices(g); vi!=vi_end; ++vi) {
put(d,*vi,0);
}
- for (tie(vi,vi_end) = vertices(g); vi!=vi_end; ++vi) {
- for (tie(ei,ei_end) = out_edges(*vi,g); ei!=ei_end; ++ei) {
+ for (boost::tie(vi,vi_end) = vertices(g); vi!=vi_end; ++vi) {
+ for (boost::tie(ei,ei_end) = out_edges(*vi,g); ei!=ei_end; ++ei) {
put(d,target(*ei,g),get(d,target(*ei,g))+get(wm,*ei));
}
}
@@ -151,7 +151,7 @@
Q.pop();
v_cn = get(c,v);
typename graph_traits<Graph>::out_edge_iterator oi,oi_end;
- for (tie(oi,oi_end) = out_edges(v,g); oi!=oi_end; ++oi) {
+ for (boost::tie(oi,oi_end) = out_edges(v,g); oi!=oi_end; ++oi) {
vis.examine_edge(*oi,g);
vertex u = target(*oi,g);
// if c[u] > c[v], then u is still in the graph,
@@ -182,7 +182,7 @@
IndexMap> MutableQueue;
MutableQueue Q(num_vertices(g), icmp, im);
typename graph_traits<Graph>::vertex_iterator vi,vi_end;
- for (tie(vi,vi_end) = vertices(g); vi!=vi_end; ++vi) {
+ for (boost::tie(vi,vi_end) = vertices(g); vi!=vi_end; ++vi) {
Q.push(*vi);
}
return core_numbers_impl(g, c, wm, Q, vis);
@@ -206,14 +206,14 @@
// compute the maximum degree (degrees are in the coremap)
typename graph_traits<Graph>::degree_size_type max_deg = 0;
- for (tie(vi,vi_end) = vertices(g); vi!=vi_end; ++vi) {
+ for (boost::tie(vi,vi_end) = vertices(g); vi!=vi_end; ++vi) {
max_deg = (std::max<typename graph_traits<Graph>::degree_size_type>)(max_deg, get(c,*vi));
}
// store the vertices in bins by their degree
// allocate two extra locations to ease boundary cases
std::vector<size_type> bin(max_deg+2);
- for (tie(vi,vi_end) = vertices(g); vi!=vi_end; ++vi) {
+ for (boost::tie(vi,vi_end) = vertices(g); vi!=vi_end; ++vi) {
++bin[get(c,*vi)];
}
@@ -229,7 +229,7 @@
// perform the bucket sort with pos and vert so that
// pos[0] is the vertex of smallest degree
std::vector<vertex> vert(num_vertices(g));
- for (tie(vi,vi_end) = vertices(g); vi!=vi_end; ++vi) {
+ for (boost::tie(vi,vi_end) = vertices(g); vi!=vi_end; ++vi) {
vertex v=*vi;
size_type p=bin[get(c,v)];
put(pos,v,p);
@@ -247,7 +247,7 @@
vis.examine_vertex(v,g);
v_cn = get(c,v);
typename graph_traits<Graph>::out_edge_iterator oi,oi_end;
- for (tie(oi,oi_end) = out_edges(v,g); oi!=oi_end; ++oi) {
+ for (boost::tie(oi,oi_end) = out_edges(v,g); oi!=oi_end; ++oi) {
vis.examine_edge(*oi,g);
vertex u = target(*oi,g);
// if c[u] > c[v], then u is still in the graph,
Modified: trunk/boost/graph/create_condensation_graph.hpp
==============================================================================
--- trunk/boost/graph/create_condensation_graph.hpp (original)
+++ trunk/boost/graph/create_condensation_graph.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -38,7 +38,7 @@
for (size_type i = 0; i < components[si].size(); ++i) {
vertex u = components[s][i];
typename graph_traits<Graph>::adjacency_iterator v, v_end;
- for (tie(v, v_end) = adjacent_vertices(u, g); v != v_end; ++v) {
+ for (boost::tie(v, v_end) = adjacent_vertices(u, g); v != v_end; ++v) {
cg_vertex t = to_cg_vertex[component_number[*v]];
if (s != t) // Avoid loops in the condensation graph
adj.push_back(t);
@@ -50,7 +50,7 @@
cg_vertex t = adj[i];
typename graph_traits<CondensationGraph>::edge_descriptor e;
bool inserted;
- tie(e, inserted) = add_edge(s, t, cg);
+ boost::tie(e, inserted) = add_edge(s, t, cg);
put(edge_mult_map, e, 1);
++i;
while (i < adj.size()) {
@@ -58,7 +58,7 @@
put(edge_mult_map, e, get(edge_mult_map, e) + 1);
else {
t = adj[i];
- tie(e, inserted) = add_edge(s, t, cg);
+ boost::tie(e, inserted) = add_edge(s, t, cg);
put(edge_mult_map, e, 1);
}
++i;
Modified: trunk/boost/graph/cuthill_mckee_ordering.hpp
==============================================================================
--- trunk/boost/graph/cuthill_mckee_ordering.hpp (original)
+++ trunk/boost/graph/cuthill_mckee_ordering.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -92,7 +92,7 @@
// Copy degree to pseudo_degree
// initialize the color map
- for (tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui){
+ for (boost::tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui){
put(color, *ui, Color::white());
}
Modified: trunk/boost/graph/dag_shortest_paths.hpp
==============================================================================
--- trunk/boost/graph/dag_shortest_paths.hpp (original)
+++ trunk/boost/graph/dag_shortest_paths.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -46,7 +46,7 @@
depth_first_visit(g, s, topo_visitor, color);
typename graph_traits<VertexListGraph>::vertex_iterator ui, ui_end;
- for (tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui) {
+ for (boost::tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui) {
put(distance, *ui, inf);
put(pred, *ui, *ui);
}
@@ -58,7 +58,7 @@
Vertex u = *i;
vis.examine_vertex(u, g);
typename graph_traits<VertexListGraph>::out_edge_iterator e, e_end;
- for (tie(e, e_end) = out_edges(u, g); e != e_end; ++e) {
+ for (boost::tie(e, e_end) = out_edges(u, g); e != e_end; ++e) {
vis.discover_vertex(target(*e, g), g);
bool decreased = relax(*e, g, weight, pred, distance,
combine, compare);
Modified: trunk/boost/graph/depth_first_search.hpp
==============================================================================
--- trunk/boost/graph/depth_first_search.hpp (original)
+++ trunk/boost/graph/depth_first_search.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -100,7 +100,7 @@
put(color, u, Color::gray());
vis.discover_vertex(u, g);
- tie(ei, ei_end) = out_edges(u, g);
+ boost::tie(ei, ei_end) = out_edges(u, g);
// Variable is needed to workaround a borland bug.
TF& fn = static_cast<TF&>(func);
if (fn(u, g)) {
@@ -112,7 +112,7 @@
while (!stack.empty()) {
VertexInfo& back = stack.back();
u = back.first;
- tie(ei, ei_end) = back.second;
+ boost::tie(ei, ei_end) = back.second;
stack.pop_back();
while (ei != ei_end) {
Vertex v = target(*ei, g);
@@ -124,7 +124,7 @@
u = v;
put(color, u, Color::gray());
vis.discover_vertex(u, g);
- tie(ei, ei_end) = out_edges(u, g);
+ boost::tie(ei, ei_end) = out_edges(u, g);
if (fn(u, g)) {
ei = ei_end;
}
@@ -166,7 +166,7 @@
// Variable is needed to workaround a borland bug.
TF& fn = static_cast<TF&>(func);
if (!fn(u, g))
- for (tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei) {
+ for (boost::tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei) {
Vertex v = target(*ei, g); vis.examine_edge(*ei, g);
ColorValue v_color = get(color, v);
if (v_color == Color::white()) { vis.tree_edge(*ei, g);
@@ -192,7 +192,7 @@
typedef color_traits<ColorValue> Color;
typename graph_traits<VertexListGraph>::vertex_iterator ui, ui_end;
- for (tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui) {
+ for (boost::tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui) {
Vertex u = implicit_cast<Vertex>(*ui);
put(color, u, Color::white()); vis.initialize_vertex(u, g);
}
@@ -202,7 +202,7 @@
detail::nontruth2());
}
- for (tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui) {
+ for (boost::tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui) {
Vertex u = implicit_cast<Vertex>(*ui);
ColorValue u_color = get(color, u);
if (u_color == Color::white()) { vis.start_vertex(u, g);
Modified: trunk/boost/graph/detail/compressed_sparse_row_struct.hpp
==============================================================================
--- trunk/boost/graph/detail/compressed_sparse_row_struct.hpp (original)
+++ trunk/boost/graph/detail/compressed_sparse_row_struct.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -326,7 +326,7 @@
m_rowstart[i] = current_edge;
g_vertex v = ordered_verts_of_g[i];
g_out_edge_iter ei, ei_end;
- for (tie(ei, ei_end) = out_edges(v, g); ei != ei_end; ++ei) {
+ for (boost::tie(ei, ei_end) = out_edges(v, g); ei != ei_end; ++ei) {
m_column[current_edge++] = get(vi, target(*ei, g));
}
}
Modified: trunk/boost/graph/detail/sparse_ordering.hpp
==============================================================================
--- trunk/boost/graph/detail/sparse_ordering.hpp (original)
+++ trunk/boost/graph/detail/sparse_ordering.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -137,7 +137,7 @@
sparse::rcm_queue<Vertex, DegreeMap> Q(degree);
typename boost::graph_traits<Graph>::vertex_iterator ui, ui_end;
- for (tie(ui, ui_end) = vertices(G); ui != ui_end; ++ui)
+ for (boost::tie(ui, ui_end) = vertices(G); ui != ui_end; ++ui)
if (get(color, *ui) != Color::red()) put(color, *ui, Color::white());
breadth_first_visit(G, u, buffer(Q).color_map(color));
Modified: trunk/boost/graph/dijkstra_shortest_paths.hpp
==============================================================================
--- trunk/boost/graph/dijkstra_shortest_paths.hpp (original)
+++ trunk/boost/graph/dijkstra_shortest_paths.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -372,7 +372,7 @@
typedef typename property_traits<ColorMap>::value_type ColorValue;
typedef color_traits<ColorValue> Color;
typename graph_traits<VertexListGraph>::vertex_iterator ui, ui_end;
- for (tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui) {
+ for (boost::tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui) {
vis.initialize_vertex(*ui, g);
put(distance, *ui, inf);
put(predecessor, *ui, *ui);
Modified: trunk/boost/graph/directed_graph.hpp
==============================================================================
--- trunk/boost/graph/directed_graph.hpp (original)
+++ trunk/boost/graph/directed_graph.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -194,7 +194,7 @@
// find all edges, (u, v)
std::vector<edge_descriptor> edges;
out_edge_iterator i, i_end;
- for(tie(i, i_end) = boost::out_edges(u, m_graph); i != i_end; ++i) {
+ for(boost::tie(i, i_end) = boost::out_edges(u, m_graph); i != i_end; ++i) {
if(boost::target(*i, m_graph) == v) {
edges.push_back(*i);
}
@@ -225,7 +225,7 @@
renumber_vertex_indices()
{
vertex_iterator i, end;
- tie(i, end) = vertices(m_graph);
+ boost::tie(i, end) = vertices(m_graph);
m_max_vertex_index = renumber_vertex_indices(i, end, 0);
}
@@ -248,7 +248,7 @@
renumber_edge_indices()
{
edge_iterator i, end;
- tie(i, end) = edges(m_graph);
+ boost::tie(i, end) = edges(m_graph);
m_max_edge_index = renumber_edge_indices(i, end, 0);
}
Modified: trunk/boost/graph/distributed/adjacency_list.hpp
==============================================================================
--- trunk/boost/graph/distributed/adjacency_list.hpp (original)
+++ trunk/boost/graph/distributed/adjacency_list.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -989,7 +989,7 @@
}
typename graph_traits<base_type>::out_edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = out_edges(v.local, bg); ei != ei_end; ++ei)
+ for (boost::tie(ei, ei_end) = out_edges(v.local, bg); ei != ei_end; ++ei)
{
if (target(*ei, g.base()) == u.local
// TBD: deal with parallel edges properly && *ei == e
@@ -2098,7 +2098,7 @@
if (src.owner == process_id(process_group_)) {
base_out_edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = out_edges(src.local, base());
+ for (boost::tie(ei, ei_end) = out_edges(src.local, base());
ei != ei_end; ++ei) {
// TBD: can't check the descriptor here, because it could
// have changed if we're allowing the removal of
@@ -2140,7 +2140,7 @@
// Remove the edge from the out-edge list, if it is there
{
base_out_edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = out_edges(local_vertex.local, base());
+ for (boost::tie(ei, ei_end) = out_edges(local_vertex.local, base());
ei != ei_end; ++ei) {
// TBD: can't check the descriptor here, because it could
// have changed if we're allowing the removal of
@@ -2890,7 +2890,7 @@
typename PBGL_DISTRIB_ADJLIST_TYPE_CONFIG(directedS)
::out_edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei) {
+ for (boost::tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei) {
if (target(*ei, g) == v) return std::make_pair(*ei, true);
}
return std::make_pair(edge_descriptor(), false);
@@ -2912,13 +2912,13 @@
// must be local
if (u.owner == process_id(g.process_group())) {
typename PBGL_DISTRIB_ADJLIST_TYPE::out_edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei) {
+ for (boost::tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei) {
if (target(*ei, g) == v) return std::make_pair(*ei, true);
}
return std::make_pair(edge_descriptor(), false);
} else if (v.owner == process_id(g.process_group())) {
typename PBGL_DISTRIB_ADJLIST_TYPE::in_edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = in_edges(v, g); ei != ei_end; ++ei) {
+ for (boost::tie(ei, ei_end) = in_edges(v, g); ei != ei_end; ++ei) {
if (source(*ei, g) == u) return std::make_pair(*ei, true);
}
return std::make_pair(edge_descriptor(), false);
Modified: trunk/boost/graph/distributed/adjlist/redistribute.hpp
==============================================================================
--- trunk/boost/graph/distributed/adjlist/redistribute.hpp (original)
+++ trunk/boost/graph/distributed/adjlist/redistribute.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -203,7 +203,7 @@
// Build the sets of relocated vertices for each process and then do
// an all-to-all transfer.
- for (tie(vi, vi_end) = vertices(*this); vi != vi_end; ++vi) {
+ for (boost::tie(vi, vi_end) = vertices(*this); vi != vi_end; ++vi) {
if (!has_stable_descriptors
|| get(vertex_to_processor, *vi) != vi->owner) {
redistributed_vertices[get(vertex_to_processor, *vi)]
@@ -230,7 +230,7 @@
// Build the sets of relocated edges for each process and then do
// an all-to-all transfer.
- for (tie(ei, ei_end) = edges(*this); ei != ei_end; ++ei) {
+ for (boost::tie(ei, ei_end) = edges(*this); ei != ei_end; ++ei) {
vertex_descriptor src = source(*ei, *this);
vertex_descriptor tgt = target(*ei, *this);
if (!has_stable_descriptors
@@ -273,7 +273,7 @@
source_or_target_migrated(vertex_to_processor, *this));
// Eliminate vertices that have migrated
- for (tie(vi, vi_end) = vertices(*this); vi != vi_end; /* in loop */) {
+ for (boost::tie(vi, vi_end) = vertices(*this); vi != vi_end; /* in loop */) {
if (get(vertex_to_processor, *vi) != vi->owner)
remove_vertex((*vi++).local, base());
else {
Modified: trunk/boost/graph/distributed/betweenness_centrality.hpp
==============================================================================
--- trunk/boost/graph/distributed/betweenness_centrality.hpp (original)
+++ trunk/boost/graph/distributed/betweenness_centrality.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -1701,7 +1701,7 @@
// Find max centrality
centrality_type max_centrality(0);
vertex_iterator v, v_end;
- for (tie(v, v_end) = vertices(g); v != v_end; ++v) {
+ for (boost::tie(v, v_end) = vertices(g); v != v_end; ++v) {
max_centrality = (max)(max_centrality, get(centrality, *v));
}
@@ -1710,7 +1710,7 @@
// Compute central point dominance
centrality_type sum(0);
- for (tie(v, v_end) = vertices(g); v != v_end; ++v) {
+ for (boost::tie(v, v_end) = vertices(g); v != v_end; ++v) {
sum += (max_centrality - get(centrality, *v));
}
Modified: trunk/boost/graph/distributed/connected_components.hpp
==============================================================================
--- trunk/boost/graph/distributed/connected_components.hpp (original)
+++ trunk/boost/graph/distributed/connected_components.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -366,7 +366,7 @@
// Build adjacency list for all roots
BGL_FORALL_VERTICES_T(v, g, DistributedGraph) {
std::vector<vertex_descriptor>& my_adj = adj[get(p, v)];
- for (tie(av1, av2) = adjacent_vertices(v, g);
+ for (boost::tie(av1, av2) = adjacent_vertices(v, g);
av1 != av2; ++av1) {
if (get(owner, *av1) != id) my_adj.push_back(*av1);
}
Modified: trunk/boost/graph/distributed/connected_components_parallel_search.hpp
==============================================================================
--- trunk/boost/graph/distributed/connected_components_parallel_search.hpp (original)
+++ trunk/boost/graph/distributed/connected_components_parallel_search.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -306,7 +306,7 @@
BGL_FORALL_VERTICES_T(v, g, Graph) put(c, v, max_component);
vertex_iterator current, end;
- tie(current, end) = vertices(g);
+ boost::tie(current, end) = vertices(g);
cc_ps_detail::component_value_allocator<component_value_type> cva(process_id(pg), num_processes(pg));
cc_ps_detail::collision_map<component_value_type> collisions;
Modified: trunk/boost/graph/distributed/crauser_et_al_shortest_paths.hpp
==============================================================================
--- trunk/boost/graph/distributed/crauser_et_al_shortest_paths.hpp (original)
+++ trunk/boost/graph/distributed/crauser_et_al_shortest_paths.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -579,7 +579,7 @@
// Initialize local portion of property maps
typename graph_traits<DistributedGraph>::vertex_iterator ui, ui_end;
- for (tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui) {
+ for (boost::tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui) {
put(distance, *ui, inf);
put(predecessor, *ui, *ui);
}
Modified: trunk/boost/graph/distributed/dehne_gotz_min_spanning_tree.hpp
==============================================================================
--- trunk/boost/graph/distributed/dehne_gotz_min_spanning_tree.hpp (original)
+++ trunk/boost/graph/distributed/dehne_gotz_min_spanning_tree.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -561,7 +561,7 @@
// Initialize the disjoint sets structures
disjoint_sets<RankMap, ParentMap> dset(rank_map, parent_map);
vertex_iterator vi, vi_end;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
dset.make_set(*vi);
std::vector<vertex_descriptor> supervertices;
@@ -728,7 +728,7 @@
// Initialize the disjoint sets structures for Boruvka steps
disjoint_sets<RankMap, ParentMap> dset(rank_map, parent_map);
vertex_iterator vi, vi_end;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
dset.make_set(*vi);
// Construct the initial set of supervertices (all vertices)
@@ -836,7 +836,7 @@
// Initialize the disjoint sets structures for Boruvka steps
disjoint_sets<RankMap, ParentMap> dset(rank_map, parent_map);
vertex_iterator vi, vi_end;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
dset.make_set(*vi);
// Construct the initial set of supervertices (all vertices)
Modified: trunk/boost/graph/distributed/depth_first_search.hpp
==============================================================================
--- trunk/boost/graph/distributed/depth_first_search.hpp (original)
+++ trunk/boost/graph/distributed/depth_first_search.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -64,7 +64,7 @@
void run(vertex_descriptor s)
{
vertex_iterator vi, vi_end;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) {
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) {
put(color, *vi, Color::white());
put(parent, *vi, *vi);
put(explore, *vi, *vi);
@@ -105,7 +105,7 @@
if (shift_center_of_activity(p.first)) break;
out_edge_iterator ei, ei_end;
- for (tie(ei,ei_end) = out_edges(p.first, g); ei != ei_end; ++ei)
+ for (boost::tie(ei,ei_end) = out_edges(p.first, g); ei != ei_end; ++ei)
{
// Notify everyone who may not know that the source
// vertex has been visited. They can then mark the
Modified: trunk/boost/graph/distributed/eager_dijkstra_shortest_paths.hpp
==============================================================================
--- trunk/boost/graph/distributed/eager_dijkstra_shortest_paths.hpp (original)
+++ trunk/boost/graph/distributed/eager_dijkstra_shortest_paths.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -363,7 +363,7 @@
// Initialize local portion of property maps
typename graph_traits<DistributedGraph>::vertex_iterator ui, ui_end;
- for (tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui) {
+ for (boost::tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui) {
put(distance, *ui, inf);
put(predecessor, *ui, *ui);
}
Modified: trunk/boost/graph/distributed/graphviz.hpp
==============================================================================
--- trunk/boost/graph/distributed/graphviz.hpp (original)
+++ trunk/boost/graph/distributed/graphviz.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -134,7 +134,7 @@
gpw(local_graph_out);
typename graph_traits<Graph>::vertex_iterator vi, vi_end;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) {
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) {
int global_idx = get(global_index, *vi);
local_graph_out << " n" << global_idx;
@@ -145,7 +145,7 @@
typename graph_traits<Graph>::edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = edges(g); ei != ei_end; ++ei) {
+ for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei) {
int source_idx = get(global_index, source(*ei, g));
int target_idx = get(global_index, target(*ei, g));
local_graph_out << " n" << source_idx << " " << edge_kind << " n"
Modified: trunk/boost/graph/distributed/page_rank.hpp
==============================================================================
--- trunk/boost/graph/distributed/page_rank.hpp (original)
+++ trunk/boost/graph/distributed/page_rank.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -205,7 +205,7 @@
old_n = num_vertices(g);
typename graph_traits<MutableGraph>::vertex_iterator vi, vi_end;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; /* in loop */) {
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; /* in loop */) {
typename graph_traits<MutableGraph>::vertex_descriptor v = *vi++;
if (out_degree(v, g) == 0) {
clear_vertex(v, g);
Modified: trunk/boost/graph/distributed/rmat_graph_generator.hpp
==============================================================================
--- trunk/boost/graph/distributed/rmat_graph_generator.hpp (original)
+++ trunk/boost/graph/distributed/rmat_graph_generator.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -70,7 +70,7 @@
edges_size_type tossed = 0;
do {
vertices_size_type u, v;
- tie(u, v) = generate_edge(this->gen, n, SCALE, a, b, c, d);
+ boost::tie(u, v) = generate_edge(this->gen, n, SCALE, a, b, c, d);
if (permute_vertices) {
u = vertexPermutation[u];
Modified: trunk/boost/graph/distributed/strong_components.hpp
==============================================================================
--- trunk/boost/graph/distributed/strong_components.hpp (original)
+++ trunk/boost/graph/distributed/strong_components.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -209,7 +209,7 @@
// Remove vertices that do not have at least one in edge and one out edge
new_vertex_sets.push_back(std::vector<vertex_descriptor>());
- for( tie(vstart, vend) = vertices(g); vstart != vend; vstart++ )
+ for( boost::tie(vstart, vend) = vertices(g); vstart != vend; vstart++ )
if( out_degree( get(fr, *vstart), gr) > 0 && out_degree(*vstart, g) > 0 )
new_vertex_sets[0].push_back( *vstart );
@@ -234,7 +234,7 @@
std::map<int, std::vector<vertex_descriptor> > local_comp_map;
typedef typename graph_traits<local_subgraph<const Graph> >::vertex_iterator ls_vertex_iterator;
ls_vertex_iterator vstart, vend;
- for( tie(vstart,vend) = vertices(ls); vstart != vend; vstart++ )
+ for( boost::tie(vstart,vend) = vertices(ls); vstart != vend; vstart++ )
local_comp_map[get(ls_component, *vstart)].push_back( *vstart );
// Filter components that have no non-local edges
@@ -245,7 +245,7 @@
for( std::size_t i = 0; i < num_comp; ++i ) {
bool local = true;
for( std::size_t j = 0; j < local_comp_map[i].size(); j++ ) {
- for( tie(abegin,aend) = adjacent_vertices(local_comp_map[i][j], g);
+ for( boost::tie(abegin,aend) = adjacent_vertices(local_comp_map[i][j], g);
abegin != aend; abegin++ )
if( get(owner, *abegin) != id ) {
local = false;
@@ -253,7 +253,7 @@
}
if( local )
- for( tie(rev_abegin,rev_aend) = adjacent_vertices(get(fr, local_comp_map[i][j]), gr);
+ for( boost::tie(rev_abegin,rev_aend) = adjacent_vertices(get(fr, local_comp_map[i][j]), gr);
rev_abegin != rev_aend; rev_abegin++ )
if( get(owner, *rev_abegin) != id ) {
local = false;
@@ -476,7 +476,7 @@
for (std::size_t i = 0; i < vertex_sets.size(); ++i)
dest_map[vertex_sets[i][0]] = i % num_procs;
- for( tie(vstart, vend) = vertices(g); vstart != vend; vstart++ ) {
+ for( boost::tie(vstart, vend) = vertices(g); vstart != vend; vstart++ ) {
vertex_descriptor v = get(succ_map, *vstart);
if( v != graph_traits<Graph>::null_vertex() ) {
if (dest_map[v] == id)
@@ -486,7 +486,7 @@
}
}
- for( tie(rev_vstart, rev_vend) = vertices(gr); rev_vstart != rev_vend; rev_vstart++ ) {
+ for( boost::tie(rev_vstart, rev_vend) = vertices(gr); rev_vstart != rev_vend; rev_vstart++ ) {
vertex_descriptor v = get(pred_map, *rev_vstart);
if( v != graph_traits<Graph>::null_vertex() ) {
if (dest_map[v] == id)
@@ -686,11 +686,11 @@
for (std::size_t j = 0; j < vertex_sets[i].size(); ++j) {
vertex_descriptor v = vertex_sets[i][j];
if (get(owner, v) == id) {
- tie(estart, eend) = out_edges(v, g);
+ boost::tie(estart, eend) = out_edges(v, g);
while (estart != eend && find(vertex_sets[i].begin(), vertex_sets[i].end(),
target(*estart,g)) == vertex_sets[i].end()) estart++;
if (estart != eend) {
- tie(restart, reend) = out_edges(get(fr, v), gr);
+ boost::tie(restart, reend) = out_edges(get(fr, v), gr);
while (restart != reend && find(vertex_sets[i].begin(), vertex_sets[i].end(),
get(rf, target(*restart,g))) == vertex_sets[i].end()) restart++;
if (restart != reend)
@@ -713,7 +713,7 @@
// Label vertices not in a SCC as their own SCC
- for( tie(vstart, vend) = vertices(g); vstart != vend; vstart++ )
+ for( boost::tie(vstart, vend) = vertices(g); vstart != vend; vstart++ )
if( get(c, *vstart) == graph_traits<Graph>::null_vertex() )
put(c, *vstart, *vstart);
@@ -745,7 +745,7 @@
vertex_descriptor v;
out_edge_iterator oestart, oeend;
- for( tie(vstart, vend) = vertices(g); vstart != vend; vstart++ )
+ for( boost::tie(vstart, vend) = vertices(g); vstart != vend; vstart++ )
{
v = add_vertex(gr);
put(fr, *vstart, v);
@@ -763,8 +763,8 @@
// Add edges to gr
std::vector<std::pair<vertex_descriptor, vertex_descriptor> > new_edges;
- for( tie(vstart, vend) = vertices(g); vstart != vend; vstart++ )
- for( tie(oestart, oeend) = out_edges(*vstart, g); oestart != oeend; oestart++ )
+ for( boost::tie(vstart, vend) = vertices(g); vstart != vend; vstart++ )
+ for( boost::tie(oestart, oeend) = out_edges(*vstart, g); oestart != oeend; oestart++ )
new_edges.push_back( std::make_pair(get(fr, target(*oestart,g)), get(fr, source(*oestart, g))) );
std::vector<VertexPairVec> edge_requests(num_procs);
@@ -814,7 +814,7 @@
std::vector<vertex_descriptor> my_roots, all_roots;
vertex_iterator vstart, vend;
- for( tie(vstart, vend) = vertices(g); vstart != vend; vstart++ )
+ for( boost::tie(vstart, vend) = vertices(g); vstart != vend; vstart++ )
if( find( my_roots.begin(), my_roots.end(), get(r, *vstart) ) == my_roots.end() )
my_roots.push_back( get(r, *vstart) );
@@ -830,7 +830,7 @@
comp_numbers[all_roots[i]] = c_num++;
// Broadcast component numbers
- for( tie(vstart, vend) = vertices(g); vstart != vend; vstart++ )
+ for( boost::tie(vstart, vend) = vertices(g); vstart != vend; vstart++ )
put( c, *vstart, comp_numbers[get(r,*vstart)] );
// Broadcast number of components
Modified: trunk/boost/graph/dominator_tree.hpp
==============================================================================
--- trunk/boost/graph/dominator_tree.hpp (original)
+++ trunk/boost/graph/dominator_tree.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -118,7 +118,7 @@
// For each predecessor of n
typename graph_traits<Graph>::in_edge_iterator inItr, inEnd;
- for (tie(inItr, inEnd) = in_edges(n, g); inItr != inEnd; ++inItr)
+ for (boost::tie(inItr, inEnd) = in_edges(n, g); inItr != inEnd; ++inItr)
{
const Vertex v = source(*inItr, g);
// To deal with unreachable nodes
@@ -396,7 +396,7 @@
if (numOfVertices == 0) return;
vertexItr vi, viend;
- tie(vi, viend) = vertices(g);
+ boost::tie(vi, viend) = vertices(g);
const std::set<Vertex> N(vi, viend);
bool change = true;
@@ -409,14 +409,14 @@
while (change)
{
change = false;
- for (tie(vi, viend) = vertices(g); vi != viend; ++vi)
+ for (boost::tie(vi, viend) = vertices(g); vi != viend; ++vi)
{
if (*vi == entry) continue;
std::set<Vertex> T(N);
typename graph_traits<Graph>::in_edge_iterator inItr, inEnd;
- for (tie(inItr, inEnd) = in_edges(*vi, g); inItr != inEnd; ++inItr)
+ for (boost::tie(inItr, inEnd) = in_edges(*vi, g); inItr != inEnd; ++inItr)
{
const Vertex p = source(*inItr, g);
@@ -434,16 +434,16 @@
change = true;
get(domMap, *vi).swap(T);
}
- } // end of for (tie(vi, viend) = vertices(g)
+ } // end of for (boost::tie(vi, viend) = vertices(g)
} // end of while(change)
// 2. Build dominator tree
- for (tie(vi, viend) = vertices(g); vi != viend; ++vi)
+ for (boost::tie(vi, viend) = vertices(g); vi != viend; ++vi)
get(domMap, *vi).erase(*vi);
Graph domTree(numOfVertices);
- for (tie(vi, viend) = vertices(g); vi != viend; ++vi)
+ for (boost::tie(vi, viend) = vertices(g); vi != viend; ++vi)
{
if (*vi == entry) continue;
@@ -464,7 +464,7 @@
}
}
- for (tie(vi, viend) = vertices(g); vi != viend; ++vi)
+ for (boost::tie(vi, viend) = vertices(g); vi != viend; ++vi)
{
if (*vi != entry && get(domMap, *vi).size() == 1)
{
Modified: trunk/boost/graph/eccentricity.hpp
==============================================================================
--- trunk/boost/graph/eccentricity.hpp (original)
+++ trunk/boost/graph/eccentricity.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -58,8 +58,8 @@
r = numeric_values<Eccentricity>::infinity(),
d = numeric_values<Eccentricity>::zero();
VertexIterator i, end;
- tie(i, end) = vertices(g);
- for(tie(i, end) = vertices(g); i != end; ++i) {
+ boost::tie(i, end) = vertices(g);
+ for(boost::tie(i, end) = vertices(g); i != end; ++i) {
DistanceMap dm = get(dist, *i);
Eccentricity e = eccentricity(g, dm);
put(ecc, *i, e);
@@ -85,7 +85,7 @@
BOOST_USING_STD_MAX();
VertexIterator i, end;
- tie(i, end) = vertices(g);
+ boost::tie(i, end) = vertices(g);
Eccentricity radius = get(ecc, *i);
Eccentricity diameter = get(ecc, *i);
for(i = boost::next(i); i != end; ++i) {
Modified: trunk/boost/graph/edge_connectivity.hpp
==============================================================================
--- trunk/boost/graph/edge_connectivity.hpp (original)
+++ trunk/boost/graph/edge_connectivity.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -34,7 +34,7 @@
size_type delta = (std::numeric_limits<size_type>::max)();
typename Traits::vertex_iterator i, iend;
- for (tie(i, iend) = vertices(g); i != iend; ++i)
+ for (boost::tie(i, iend) = vertices(g); i != iend; ++i)
if (degree(*i, g) < delta) {
delta = degree(*i, g);
p = *i;
@@ -48,7 +48,7 @@
OutputIterator result)
{
typename graph_traits<Graph>::adjacency_iterator ai, aend;
- for (tie(ai, aend) = adjacent_vertices(u, g); ai != aend; ++ai)
+ for (boost::tie(ai, aend) = adjacent_vertices(u, g); ai != aend; ++ai)
*result++ = *ai;
}
@@ -111,11 +111,11 @@
typename property_map<FlowGraph, edge_reverse_t>::type
rev_edge = get(edge_reverse, flow_g);
- for (tie(ei, ei_end) = edges(g); ei != ei_end; ++ei) {
+ for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei) {
u = source(*ei, g), v = target(*ei, g);
- tie(e1, inserted) = add_edge(u, v, flow_g);
+ boost::tie(e1, inserted) = add_edge(u, v, flow_g);
cap[e1] = 1;
- tie(e2, inserted) = add_edge(v, u, flow_g);
+ boost::tie(e2, inserted) = add_edge(v, u, flow_g);
cap[e2] = 1; // not sure about this
rev_edge[e1] = e2;
rev_edge[e2] = e1;
@@ -124,7 +124,7 @@
//-------------------------------------------------------------------------
// The Algorithm
- tie(p, delta) = detail::min_degree_vertex(g);
+ boost::tie(p, delta) = detail::min_degree_vertex(g);
S_star.push_back(p);
alpha_star = delta;
S.insert(p);
@@ -132,7 +132,7 @@
detail::neighbors(g, S.begin(), S.end(),
std::inserter(neighbor_S, neighbor_S.begin()));
- tie(vi, vi_end) = vertices(g);
+ boost::tie(vi, vi_end) = vertices(g);
std::set_difference(vi, vi_end,
neighbor_S.begin(), neighbor_S.end(),
std::back_inserter(non_neighbor_S));
@@ -146,7 +146,7 @@
if (alpha_S_k < alpha_star) {
alpha_star = alpha_S_k;
S_star.clear();
- for (tie(vi, vi_end) = vertices(flow_g); vi != vi_end; ++vi)
+ for (boost::tie(vi, vi_end) = vertices(flow_g); vi != vi_end; ++vi)
if (color[*vi] != Color::white())
S_star.push_back(*vi);
}
@@ -154,7 +154,7 @@
neighbor_S.insert(k);
detail::neighbors(g, k, std::inserter(neighbor_S, neighbor_S.begin()));
non_neighbor_S.clear();
- tie(vi, vi_end) = vertices(g);
+ boost::tie(vi, vi_end) = vertices(g);
std::set_difference(vi, vi_end,
neighbor_S.begin(), neighbor_S.end(),
std::back_inserter(non_neighbor_S));
@@ -169,7 +169,7 @@
degree_size_type c = 0;
for (si = S_star.begin(); si != S_star.end(); ++si) {
out_edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = out_edges(*si, g); ei != ei_end; ++ei)
+ for (boost::tie(ei, ei_end) = out_edges(*si, g); ei != ei_end; ++ei)
if (!in_S_star[target(*ei, g)]) {
*disconnecting_set++ = *ei;
++c;
Modified: trunk/boost/graph/edmonds_karp_max_flow.hpp
==============================================================================
--- trunk/boost/graph/edmonds_karp_max_flow.hpp (original)
+++ trunk/boost/graph/edmonds_karp_max_flow.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -92,8 +92,8 @@
typename graph_traits<Graph>::vertex_iterator u_iter, u_end;
typename graph_traits<Graph>::out_edge_iterator ei, e_end;
- for (tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter)
- for (tie(ei, e_end) = out_edges(*u_iter, g); ei != e_end; ++ei)
+ for (boost::tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter)
+ for (boost::tie(ei, e_end) = out_edges(*u_iter, g); ei != e_end; ++ei)
res[*ei] = cap[*ei];
color[sink] = Color::gray();
@@ -108,7 +108,7 @@
} // while
typename property_traits<CapacityEdgeMap>::value_type flow = 0;
- for (tie(ei, e_end) = out_edges(src, g); ei != e_end; ++ei)
+ for (boost::tie(ei, e_end) = out_edges(src, g); ei != e_end; ++ei)
flow += (cap[*ei] - res[*ei]);
return flow;
} // edmonds_karp_max_flow()
Modified: trunk/boost/graph/filtered_graph.hpp
==============================================================================
--- trunk/boost/graph/filtered_graph.hpp (original)
+++ trunk/boost/graph/filtered_graph.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -279,7 +279,7 @@
{
typedef filtered_graph<G, EP, VP> Graph;
typename graph_traits<G>::vertex_iterator f, l;
- tie(f, l) = vertices(g.m_g);
+ boost::tie(f, l) = vertices(g.m_g);
typedef typename Graph::vertex_iterator iter;
return std::make_pair(iter(g.m_vertex_pred, f, l),
iter(g.m_vertex_pred, l, l));
@@ -293,7 +293,7 @@
typedef filtered_graph<G, EP, VP> Graph;
typename Graph::EdgePred pred(g.m_edge_pred, g.m_vertex_pred, g);
typename graph_traits<G>::edge_iterator f, l;
- tie(f, l) = edges(g.m_g);
+ boost::tie(f, l) = edges(g.m_g);
typedef typename Graph::edge_iterator iter;
return std::make_pair(iter(pred, f, l), iter(pred, l, l));
}
@@ -308,7 +308,7 @@
//
// However, the current solution is still unsatisfactory because
// the following semantic constraints no longer hold:
- // tie(vi, viend) = vertices(g);
+ // boost::tie(vi, viend) = vertices(g);
// assert(std::distance(vi, viend) == num_vertices(g));
template <typename G, typename EP, typename VP>
@@ -349,7 +349,7 @@
typename Graph::OutEdgePred pred(g.m_edge_pred, g.m_vertex_pred, g);
typedef typename Graph::out_edge_iterator iter;
typename graph_traits<G>::out_edge_iterator f, l;
- tie(f, l) = out_edges(u, g.m_g);
+ boost::tie(f, l) = out_edges(u, g.m_g);
return std::make_pair(iter(pred, f, l), iter(pred, l, l));
}
@@ -360,7 +360,7 @@
{
typename filtered_graph<G, EP, VP>::degree_size_type n = 0;
typename filtered_graph<G, EP, VP>::out_edge_iterator f, l;
- for (tie(f, l) = out_edges(u, g); f != l; ++f)
+ for (boost::tie(f, l) = out_edges(u, g); f != l; ++f)
++n;
return n;
}
@@ -374,7 +374,7 @@
typedef filtered_graph<G, EP, VP> Graph;
typedef typename Graph::adjacency_iterator adjacency_iterator;
typename Graph::out_edge_iterator f, l;
- tie(f, l) = out_edges(u, g);
+ boost::tie(f, l) = out_edges(u, g);
return std::make_pair(adjacency_iterator(f, const_cast<Graph*>(&g)),
adjacency_iterator(l, const_cast<Graph*>(&g)));
}
@@ -389,7 +389,7 @@
typename Graph::InEdgePred pred(g.m_edge_pred, g.m_vertex_pred, g);
typedef typename Graph::in_edge_iterator iter;
typename graph_traits<G>::in_edge_iterator f, l;
- tie(f, l) = in_edges(u, g.m_g);
+ boost::tie(f, l) = in_edges(u, g.m_g);
return std::make_pair(iter(pred, f, l), iter(pred, l, l));
}
@@ -400,7 +400,7 @@
{
typename filtered_graph<G, EP, VP>::degree_size_type n = 0;
typename filtered_graph<G, EP, VP>::in_edge_iterator f, l;
- for (tie(f, l) = in_edges(u, g); f != l; ++f)
+ for (boost::tie(f, l) = in_edges(u, g); f != l; ++f)
++n;
return n;
}
@@ -413,7 +413,7 @@
{
typename graph_traits<G>::edge_descriptor e;
bool exists;
- tie(e, exists) = edge(u, v, g.m_g);
+ boost::tie(e, exists) = edge(u, v, g.m_g);
return std::make_pair(e, exists && g.m_edge_pred(e));
}
@@ -428,7 +428,7 @@
typename Graph::OutEdgePred pred(g.m_edge_pred, g.m_vertex_pred, g);
typedef typename Graph::out_edge_iterator iter;
typename graph_traits<G>::out_edge_iterator f, l;
- tie(f, l) = edge_range(u, v, g.m_g);
+ boost::tie(f, l) = edge_range(u, v, g.m_g);
return std::make_pair(iter(pred, f, l), iter(pred, l, l));
}
Modified: trunk/boost/graph/floyd_warshall_shortest.hpp
==============================================================================
--- trunk/boost/graph/floyd_warshall_shortest.hpp (original)
+++ trunk/boost/graph/floyd_warshall_shortest.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -57,10 +57,10 @@
i, lasti, j, lastj, k, lastk;
- for (tie(k, lastk) = vertices(g); k != lastk; k++)
- for (tie(i, lasti) = vertices(g); i != lasti; i++)
+ for (boost::tie(k, lastk) = vertices(g); k != lastk; k++)
+ for (boost::tie(i, lasti) = vertices(g); i != lasti; i++)
if(d[*i][*k] != inf)
- for (tie(j, lastj) = vertices(g); j != lastj; j++)
+ for (boost::tie(j, lastj) = vertices(g); j != lastj; j++)
if(d[*k][*j] != inf)
d[*i][*j] =
detail::min_with_compare(d[*i][*j],
@@ -68,7 +68,7 @@
compare);
- for (tie(i, lasti) = vertices(g); i != lasti; i++)
+ for (boost::tie(i, lasti) = vertices(g); i != lasti; i++)
if (compare(d[*i][*i], zero))
return false;
return true;
@@ -110,16 +110,16 @@
typename graph_traits<VertexAndEdgeListGraph>::edge_iterator first, last;
- for(tie(firstv, lastv) = vertices(g); firstv != lastv; firstv++)
- for(tie(firstv2, lastv2) = vertices(g); firstv2 != lastv2; firstv2++)
+ for(boost::tie(firstv, lastv) = vertices(g); firstv != lastv; firstv++)
+ for(boost::tie(firstv2, lastv2) = vertices(g); firstv2 != lastv2; firstv2++)
d[*firstv][*firstv2] = inf;
- for(tie(firstv, lastv) = vertices(g); firstv != lastv; firstv++)
+ for(boost::tie(firstv, lastv) = vertices(g); firstv != lastv; firstv++)
d[*firstv][*firstv] = zero;
- for(tie(first, last) = edges(g); first != last; first++)
+ for(boost::tie(first, last) = edges(g); first != last; first++)
{
if (d[source(*first, g)][target(*first, g)] != inf) {
d[source(*first, g)][target(*first, g)] =
@@ -136,7 +136,7 @@
undirected_tag>::value;
if (is_undirected)
{
- for(tie(first, last) = edges(g); first != last; first++)
+ for(boost::tie(first, last) = edges(g); first != last; first++)
{
if (d[target(*first, g)][source(*first, g)] != inf)
d[target(*first, g)][source(*first, g)] =
Modified: trunk/boost/graph/fruchterman_reingold.hpp
==============================================================================
--- trunk/boost/graph/fruchterman_reingold.hpp (original)
+++ trunk/boost/graph/fruchterman_reingold.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -78,7 +78,7 @@
{
typedef typename graph_traits<Graph>::vertex_iterator vertex_iterator;
vertex_iterator v, end;
- for (tie(v, end) = vertices(g); v != end; ++v) {
+ for (boost::tie(v, end) = vertices(g); v != end; ++v) {
vertex_iterator u = v;
for (++u; u != end; ++u) {
apply_force(*u, *v);
@@ -116,7 +116,7 @@
std::size_t rows = std::size_t(topology.extent()[1] / two_k + 1.);
buckets_t buckets(rows * columns);
vertex_iterator v, v_end;
- for (tie(v, v_end) = vertices(g); v != v_end; ++v) {
+ for (boost::tie(v, v_end) = vertices(g); v != v_end; ++v) {
std::size_t column =
std::size_t((get(position, *v)[0] + topology.extent()[0] / 2) / two_k);
std::size_t row =
@@ -299,13 +299,13 @@
do {
// Calculate repulsive forces
vertex_iterator v, v_end;
- for (tie(v, v_end) = vertices(g); v != v_end; ++v)
+ for (boost::tie(v, v_end) = vertices(g); v != v_end; ++v)
put(displacement, *v, typename Topology::point_difference_type());
force_pairs(g, apply_force);
// Calculate attractive forces
edge_iterator e, e_end;
- for (tie(e, e_end) = edges(g); e != e_end; ++e) {
+ for (boost::tie(e, e_end) = edges(g); e != e_end; ++e) {
vertex_descriptor v = source(*e, g);
vertex_descriptor u = target(*e, g);
Modified: trunk/boost/graph/graph_stats.hpp
==============================================================================
--- trunk/boost/graph/graph_stats.hpp (original)
+++ trunk/boost/graph/graph_stats.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -77,7 +77,7 @@
BGL_FORALL_VERTICES_T( v, g, Graph ) {
std::list<vertex_type> front_neighbors;
a_iterator_type a_iter, a_end;
- for( tie( a_iter, a_end ) = adjacent_vertices( v, g );
+ for( boost::tie( a_iter, a_end ) = adjacent_vertices( v, g );
a_iter != a_end; ++a_iter ) {
front_neighbors.push_back( *a_iter );
}
Modified: trunk/boost/graph/graph_utility.hpp
==============================================================================
--- trunk/boost/graph/graph_utility.hpp (original)
+++ trunk/boost/graph/graph_utility.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -157,11 +157,11 @@
void print_in_edges(const IncidenceGraph& G, Name name)
{
typename graph_traits<IncidenceGraph>::vertex_iterator ui,ui_end;
- for (tie(ui,ui_end) = vertices(G); ui != ui_end; ++ui) {
+ for (boost::tie(ui,ui_end) = vertices(G); ui != ui_end; ++ui) {
std::cout << get(name,*ui) << " <-- ";
typename graph_traits<IncidenceGraph>
::in_edge_iterator ei, ei_end;
- for(tie(ei,ei_end) = in_edges(*ui,G); ei != ei_end; ++ei)
+ for(boost::tie(ei,ei_end) = in_edges(*ui,G); ei != ei_end; ++ei)
std::cout << get(name,source(*ei,G)) << " ";
std::cout << std::endl;
}
@@ -171,11 +171,11 @@
void print_graph_dispatch(const IncidenceGraph& G, Name name, directed_tag)
{
typename graph_traits<IncidenceGraph>::vertex_iterator ui,ui_end;
- for (tie(ui,ui_end) = vertices(G); ui != ui_end; ++ui) {
+ for (boost::tie(ui,ui_end) = vertices(G); ui != ui_end; ++ui) {
std::cout << get(name,*ui) << " --> ";
typename graph_traits<IncidenceGraph>
::out_edge_iterator ei, ei_end;
- for(tie(ei,ei_end) = out_edges(*ui,G); ei != ei_end; ++ei)
+ for(boost::tie(ei,ei_end) = out_edges(*ui,G); ei != ei_end; ++ei)
std::cout << get(name,target(*ei,G)) << " ";
std::cout << std::endl;
}
@@ -184,11 +184,11 @@
void print_graph_dispatch(const IncidenceGraph& G, Name name, undirected_tag)
{
typename graph_traits<IncidenceGraph>::vertex_iterator ui,ui_end;
- for (tie(ui,ui_end) = vertices(G); ui != ui_end; ++ui) {
+ for (boost::tie(ui,ui_end) = vertices(G); ui != ui_end; ++ui) {
std::cout << get(name,*ui) << " <--> ";
typename graph_traits<IncidenceGraph>
::out_edge_iterator ei, ei_end;
- for(tie(ei,ei_end) = out_edges(*ui,G); ei != ei_end; ++ei)
+ for(boost::tie(ei,ei_end) = out_edges(*ui,G); ei != ei_end; ++ei)
std::cout << get(name,target(*ei,G)) << " ";
std::cout << std::endl;
}
@@ -209,7 +209,7 @@
void print_edges(const EdgeListGraph& G, Name name)
{
typename graph_traits<EdgeListGraph>::edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = edges(G); ei != ei_end; ++ei)
+ for (boost::tie(ei, ei_end) = edges(G); ei != ei_end; ++ei)
std::cout << "(" << get(name, source(*ei, G))
<< "," << get(name, target(*ei, G)) << ") ";
std::cout << std::endl;
@@ -219,7 +219,7 @@
void print_edges2(const EdgeListGraph& G, VertexName vname, EdgeName ename)
{
typename graph_traits<EdgeListGraph>::edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = edges(G); ei != ei_end; ++ei)
+ for (boost::tie(ei, ei_end) = edges(G); ei != ei_end; ++ei)
std::cout << get(ename, *ei) << "(" << get(vname, source(*ei, G))
<< "," << get(vname, target(*ei, G)) << ") ";
std::cout << std::endl;
@@ -229,7 +229,7 @@
void print_vertices(const VertexListGraph& G, Name name)
{
typename graph_traits<VertexListGraph>::vertex_iterator vi,vi_end;
- for (tie(vi,vi_end) = vertices(G); vi != vi_end; ++vi)
+ for (boost::tie(vi,vi_end) = vertices(G); vi != vi_end; ++vi)
std::cout << get(name,*vi) << " ";
std::cout << std::endl;
}
@@ -241,21 +241,21 @@
edge_descriptor;
typename graph_traits<Graph>::adjacency_iterator vi, viend,
adj_found;
- tie(vi, viend) = adjacent_vertices(a, g);
+ boost::tie(vi, viend) = adjacent_vertices(a, g);
adj_found = std::find(vi, viend, b);
if (adj_found == viend)
return false;
typename graph_traits<Graph>::out_edge_iterator oi, oiend,
out_found;
- tie(oi, oiend) = out_edges(a, g);
+ boost::tie(oi, oiend) = out_edges(a, g);
out_found = std::find_if(oi, oiend, incident_to(b, g));
if (out_found == oiend)
return false;
typename graph_traits<Graph>::in_edge_iterator ii, iiend,
in_found;
- tie(ii, iiend) = in_edges(b, g);
+ boost::tie(ii, iiend) = in_edges(b, g);
in_found = std::find_if(ii, iiend, incident_from(a, g));
if (in_found == iiend)
return false;
@@ -268,7 +268,7 @@
typedef typename graph_traits<Graph>::edge_descriptor
edge_descriptor;
typename graph_traits<Graph>::adjacency_iterator vi, viend, found;
- tie(vi, viend) = adjacent_vertices(a, g);
+ boost::tie(vi, viend) = adjacent_vertices(a, g);
#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 && defined(__SGI_STL_PORT)
// Getting internal compiler error with std::find()
found = viend;
@@ -285,7 +285,7 @@
typename graph_traits<Graph>::out_edge_iterator oi, oiend,
out_found;
- tie(oi, oiend) = out_edges(a, g);
+ boost::tie(oi, oiend) = out_edges(a, g);
#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 && defined(__SGI_STL_PORT)
// Getting internal compiler error with std::find()
@@ -318,7 +318,7 @@
bool in_edge_set(Graph& g, Edge e)
{
typename Graph::edge_iterator ei, ei_end, found;
- tie(ei, ei_end) = edges(g);
+ boost::tie(ei, ei_end) = edges(g);
found = std::find(ei, ei_end, e);
return found != ei_end;
}
@@ -327,7 +327,7 @@
bool in_vertex_set(Graph& g, Vertex v)
{
typename Graph::vertex_iterator vi, vi_end, found;
- tie(vi, vi_end) = vertices(g);
+ boost::tie(vi, vi_end) = vertices(g);
found = std::find(vi, vi_end, v);
return found != vi_end;
}
@@ -336,7 +336,7 @@
bool in_edge_set(Graph& g, Vertex u, Vertex v)
{
typename Graph::edge_iterator ei, ei_end;
- for (tie(ei,ei_end) = edges(g); ei != ei_end; ++ei)
+ for (boost::tie(ei,ei_end) = edges(g); ei != ei_end; ++ei)
if (source(*ei,g) == u && target(*ei,g) == v)
return true;
return false;
@@ -380,10 +380,10 @@
typedef color_traits<ColorValue> Color;
typename graph_traits<VertexListGraph>::vertex_iterator
ui, ui_end, vi, vi_end, ci, ci_end;
- for (tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui)
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
+ for (boost::tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui)
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
if (*ui != *vi) {
- for (tie(ci, ci_end) = vertices(g); ci != ci_end; ++ci)
+ for (boost::tie(ci, ci_end) = vertices(g); ci != ci_end; ++ci)
put(color, *ci, Color::white());
if (! is_reachable(*ui, *vi, g, color))
return false;
Modified: trunk/boost/graph/graphml.hpp
==============================================================================
--- trunk/boost/graph/graphml.hpp (original)
+++ trunk/boost/graph/graphml.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -296,7 +296,7 @@
typedef typename graph_traits<Graph>::vertex_iterator vertex_iterator;
vertex_iterator v, v_end;
- for (tie(v, v_end) = vertices(g); v != v_end; ++v)
+ for (boost::tie(v, v_end) = vertices(g); v != v_end; ++v)
{
out << " <node id=\"n" << get(vertex_index, *v) << "\">\n";
// Output data
@@ -314,7 +314,7 @@
typedef typename graph_traits<Graph>::edge_iterator edge_iterator;
edge_iterator e, e_end;
typename graph_traits<Graph>::edges_size_type edge_count = 0;
- for (tie(e, e_end) = edges(g); e != e_end; ++e)
+ for (boost::tie(e, e_end) = edges(g); e != e_end; ++e)
{
out << " <edge id=\"e" << edge_count++ << "\" source=\"n"
<< get(vertex_index, source(*e, g)) << "\" target=\"n"
Modified: trunk/boost/graph/graphviz.hpp
==============================================================================
--- trunk/boost/graph/graphviz.hpp (original)
+++ trunk/boost/graph/graphviz.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -245,13 +245,13 @@
typename graph_traits<Graph>::vertex_iterator i, end;
- for(tie(i,end) = vertices(g); i != end; ++i) {
+ for(boost::tie(i,end) = vertices(g); i != end; ++i) {
out << get(vertex_id, *i);
vpw(out, *i); //print vertex attributes
out << ";" << std::endl;
}
typename graph_traits<Graph>::edge_iterator ei, edge_end;
- for(tie(ei, edge_end) = edges(g); ei != edge_end; ++ei) {
+ for(boost::tie(ei, edge_end) = edges(g); ei != edge_end; ++ei) {
out << get(vertex_id, source(*ei, g)) << Traits::delimiter() << get(vertex_id, target(*ei, g)) << " ";
epw(out, *ei); //print edge attributes
out << ";" << std::endl;
@@ -346,7 +346,7 @@
#endif
//print subgraph
- for ( tie(i_child,j_child) = g.children();
+ for ( boost::tie(i_child,j_child) = g.children();
i_child != j_child; ++i_child )
write_graphviz_subgraph(out, *i_child, vertex_marker, edge_marker,
vertex_id);
@@ -356,7 +356,7 @@
typename graph_traits<Graph>::vertex_iterator i, end;
typename graph_traits<Graph>::edge_iterator ei, edge_end;
- for(tie(i,end) = vertices(g); i != end; ++i) {
+ for(boost::tie(i,end) = vertices(g); i != end; ++i) {
Vertex v = g.local_to_global(*i);
int pos = get(vertex_id, v);
if ( vertex_marker[pos] ) {
@@ -375,7 +375,7 @@
}
}
- for (tie(ei, edge_end) = edges(g); ei != edge_end; ++ei) {
+ for (boost::tie(ei, edge_end) = edges(g); ei != edge_end; ++ei) {
Vertex u = g.local_to_global(source(*ei,g)),
v = g.local_to_global(target(*ei, g));
int pos = get(get(edge_index, g.root()), g.local_to_global(*ei));
Modified: trunk/boost/graph/howard_cycle_ratio.hpp
==============================================================================
--- trunk/boost/graph/howard_cycle_ratio.hpp (original)
+++ trunk/boost/graph/howard_cycle_ratio.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -187,9 +187,9 @@
float_t cz = (std::numeric_limits<float_t>::max)(); //Closest to zero value
float_t s = 0;
const float_t eps_ = std::numeric_limits<float_t>::epsilon();
- for (tie(vi, vie) = vertices(m_g); vi != vie; ++vi)
+ for (boost::tie(vi, vie) = vertices(m_g); vi != vie; ++vi)
{
- for (tie(oei, oeie) = out_edges(*vi, m_g); oei != oeie; ++oei)
+ for (boost::tie(oei, oeie) = out_edges(*vi, m_g); oei != oeie; ++oei)
{
s += std::abs(m_ew1m[*oei]);
float_t a = std::abs(m_ew2m[*oei]);
@@ -211,9 +211,9 @@
m_sink = graph_traits<Graph>().null_vertex();
typename graph_traits<Graph>::vertex_iterator vi, vie;
typename graph_traits<Graph>::out_edge_iterator oei, oeie;
- for ( tie(vi, vie) = vertices(m_g); vi != vie; ++vi )
+ for ( boost::tie(vi, vie) = vertices(m_g); vi != vie; ++vi )
{
- tie(oei, oeie) = out_edges(*vi, m_g);
+ boost::tie(oei, oeie) = out_edges(*vi, m_g);
typename graph_traits<Graph>::out_edge_iterator mei =
std::max_element(oei, oeie,
boost::bind(m_cmp,
@@ -331,7 +331,7 @@
std::fill(m_col_bfs.begin(), m_col_bfs.end(), my_white);
color_map_t vcm_ = color_map_t(m_col_bfs.begin(), m_vim);
typename graph_traits<Graph>::vertex_iterator uv_itr, vie;
- tie(uv_itr, vie) = vertices(m_g);
+ boost::tie(uv_itr, vie) = vertices(m_g);
float_t mcr = m_bound;
while ( (uv_itr = std::find_if(uv_itr, vie,
boost::bind(std::equal_to<my_color_type>(),
@@ -373,11 +373,11 @@
typename graph_traits<Graph>::vertex_iterator vi, vie;
typename graph_traits<Graph>::out_edge_iterator oei, oeie;
const float_t eps_ = FloatTraits::epsilon();
- for (tie(vi, vie) = vertices(m_g); vi != vie; ++vi)
+ for (boost::tie(vi, vie) = vertices(m_g); vi != vie; ++vi)
{
if (!m_badv[*vi])
{
- for (tie(oei, oeie) = out_edges(*vi, m_g); oei != oeie; ++oei)
+ for (boost::tie(oei, oeie) = out_edges(*vi, m_g); oei != oeie; ++oei)
{
vertex_t t = target(*oei, m_g);
//Current distance from *vi to some vertex
Modified: trunk/boost/graph/incremental_components.hpp
==============================================================================
--- trunk/boost/graph/incremental_components.hpp (original)
+++ trunk/boost/graph/incremental_components.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -55,7 +55,7 @@
void incremental_components(EdgeListGraph& g, DisjointSets& ds)
{
typename graph_traits<EdgeListGraph>::edge_iterator e, end;
- for (tie(e,end) = edges(g); e != end; ++e)
+ for (boost::tie(e,end) = edges(g); e != end; ++e)
ds.union_set(source(*e,g),target(*e,g));
}
@@ -91,7 +91,7 @@
{
typename graph_traits<VertexListGraph>
::vertex_iterator v, vend;
- for (tie(v, vend) = vertices(G); v != vend; ++v)
+ for (boost::tie(v, vend) = vertices(G); v != vend; ++v)
ds.make_set(*v);
}
Modified: trunk/boost/graph/johnson_all_pairs_shortest.hpp
==============================================================================
--- trunk/boost/graph/johnson_all_pairs_shortest.hpp (original)
+++ trunk/boost/graph/johnson_all_pairs_shortest.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -74,21 +74,21 @@
{
typename Traits1::vertex_iterator v, v_end;
int i = 1;
- for (tie(v, v_end) = vertices(g1); v != v_end; ++v, ++i) {
+ for (boost::tie(v, v_end) = vertices(g1); v != v_end; ++v, ++i) {
typename Traits2::edge_descriptor e; bool z;
- tie(e, z) = add_edge(s, get(id1, *v) + 1, g2);
+ boost::tie(e, z) = add_edge(s, get(id1, *v) + 1, g2);
put(w, e, zero);
verts1[i] = *v;
}
typename Traits1::edge_iterator e, e_end;
- for (tie(e, e_end) = edges(g1); e != e_end; ++e) {
+ for (boost::tie(e, e_end) = edges(g1); e != e_end; ++e) {
typename Traits2::edge_descriptor e2; bool z;
- tie(e2, z) = add_edge(get(id1, source(*e, g1)) + 1,
- get(id1, target(*e, g1)) + 1, g2);
+ boost::tie(e2, z) = add_edge(get(id1, source(*e, g1)) + 1,
+ get(id1, target(*e, g1)) + 1, g2);
put(w, e2, get(w1, *e));
if (is_undirected) {
- tie(e2, z) = add_edge(get(id1, target(*e, g1)) + 1,
- get(id1, source(*e, g1)) + 1, g2);
+ boost::tie(e2, z) = add_edge(get(id1, target(*e, g1)) + 1,
+ get(id1, source(*e, g1)) + 1, g2);
put(w, e2, get(w1, *e));
}
}
@@ -97,7 +97,7 @@
typename Traits2::edge_iterator e, e_end;
shared_array_property_map<DT,VertexID2> h(num_vertices(g2), id2);
- for (tie(v, v_end) = vertices(g2); v != v_end; ++v)
+ for (boost::tie(v, v_end) = vertices(g2); v != v_end; ++v)
put(d, *v, inf);
put(d, s, zero);
@@ -106,19 +106,19 @@
dummy_property_map pred; bellman_visitor<> bvis;
if (bellman_ford_shortest_paths
(g2, num_vertices(g2), w, pred, d, combine, compare, bvis)) {
- for (tie(v, v_end) = vertices(g2); v != v_end; ++v)
+ for (boost::tie(v, v_end) = vertices(g2); v != v_end; ++v)
put(h, *v, get(d, *v));
// Reweight the edges to remove negatives
- for (tie(e, e_end) = edges(g2); e != e_end; ++e) {
+ for (boost::tie(e, e_end) = edges(g2); e != e_end; ++e) {
typename Traits2::vertex_descriptor a = source(*e, g2),
b = target(*e, g2);
put(w_hat, *e, combine(get(w, *e), (get(h, a) - get(h, b))));
}
- for (tie(u, u_end) = vertices(g2); u != u_end; ++u) {
+ for (boost::tie(u, u_end) = vertices(g2); u != u_end; ++u) {
dijkstra_visitor<> dvis;
dijkstra_shortest_paths
(g2, *u, pred, d, w_hat, id2, compare, combine, inf, zero,dvis);
- for (tie(v, v_end) = vertices(g2); v != v_end; ++v) {
+ for (boost::tie(v, v_end) = vertices(g2); v != v_end; ++v) {
if (*u != s && *v != s) {
typename Traits1::vertex_descriptor u1, v1;
u1 = verts1[get(id2, *u)]; v1 = verts1[get(id2, *v)];
Modified: trunk/boost/graph/king_ordering.hpp
==============================================================================
--- trunk/boost/graph/king_ordering.hpp (original)
+++ trunk/boost/graph/king_ordering.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -59,7 +59,7 @@
for( ; rbegin != rend; rend--){
percolate_down<Vertex>(i);
w = (*Qptr)[index_begin+i];
- for (tie(ei, ei_end) = out_edges(w, g); ei != ei_end; ++ei) {
+ for (boost::tie(ei, ei_end) = out_edges(w, g); ei != ei_end; ++ei) {
v = target(*ei, g);
put(degree, v, get(degree, v) - 1);
@@ -212,7 +212,7 @@
queue Q;
// Copy degree to pseudo_degree
// initialize the color map
- for (tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui){
+ for (boost::tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui){
put(pseudo_degree, *ui, get(degree, *ui));
put(color, *ui, Color::white());
}
Modified: trunk/boost/graph/kolmogorov_max_flow.hpp
==============================================================================
--- trunk/boost/graph/kolmogorov_max_flow.hpp (original)
+++ trunk/boost/graph/kolmogorov_max_flow.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -109,13 +109,13 @@
m_last_grow_vertex(graph_traits<Graph>::null_vertex()){
// initialize the color-map with gray-values
vertex_iterator vi, v_end;
- for(tie(vi, v_end) = vertices(m_g); vi != v_end; ++vi){
+ for(boost::tie(vi, v_end) = vertices(m_g); vi != v_end; ++vi){
set_tree(*vi, tColorTraits::gray());
}
// Initialize flow to zero which means initializing
// the residual capacity equal to the capacity
edge_iterator ei, e_end;
- for(tie(ei, e_end) = edges(m_g); ei != e_end; ++ei) {
+ for(boost::tie(ei, e_end) = edges(m_g); ei != e_end; ++ei) {
m_res_cap_map[*ei] = m_cap_map[*ei];
assert(m_rev_edge_map[m_rev_edge_map[*ei]] == *ei); //check if the reverse edge map is build up properly
}
@@ -135,7 +135,7 @@
while(true){
bool path_found;
edge_descriptor connecting_edge;
- tie(connecting_edge, path_found) = grow(); //find a path from source to sink
+ boost::tie(connecting_edge, path_found) = grow(); //find a path from source to sink
if(!path_found){
//we're finished, no more paths were found
break;
@@ -155,7 +155,7 @@
//this improves especially graphcuts for segmentation, as most of the nodes have source/sink connects
//but shouldn't have an impact on other maxflow problems (this is done in grow() anyway)
out_edge_iterator ei, e_end;
- for(tie(ei, e_end) = out_edges(m_source, m_g); ei != e_end; ++ei){
+ for(boost::tie(ei, e_end) = out_edges(m_source, m_g); ei != e_end; ++ei){
edge_descriptor from_source = *ei;
vertex_descriptor current_node = target(from_source, m_g);
if(current_node == m_sink){
@@ -166,7 +166,7 @@
}
edge_descriptor to_sink;
bool is_there;
- tie(to_sink, is_there) = lookup_edge(current_node, m_sink, m_g);
+ boost::tie(to_sink, is_there) = lookup_edge(current_node, m_sink, m_g);
if(is_there){
tEdgeVal cap_from_source = m_res_cap_map[from_source];
tEdgeVal cap_to_sink = m_res_cap_map[to_sink];
@@ -203,7 +203,7 @@
add_active_node(current_node);
}
}
- for(tie(ei, e_end) = out_edges(m_sink, m_g); ei != e_end; ++ei){
+ for(boost::tie(ei, e_end) = out_edges(m_sink, m_g); ei != e_end; ++ei){
edge_descriptor to_sink = m_rev_edge_map[*ei];
vertex_descriptor current_node = source(to_sink, m_g);
if(m_res_cap_map[to_sink]){
@@ -231,7 +231,7 @@
out_edge_iterator ei, e_end;
if(current_node != m_last_grow_vertex){
m_last_grow_vertex = current_node;
- tie(m_last_grow_edge_it, m_last_grow_edge_end) = out_edges(current_node, m_g);
+ boost::tie(m_last_grow_edge_it, m_last_grow_edge_end) = out_edges(current_node, m_g);
}
for(; m_last_grow_edge_it != m_last_grow_edge_end; ++m_last_grow_edge_it){
edge_descriptor out_edge = *m_last_grow_edge_it;
@@ -262,7 +262,7 @@
out_edge_iterator ei, e_end;
if(current_node != m_last_grow_vertex){
m_last_grow_vertex = current_node;
- tie(m_last_grow_edge_it, m_last_grow_edge_end) = out_edges(current_node, m_g);
+ boost::tie(m_last_grow_edge_it, m_last_grow_edge_end) = out_edges(current_node, m_g);
}
for(; m_last_grow_edge_it != m_last_grow_edge_end; ++m_last_grow_edge_it){
edge_descriptor in_edge = m_rev_edge_map[*m_last_grow_edge_it];
@@ -390,7 +390,7 @@
tDistanceVal min_distance = (std::numeric_limits<tDistanceVal>::max)();
edge_descriptor new_parent_edge;
out_edge_iterator ei, e_end;
- for(tie(ei, e_end) = out_edges(current_node, m_g); ei != e_end; ++ei){
+ for(boost::tie(ei, e_end) = out_edges(current_node, m_g); ei != e_end; ++ei){
const edge_descriptor in_edge = m_rev_edge_map[*ei];
assert(target(in_edge, m_g) == current_node); //we should be the target of this edge
if(m_res_cap_map[in_edge] > 0){
@@ -409,7 +409,7 @@
m_time_map[current_node] = m_time;
} else{
m_time_map[current_node] = 0;
- for(tie(ei, e_end) = out_edges(current_node, m_g); ei != e_end; ++ei){
+ for(boost::tie(ei, e_end) = out_edges(current_node, m_g); ei != e_end; ++ei){
edge_descriptor in_edge = m_rev_edge_map[*ei];
vertex_descriptor other_node = source(in_edge, m_g);
if(get_tree(other_node) == tColorTraits::black() && has_parent(other_node)){
@@ -433,7 +433,7 @@
out_edge_iterator ei, e_end;
edge_descriptor new_parent_edge;
tDistanceVal min_distance = (std::numeric_limits<tDistanceVal>::max)();
- for(tie(ei, e_end) = out_edges(current_node, m_g); ei != e_end; ++ei){
+ for(boost::tie(ei, e_end) = out_edges(current_node, m_g); ei != e_end; ++ei){
const edge_descriptor out_edge = *ei;
if(m_res_cap_map[out_edge] > 0){
const vertex_descriptor other_node = target(out_edge, m_g);
@@ -450,7 +450,7 @@
m_time_map[current_node] = m_time;
} else{
m_time_map[current_node] = 0;
- for(tie(ei, e_end) = out_edges(current_node, m_g); ei != e_end; ++ei){
+ for(boost::tie(ei, e_end) = out_edges(current_node, m_g); ei != e_end; ++ei){
const edge_descriptor out_edge = *ei;
const vertex_descriptor other_node = target(out_edge, m_g);
if(get_tree(other_node) == tColorTraits::white() && has_parent(other_node)){
Modified: trunk/boost/graph/leda_graph.hpp
==============================================================================
--- trunk/boost/graph/leda_graph.hpp (original)
+++ trunk/boost/graph/leda_graph.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -481,11 +481,11 @@
leda::GRAPH<vtype,etype>& g)
{
typename graph_traits< leda::GRAPH<vtype,etype> >::out_edge_iterator ei, ei_end;
- for (tie(ei, ei_end)=out_edges(u,g); ei!=ei_end; ei++)
+ for (boost::tie(ei, ei_end)=out_edges(u,g); ei!=ei_end; ei++)
remove_edge(*ei);
typename graph_traits< leda::GRAPH<vtype,etype> >::in_edge_iterator iei, iei_end;
- for (tie(iei, iei_end)=in_edges(u,g); iei!=iei_end; iei++)
+ for (boost::tie(iei, iei_end)=in_edges(u,g); iei!=iei_end; iei++)
remove_edge(*iei);
}
@@ -684,11 +684,11 @@
leda::graph& g)
{
graph_traits<leda::graph>::out_edge_iterator ei, ei_end;
- for (tie(ei, ei_end)=out_edges(u,g); ei!=ei_end; ei++)
+ for (boost::tie(ei, ei_end)=out_edges(u,g); ei!=ei_end; ei++)
remove_edge(*ei, g);
graph_traits<leda::graph>::in_edge_iterator iei, iei_end;
- for (tie(iei, iei_end)=in_edges(u,g); iei!=iei_end; iei++)
+ for (boost::tie(iei, iei_end)=in_edges(u,g); iei!=iei_end; iei++)
remove_edge(*iei, g);
}
Modified: trunk/boost/graph/make_connected.hpp
==============================================================================
--- trunk/boost/graph/make_connected.hpp (original)
+++ trunk/boost/graph/make_connected.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -46,7 +46,7 @@
return;
vertex_iterator_t vi, vi_end;
- tie(vi,vi_end) = vertices(g);
+ boost::tie(vi,vi_end) = vertices(g);
std::copy(vi, vi_end, vertices_by_component.begin());
bucket_sort(vertices_by_component.begin(),
Modified: trunk/boost/graph/max_cardinality_matching.hpp
==============================================================================
--- trunk/boost/graph/max_cardinality_matching.hpp (original)
+++ trunk/boost/graph/max_cardinality_matching.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -43,7 +43,7 @@
v_size_t size_of_matching = 0;
vertex_iterator_t vi, vi_end;
- for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
+ for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
{
vertex_descriptor_t v = *vi;
if (get(mate,v) != graph_traits<Graph>::null_vertex()
@@ -74,7 +74,7 @@
typedef typename graph_traits<Graph>::vertex_iterator vertex_iterator_t;
vertex_iterator_t vi, vi_end;
- for( tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
+ for( boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
{
vertex_descriptor_t v = *vi;
if (get(mate,v) != graph_traits<Graph>::null_vertex()
@@ -187,7 +187,7 @@
ds(ds_rank_map, ds_parent_map)
{
vertex_iterator_t vi, vi_end;
- for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
+ for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
mate[*vi] = get(arg_mate, *vi);
}
@@ -205,7 +205,7 @@
even_edges.clear();
vertex_iterator_t vi, vi_end;
- for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
+ for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
{
vertex_descriptor_t u = *vi;
@@ -219,7 +219,7 @@
{
vertex_state[u] = graph::detail::V_EVEN;
out_edge_iterator_t ei, ei_end;
- for(tie(ei,ei_end) = out_edges(u,g); ei != ei_end; ++ei)
+ for(boost::tie(ei,ei_end) = out_edges(u,g); ei != ei_end; ++ei)
even_edges.push_back( *ei );
}
else
@@ -261,7 +261,7 @@
vertex_state[w_prime] = graph::detail::V_ODD;
vertex_state[mate[w_prime]] = graph::detail::V_EVEN;
out_edge_iterator_t ei, ei_end;
- for( tie(ei,ei_end) = out_edges(mate[w_prime], g); ei != ei_end; ++ei)
+ for( boost::tie(ei,ei_end) = out_edges(mate[w_prime], g); ei != ei_end; ++ei)
even_edges.push_back(*ei);
pred[w_prime] = v;
}
@@ -356,7 +356,7 @@
void get_current_matching(PropertyMap pm)
{
vertex_iterator_t vi,vi_end;
- for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
+ for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
put(pm, *vi, mate[*vi]);
}
@@ -367,7 +367,7 @@
void get_vertex_state_map(PropertyMap pm)
{
vertex_iterator_t vi,vi_end;
- for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
+ for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
put(pm, *vi, vertex_state[origin[ds.find_set(*vi)]]);
}
@@ -403,7 +403,7 @@
{
bridge[v] = the_bridge;
out_edge_iterator_t oei, oei_end;
- for(tie(oei, oei_end) = out_edges(v,g); oei != oei_end; ++oei)
+ for(boost::tie(oei, oei_end) = out_edges(v,g); oei != oei_end; ++oei)
even_edges.push_back(*oei);
}
}
@@ -520,11 +520,11 @@
static void find_matching(const Graph& g, MateMap mate)
{
vertex_iterator_t vi, vi_end;
- for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
+ for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
put(mate, *vi, graph_traits<Graph>::null_vertex());
edge_iterator_t ei, ei_end;
- for( tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
+ for( boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
{
edge_descriptor_t e = *ei;
vertex_descriptor_t u = source(e,g);
@@ -598,11 +598,11 @@
directed_edges_vector_t edge_list;
vertex_iterator_t vi, vi_end;
- for(tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
+ for(boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
put(mate, *vi, graph_traits<Graph>::null_vertex());
edge_iterator_t ei, ei_end;
- for(tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
+ for(boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
{
edge_descriptor_t e = *ei;
vertex_descriptor_t u = source(e,g);
@@ -642,7 +642,7 @@
static void find_matching(const Graph& g, MateMap mate)
{
vertex_iterator_t vi, vi_end;
- for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
+ for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
put(mate, *vi, graph_traits<Graph>::null_vertex());
}
};
@@ -791,7 +791,7 @@
//count the number of graph::detail::V_ODD vertices
v_size_t num_odd_vertices = 0;
vertex_iterator_t vi, vi_end;
- for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
+ for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
if (vertex_state[*vi] == graph::detail::V_ODD)
++num_odd_vertices;
Modified: trunk/boost/graph/mcgregor_common_subgraphs.hpp
==============================================================================
--- trunk/boost/graph/mcgregor_common_subgraphs.hpp (original)
+++ trunk/boost/graph/mcgregor_common_subgraphs.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -288,8 +288,8 @@
typename graph_traits<GraphSecond>::vertex_iterator
vertex2_begin, vertex2_end, vertex2_iter;
- tie(vertex1_iter, vertex1_end) = vertices(graph1);
- tie(vertex2_begin, vertex2_end) = vertices(graph2);
+ boost::tie(vertex1_iter, vertex1_end) = vertices(graph1);
+ boost::tie(vertex2_begin, vertex2_end) = vertices(graph2);
vertex2_iter = vertex2_begin;
// Iterate until all vertices have been visited
Modified: trunk/boost/graph/metric_tsp_approx.hpp
==============================================================================
--- trunk/boost/graph/metric_tsp_approx.hpp (original)
+++ trunk/boost/graph/metric_tsp_approx.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -285,7 +285,7 @@
// would require revisiting the core algorithm.
Edge e;
bool found;
- tie(e, found) = lookup_edge(previous_, v, g);
+ boost::tie(e, found) = lookup_edge(previous_, v, g);
if(!found) {
BOOST_THROW_EXCEPTION(not_complete());
}
Modified: trunk/boost/graph/minimum_degree_ordering.hpp
==============================================================================
--- trunk/boost/graph/minimum_degree_ordering.hpp (original)
+++ trunk/boost/graph/minimum_degree_ordering.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -310,13 +310,13 @@
{
typename graph_traits<Graph>::vertex_iterator v, vend;
size_type vid = 0;
- for (tie(v, vend) = vertices(G); v != vend; ++v, ++vid)
+ for (boost::tie(v, vend) = vertices(G); v != vend; ++v, ++vid)
index_vertex_vec[vid] = *v;
index_vertex_map = IndexVertexMap(&index_vertex_vec[0]);
// Initialize degreelists. Degreelists organizes the nodes
// according to their degree.
- for (tie(v, vend) = vertices(G); v != vend; ++v) {
+ for (boost::tie(v, vend) = vertices(G); v != vend; ++v) {
put(degree, *v, out_degree(*v, G));
degreelists.push(*v);
}
@@ -409,7 +409,7 @@
size_type e_id = element_neighbor.top();
vertex_t element = get(index_vertex_map, e_id);
adj_iter i, i_end;
- for (tie(i, i_end) = adjacent_vertices(element, G); i != i_end; ++i){
+ for (boost::tie(i, i_end) = adjacent_vertices(element, G); i != i_end; ++i){
vertex_t i_node = *i;
if (!marker.is_tagged(i_node) && !numbering.is_numbered(i_node)) {
marker.mark_tagged(i_node);
@@ -419,7 +419,7 @@
element_neighbor.pop();
}
adj_iter v, ve;
- for (tie(v, ve) = adjacent_vertices(node, G); v != ve; ++v) {
+ for (boost::tie(v, ve) = adjacent_vertices(node, G); v != ve; ++v) {
vertex_t v_node = *v;
if (!degree_lists_marker.need_update(v_node)
&& !degree_lists_marker.outmatched_or_done(v_node)) {
@@ -456,7 +456,7 @@
vertex_t current = get(index_vertex_map, llist.top());
adj_iter i, ie;
- for (tie(i,ie) = adjacent_vertices(current, G); i != ie; ++i) {
+ for (boost::tie(i,ie) = adjacent_vertices(current, G); i != ie; ++i) {
vertex_t i_node = *i;
const size_type i_id = get(vertex_index_map, i_node);
if (supernode_size[i_node] != 0) {
@@ -490,7 +490,7 @@
}
if (numbering.is_numbered(neighbor)) {
adj_iter i, ie;
- for (tie(i,ie) = adjacent_vertices(neighbor, G);
+ for (boost::tie(i,ie) = adjacent_vertices(neighbor, G);
i != ie; ++i) {
const vertex_t i_node = *i;
if (i_node == u_node || supernode_size[i_node] == 0)
@@ -536,7 +536,7 @@
marker.increment_tag();
deg = deg0;
adj_iter i, ie;
- for (tie(i, ie) = adjacent_vertices(u_node, G); i != ie; ++i) {
+ for (boost::tie(i, ie) = adjacent_vertices(u_node, G); i != ie; ++i) {
vertex_t i_node = *i;
if (marker.is_tagged(i_node))
continue;
@@ -544,7 +544,7 @@
if (numbering.is_numbered(i_node)) {
adj_iter j, je;
- for (tie(j, je) = adjacent_vertices(i_node, G); j != je; ++j) {
+ for (boost::tie(j, je) = adjacent_vertices(i_node, G); j != je; ++j) {
const vertex_t j_node = *j;
if (marker.is_not_tagged(j_node)) {
marker.mark_tagged(j_node);
Modified: trunk/boost/graph/neighbor_bfs.hpp
==============================================================================
--- trunk/boost/graph/neighbor_bfs.hpp (original)
+++ trunk/boost/graph/neighbor_bfs.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -152,7 +152,7 @@
vis.examine_vertex(u, g);
typename GTraits::out_edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei) {
+ for (boost::tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei) {
Edge e = *ei;
vis.examine_out_edge(e, g);
Vertex v = target(e, g);
@@ -172,7 +172,7 @@
} // for out-edges
typename GTraits::in_edge_iterator in_ei, in_ei_end;
- for (tie(in_ei, in_ei_end) = in_edges(u, g);
+ for (boost::tie(in_ei, in_ei_end) = in_edges(u, g);
in_ei != in_ei_end; ++in_ei) {
Edge e = *in_ei;
vis.examine_in_edge(e, g);
@@ -216,7 +216,7 @@
typedef typename property_traits<ColorMap>::value_type ColorValue;
typedef color_traits<ColorValue> Color;
typename boost::graph_traits<VertexListGraph>::vertex_iterator i, i_end;
- for (tie(i, i_end) = vertices(g); i != i_end; ++i) {
+ for (boost::tie(i, i_end) = vertices(g); i != i_end; ++i) {
put(color, *i, Color::white());
vis.initialize_vertex(*i, g);
}
Modified: trunk/boost/graph/page_rank.hpp
==============================================================================
--- trunk/boost/graph/page_rank.hpp (original)
+++ trunk/boost/graph/page_rank.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -142,7 +142,7 @@
old_n = num_vertices(g);
typename graph_traits<MutableGraph>::vertex_iterator vi, vi_end;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; /* in loop */) {
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; /* in loop */) {
typename graph_traits<MutableGraph>::vertex_descriptor v = *vi++;
if (out_degree(v, g) == 0) {
clear_vertex(v, g);
Modified: trunk/boost/graph/planar_detail/boyer_myrvold_impl.hpp
==============================================================================
--- trunk/boost/graph/planar_detail/boyer_myrvold_impl.hpp (original)
+++ trunk/boost/graph/planar_detail/boyer_myrvold_impl.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -346,7 +346,7 @@
// the walkup and consumed by the walkdown.
vertex_iterator_t vi, vi_end;
- for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
+ for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
{
vertex_t v(*vi);
vertex_t parent = dfs_parent[v];
@@ -471,7 +471,7 @@
typedef typename face_vertex_iterator<both_sides>::type walkup_iterator_t;
out_edge_iterator_t oi, oi_end;
- for(tie(oi,oi_end) = out_edges(v,g); oi != oi_end; ++oi)
+ for(boost::tie(oi,oi_end) = out_edges(v,g); oi != oi_end; ++oi)
{
edge_t e(*oi);
vertex_t e_source(source(e,g));
@@ -689,7 +689,7 @@
= face_handles[first_tail].first_vertex();
vertex_t second
= face_handles[first_tail].second_vertex();
- tie(first_side_vertex, first_tail)
+ boost::tie(first_side_vertex, first_tail)
= make_tuple(first_tail,
first == first_side_vertex ?
second : first
@@ -701,7 +701,7 @@
= face_handles[second_tail].first_vertex();
vertex_t second
= face_handles[second_tail].second_vertex();
- tie(second_side_vertex, second_tail)
+ boost::tie(second_side_vertex, second_tail)
= make_tuple(second_tail,
first == second_side_vertex ?
second : first);
@@ -790,10 +790,10 @@
{
bottom_path_follows_first = next_bottom_follows_first;
- tie(merge_point,
- next_bottom_follows_first,
- top_path_follows_first
- ) = merge_stack.back();
+ boost::tie(merge_point,
+ next_bottom_follows_first,
+ top_path_follows_first
+ ) = merge_stack.back();
merge_stack.pop_back();
face_handle_t top_handle(face_handles[merge_point]);
@@ -918,7 +918,7 @@
// planar embedding no matter what order we embed them in.
vertex_iterator_t xi, xi_end;
- for(tie(xi,xi_end) = vertices(g); xi != xi_end; ++xi)
+ for(boost::tie(xi,xi_end) = vertices(g); xi != xi_end; ++xi)
{
if (!separated_dfs_child_list[*xi]->empty())
{
@@ -1058,10 +1058,10 @@
bool seen_goal_edge = false;
out_edge_iterator_t oi, oi_end;
- for(tie(oi,oi_end) = out_edges(v,g); oi != oi_end; ++oi)
+ for(boost::tie(oi,oi_end) = out_edges(v,g); oi != oi_end; ++oi)
forbidden_edge[*oi] = true;
- for(tie(oi,oi_end) = out_edges(v,g); oi != oi_end; ++oi)
+ for(boost::tie(oi,oi_end) = out_edges(v,g); oi != oi_end; ++oi)
{
path_edges.clear();
@@ -1195,7 +1195,7 @@
// Clear the short-circuit edges - these are needed for the planar
// testing/embedding algorithm to run in linear time, but they'll
// complicate the kuratowski subgraph isolation
- for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
+ for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
{
face_handles[*vi].reset_vertex_cache();
dfs_child_handles[*vi].reset_vertex_cache();
@@ -1352,7 +1352,7 @@
//Find external path to x and to y
- for(tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
+ for(boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
{
edge_t e(*ei);
goal_edge[e]
@@ -1376,7 +1376,7 @@
}
- for(tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
+ for(boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
{
edge_t e(*ei);
goal_edge[e]
@@ -1407,13 +1407,13 @@
{
chosen_case = detail::BM_CASE_A;
- for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
+ for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
if (lower_face_vertex[*vi])
- for(tie(oei,oei_end) = out_edges(*vi,g); oei != oei_end; ++oei)
+ for(boost::tie(oei,oei_end) = out_edges(*vi,g); oei != oei_end; ++oei)
if(!outer_face_edge[*oei])
goal_edge[*oei] = true;
- for(tie(ei,ei_end) = edges(g); ei != ei_end; ++ei)
+ for(boost::tie(ei,ei_end) = edges(g); ei != ei_end; ++ei)
forbidden_edge[*ei] = outer_face_edge[*ei];
z = kuratowski_walkup
@@ -1424,7 +1424,7 @@
{
chosen_case = detail::BM_CASE_B;
- for(tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
+ for(boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
{
edge_t e(*ei);
goal_edge[e] = false;
@@ -1442,7 +1442,7 @@
);
- for(tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
+ for(boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
{
forbidden_edge[*ei] = outer_face_edge[*ei];
}
@@ -1646,7 +1646,7 @@
//First, get a list of all of v's embedded child edges
out_edge_iterator_t v_edge_itr, v_edge_end;
- for(tie(v_edge_itr,v_edge_end) = out_edges(v,g);
+ for(boost::tie(v_edge_itr,v_edge_end) = out_edges(v,g);
v_edge_itr != v_edge_end; ++v_edge_itr
)
{
@@ -1711,7 +1711,7 @@
//Finding z and w.
- for(tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
+ for(boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
{
edge_t e(*ei);
goal_edge[e] = !outer_face_edge[e] &&
@@ -1729,14 +1729,14 @@
if (chosen_case == detail::BM_CASE_E)
{
- for(tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
+ for(boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
{
forbidden_edge[*ei] = outer_face_edge[*ei];
goal_edge[*ei] = !outer_face_edge[*ei] &&
(source(*ei,g) == w || target(*ei,g) == w);
}
- for(tie(oei, oei_end) = out_edges(w,g); oei != oei_end; ++oei)
+ for(boost::tie(oei, oei_end) = out_edges(w,g); oei != oei_end; ++oei)
{
if (!outer_face_edge[*oei])
goal_edge[*oei] = true;
@@ -1800,7 +1800,7 @@
while(child != parent)
{
is_in_subgraph[dfs_parent_edge[child]] = true;
- tie(parent, child) = std::make_pair( dfs_parent[parent], parent );
+ boost::tie(parent, child) = std::make_pair( dfs_parent[parent], parent );
}
@@ -1928,7 +1928,7 @@
}
- for(tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
+ for(boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
if (is_in_subgraph[*ei])
*o_itr = *ei;
@@ -1940,7 +1940,7 @@
void make_edge_permutation(EdgePermutation perm)
{
vertex_iterator_t vi, vi_end;
- for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
+ for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
{
vertex_t v(*vi);
perm[v].clear();
Modified: trunk/boost/graph/profile.hpp
==============================================================================
--- trunk/boost/graph/profile.hpp (original)
+++ trunk/boost/graph/profile.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -23,7 +23,7 @@
{
typename graph_traits<Graph>::vertices_size_type b = 0;
typename graph_traits<Graph>::vertex_iterator i, end;
- for (tie(i, end) = vertices(g); i != end; ++i){
+ for (boost::tie(i, end) = vertices(g); i != end; ++i){
b += ith_bandwidth(*i, g, index) + 1;
}
Modified: trunk/boost/graph/push_relabel_max_flow.hpp
==============================================================================
--- trunk/boost/graph/push_relabel_max_flow.hpp (original)
+++ trunk/boost/graph/push_relabel_max_flow.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -146,12 +146,12 @@
// Initialize flow to zero which means initializing
// the residual capacity to equal the capacity.
out_edge_iterator ei, e_end;
- for (tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter)
- for (tie(ei, e_end) = out_edges(*u_iter, g); ei != e_end; ++ei) {
+ for (boost::tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter)
+ for (boost::tie(ei, e_end) = out_edges(*u_iter, g); ei != e_end; ++ei) {
put(residual_capacity, *ei, get(capacity, *ei));
}
- for (tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter) {
+ for (boost::tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter) {
vertex_descriptor u = *u_iter;
put(excess_flow, u, 0);
current[u] = out_edges(u, g);
@@ -161,7 +161,7 @@
FlowValue test_excess = 0;
out_edge_iterator a_iter, a_end;
- for (tie(a_iter, a_end) = out_edges(src, g); a_iter != a_end; ++a_iter)
+ for (boost::tie(a_iter, a_end) = out_edges(src, g); a_iter != a_end; ++a_iter)
if (target(*a_iter, g) != src)
test_excess += get(residual_capacity, *a_iter);
if (test_excess > (std::numeric_limits<FlowValue>::max)())
@@ -171,7 +171,7 @@
put(excess_flow, src, (std::numeric_limits<FlowValue>::max)());
else {
put(excess_flow, src, 0);
- for (tie(a_iter, a_end) = out_edges(src, g);
+ for (boost::tie(a_iter, a_end) = out_edges(src, g);
a_iter != a_end; ++a_iter) {
edge_descriptor a = *a_iter;
vertex_descriptor tgt = target(a, g);
@@ -189,7 +189,7 @@
max_active = 0;
min_active = n;
- for (tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter) {
+ for (boost::tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter) {
vertex_descriptor u = *u_iter;
if (u == sink) {
put(distance, u, 0);
@@ -218,7 +218,7 @@
BOOST_USING_STD_MAX();
++update_count;
vertex_iterator u_iter, u_end;
- for (tie(u_iter,u_end) = vertices(g); u_iter != u_end; ++u_iter) {
+ for (boost::tie(u_iter,u_end) = vertices(g); u_iter != u_end; ++u_iter) {
put(color, *u_iter, ColorTraits::white());
put(distance, *u_iter, n);
}
@@ -240,7 +240,7 @@
distance_size_type d_v = get(distance, u) + 1;
out_edge_iterator ai, a_end;
- for (tie(ai, a_end) = out_edges(u, g); ai != a_end; ++ai) {
+ for (boost::tie(ai, a_end) = out_edges(u, g); ai != a_end; ++ai) {
edge_descriptor a = *ai;
vertex_descriptor v = target(a, g);
if (get(color, v) == ColorTraits::white()
@@ -269,7 +269,7 @@
assert(get(excess_flow, u) > 0);
while (1) {
out_edge_iterator ai, ai_end;
- for (tie(ai, ai_end) = current[u]; ai != ai_end; ++ai) {
+ for (boost::tie(ai, ai_end) = current[u]; ai != ai_end; ++ai) {
edge_descriptor a = *ai;
if (is_residual_edge(a)) {
vertex_descriptor v = target(a, g);
@@ -345,7 +345,7 @@
// Examine the residual out-edges of vertex i, choosing the
// edge whose target vertex has the minimal distance.
out_edge_iterator ai, a_end, min_edge_iter;
- for (tie(ai, a_end) = out_edges(u, g); ai != a_end; ++ai) {
+ for (boost::tie(ai, a_end) = out_edges(u, g); ai != a_end; ++ai) {
++work_since_last_update;
edge_descriptor a = *ai;
vertex_descriptor v = target(a, g);
@@ -441,20 +441,20 @@
bool bos_null = true;
// handle self-loops
- for (tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter)
- for (tie(ai, a_end) = out_edges(*u_iter, g); ai != a_end; ++ai)
+ for (boost::tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter)
+ for (boost::tie(ai, a_end) = out_edges(*u_iter, g); ai != a_end; ++ai)
if (target(*ai, g) == *u_iter)
put(residual_capacity, *ai, get(capacity, *ai));
// initialize
- for (tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter) {
+ for (boost::tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter) {
u = *u_iter;
put(color, u, ColorTraits::white());
parent[u] = u;
current[u] = out_edges(u, g);
}
// eliminate flow cycles and topologically order the vertices
- for (tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter) {
+ for (boost::tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter) {
u = *u_iter;
if (get(color, u) == ColorTraits::white()
&& get(excess_flow, u) > 0
@@ -541,7 +541,7 @@
// note that the sink is not on the stack
if (! bos_null) {
for (u = tos; u != bos; u = topo_next[u]) {
- tie(ai, a_end) = out_edges(u, g);
+ boost::tie(ai, a_end) = out_edges(u, g);
while (get(excess_flow, u) > 0 && ai != a_end) {
if (get(capacity, *ai) == 0 && is_residual_edge(*ai))
push_flow(*ai);
@@ -567,8 +567,8 @@
out_edge_iterator ai, a_end;
// check edge flow values
- for (tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter) {
- for (tie(ai, a_end) = out_edges(*u_iter, g); ai != a_end; ++ai) {
+ for (boost::tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter) {
+ for (boost::tie(ai, a_end) = out_edges(*u_iter, g); ai != a_end; ++ai) {
edge_descriptor a = *ai;
if (get(capacity, a) > 0)
if ((get(residual_capacity, a) + get(residual_capacity, get(reverse_edge, a))
@@ -581,13 +581,13 @@
// check conservation
FlowValue sum;
- for (tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter) {
+ for (boost::tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter) {
vertex_descriptor u = *u_iter;
if (u != src && u != sink) {
if (get(excess_flow, u) != 0)
return false;
sum = 0;
- for (tie(ai, a_end) = out_edges(u, g); ai != a_end; ++ai)
+ for (boost::tie(ai, a_end) = out_edges(u, g); ai != a_end; ++ai)
if (get(capacity, *ai) > 0)
sum -= get(capacity, *ai) - get(residual_capacity, *ai);
else
@@ -620,8 +620,8 @@
os << "flow values" << std::endl;
vertex_iterator u_iter, u_end;
out_edge_iterator ei, e_end;
- for (tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter)
- for (tie(ei, e_end) = out_edges(*u_iter, g); ei != e_end; ++ei)
+ for (boost::tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter)
+ for (boost::tie(ei, e_end) = out_edges(*u_iter, g); ei != e_end; ++ei)
if (get(capacity, *ei) > 0)
os << *u_iter << " " << target(*ei, g) << " "
<< (get(capacity, *ei) - get(residual_capacity, *ei)) << std::endl;
Modified: trunk/boost/graph/r_c_shortest_paths.hpp
==============================================================================
--- trunk/boost/graph/r_c_shortest_paths.hpp (original)
+++ trunk/boost/graph/r_c_shortest_paths.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -359,7 +359,7 @@
typename graph_traits<Graph>::vertex_descriptor cur_vertex =
cur_label->resident_vertex;
typename graph_traits<Graph>::out_edge_iterator oei, oei_end;
- for( tie( oei, oei_end ) = out_edges( cur_vertex, g );
+ for( boost::tie( oei, oei_end ) = out_edges( cur_vertex, g );
oei != oei_end;
++oei )
{
Modified: trunk/boost/graph/random.hpp
==============================================================================
--- trunk/boost/graph/random.hpp (original)
+++ trunk/boost/graph/random.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -157,7 +157,7 @@
b = random_vertex(g, gen);
} while (self_edges == false && a == b);
edge_t e; bool inserted;
- tie(e, inserted) = add_edge(a, b, g);
+ boost::tie(e, inserted) = add_edge(a, b, g);
if (inserted)
*edge_out++ = std::make_pair(source(e, g), target(e, g));
}
@@ -171,7 +171,7 @@
{
typename property_map<G, Property>::type pm = get(Property(), g);
typename graph_traits<G>::vertex_iterator vi, ve;
- for (tie(vi, ve) = vertices(g); vi != ve; ++vi) {
+ for (boost::tie(vi, ve) = vertices(g); vi != ve; ++vi) {
pm[*vi] = rg();
}
}
@@ -182,7 +182,7 @@
{
typename property_map<G, Property>::type pm = get(Property(), g);
typename graph_traits<G>::edge_iterator ei, ee;
- for (tie(ei, ee) = edges(g); ei != ee; ++ei) {
+ for (boost::tie(ei, ee) = edges(g); ei != ee; ++ei) {
pm[*ei] = rg();
}
}
Modified: trunk/boost/graph/read_dimacs.hpp
==============================================================================
--- trunk/boost/graph/read_dimacs.hpp (original)
+++ trunk/boost/graph/read_dimacs.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -231,8 +231,8 @@
{
edge_descriptor e1, e2;
bool in1, in2;
- tie(e1, in1) = add_edge(verts[tail], verts[head], g);
- tie(e2, in2) = add_edge(verts[head], verts[tail], g);
+ boost::tie(e1, in1) = add_edge(verts[tail], verts[head], g);
+ boost::tie(e2, in2) = add_edge(verts[head], verts[tail], g);
if (!in1 || !in2) {
std::cerr << "unable to add edge (" << head << "," << tail << ")"
<< std::endl;
Modified: trunk/boost/graph/reverse_graph.hpp
==============================================================================
--- trunk/boost/graph/reverse_graph.hpp (original)
+++ trunk/boost/graph/reverse_graph.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -220,7 +220,7 @@
{
typedef reverse_graph<BidirectionalGraph,GRef> Graph;
typename graph_traits<Graph>::out_edge_iterator first, last;
- tie(first, last) = out_edges(u, g);
+ boost::tie(first, last) = out_edges(u, g);
typedef typename graph_traits<Graph>::adjacency_iterator adjacency_iterator;
return std::make_pair(adjacency_iterator(first, const_cast<Graph*>(&g)),
adjacency_iterator(last, const_cast<Graph*>(&g)));
Modified: trunk/boost/graph/rmat_graph_generator.hpp
==============================================================================
--- trunk/boost/graph/rmat_graph_generator.hpp (original)
+++ trunk/boost/graph/rmat_graph_generator.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -164,7 +164,7 @@
// Generate the first edge
vertices_size_type u, v;
- tie(u, v) = generate_edge(this->gen, n, SCALE, a, b, c, d);
+ boost::tie(u, v) = generate_edge(this->gen, n, SCALE, a, b, c, d);
if (permute_vertices)
current = std::make_pair(vertexPermutation[u],
@@ -181,7 +181,7 @@
rmat_iterator& operator++()
{
vertices_size_type u, v;
- tie(u, v) = generate_edge(this->gen, n, SCALE, a, b, c, d);
+ boost::tie(u, v) = generate_edge(this->gen, n, SCALE, a, b, c, d);
if (permute_vertices)
current = std::make_pair(vertexPermutation[u],
@@ -279,7 +279,7 @@
for (edges_size_type i = 0; i < m; ++i) {
vertices_size_type u, v;
- tie(u, v) = generate_edge(this->gen, n, SCALE, a, b, c, d);
+ boost::tie(u, v) = generate_edge(this->gen, n, SCALE, a, b, c, d);
if (permute_vertices) {
if (ep(vertexPermutation[u], vertexPermutation[v]))
@@ -381,7 +381,7 @@
edges_size_type edges = 0;
do {
vertices_size_type u, v;
- tie(u, v) = generate_edge(this->gen, n, SCALE, a, b, c, d);
+ boost::tie(u, v) = generate_edge(this->gen, n, SCALE, a, b, c, d);
// Lowest vertex number always comes first
// (this means we don't have to worry about i->j and j->i being in the edge list)
@@ -495,7 +495,7 @@
do {
vertices_size_type u, v;
- tie(u, v) = generate_edge(this->gen, n, SCALE, a, b, c, d);
+ boost::tie(u, v) = generate_edge(this->gen, n, SCALE, a, b, c, d);
if (bidirectional) {
if (edge_map.find(std::make_pair(u, v)) == edge_map.end()) {
Modified: trunk/boost/graph/sequential_vertex_coloring.hpp
==============================================================================
--- trunk/boost/graph/sequential_vertex_coloring.hpp (original)
+++ trunk/boost/graph/sequential_vertex_coloring.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -61,7 +61,7 @@
//Initialize colors
typename GraphTraits::vertex_iterator v, vend;
- for (tie(v, vend) = vertices(G); v != vend; ++v)
+ for (boost::tie(v, vend) = vertices(G); v != vend; ++v)
put(color, *v, V-1);
//Determine the color for every vertex one by one
@@ -71,7 +71,7 @@
//Mark the colors of vertices adjacent to current.
//i can be the value for marking since i increases successively
- for (tie(v,vend) = adjacent_vertices(current, G); v != vend; ++v)
+ for (boost::tie(v,vend) = adjacent_vertices(current, G); v != vend; ++v)
mark[get(color,*v)] = i;
//Next step is to assign the smallest un-marked color
Modified: trunk/boost/graph/sloan_ordering.hpp
==============================================================================
--- trunk/boost/graph/sloan_ordering.hpp (original)
+++ trunk/boost/graph/sloan_ordering.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -139,7 +139,7 @@
//step 1
//Scan for the vertex with the smallest degree and the maximum degree
typename graph_traits<Graph>::vertex_iterator ui, ui_end;
- for (tie(ui, ui_end) = vertices(G); ui != ui_end; ++ui)
+ for (boost::tie(ui, ui_end) = vertices(G); ui != ui_end; ++ui)
{
dummy = get(degree, *ui);
@@ -180,7 +180,7 @@
//step 4
//pushing one node of each degree in an ascending manner into degree_queue
std::vector<bool> shrink_trace(maximum_degree, false);
- for (tie(ui, ui_end) = vertices(G); ui != ui_end; ++ui)
+ for (boost::tie(ui, ui_end) = vertices(G); ui != ui_end; ++ui)
{
dummy = get(degree, *ui);
@@ -292,7 +292,7 @@
//Sets the color and priority to their initial status
unsigned cdeg;
typename graph_traits<Graph>::vertex_iterator ui, ui_end;
- for (tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui)
+ for (boost::tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui)
{
put(color, *ui, Color::white());
cdeg=get(degree, *ui)+1;
@@ -321,7 +321,7 @@
if(get(color, u) == Color::green() )
{
//for-loop over all out-edges of vertex u
- for (tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei)
+ for (boost::tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei)
{
v = target(*ei, g);
@@ -340,7 +340,7 @@
put(color, u, Color::black() ); //Gives u an inactive status
//for loop over all the adjacent vertices of u
- for (tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei) {
+ for (boost::tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei) {
v = target(*ei, g);
@@ -350,7 +350,7 @@
put(priority, v, get(priority, v)+W2); //updates the priority
//for loop over alll adjacent vertices of v
- for (tie(ei2, ei2_end) = out_edges(v, g); ei2 != ei2_end; ++ei2) {
+ for (boost::tie(ei2, ei2_end) = out_edges(v, g); ei2 != ei2_end; ++ei2) {
w = target(*ei2, g);
if(get(color, w) != Color::black() ) { //tests if vertex is postactive
Modified: trunk/boost/graph/strong_components.hpp
==============================================================================
--- trunk/boost/graph/strong_components.hpp (original)
+++ trunk/boost/graph/strong_components.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -54,7 +54,7 @@
const Graph& g) {
typename graph_traits<Graph>::vertex_descriptor w;
typename graph_traits<Graph>::out_edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = out_edges(v, g); ei != ei_end; ++ei) {
+ for (boost::tie(ei, ei_end) = out_edges(v, g); ei != ei_end; ++ei) {
w = target(*ei, g);
if (get(comp, w) == (std::numeric_limits<comp_type>::max)())
put(root, v, this->min_discover_time(get(root,v), get(root,w)));
@@ -249,7 +249,7 @@
{
components.resize(num_scc);
typename graph_traits<Graph>::vertex_iterator vi, vi_end;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
components[component_number[*vi]].push_back(*vi);
}
@@ -304,7 +304,7 @@
// initialize G_T
typename graph_traits<Graph>::vertex_iterator ui, ui_end;
- for (tie(ui, ui_end) = vertices(G_T); ui != ui_end; ++ui)
+ for (boost::tie(ui, ui_end) = vertices(G_T); ui != ui_end; ++ui)
put(color, *ui, Color::white());
typedef typename property_traits<FinishTime>::value_type D;
@@ -314,8 +314,8 @@
std::priority_queue<Vertex, std::vector<Vertex>, Compare > Q(fl);
typename graph_traits<Graph>::vertex_iterator i, j, iend, jend;
- tie(i, iend) = vertices(G_T);
- tie(j, jend) = vertices(G);
+ boost::tie(i, iend) = vertices(G_T);
+ boost::tie(j, jend) = vertices(G);
for ( ; i != iend; ++i, ++j) {
put(finish_time, *i, get(finish_time, *j));
Q.push(*i);
Modified: trunk/boost/graph/subgraph.hpp
==============================================================================
--- trunk/boost/graph/subgraph.hpp (original)
+++ trunk/boost/graph/subgraph.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -124,7 +124,7 @@
{
typename Graph::vertex_iterator v, v_end;
vertices_size_type i = 0;
- for(tie(v, v_end) = vertices(m_graph); v != v_end; ++v)
+ for(boost::tie(v, v_end) = vertices(m_graph); v != v_end; ++v)
m_global_vertex[i++] = *v;
}
@@ -180,7 +180,7 @@
vertex_descriptor global_to_local(vertex_descriptor u_global) const {
vertex_descriptor u_local; bool in_subgraph;
if (is_root()) return u_global;
- tie(u_local, in_subgraph) = this->find_vertex(u_global);
+ boost::tie(u_local, in_subgraph) = this->find_vertex(u_global);
assert(in_subgraph == true);
return u_local;
}
@@ -315,7 +315,7 @@
{
edge_descriptor e_local;
bool inserted;
- tie(e_local, inserted) = add_edge(u_local, v_local, m_graph);
+ boost::tie(e_local, inserted) = add_edge(u_local, v_local, m_graph);
put(edge_index, m_graph, e_local, m_edge_counter++);
m_global_edge.push_back(e_global);
m_local_edge[get(get(edge_index, this->root()), e_global)] = e_local;
@@ -358,7 +358,7 @@
// remember edge global and local maps
{
typename subgraph<G>::out_edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = out_edges(u_global, r);
+ for (boost::tie(ei, ei_end) = out_edges(u_global, r);
ei != ei_end; ++ei) {
e_global = *ei;
v_global = target(e_global, r);
@@ -369,10 +369,10 @@
if (is_directed(g)) { // not necessary for undirected graph
typename subgraph<G>::vertex_iterator vi, vi_end;
typename subgraph<G>::out_edge_iterator ei, ei_end;
- for(tie(vi, vi_end) = vertices(r); vi != vi_end; ++vi) {
+ for(boost::tie(vi, vi_end) = vertices(r); vi != vi_end; ++vi) {
v_global = *vi;
if(g.find_vertex(v_global).second)
- for(tie(ei, ei_end) = out_edges(*vi, r); ei != ei_end; ++ei) {
+ for(boost::tie(ei, ei_end) = out_edges(*vi, r); ei != ei_end; ++ei) {
e_global = *ei;
uu_global = target(e_global, r);
if(uu_global == u_global && g.find_vertex(v_global).second) {
@@ -507,8 +507,8 @@
// add local edge only if u_global and v_global are in subgraph g
Vertex u_local, v_local;
bool u_in_subgraph, v_in_subgraph;
- tie(u_local, u_in_subgraph) = g.find_vertex(u_global);
- tie(v_local, v_in_subgraph) = g.find_vertex(v_global);
+ boost::tie(u_local, u_in_subgraph) = g.find_vertex(u_global);
+ boost::tie(v_local, v_in_subgraph) = g.find_vertex(v_global);
if(u_in_subgraph && v_in_subgraph) {
g.local_add_edge(u_local, v_local, e_global);
}
@@ -525,7 +525,7 @@
if(g.is_root()) {
typename subgraph<Graph>::edge_descriptor e_global;
bool inserted;
- tie(e_global, inserted) = add_edge(u_global, v_global, ep, g.m_graph);
+ boost::tie(e_global, inserted) = add_edge(u_global, v_global, ep, g.m_graph);
put(edge_index, g.m_graph, e_global, g.m_edge_counter++);
g.m_global_edge.push_back(e_global);
children_add_edge(u_global, v_global, e_global, g.m_children, orig);
@@ -554,7 +554,7 @@
} else {
typename subgraph<G>::edge_descriptor e_local, e_global;
bool inserted;
- tie(e_global, inserted) =
+ boost::tie(e_global, inserted) =
detail::add_edge_recur_up(g.local_to_global(u),
g.local_to_global(v),
ep, g, &g);
Modified: trunk/boost/graph/transitive_closure.hpp
==============================================================================
--- trunk/boost/graph/transitive_closure.hpp (original)
+++ trunk/boost/graph/transitive_closure.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -101,7 +101,7 @@
for (size_type i = 0; i < components[s].size(); ++i) {
vertex u = components[s][i];
adjacency_iterator v, v_end;
- for (tie(v, v_end) = adjacent_vertices(u, g); v != v_end; ++v) {
+ for (boost::tie(v, v_end) = adjacent_vertices(u, g); v != v_end; ++v) {
cg_vertex t = component_number[*v];
if (s != t) // Avoid loops in the condensation graph
adj.push_back(t);
@@ -144,7 +144,7 @@
chain.push_back(v);
in_a_chain[v] = true;
typename graph_traits<CG_t>::adjacency_iterator adj_first, adj_last;
- tie(adj_first, adj_last) = adjacent_vertices(v, CG);
+ boost::tie(adj_first, adj_last) = adjacent_vertices(v, CG);
typename graph_traits<CG_t>::adjacency_iterator next
= std::find_if(adj_first, adj_last,
std::not1(detail::subscript(in_a_chain)));
@@ -174,7 +174,7 @@
i = topo_order.rbegin(); i != topo_order.rend(); ++i) {
cg_vertex u = *i;
typename graph_traits<CG_t>::adjacency_iterator adj, adj_last;
- for (tie(adj, adj_last) = adjacent_vertices(u, CG);
+ for (boost::tie(adj, adj_last) = adjacent_vertices(u, CG);
adj != adj_last; ++adj) {
cg_vertex v = *adj;
if (topo_number[v] < successors[u][chain_number[v]]) {
@@ -204,15 +204,15 @@
typedef typename graph_traits < GraphTC >::vertex_descriptor tc_vertex;
{
vertex_iterator i, i_end;
- for (tie(i, i_end) = vertices(g); i != i_end; ++i)
+ for (boost::tie(i, i_end) = vertices(g); i != i_end; ++i)
g_to_tc_map[*i] = add_vertex(tc);
}
// Add edges between all the vertices in two adjacent SCCs
typename graph_traits<CG_t>::vertex_iterator si, si_end;
- for (tie(si, si_end) = vertices(CG); si != si_end; ++si) {
+ for (boost::tie(si, si_end) = vertices(CG); si != si_end; ++si) {
cg_vertex s = *si;
typename graph_traits<CG_t>::adjacency_iterator i, i_end;
- for (tie(i, i_end) = adjacent_vertices(s, CG); i != i_end; ++i) {
+ for (boost::tie(i, i_end) = adjacent_vertices(s, CG); i != i_end; ++i) {
cg_vertex t = *i;
for (size_type k = 0; k < components[s].size(); ++k)
for (size_type l = 0; l < components[t].size(); ++l)
@@ -233,7 +233,7 @@
// Need to add it to transitive closure.
{
vertex_iterator i, i_end;
- for (tie(i, i_end) = vertices(g); i != i_end; ++i)
+ for (boost::tie(i, i_end) = vertices(g); i != i_end; ++i)
{
adjacency_iterator ab, ae;
for (boost::tie(ab, ae) = adjacent_vertices(*i, g); ab != ae; ++ab)
@@ -312,10 +312,10 @@
// for j
// A[i,j] = A[i,j] | A[k,j]
vertex_iterator ki, ke, ii, ie, ji, je;
- for (tie(ki, ke) = vertices(g); ki != ke; ++ki)
- for (tie(ii, ie) = vertices(g); ii != ie; ++ii)
+ for (boost::tie(ki, ke) = vertices(g); ki != ke; ++ki)
+ for (boost::tie(ii, ie) = vertices(g); ii != ie; ++ii)
if (edge(*ii, *ki, g).second)
- for (tie(ji, je) = vertices(g); ji != je; ++ji)
+ for (boost::tie(ji, je) = vertices(g); ji != je; ++ji)
if (!edge(*ii, *ji, g).second && edge(*ki, *ji, g).second) {
add_edge(*ii, *ji, g);
}
@@ -342,10 +342,10 @@
// A[i,j] = A[i,j] | A[k,j]
vertex_iterator ic, ie, jc, je, kc, ke;
- for (tie(ic, ie) = vertices(g), ++ic; ic != ie; ++ic)
- for (tie(kc, ke) = vertices(g); *kc != *ic; ++kc)
+ for (boost::tie(ic, ie) = vertices(g), ++ic; ic != ie; ++ic)
+ for (boost::tie(kc, ke) = vertices(g); *kc != *ic; ++kc)
if (edge(*ic, *kc, g).second)
- for (tie(jc, je) = vertices(g); jc != je; ++jc)
+ for (boost::tie(jc, je) = vertices(g); jc != je; ++jc)
if (!edge(*ic, *jc, g).second && edge(*kc, *jc, g).second) {
add_edge(*ic, *jc, g);
}
@@ -355,10 +355,10 @@
// for j = 1 to n
// A[i,j] = A[i,j] | A[k,j]
- for (tie(ic, ie) = vertices(g), --ie; ic != ie; ++ic)
+ for (boost::tie(ic, ie) = vertices(g), --ie; ic != ie; ++ic)
for (kc = ic, ke = ie, ++kc; kc != ke; ++kc)
if (edge(*ic, *kc, g).second)
- for (tie(jc, je) = vertices(g); jc != je; ++jc)
+ for (boost::tie(jc, je) = vertices(g); jc != je; ++jc)
if (!edge(*ic, *jc, g).second && edge(*kc, *jc, g).second) {
add_edge(*ic, *jc, g);
}
Modified: trunk/boost/graph/transitive_reduction.hpp
==============================================================================
--- trunk/boost/graph/transitive_reduction.hpp (original)
+++ trunk/boost/graph/transitive_reduction.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -91,7 +91,7 @@
//do that. So what I'm doint is, collection the successors of *it here
{
typename Graph::out_edge_iterator oi,oi_end;
- for( tie(oi, oi_end) = out_edges( *it, g ); oi != oi_end; ++oi ) {
+ for( boost::tie(oi, oi_end) = out_edges( *it, g ); oi != oi_end; ++oi ) {
neighbors.push_back( target( *oi, g ) );
}
}
Modified: trunk/boost/graph/tree_traits.hpp
==============================================================================
--- trunk/boost/graph/tree_traits.hpp (original)
+++ trunk/boost/graph/tree_traits.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -21,7 +21,7 @@
{
visitor.preorder(v, t);
typename tree_traits<Tree>::children_iterator i, end;
- tie(i, end) = children(v, t);
+ boost::tie(i, end) = children(v, t);
if (i != end) {
traverse_tree(*i++, t, visitor);
visitor.inorder(v, t);
Modified: trunk/boost/graph/undirected_dfs.hpp
==============================================================================
--- trunk/boost/graph/undirected_dfs.hpp (original)
+++ trunk/boost/graph/undirected_dfs.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -56,7 +56,7 @@
VertexInfo& back = stack.back();
u = back.first;
Iter ei, ei_end;
- tie(ei, ei_end) = back.second;
+ boost::tie(ei, ei_end) = back.second;
stack.pop_back();
while (ei != ei_end) {
Vertex v = target(*ei, g);
@@ -70,7 +70,7 @@
u = v;
put(vertex_color, u, Color::gray());
vis.discover_vertex(u, g);
- tie(ei, ei_end) = out_edges(u, g);
+ boost::tie(ei, ei_end) = out_edges(u, g);
} else if (v_color == Color::gray()) {
if (uv_color == EColor::white()) vis.back_edge(*ei, g);
++ei;
@@ -109,7 +109,7 @@
typename graph_traits<IncidenceGraph>::out_edge_iterator ei, ei_end;
put(vertex_color, u, Color::gray()); vis.discover_vertex(u, g);
- for (tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei) {
+ for (boost::tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei) {
Vertex v = target(*ei, g); vis.examine_edge(*ei, g);
ColorValue v_color = get(vertex_color, v);
EColorValue uv_color = get(edge_color, *ei);
@@ -141,18 +141,18 @@
typedef color_traits<ColorValue> Color;
typename graph_traits<Graph>::vertex_iterator ui, ui_end;
- for (tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui) {
+ for (boost::tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui) {
put(vertex_color, *ui, Color::white()); vis.initialize_vertex(*ui, g);
}
typename graph_traits<Graph>::edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
+ for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
put(edge_color, *ei, Color::white());
if (start_vertex != *vertices(g).first){ vis.start_vertex(start_vertex, g);
detail::undir_dfv_impl(g, start_vertex, vis, vertex_color, edge_color);
}
- for (tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui) {
+ for (boost::tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui) {
ColorValue u_color = get(vertex_color, *ui);
if (u_color == Color::white()) { vis.start_vertex(*ui, g);
detail::undir_dfv_impl(g, *ui, vis, vertex_color, edge_color);
Modified: trunk/boost/graph/undirected_graph.hpp
==============================================================================
--- trunk/boost/graph/undirected_graph.hpp (original)
+++ trunk/boost/graph/undirected_graph.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -199,7 +199,7 @@
// find all edges, (u, v)
std::vector<edge_descriptor> edges;
out_edge_iterator i, i_end;
- for(tie(i, i_end) = boost::out_edges(u, m_graph); i != i_end; ++i) {
+ for(boost::tie(i, i_end) = boost::out_edges(u, m_graph); i != i_end; ++i) {
if(boost::target(*i, m_graph) == v) {
edges.push_back(*i);
}
@@ -226,7 +226,7 @@
void renumber_vertex_indices() {
vertex_iterator i, i_end;
- tie(i, i_end) = vertices(m_graph);
+ boost::tie(i, i_end) = vertices(m_graph);
m_max_vertex_index = renumber_vertex_indices(i, i_end, 0);
}
@@ -245,7 +245,7 @@
void renumber_edge_indices() {
edge_iterator i, end;
- tie(i, end) = edges(m_graph);
+ boost::tie(i, end) = edges(m_graph);
m_max_edge_index = renumber_edge_indices(i, end, 0);
}
Modified: trunk/boost/graph/wavefront.hpp
==============================================================================
--- trunk/boost/graph/wavefront.hpp (original)
+++ trunk/boost/graph/wavefront.hpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -37,12 +37,12 @@
rows_active[index_i] = true;
typename graph_traits<Graph>::vertex_iterator ui, ui_end;
- for (tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui)
+ for (boost::tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui)
{
v = *ui;
if(index[v] <= index_i)
{
- for (tie(edge_it2, edge_it2_end) = out_edges(v, g); edge_it2 != edge_it2_end; ++edge_it2)
+ for (boost::tie(edge_it2, edge_it2_end) = out_edges(v, g); edge_it2 != edge_it2_end; ++edge_it2)
{
w = target(*edge_it2, g);
if( (index[w] >= index_i) && (!rows_active[index[w]]) )
@@ -74,7 +74,7 @@
BOOST_USING_STD_MAX();
typename graph_traits<Graph>::vertices_size_type b = 0;
typename graph_traits<Graph>::vertex_iterator i, end;
- for (tie(i, end) = vertices(g); i != end; ++i)
+ for (boost::tie(i, end) = vertices(g); i != end; ++i)
b = max BOOST_PREVENT_MACRO_SUBSTITUTION(b, ith_wavefront(*i, g, index));
return b;
}
@@ -93,7 +93,7 @@
{
double b = 0;
typename graph_traits<Graph>::vertex_iterator i, end;
- for (tie(i, end) = vertices(g); i != end; ++i)
+ for (boost::tie(i, end) = vertices(g); i != end; ++i)
b += ith_wavefront(*i, g, index);
b /= num_vertices(g);
@@ -114,7 +114,7 @@
{
double b = 0;
typename graph_traits<Graph>::vertex_iterator i, end;
- for (tie(i, end) = vertices(g); i != end; ++i)
+ for (boost::tie(i, end) = vertices(g); i != end; ++i)
b += std::pow(double ( ith_wavefront(*i, g, index) ), 2.0);
b /= num_vertices(g);
Modified: trunk/libs/graph/example/accum-compile-times.cpp
==============================================================================
--- trunk/libs/graph/example/accum-compile-times.cpp (original)
+++ trunk/libs/graph/example/accum-compile-times.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -85,14 +85,14 @@
std::ifstream name_in("makefile-target-names.dat");
std::ifstream compile_cost_in("target-compile-costs.dat");
graph_traits < file_dep_graph2 >::vertex_iterator vi, vi_end;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) {
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) {
name_in >> name_map[*vi];
compile_cost_in >> compile_cost_map[*vi];
}
graph_property_iter_range < file_dep_graph2,
vertex_compile_cost_t >::iterator ci, ci_end;
- tie(ci, ci_end) = get_property_iter_range(g, vertex_compile_cost);
+ boost::tie(ci, ci_end) = get_property_iter_range(g, vertex_compile_cost);
std::cout << "total (sequential) compile time: "
<< std::accumulate(ci, ci_end, 0.0) << std::endl;
Modified: trunk/libs/graph/example/astar-cities.cpp
==============================================================================
--- trunk/libs/graph/example/astar-cities.cpp (original)
+++ trunk/libs/graph/example/astar-cities.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -164,8 +164,8 @@
WeightMap weightmap = get(edge_weight, g);
for(std::size_t j = 0; j < num_edges; ++j) {
edge_descriptor e; bool inserted;
- tie(e, inserted) = add_edge(edge_array[j].first,
- edge_array[j].second, g);
+ boost::tie(e, inserted) = add_edge(edge_array[j].first,
+ edge_array[j].second, g);
weightmap[e] = weights[j];
}
Modified: trunk/libs/graph/example/bellman-example.cpp
==============================================================================
--- trunk/libs/graph/example/bellman-example.cpp (original)
+++ trunk/libs/graph/example/bellman-example.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -74,7 +74,7 @@
property_map<Graph, int EdgeProperties::*>::type
weight_pmap = get(&EdgeProperties::weight, g);
int i = 0;
- for (tie(ei, ei_end) = edges(g); ei != ei_end; ++ei, ++i)
+ for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei, ++i)
weight_pmap[*ei] = weight[i];
std::vector<int> distance(N, (std::numeric_limits < short >::max)());
@@ -108,7 +108,7 @@
<< " edge[style=\"bold\"]\n" << " node[shape=\"circle\"]\n";
{
- for (tie(ei, ei_end) = edges(g); ei != ei_end; ++ei) {
+ for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei) {
graph_traits < Graph >::edge_descriptor e = *ei;
graph_traits < Graph >::vertex_descriptor
u = source(e, g), v = target(e, g);
Modified: trunk/libs/graph/example/bfs-example2.cpp
==============================================================================
--- trunk/libs/graph/example/bfs-example2.cpp (original)
+++ trunk/libs/graph/example/bfs-example2.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -78,7 +78,7 @@
std::vector < Size > dtime(num_vertices(g));
graph_traits<graph_t>::vertex_iterator vi, vi_end;
std::size_t c = 0;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi, ++c)
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi, ++c)
dtime[c] = dtime_map[*vi];
// Use std::sort to order the vertices by their discover time
Modified: trunk/libs/graph/example/bfs-name-printer.cpp
==============================================================================
--- trunk/libs/graph/example/bfs-name-printer.cpp (original)
+++ trunk/libs/graph/example/bfs-name-printer.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -32,19 +32,19 @@
typename graph_traits<Graph>::edge_descriptor ed;
bool inserted;
- tie(ed, inserted) = add_edge(a, b, g);
+ boost::tie(ed, inserted) = add_edge(a, b, g);
delay_map[ed] = 1.2;
- tie(ed, inserted) = add_edge(a, d, g);
+ boost::tie(ed, inserted) = add_edge(a, d, g);
delay_map[ed] = 4.5;
- tie(ed, inserted) = add_edge(b, d, g);
+ boost::tie(ed, inserted) = add_edge(b, d, g);
delay_map[ed] = 1.8;
- tie(ed, inserted) = add_edge(c, a, g);
+ boost::tie(ed, inserted) = add_edge(c, a, g);
delay_map[ed] = 2.6;
- tie(ed, inserted) = add_edge(c, e, g);
+ boost::tie(ed, inserted) = add_edge(c, e, g);
delay_map[ed] = 5.2;
- tie(ed, inserted) = add_edge(d, c, g);
+ boost::tie(ed, inserted) = add_edge(d, c, g);
delay_map[ed] = 0.4;
- tie(ed, inserted) = add_edge(d, e, g);
+ boost::tie(ed, inserted) = add_edge(d, e, g);
delay_map[ed] = 3.3;
}
Modified: trunk/libs/graph/example/biconnected_components.cpp
==============================================================================
--- trunk/libs/graph/example/biconnected_components.cpp (original)
+++ trunk/libs/graph/example/biconnected_components.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -63,7 +63,7 @@
}
graph_traits < graph_t >::edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
+ for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
std::cout << (char)(source(*ei, g) + 'A') << " -- "
<< (char)(target(*ei, g) + 'A')
<< "[label=\"" << component[*ei] << "\"]\n";
Modified: trunk/libs/graph/example/bipartite_example.cpp
==============================================================================
--- trunk/libs/graph/example/bipartite_example.cpp (original)
+++ trunk/libs/graph/example/bipartite_example.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -41,7 +41,7 @@
is_bipartite (g, get (vertex_index, g), partition_map);
- for (tie (vertex_iter, vertex_end) = vertices (g); vertex_iter != vertex_end; ++vertex_iter)
+ for (boost::tie (vertex_iter, vertex_end) = vertices (g); vertex_iter != vertex_end; ++vertex_iter)
{
std::cout << "Vertex " << *vertex_iter << " has color " << (get (partition_map, *vertex_iter) == color_traits <
default_color_type>::white () ? "white" : "black") << std::endl;
Modified: trunk/libs/graph/example/boost_web_graph.cpp
==============================================================================
--- trunk/libs/graph/example/boost_web_graph.cpp (original)
+++ trunk/libs/graph/example/boost_web_graph.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -116,7 +116,7 @@
std::list<std::string>::iterator i = line_toks.begin();
- tie(pos, inserted) = name2vertex.insert(std::make_pair(*i, Vertex()));
+ boost::tie(pos, inserted) = name2vertex.insert(std::make_pair(*i, Vertex()));
if (inserted) {
u = add_vertex(g);
put(node_name, u, *i);
@@ -127,7 +127,7 @@
std::string hyperlink_name = *i++;
- tie(pos, inserted) = name2vertex.insert(std::make_pair(*i, Vertex()));
+ boost::tie(pos, inserted) = name2vertex.insert(std::make_pair(*i, Vertex()));
if (inserted) {
v = add_vertex(g);
put(node_name, v, *i);
@@ -136,7 +136,7 @@
v = pos->second;
Edge e;
- tie(e, inserted) = add_edge(u, v, g);
+ boost::tie(e, inserted) = add_edge(u, v, g);
if (inserted) {
put(link_name, e, hyperlink_name);
}
@@ -170,7 +170,7 @@
std::cout << "Number of clicks from the home page: " << std::endl;
Traits::vertex_iterator vi, vi_end;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
std::cout << d_matrix[0][*vi] << "\t" << node_name[*vi] << std::endl;
std::cout << std::endl;
@@ -179,7 +179,7 @@
// Create storage for a mapping from vertices to their parents
std::vector<Traits::vertex_descriptor> parent(num_vertices(g));
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
parent[*vi] = *vi;
// Do a BFS starting at the home page, recording the parent of each
@@ -192,7 +192,7 @@
// Add all the search tree edges into a new graph
Graph search_tree(num_vertices(g));
- tie(vi, vi_end) = vertices(g);
+ boost::tie(vi, vi_end) = vertices(g);
++vi;
for (; vi != vi_end; ++vi)
add_edge(parent[*vi], *vi, search_tree);
@@ -205,7 +205,7 @@
std::vector<size_type> dfs_distances(num_vertices(g), 0);
print_tree_visitor<NameMap, size_type*>
tree_printer(node_name, &dfs_distances[0]);
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
get(vertex_color, g)[*vi] = white_color;
depth_first_visit(search_tree, src, tree_printer, get(vertex_color, g));
Modified: trunk/libs/graph/example/boykov_kolmogorov-eg.cpp
==============================================================================
--- trunk/libs/graph/example/boykov_kolmogorov-eg.cpp (original)
+++ trunk/libs/graph/example/boykov_kolmogorov-eg.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -101,8 +101,8 @@
std::cout << "c flow values:" << std::endl;
graph_traits < Graph >::vertex_iterator u_iter, u_end;
graph_traits < Graph >::out_edge_iterator ei, e_end;
- for (tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter)
- for (tie(ei, e_end) = out_edges(*u_iter, g); ei != e_end; ++ei)
+ for (boost::tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter)
+ for (boost::tie(ei, e_end) = out_edges(*u_iter, g); ei != e_end; ++ei)
if (capacity[*ei] > 0)
std::cout << "f " << *u_iter << " " << target(*ei, g) << " "
<< (capacity[*ei] - residual_capacity[*ei]) << std::endl;
Modified: trunk/libs/graph/example/cc-internet.cpp
==============================================================================
--- trunk/libs/graph/example/cc-internet.cpp (original)
+++ trunk/libs/graph/example/cc-internet.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -30,7 +30,7 @@
std::string color[] = {
"white", "gray", "black", "lightgray"};
graph_traits < GraphvizGraph >::vertex_iterator vi, vi_end;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) {
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) {
vertex_attr_map[*vi]["color"] = color[component[*vi]];
vertex_attr_map[*vi]["style"] = "filled";
if (vertex_attr_map[*vi]["color"] == "black")
Modified: trunk/libs/graph/example/copy-example.cpp
==============================================================================
--- trunk/libs/graph/example/copy-example.cpp (original)
+++ trunk/libs/graph/example/copy-example.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -26,7 +26,7 @@
name_map = get(vertex_name, G);
char name = 'a';
graph_traits < graph_t >::vertex_iterator v, v_end;
- for (tie(v, v_end) = vertices(G); v != v_end; ++v, ++name)
+ for (boost::tie(v, v_end) = vertices(G); v != v_end; ++v, ++name)
name_map[*v] = name;
typedef std::pair < int, int >E;
Modified: trunk/libs/graph/example/cycle-file-dep.cpp
==============================================================================
--- trunk/libs/graph/example/cycle-file-dep.cpp (original)
+++ trunk/libs/graph/example/cycle-file-dep.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -38,7 +38,7 @@
{
color[u] = gray_color;
graph_traits < file_dep_graph >::adjacency_iterator vi, vi_end;
- for (tie(vi, vi_end) = adjacent_vertices(u, g); vi != vi_end; ++vi)
+ for (boost::tie(vi, vi_end) = adjacent_vertices(u, g); vi != vi_end; ++vi)
if (color[*vi] == white_color) {
if (has_cycle_dfs(g, *vi, color))
return true; // cycle detected, return immediately
@@ -53,7 +53,7 @@
{
std::vector < default_color_type > color(num_vertices(g), white_color);
graph_traits < file_dep_graph >::vertex_iterator vi, vi_end;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
if (color[*vi] == white_color)
if (has_cycle_dfs(g, *vi, &color[0]))
return true;
@@ -75,7 +75,7 @@
file_dep_graph g(n_vertices);
while (input_begin != input_end) {
size_type i, j;
- tie(i, j) = *input_begin++;
+ boost::tie(i, j) = *input_begin++;
add_edge(i, j, g);
}
#else
@@ -85,7 +85,7 @@
std::vector < std::string > name(num_vertices(g));
std::ifstream name_in("makefile-target-names.dat");
graph_traits < file_dep_graph >::vertex_iterator vi, vi_end;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
name_in >> name[*vi];
assert(has_cycle(g) == false);
Modified: trunk/libs/graph/example/cycle-file-dep2.cpp
==============================================================================
--- trunk/libs/graph/example/cycle-file-dep2.cpp (original)
+++ trunk/libs/graph/example/cycle-file-dep2.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -42,7 +42,7 @@
color[u] = gray_color;
vis.discover_vertex(u, g);
graph_traits < file_dep_graph >::out_edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei) {
+ for (boost::tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei) {
if (color[target(*ei, g)] == white_color) {
vis.tree_edge(*ei, g);
dfs_v1(g, target(*ei, g), color, vis);
@@ -60,7 +60,7 @@
{
std::vector < default_color_type > color(num_vertices(g), white_color);
graph_traits < file_dep_graph >::vertex_iterator vi, vi_end;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) {
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) {
if (color[*vi] == white_color)
dfs_v1(g, *vi, &color[0], vis);
}
@@ -132,7 +132,7 @@
file_dep_graph g(n_vertices);
while (input_begin != input_end) {
size_type i, j;
- tie(i, j) = *input_begin++;
+ boost::tie(i, j) = *input_begin++;
add_edge(i, j, g);
}
#else
@@ -142,7 +142,7 @@
std::vector < std::string > name(num_vertices(g));
std::ifstream name_in("makefile-target-names.dat");
graph_traits < file_dep_graph >::vertex_iterator vi, vi_end;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
name_in >> name[*vi];
assert(has_cycle(g) == false);
Modified: trunk/libs/graph/example/cycle_ratio_example.cpp
==============================================================================
--- trunk/libs/graph/example/cycle_ratio_example.cpp (original)
+++ trunk/libs/graph/example/cycle_ratio_example.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -60,7 +60,7 @@
cout << "Edges number: " << num_edges(tgr) << endl;
int i = 0;
graph_traits<grap_real_t>::vertex_iterator vi, vi_end;
- for (tie(vi, vi_end) = vertices(tgr); vi != vi_end; vi++) {
+ for (boost::tie(vi, vi_end) = vertices(tgr); vi != vi_end; vi++) {
vim[*vi] = i++; ///Initialize vertex index property
}
max_cr = maximum_cycle_ratio(tgr, vim, ew1, ew2);
Modified: trunk/libs/graph/example/dag_shortest_paths.cpp
==============================================================================
--- trunk/libs/graph/example/dag_shortest_paths.cpp (original)
+++ trunk/libs/graph/example/dag_shortest_paths.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -60,7 +60,7 @@
#endif
graph_traits<graph_t>::vertex_iterator vi , vi_end;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
if (d_map[*vi] == (std::numeric_limits<int>::max)())
std::cout << name[*vi] << ": inifinity\n";
else
Modified: trunk/libs/graph/example/dfs-parenthesis.cpp
==============================================================================
--- trunk/libs/graph/example/dfs-parenthesis.cpp (original)
+++ trunk/libs/graph/example/dfs-parenthesis.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -36,7 +36,7 @@
GraphvizGraph g;
read_graphviz("figs/dfs-example.dot", g);
graph_traits < GraphvizGraph >::edge_iterator e, e_end;
- for (tie(e, e_end) = edges(g); e != e_end; ++e)
+ for (boost::tie(e, e_end) = edges(g); e != e_end; ++e)
std::cout << '(' << name[source(*e, g)] << ' '
<< name[target(*e, g)] << ')' << std::endl;
parenthesis_visitor
Modified: trunk/libs/graph/example/dijkstra-example-listS.cpp
==============================================================================
--- trunk/libs/graph/example/dijkstra-example-listS.cpp (original)
+++ trunk/libs/graph/example/dijkstra-example-listS.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -43,13 +43,13 @@
property_map<graph_t, edge_weight_t>::type weightmap = get(edge_weight, g);
std::vector<vertex_descriptor> msvc_vertices;
- for (tie(i, iend) = vertices(g); i != iend; ++i)
+ for (boost::tie(i, iend) = vertices(g); i != iend; ++i)
msvc_vertices.push_back(*i);
for (std::size_t j = 0; j < num_arcs; ++j) {
edge_descriptor e; bool inserted;
- tie(e, inserted) = add_edge(msvc_vertices[edge_array[j].first],
- msvc_vertices[edge_array[j].second], g);
+ boost::tie(e, inserted) = add_edge(msvc_vertices[edge_array[j].first],
+ msvc_vertices[edge_array[j].second], g);
weightmap[e] = weights[j];
}
@@ -62,7 +62,7 @@
property_map<graph_t, vertex_index_t>::type indexmap = get(vertex_index, g);
property_map<graph_t, vertex_name_t>::type name = get(vertex_name, g);
int c = 0;
- for (tie(i, iend) = vertices(g); i != iend; ++i, ++c) {
+ for (boost::tie(i, iend) = vertices(g); i != iend; ++i, ++c) {
indexmap[*i] = c;
name[*i] = 'A' + c;
}
@@ -86,7 +86,7 @@
std::cout << "distances and parents:" << std::endl;
graph_traits < graph_t >::vertex_iterator vi, vend;
- for (tie(vi, vend) = vertices(g); vi != vend; ++vi) {
+ for (boost::tie(vi, vend) = vertices(g); vi != vend; ++vi) {
std::cout << "distance(" << name[*vi] << ") = " << d[*vi] << ", ";
std::cout << "parent(" << name[*vi] << ") = " << name[p[*vi]] << std::
endl;
@@ -101,7 +101,7 @@
<< " edge[style=\"bold\"]\n" << " node[shape=\"circle\"]\n";
graph_traits < graph_t >::edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = edges(g); ei != ei_end; ++ei) {
+ for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei) {
graph_traits < graph_t >::edge_descriptor e = *ei;
graph_traits < graph_t >::vertex_descriptor
u = source(e, g), v = target(e, g);
Modified: trunk/libs/graph/example/dijkstra-example.cpp
==============================================================================
--- trunk/libs/graph/example/dijkstra-example.cpp (original)
+++ trunk/libs/graph/example/dijkstra-example.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -37,7 +37,7 @@
property_map<graph_t, edge_weight_t>::type weightmap = get(edge_weight, g);
for (std::size_t j = 0; j < num_arcs; ++j) {
edge_descriptor e; bool inserted;
- tie(e, inserted) = add_edge(edge_array[j].first, edge_array[j].second, g);
+ boost::tie(e, inserted) = add_edge(edge_array[j].first, edge_array[j].second, g);
weightmap[e] = weights[j];
}
#else
@@ -61,7 +61,7 @@
std::cout << "distances and parents:" << std::endl;
graph_traits < graph_t >::vertex_iterator vi, vend;
- for (tie(vi, vend) = vertices(g); vi != vend; ++vi) {
+ for (boost::tie(vi, vend) = vertices(g); vi != vend; ++vi) {
std::cout << "distance(" << name[*vi] << ") = " << d[*vi] << ", ";
std::cout << "parent(" << name[*vi] << ") = " << name[p[*vi]] << std::
endl;
@@ -77,7 +77,7 @@
<< " edge[style=\"bold\"]\n" << " node[shape=\"circle\"]\n";
graph_traits < graph_t >::edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = edges(g); ei != ei_end; ++ei) {
+ for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei) {
graph_traits < graph_t >::edge_descriptor e = *ei;
graph_traits < graph_t >::vertex_descriptor
u = source(e, g), v = target(e, g);
Modified: trunk/libs/graph/example/dijkstra-no-color-map-example.cpp
==============================================================================
--- trunk/libs/graph/example/dijkstra-no-color-map-example.cpp (original)
+++ trunk/libs/graph/example/dijkstra-no-color-map-example.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -41,7 +41,7 @@
property_map<graph_t, edge_weight_t>::type weightmap = get(edge_weight, g);
for (std::size_t j = 0; j < num_arcs; ++j) {
edge_descriptor e; bool inserted;
- tie(e, inserted) = add_edge(edge_array[j].first, edge_array[j].second, g);
+ boost::tie(e, inserted) = add_edge(edge_array[j].first, edge_array[j].second, g);
weightmap[e] = weights[j];
}
#else
@@ -66,7 +66,7 @@
std::cout << "distances and parents:" << std::endl;
graph_traits < graph_t >::vertex_iterator vi, vend;
- for (tie(vi, vend) = vertices(g); vi != vend; ++vi) {
+ for (boost::tie(vi, vend) = vertices(g); vi != vend; ++vi) {
std::cout << "distance(" << name[*vi] << ") = " << d[*vi] << ", ";
std::cout << "parent(" << name[*vi] << ") = " << name[p[*vi]] << std::
endl;
@@ -82,7 +82,7 @@
<< " edge[style=\"bold\"]\n" << " node[shape=\"circle\"]\n";
graph_traits < graph_t >::edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = edges(g); ei != ei_end; ++ei) {
+ for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei) {
graph_traits < graph_t >::edge_descriptor e = *ei;
graph_traits < graph_t >::vertex_descriptor
u = source(e, g), v = target(e, g);
Modified: trunk/libs/graph/example/eccentricity.cpp
==============================================================================
--- trunk/libs/graph/example/eccentricity.cpp (original)
+++ trunk/libs/graph/example/eccentricity.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -73,11 +73,11 @@
int r, d;
EccentricityContainer eccs(num_vertices(g));
EccentricityMap em(eccs, g);
- tie(r, d) = all_eccentricities(g, dm, em);
+ boost::tie(r, d) = all_eccentricities(g, dm, em);
// Print the closeness centrality of each vertex.
graph_traits<Graph>::vertex_iterator i, end;
- for(tie(i, end) = vertices(g); i != end; ++i) {
+ for(boost::tie(i, end) = vertices(g); i != end; ++i) {
cout << setw(12) << setiosflags(ios::left)
<< g[*i].name << get(em, *i) << endl;
}
Modified: trunk/libs/graph/example/edge-connectivity.cpp
==============================================================================
--- trunk/libs/graph/example/edge-connectivity.cpp (original)
+++ trunk/libs/graph/example/edge-connectivity.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -24,7 +24,7 @@
typedef typename graph_traits < Graph >::degree_size_type size_type;
size_type delta = (std::numeric_limits < size_type >::max)();
typename graph_traits < Graph >::vertex_iterator i, iend;
- for (tie(i, iend) = vertices(g); i != iend; ++i)
+ for (boost::tie(i, iend) = vertices(g); i != iend; ++i)
if (degree(*i, g) < delta)
{
delta = degree(*i, g);
@@ -39,7 +39,7 @@
OutputIterator result)
{
typename graph_traits < Graph >::adjacency_iterator ai, aend;
- for (tie(ai, aend) = adjacent_vertices(u, g); ai != aend; ++ai)
+ for (boost::tie(ai, aend) = adjacent_vertices(u, g); ai != aend; ++ai)
*result++ = *ai;
}
template < typename Graph, typename VertexIterator,
@@ -87,17 +87,17 @@
rev_edge = get(edge_reverse, flow_g);
typename graph_traits < VertexListGraph >::edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = edges(g); ei != ei_end; ++ei) {
+ for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei) {
u = source(*ei, g), v = target(*ei, g);
- tie(e1, inserted) = add_edge(u, v, flow_g);
+ boost::tie(e1, inserted) = add_edge(u, v, flow_g);
cap[e1] = 1;
- tie(e2, inserted) = add_edge(v, u, flow_g);
+ boost::tie(e2, inserted) = add_edge(v, u, flow_g);
cap[e2] = 1;
rev_edge[e1] = e2;
rev_edge[e2] = e1;
}
- tie(p, delta) = min_degree_vertex(g);
+ boost::tie(p, delta) = min_degree_vertex(g);
S_star.push_back(p);
alpha_star = delta;
S.insert(p);
@@ -115,7 +115,7 @@
if (alpha_S_k < alpha_star) {
alpha_star = alpha_S_k;
S_star.clear();
- for (tie(vi, vi_end) = vertices(flow_g); vi != vi_end; ++vi)
+ for (boost::tie(vi, vi_end) = vertices(flow_g); vi != vi_end; ++vi)
if (color[*vi] != Color::white())
S_star.push_back(*vi);
}
@@ -135,7 +135,7 @@
degree_size_type c = 0;
for (si = S_star.begin(); si != S_star.end(); ++si) {
typename graph_traits < VertexListGraph >::out_edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = out_edges(*si, g); ei != ei_end; ++ei)
+ for (boost::tie(ei, ei_end) = out_edges(*si, g); ei != ei_end; ++ei)
if (!in_S_star[target(*ei, g)]) {
*disconnecting_set++ = *ei;
++c;
Modified: trunk/libs/graph/example/edge-function.cpp
==============================================================================
--- trunk/libs/graph/example/edge-function.cpp (original)
+++ trunk/libs/graph/example/edge-function.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -43,7 +43,7 @@
{
typename graph_traits < Graph >::adjacency_iterator vi, vi_end;
out << get(name_map, u) << " -> { ";
- for (tie(vi, vi_end) = adjacent_vertices(u, g); vi != vi_end; ++vi)
+ for (boost::tie(vi, vi_end) = adjacent_vertices(u, g); vi != vi_end; ++vi)
out << get(name_map, *vi) << " ";
out << "}" << std::endl;
}
@@ -108,7 +108,7 @@
name_map_t name = get(vertex_name, g);
// Get iterators for the vertex set
graph_traits < graph_type >::vertex_iterator i, end;
- tie(i, end) = vertices(g);
+ boost::tie(i, end) = vertices(g);
// Find yow.h
name_equals_t < name_map_t > predicate1("yow.h", name);
yow = *std::find_if(i, end, predicate1);
@@ -123,13 +123,13 @@
bool exists;
// Get the edge connecting yow.h to zag.o
- tie(e1, exists) = edge(yow, zag, g);
+ boost::tie(e1, exists) = edge(yow, zag, g);
assert(exists == true);
assert(source(e1, g) == yow);
assert(target(e1, g) == zag);
// Discover that there is no edge connecting zag.o to bar.o
- tie(e2, exists) = edge(zag, bar, g);
+ boost::tie(e2, exists) = edge(zag, bar, g);
assert(exists == false);
assert(num_vertices(g) == 15);
Modified: trunk/libs/graph/example/edge_property.cpp
==============================================================================
--- trunk/libs/graph/example/edge_property.cpp (original)
+++ trunk/libs/graph/example/edge_property.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -151,8 +151,8 @@
boost::graph_traits<Graph>::vertex_iterator v, v_end;
boost::graph_traits<Graph>::out_edge_iterator e, e_end;
int f = 0;
- for (tie(v, v_end) = vertices(G); v != v_end; ++v)
- for (tie(e, e_end) = out_edges(*v, G); e != e_end; ++e)
+ for (boost::tie(v, v_end) = vertices(G); v != v_end; ++v)
+ for (boost::tie(e, e_end) = out_edges(*v, G); e != e_end; ++e)
flow[*e] = ++f;
cout << endl << endl;
Modified: trunk/libs/graph/example/edmonds-karp-eg.cpp
==============================================================================
--- trunk/libs/graph/example/edmonds-karp-eg.cpp (original)
+++ trunk/libs/graph/example/edmonds-karp-eg.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -80,8 +80,8 @@
std::cout << "c flow values:" << std::endl;
graph_traits < Graph >::vertex_iterator u_iter, u_end;
graph_traits < Graph >::out_edge_iterator ei, e_end;
- for (tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter)
- for (tie(ei, e_end) = out_edges(*u_iter, g); ei != e_end; ++ei)
+ for (boost::tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter)
+ for (boost::tie(ei, e_end) = out_edges(*u_iter, g); ei != e_end; ++ei)
if (capacity[*ei] > 0)
std::cout << "f " << *u_iter << " " << target(*ei, g) << " "
<< (capacity[*ei] - residual_capacity[*ei]) << std::endl;
Modified: trunk/libs/graph/example/family-tree-eg.cpp
==============================================================================
--- trunk/libs/graph/example/family-tree-eg.cpp (original)
+++ trunk/libs/graph/example/family-tree-eg.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -34,9 +34,9 @@
property_map < adjacency_list <>, vertex_index_t >::type
index_map = get(vertex_index, g);
- for (tie(i, end) = vertices(g); i != end; ++i) {
+ for (boost::tie(i, end) = vertices(g); i != end; ++i) {
std::cout << name[get(index_map, *i)];
- tie(ai, a_end) = adjacent_vertices(*i, g);
+ boost::tie(ai, a_end) = adjacent_vertices(*i, g);
if (ai == a_end)
std::cout << " has no children";
else
Modified: trunk/libs/graph/example/file_dependencies.cpp
==============================================================================
--- trunk/libs/graph/example/file_dependencies.cpp (original)
+++ trunk/libs/graph/example/file_dependencies.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -104,7 +104,7 @@
Graph g(N);
for (std::size_t j = 0; j < nedges; ++j) {
graph_traits<Graph>::edge_descriptor e; bool inserted;
- tie(e, inserted) = add_edge(used_by[j].first, used_by[j].second, g);
+ boost::tie(e, inserted) = add_edge(used_by[j].first, used_by[j].second, g);
}
#else
Graph g(used_by, used_by + nedges, N);
@@ -135,7 +135,7 @@
int maxdist=0;
// Through the order from topological sort, we are sure that every
// time we are using here is already initialized.
- for (tie(j, j_end) = in_edges(*i, g); j != j_end; ++j)
+ for (boost::tie(j, j_end) = in_edges(*i, g); j != j_end; ++j)
maxdist=(std::max)(time[source(*j, g)], maxdist);
time[*i]=maxdist+1;
}
@@ -145,7 +145,7 @@
<< "vertices with same group number can be made in parallel" << endl;
{
graph_traits<Graph>::vertex_iterator i, iend;
- for (tie(i,iend) = vertices(g); i != iend; ++i)
+ for (boost::tie(i,iend) = vertices(g); i != iend; ++i)
cout << "time_slot[" << name[*i] << "] = " << time[*i] << endl;
}
Modified: trunk/libs/graph/example/filtered-copy-example.cpp
==============================================================================
--- trunk/libs/graph/example/filtered-copy-example.cpp (original)
+++ trunk/libs/graph/example/filtered-copy-example.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -39,7 +39,7 @@
name_map = get(vertex_name, G);
char name = 'a';
graph_traits < graph_t >::vertex_iterator v, v_end;
- for (tie(v, v_end) = vertices(G); v != v_end; ++v, ++name)
+ for (boost::tie(v, v_end) = vertices(G); v != v_end; ++v, ++name)
name_map[*v] = name;
typedef std::pair < int, int >E;
Modified: trunk/libs/graph/example/filtered_graph_edge_range.cpp
==============================================================================
--- trunk/libs/graph/example/filtered_graph_edge_range.cpp (original)
+++ trunk/libs/graph/example/filtered_graph_edge_range.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -61,7 +61,7 @@
std::cout << "unfiltered edge_range(C,D)\n";
graph_traits<Graph>::out_edge_iterator f, l;
- for (tie(f, l) = edge_range(C, D, g); f != l; ++f)
+ for (boost::tie(f, l) = edge_range(C, D, g); f != l; ++f)
std::cout << name[source(*f, g)] << " --" << weight[*f]
<< "-> " << name[target(*f, g)] << "\n";
@@ -71,7 +71,7 @@
std::cout << "filtered edge_range(C,D)\n";
graph_traits<FGraph>::out_edge_iterator first, last;
- for (tie(first, last) = edge_range(C, D, fg); first != last; ++first)
+ for (boost::tie(first, last) = edge_range(C, D, fg); first != last; ++first)
std::cout << name[source(*first, fg)] << " --" << weight[*first]
<< "-> " << name[target(*first, fg)] << "\n";
Modified: trunk/libs/graph/example/fr_layout.cpp
==============================================================================
--- trunk/libs/graph/example/fr_layout.cpp (original)
+++ trunk/libs/graph/example/fr_layout.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -128,7 +128,7 @@
cooling(progress_cooling(iterations)));
graph_traits<Graph>::vertex_iterator vi, vi_end;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) {
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) {
std::cout << get(vertex_name, g, *vi) << '\t'
<< position[*vi][0] << '\t' << position[*vi][1] << std::endl;
}
Modified: trunk/libs/graph/example/gerdemann.cpp
==============================================================================
--- trunk/libs/graph/example/gerdemann.cpp (original)
+++ trunk/libs/graph/example/gerdemann.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -46,13 +46,13 @@
typedef boost::graph_traits<Graph> Traits;
typename Traits::edge_descriptor e;
typename Traits::out_edge_iterator out_i, out_end;
- for (tie(out_i, out_end) = out_edges(v, g); out_i != out_end; ++out_i) {
+ for (boost::tie(out_i, out_end) = out_edges(v, g); out_i != out_end; ++out_i) {
e = *out_i;
typename Traits::vertex_descriptor targ = target(e, g);
add_edge(u, targ, getp(e), g);
}
typename Traits::in_edge_iterator in_i, in_end;
- for (tie(in_i, in_end) = in_edges(v, g); in_i != in_end; ++in_i) {
+ for (boost::tie(in_i, in_end) = in_edges(v, g); in_i != in_end; ++in_i) {
e = *in_i;
typename Traits::vertex_descriptor src = source(e, g);
add_edge(src, u, getp(e), g);
Modified: trunk/libs/graph/example/graph-property-iter-eg.cpp
==============================================================================
--- trunk/libs/graph/example/graph-property-iter-eg.cpp (original)
+++ trunk/libs/graph/example/graph-property-iter-eg.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -23,11 +23,11 @@
const char *vertex_names[] = { "Kubrick", "Clark", "Hal" };
int i = 0;
graph_property_iter_range < graph_t, vertex_name_t >::iterator v, v_end;
- for (tie(v, v_end) = get_property_iter_range(g, vertex_name);
+ for (boost::tie(v, v_end) = get_property_iter_range(g, vertex_name);
v != v_end; ++v, ++i)
*v = vertex_names[i];
- tie(v, v_end) = get_property_iter_range(g, vertex_name);
+ boost::tie(v, v_end) = get_property_iter_range(g, vertex_name);
std::copy(v, v_end, std::ostream_iterator < std::string > (std::cout, " "));
std::cout << std::endl;
return 0;
Modified: trunk/libs/graph/example/in_edges.cpp
==============================================================================
--- trunk/libs/graph/example/in_edges.cpp (original)
+++ trunk/libs/graph/example/in_edges.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -43,9 +43,9 @@
boost::graph_traits<Graph>::vertex_iterator i, end;
boost::graph_traits<Graph>::in_edge_iterator ei, edge_end;
- for(tie(i,end) = vertices(g); i != end; ++i) {
+ for(boost::tie(i,end) = vertices(g); i != end; ++i) {
cout << *i << " <-- ";
- for (tie(ei,edge_end) = in_edges(*i, g); ei != edge_end; ++ei)
+ for (boost::tie(ei,edge_end) = in_edges(*i, g); ei != edge_end; ++ei)
cout << source(*ei, g) << " ";
cout << endl;
}
Modified: trunk/libs/graph/example/isomorphism.cpp
==============================================================================
--- trunk/libs/graph/example/isomorphism.cpp (original)
+++ trunk/libs/graph/example/isomorphism.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -35,12 +35,12 @@
graph_traits<graph_t>::vertex_iterator i, end;
int id = 0;
- for (tie(i, end) = vertices(g1); i != end; ++i, ++id) {
+ for (boost::tie(i, end) = vertices(g1); i != end; ++i, ++id) {
put(v1_index_map, *i, id);
v1[id] = *i;
}
id = 0;
- for (tie(i, end) = vertices(g2); i != end; ++i, ++id) {
+ for (boost::tie(i, end) = vertices(g2); i != end; ++i, ++id) {
put(v2_index_map, *i, id);
v2[id] = *i;
}
Modified: trunk/libs/graph/example/johnson-eg.cpp
==============================================================================
--- trunk/libs/graph/example/johnson-eg.cpp (original)
+++ trunk/libs/graph/example/johnson-eg.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -73,7 +73,7 @@
<< "edge[style=\"bold\"]\n" << "node[shape=\"circle\"]\n";
graph_traits < Graph >::edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
+ for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
fout << source(*ei, g) << " -> " << target(*ei, g)
<< "[label=" << get(edge_weight, g)[*ei] << "]\n";
Modified: trunk/libs/graph/example/kevin-bacon.cpp
==============================================================================
--- trunk/libs/graph/example/kevin-bacon.cpp (original)
+++ trunk/libs/graph/example/kevin-bacon.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -74,7 +74,7 @@
NameVertexMap::iterator pos;
bool inserted;
Vertex u, v;
- tie(pos, inserted) = actors.insert(std::make_pair(actors_name, Vertex()));
+ boost::tie(pos, inserted) = actors.insert(std::make_pair(actors_name, Vertex()));
if (inserted) {
u = add_vertex(g);
actor_name[u] = actors_name;
@@ -84,7 +84,7 @@
std::string movie_name = *i++;
- tie(pos, inserted) = actors.insert(std::make_pair(*i, Vertex()));
+ boost::tie(pos, inserted) = actors.insert(std::make_pair(*i, Vertex()));
if (inserted) {
v = add_vertex(g);
actor_name[v] = *i;
@@ -93,7 +93,7 @@
v = pos->second;
graph_traits < Graph >::edge_descriptor e;
- tie(e, inserted) = add_edge(u, v, g);
+ boost::tie(e, inserted) = add_edge(u, v, g);
if (inserted)
connecting_movie[e] = movie_name;
@@ -108,7 +108,7 @@
visitor(record_bacon_number(&bacon_number[0])));
graph_traits < Graph >::vertex_iterator i, end;
- for (tie(i, end) = vertices(g); i != end; ++i) {
+ for (boost::tie(i, end) = vertices(g); i != end; ++i) {
std::cout << actor_name[*i] << " has a Bacon number of "
<< bacon_number[*i] << std::endl;
}
Modified: trunk/libs/graph/example/kevin-bacon2.cpp
==============================================================================
--- trunk/libs/graph/example/kevin-bacon2.cpp (original)
+++ trunk/libs/graph/example/kevin-bacon2.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -71,7 +71,7 @@
// Get the vertex for Kevin Bacon
Vertex src;
graph_traits<Graph>::vertex_iterator i, end;
- for (tie(i, end) = vertices(g); i != end; ++i)
+ for (boost::tie(i, end) = vertices(g); i != end; ++i)
if (g[*i].name == "Kevin Bacon")
src = *i;
@@ -82,7 +82,7 @@
breadth_first_search(g, src,
visitor(bacon_number_recorder(&bacon_number[0])));
- for (tie(i, end) = vertices(g); i != end; ++i)
+ for (boost::tie(i, end) = vertices(g); i != end; ++i)
std::cout << g[*i].name << " has a Bacon number of "
<< bacon_number[*i] << std::endl;
Modified: trunk/libs/graph/example/knights-tour.cpp
==============================================================================
--- trunk/libs/graph/example/knights-tour.cpp (original)
+++ trunk/libs/graph/example/knights-tour.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -179,7 +179,7 @@
S.push(std::make_pair(time_stamp, src));
while (!S.empty()) {
Vertex x;
- tie(time_stamp, x) = S.top();
+ boost::tie(time_stamp, x) = S.top();
put(time_map, x, time_stamp);
// all vertices have been visited, success!
if (time_stamp == num_vertices(g) - 1)
@@ -187,7 +187,7 @@
bool deadend = true;
typename graph_traits < Graph >::adjacency_iterator i, end;
- for (tie(i, end) = adjacent_vertices(x, g); i != end; ++i)
+ for (boost::tie(i, end) = adjacent_vertices(x, g); i != end; ++i)
if (get(time_map, *i) == -1) {
S.push(std::make_pair(time_stamp + 1, *i));
deadend = false;
@@ -196,11 +196,11 @@
if (deadend) {
put(time_map, x, -1);
S.pop();
- tie(time_stamp, x) = S.top();
+ boost::tie(time_stamp, x) = S.top();
while (get(time_map, x) != -1) { // unwind stack to last unexplored vertex
put(time_map, x, -1);
S.pop();
- tie(time_stamp, x) = S.top();
+ boost::tie(time_stamp, x) = S.top();
}
}
@@ -213,7 +213,7 @@
{
int s_x = 0;
typename graph_traits < Graph >::adjacency_iterator i, end;
- for (tie(i, end) = adjacent_vertices(x, g); i != end; ++i)
+ for (boost::tie(i, end) = adjacent_vertices(x, g); i != end; ++i)
if (get(time_map, *i) == -1)
++s_x;
return s_x;
@@ -232,7 +232,7 @@
S.push(std::make_pair(time_stamp, src));
while (!S.empty()) {
Vertex x;
- tie(time_stamp, x) = S.top();
+ boost::tie(time_stamp, x) = S.top();
put(time_map, x, time_stamp);
// all vertices have been visited, success!
if (time_stamp == num_vertices(g) - 1)
@@ -242,7 +242,7 @@
std::priority_queue < P, std::vector < P >, compare_first > Q;
typename graph_traits < Graph >::adjacency_iterator i, end;
int num_succ;
- for (tie(i, end) = adjacent_vertices(x, g); i != end; ++i)
+ for (boost::tie(i, end) = adjacent_vertices(x, g); i != end; ++i)
if (get(time_map, *i) == -1) {
num_succ = number_of_successors(*i, g, time_map);
Q.push(std::make_pair(num_succ, *i));
@@ -250,17 +250,17 @@
bool deadend = Q.empty();
// move vertices from local priority queue to the stack
for (; !Q.empty(); Q.pop()) {
- tie(num_succ, x) = Q.top();
+ boost::tie(num_succ, x) = Q.top();
S.push(std::make_pair(time_stamp + 1, x));
}
if (deadend) {
put(time_map, x, -1);
S.pop();
- tie(time_stamp, x) = S.top();
+ boost::tie(time_stamp, x) = S.top();
while (get(time_map, x) != -1) { // unwind stack to last unexplored vertex
put(time_map, x, -1);
S.pop();
- tie(time_stamp, x) = S.top();
+ boost::tie(time_stamp, x) = S.top();
}
}
Modified: trunk/libs/graph/example/kruskal-example.cpp
==============================================================================
--- trunk/libs/graph/example/kruskal-example.cpp (original)
+++ trunk/libs/graph/example/kruskal-example.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -31,7 +31,7 @@
property_map<Graph, edge_weight_t>::type weightmap = get(edge_weight, g);
for (std::size_t j = 0; j < num_edges; ++j) {
Edge e; bool inserted;
- tie(e, inserted) = add_edge(edge_array[j].first, edge_array[j].second, g);
+ boost::tie(e, inserted) = add_edge(edge_array[j].first, edge_array[j].second, g);
weightmap[e] = weights[j];
}
#else
@@ -57,7 +57,7 @@
<< " ratio=\"filled\"\n"
<< " edge[style=\"bold\"]\n" << " node[shape=\"circle\"]\n";
graph_traits<Graph>::edge_iterator eiter, eiter_end;
- for (tie(eiter, eiter_end) = edges(g); eiter != eiter_end; ++eiter) {
+ for (boost::tie(eiter, eiter_end) = edges(g); eiter != eiter_end; ++eiter) {
fout << source(*eiter, g) << " -- " << target(*eiter, g);
if (std::find(spanning_tree.begin(), spanning_tree.end(), *eiter)
!= spanning_tree.end())
Modified: trunk/libs/graph/example/kruskal-telephone.cpp
==============================================================================
--- trunk/libs/graph/example/kruskal-telephone.cpp (original)
+++ trunk/libs/graph/example/kruskal-telephone.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -25,7 +25,7 @@
property_map < GraphvizGraph, edge_attribute_t >::type
edge_attr_map = get(edge_attribute, g_dot);
graph_traits < GraphvizGraph >::edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = edges(g_dot); ei != ei_end; ++ei) {
+ for (boost::tie(ei, ei_end) = edges(g_dot); ei != ei_end; ++ei) {
int weight = lexical_cast < int >(edge_attr_map[*ei]["label"]);
property < edge_weight_t, int >edge_property(weight);
add_edge(source(*ei, g_dot), target(*ei, g_dot), edge_property, g);
Modified: trunk/libs/graph/example/leda-graph-eg.cpp
==============================================================================
--- trunk/libs/graph/example/leda-graph-eg.cpp (original)
+++ trunk/libs/graph/example/leda-graph-eg.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -22,7 +22,7 @@
typedef property_map < graph_t, vertex_all_t >::type NodeMap;
NodeMap node_name_map = get(vertex_all, g);
graph_traits < graph_t >::vertex_iterator vi, vi_end;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
std::cout << node_name_map[*vi] << std::endl;
return EXIT_SUCCESS;
}
Modified: trunk/libs/graph/example/loops_dfs.cpp
==============================================================================
--- trunk/libs/graph/example/loops_dfs.cpp (original)
+++ trunk/libs/graph/example/loops_dfs.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -91,7 +91,7 @@
get(vertex_index, g), c));
typename graph_traits < Graph >::vertex_iterator vi, vi_end;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
if (reachable_from_head[*vi] != Color::white()
&& reachable_to_tail[*vi] != Color::white())
loop_set.insert(*vi);
@@ -138,7 +138,7 @@
vattr_map[*j]["color"] = "gray";
in_loop[*j] = true;
}
- for (tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
+ for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
if (in_loop[source(*ei, g)] && in_loop[target(*ei, g)])
eattr_map[*ei]["color"] = "gray";
}
@@ -151,7 +151,7 @@
<< "ratio=\"fill\"\n"
<< "shape=\"box\"\n";
graph_traits<Graph>::vertex_iterator vi, vi_end;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) {
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) {
loops_out << *vi << "[";
for (std::map<std::string,std::string>::iterator ai = vattr_map[*vi].begin();
ai != vattr_map[*vi].end(); ++ai) {
@@ -162,7 +162,7 @@
loops_out<< "]";
}
- for (tie(ei, ei_end) = edges(g); ei != ei_end; ++ei) {
+ for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei) {
loops_out << source(*ei, g) << " -> " << target(*ei, g) << "[";
std::map<std::string,std::string>& attr_map = eattr_map[*ei];
for (std::map<std::string,std::string>::iterator eai = attr_map.begin();
Modified: trunk/libs/graph/example/max_flow.cpp
==============================================================================
--- trunk/libs/graph/example/max_flow.cpp (original)
+++ trunk/libs/graph/example/max_flow.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -85,8 +85,8 @@
std::cout << "c flow values:" << std::endl;
graph_traits<Graph>::vertex_iterator u_iter, u_end;
graph_traits<Graph>::out_edge_iterator ei, e_end;
- for (tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter)
- for (tie(ei, e_end) = out_edges(*u_iter, g); ei != e_end; ++ei)
+ for (boost::tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter)
+ for (boost::tie(ei, e_end) = out_edges(*u_iter, g); ei != e_end; ++ei)
if (capacity[*ei] > 0)
std::cout << "f " << *u_iter << " " << target(*ei, g) << " "
<< (capacity[*ei] - residual_capacity[*ei]) << std::endl;
Modified: trunk/libs/graph/example/min_max_paths.cpp
==============================================================================
--- trunk/libs/graph/example/min_max_paths.cpp (original)
+++ trunk/libs/graph/example/min_max_paths.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -58,7 +58,7 @@
property_map<Graph, edge_weight_t>::type weightmap = get(edge_weight, G);
for (std::size_t j = 0; j < sizeof(edges) / sizeof(E); ++j) {
graph_traits<Graph>::edge_descriptor e; bool inserted;
- tie(e, inserted) = add_edge(edges[j].first, edges[j].second, G);
+ boost::tie(e, inserted) = add_edge(edges[j].first, edges[j].second, G);
weightmap[e] = weights[j];
}
#else
@@ -85,14 +85,14 @@
std::cout << "distances from start vertex:" << std::endl;
graph_traits<Graph>::vertex_iterator vi, vend;
- for(tie(vi,vend) = vertices(G); vi != vend; ++vi)
+ for(boost::tie(vi,vend) = vertices(G); vi != vend; ++vi)
std::cout << "distance(" << name[*vi] << ") = " << d[*vi] << std::endl;
std::cout << std::endl;
std::cout << "min-max paths tree" << std::endl;
adjacency_list<> tree(num_nodes);
- for(tie(vi,vend) = vertices(G); vi != vend; ++vi)
+ for(boost::tie(vi,vend) = vertices(G); vi != vend; ++vi)
if (*vi != p[*vi])
add_edge(p[*vi], *vi, tree);
Modified: trunk/libs/graph/example/modify_graph.cpp
==============================================================================
--- trunk/libs/graph/example/modify_graph.cpp (original)
+++ trunk/libs/graph/example/modify_graph.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -86,7 +86,7 @@
u = add_vertex(g);
v = add_vertex(g);
- tie(e, added) = add_edge(u, v, g);
+ boost::tie(e, added) = add_edge(u, v, g);
assert(num_edges(g) == m + 2);
assert(added == true); // edge should have been added
@@ -102,14 +102,14 @@
assert(num_edges(g) == m + 1);
bool exists;
- tie(e, exists) = edge(u, v, g);
+ boost::tie(e, exists) = edge(u, v, g);
assert(exists == false);
assert(out_degree(u, g) == 0);
assert(in_degree(v, g) == 0);
}
{
e = *edges(g).first;
- tie(u, v) = incident(e, g);
+ boost::tie(u, v) = incident(e, g);
remove_edge(e, g);
@@ -121,7 +121,7 @@
add_edge(u, v, g);
typename GraphTraits::out_edge_iterator iter, iter_end;
- tie(iter, iter_end) = out_edges(u, g);
+ boost::tie(iter, iter_end) = out_edges(u, g);
remove_edge(iter, g);
@@ -131,13 +131,13 @@
}
{
w = add_vertex(g);
- tie(e1, added) = add_edge(u, v, g);
- tie(e2, added) = add_edge(v, w, g);
+ boost::tie(e1, added) = add_edge(u, v, g);
+ boost::tie(e2, added) = add_edge(v, w, g);
name_map[e1] = "I-5";
name_map[e2] = "Route 66";
typename GraphTraits::out_edge_iterator iter, iter_end;
- tie(iter, iter_end) = out_edges(u, g);
+ boost::tie(iter, iter_end) = out_edges(u, g);
remove_edge_if(name_equals("Route 66", name_map), g);
@@ -152,8 +152,8 @@
assert(in_degree(w, g) == 0);
}
{
- tie(e1, added) = add_edge(u, v, g);
- tie(e2, added) = add_edge(u, w, g);
+ boost::tie(e1, added) = add_edge(u, v, g);
+ boost::tie(e2, added) = add_edge(u, w, g);
name_map[e1] = "foo";
name_map[e2] = "foo";
@@ -163,8 +163,8 @@
assert(out_degree(u, g) == 0);
}
{
- tie(e1, added) = add_edge(u, v, g);
- tie(e2, added) = add_edge(w, v, g);
+ boost::tie(e1, added) = add_edge(u, v, g);
+ boost::tie(e2, added) = add_edge(w, v, g);
name_map[e1] = "bar";
name_map[e2] = "bar";
@@ -183,9 +183,9 @@
assert(out_degree(u, g) == 0);
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) {
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) {
typename GraphTraits::adjacency_iterator ai, ai_end;
- for (tie(ai, ai_end) = adjacent_vertices(*vi, g);
+ for (boost::tie(ai, ai_end) = adjacent_vertices(*vi, g);
ai != ai_end; ++ai)
assert(*ai != u);
}
Modified: trunk/libs/graph/example/ordered_out_edges.cpp
==============================================================================
--- trunk/libs/graph/example/ordered_out_edges.cpp (original)
+++ trunk/libs/graph/example/ordered_out_edges.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -108,14 +108,14 @@
Traits::edge_descriptor e;
Traits::out_edge_iterator e_first, e_last;
- tie(e, found) = edge(0, 1, g);
+ boost::tie(e, found) = edge(0, 1, g);
if (found)
std::cout << "name(0,1) = " << name[e] << std::endl;
else
std::cout << "not found" << std::endl;
std::cout << std::endl;
- tie(e_first, e_last) = edge_range(0, 1, g);
+ boost::tie(e_first, e_last) = edge_range(0, 1, g);
while (e_first != e_last)
std::cout << "name(0,1) = " << name[*e_first++] << std::endl;
#endif
Modified: trunk/libs/graph/example/ospf-example.cpp
==============================================================================
--- trunk/libs/graph/example/ospf-example.cpp (original)
+++ trunk/libs/graph/example/ospf-example.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -43,7 +43,7 @@
typedef graph_traits < Graph >::vertex_descriptor vertex_descriptor;
Graph g(num_vertices(g_dot));
graph_traits < g_dot_type >::edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = edges(g_dot); ei != ei_end; ++ei) {
+ for (boost::tie(ei, ei_end) = edges(g_dot); ei != ei_end; ++ei) {
int weight = get(edge_weight, g_dot, *ei);
property < edge_weight_t, int >edge_property(weight);
add_edge(source(*ei, g_dot), target(*ei, g_dot), edge_property, g);
@@ -51,7 +51,7 @@
vertex_descriptor router_six;
graph_traits < g_dot_type >::vertex_iterator vi, vi_end;
- for (tie(vi, vi_end) = vertices(g_dot); vi != vi_end; ++vi)
+ for (boost::tie(vi, vi_end) = vertices(g_dot); vi != vi_end; ++vi)
if ("RT6" == get(vertex_name, g_dot, *vi)) {
router_six = *vi;
break;
@@ -90,7 +90,7 @@
std::ofstream rtable("routing-table.dat");
rtable << "Dest Next Hop Total Cost" << std::endl;
- for (tie(vi, vi_end) = vertices(g_dot); vi != vi_end; ++vi)
+ for (boost::tie(vi, vi_end) = vertices(g_dot); vi != vi_end; ++vi)
if (parent[*vi] != *vi) {
rtable << get(vertex_name, g_dot, *vi) << " ";
vertex_descriptor v = *vi, child;
Modified: trunk/libs/graph/example/parallel-compile-time.cpp
==============================================================================
--- trunk/libs/graph/example/parallel-compile-time.cpp (original)
+++ trunk/libs/graph/example/parallel-compile-time.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -59,7 +59,7 @@
color[u] = ColorT::gray();
vis.discover_vertex(u, g);
typename graph_traits < Graph >::out_edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei)
+ for (boost::tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei)
if (color[target(*ei, g)] == ColorT::white()) {
vis.tree_edge(*ei, g);
dfs_v2(g, target(*ei, g), color, vis);
@@ -77,9 +77,9 @@
typedef typename property_traits <ColorMap >::value_type ColorValue;
typedef color_traits < ColorValue > ColorT;
typename graph_traits < Graph >::vertex_iterator vi, vi_end;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
color[*vi] = ColorT::white();
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
if (color[*vi] == ColorT::white())
dfs_v2(g, *vi, color, vis);
}
@@ -134,7 +134,7 @@
id2vertex.push_back(add_vertex(g));
while (input_begin != input_end) {
size_type i, j;
- tie(i, j) = *input_begin++;
+ boost::tie(i, j) = *input_begin++;
add_edge(id2vertex[i], id2vertex[j], g);
}
#else
@@ -158,7 +158,7 @@
std::ifstream name_in("makefile-target-names.dat");
std::ifstream compile_cost_in("target-compile-costs.dat");
graph_traits < file_dep_graph2 >::vertex_iterator vi, vi_end;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) {
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) {
name_in >> name_map[*vi];
compile_cost_in >> compile_cost_map[*vi];
}
@@ -171,14 +171,14 @@
graph_traits < file_dep_graph2 >::adjacency_iterator vi, vi_end;
// find source vertices with zero in-degree by marking all vertices with incoming edges
- for (tie(i, i_end) = vertices(g); i != i_end; ++i)
+ for (boost::tie(i, i_end) = vertices(g); i != i_end; ++i)
color_map[*i] = white_color;
- for (tie(i, i_end) = vertices(g); i != i_end; ++i)
- for (tie(vi, vi_end) = adjacent_vertices(*i, g); vi != vi_end; ++vi)
+ for (boost::tie(i, i_end) = vertices(g); i != i_end; ++i)
+ for (boost::tie(vi, vi_end) = adjacent_vertices(*i, g); vi != vi_end; ++vi)
color_map[*vi] = black_color;
// initialize distances to zero, or for source vertices, to the compile cost
- for (tie(i, i_end) = vertices(g); i != i_end; ++i)
+ for (boost::tie(i, i_end) = vertices(g); i != i_end; ++i)
if (color_map[*i] == white_color)
distance_map[*i] = compile_cost_map[*i];
else
@@ -189,14 +189,14 @@
vertex_t
u = *
ui;
- for (tie(vi, vi_end) = adjacent_vertices(u, g); vi != vi_end; ++vi)
+ for (boost::tie(vi, vi_end) = adjacent_vertices(u, g); vi != vi_end; ++vi)
if (distance_map[*vi] < distance_map[u] + compile_cost_map[*vi])
distance_map[*vi] = distance_map[u] + compile_cost_map[*vi];
}
graph_property_iter_range < file_dep_graph2,
vertex_distance_t >::iterator ci, ci_end;
- tie(ci, ci_end) = get_property_iter_range(g, vertex_distance);
+ boost::tie(ci, ci_end) = get_property_iter_range(g, vertex_distance);
std::cout << "total (parallel) compile time: "
<< *std::max_element(ci, ci_end) << std::endl;
Modified: trunk/libs/graph/example/prim-example.cpp
==============================================================================
--- trunk/libs/graph/example/prim-example.cpp (original)
+++ trunk/libs/graph/example/prim-example.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -27,7 +27,7 @@
property_map<Graph, edge_weight_t>::type weightmap = get(edge_weight, g);
for (std::size_t j = 0; j < sizeof(edges) / sizeof(E); ++j) {
graph_traits<Graph>::edge_descriptor e; bool inserted;
- tie(e, inserted) = add_edge(edges[j].first, edges[j].second, g);
+ boost::tie(e, inserted) = add_edge(edges[j].first, edges[j].second, g);
weightmap[e] = weights[j];
}
#else
Modified: trunk/libs/graph/example/prim-telephone.cpp
==============================================================================
--- trunk/libs/graph/example/prim-telephone.cpp (original)
+++ trunk/libs/graph/example/prim-telephone.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -25,7 +25,7 @@
property_map < GraphvizGraph, edge_attribute_t >::type
edge_attr_map = get(edge_attribute, g_dot);
graph_traits < GraphvizGraph >::edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = edges(g_dot); ei != ei_end; ++ei) {
+ for (boost::tie(ei, ei_end) = edges(g_dot); ei != ei_end; ++ei) {
int weight = lexical_cast < int >(edge_attr_map[*ei]["label"]);
property < edge_weight_t, int >edge_property(weight);
add_edge(source(*ei, g_dot), target(*ei, g_dot), edge_property, g);
Modified: trunk/libs/graph/example/print-adjacent-vertices.cpp
==============================================================================
--- trunk/libs/graph/example/print-adjacent-vertices.cpp (original)
+++ trunk/libs/graph/example/print-adjacent-vertices.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -43,7 +43,7 @@
{
typename graph_traits < Graph >::adjacency_iterator vi, vi_end;
out << get(name_map, u) << " -> { ";
- for (tie(vi, vi_end) = adjacent_vertices(u, g); vi != vi_end; ++vi)
+ for (boost::tie(vi, vi_end) = adjacent_vertices(u, g); vi != vi_end; ++vi)
out << get(name_map, *vi) << " ";
out << "}" << std::endl;
}
@@ -101,7 +101,7 @@
read_graph_file(file_in, name_in, g, name_map);
graph_traits < graph_type >::vertex_iterator i, end;
- tie(i, end) = vertices(g);
+ boost::tie(i, end) = vertices(g);
i = std::find_if(i, end, name_equals("dax.h", get(vertex_name, g)));
output_adjacent_vertices(std::cout, *i, g, get(vertex_name, g));
Modified: trunk/libs/graph/example/print-edges.cpp
==============================================================================
--- trunk/libs/graph/example/print-edges.cpp (original)
+++ trunk/libs/graph/example/print-edges.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -41,7 +41,7 @@
VertexNameMap name_map)
{
typename graph_traits < Graph >::edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
+ for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
out << get(name_map, source(*ei, g)) << " -$>$ "
<< get(name_map, target(*ei, g)) << std::endl;
}
Modified: trunk/libs/graph/example/print-in-edges.cpp
==============================================================================
--- trunk/libs/graph/example/print-in-edges.cpp (original)
+++ trunk/libs/graph/example/print-in-edges.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -42,7 +42,7 @@
VertexNameMap name_map)
{
typename graph_traits < Graph >::in_edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = in_edges(v, g); ei != ei_end; ++ei)
+ for (boost::tie(ei, ei_end) = in_edges(v, g); ei != ei_end; ++ei)
out << get(name_map, source(*ei, g)) << " -> "
<< get(name_map, target(*ei, g)) << std::endl;
}
@@ -101,7 +101,7 @@
read_graph_file(file_in, name_in, g, name_map);
graph_traits < graph_type >::vertex_iterator i, end;
- tie(i, end) = vertices(g);
+ boost::tie(i, end) = vertices(g);
typedef property_map < graph_type, vertex_name_t >::type name_map_t;
i = std::find_if(i, end, name_equals("libzigzag.a", get(vertex_name, g)));
output_in_edges(std::cout, g, *i, get(vertex_name, g));
Modified: trunk/libs/graph/example/print-out-edges.cpp
==============================================================================
--- trunk/libs/graph/example/print-out-edges.cpp (original)
+++ trunk/libs/graph/example/print-out-edges.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -42,7 +42,7 @@
VertexNameMap name_map)
{
typename graph_traits < Graph >::out_edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei)
+ for (boost::tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei)
out << get(name_map, source(*ei, g)) << " -> "
<< get(name_map, target(*ei, g)) << std::endl;
}
@@ -100,7 +100,7 @@
read_graph_file(file_in, name_in, g, name_map);
graph_traits < graph_type >::vertex_iterator i, end;
- tie(i, end) = vertices(g);
+ boost::tie(i, end) = vertices(g);
typedef property_map < graph_type, vertex_name_t >::type name_map_t;
name_equals_t < name_map_t > predicate("dax.h", get(vertex_name, g));
i = std::find_if(i, end, predicate);
Modified: trunk/libs/graph/example/push-relabel-eg.cpp
==============================================================================
--- trunk/libs/graph/example/push-relabel-eg.cpp (original)
+++ trunk/libs/graph/example/push-relabel-eg.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -75,8 +75,8 @@
std::cout << "c flow values:" << std::endl;
graph_traits < Graph >::vertex_iterator u_iter, u_end;
graph_traits < Graph >::out_edge_iterator ei, e_end;
- for (tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter)
- for (tie(ei, e_end) = out_edges(*u_iter, g); ei != e_end; ++ei)
+ for (boost::tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter)
+ for (boost::tie(ei, e_end) = out_edges(*u_iter, g); ei != e_end; ++ei)
if (capacity[*ei] > 0)
std::cout << "f " << *u_iter << " " << target(*ei, g) << " "
<< (capacity[*ei] - residual_capacity[*ei]) << std::endl;
Modified: trunk/libs/graph/example/quick-tour.cpp
==============================================================================
--- trunk/libs/graph/example/quick-tour.cpp (original)
+++ trunk/libs/graph/example/quick-tour.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -46,7 +46,7 @@
VertexNameMap name_map)
{
typename graph_traits < Graph >::edge_iterator first, last;
- for (tie(first, last) = edges(g); first != last; ++first) {
+ for (boost::tie(first, last) = edges(g); first != last; ++first) {
print_trans_delay(*first, g, trans_delay_map, name_map);
std::cout << std::endl;
}
@@ -71,19 +71,19 @@
typename graph_traits < Graph >::edge_descriptor ed;
bool inserted;
- tie(ed, inserted) = add_edge(a, b, g);
+ boost::tie(ed, inserted) = add_edge(a, b, g);
delay_map[ed] = 1.2;
- tie(ed, inserted) = add_edge(a, d, g);
+ boost::tie(ed, inserted) = add_edge(a, d, g);
delay_map[ed] = 4.5;
- tie(ed, inserted) = add_edge(b, d, g);
+ boost::tie(ed, inserted) = add_edge(b, d, g);
delay_map[ed] = 1.8;
- tie(ed, inserted) = add_edge(c, a, g);
+ boost::tie(ed, inserted) = add_edge(c, a, g);
delay_map[ed] = 2.6;
- tie(ed, inserted) = add_edge(c, e, g);
+ boost::tie(ed, inserted) = add_edge(c, e, g);
delay_map[ed] = 5.2;
- tie(ed, inserted) = add_edge(d, c, g);
+ boost::tie(ed, inserted) = add_edge(d, c, g);
delay_map[ed] = 0.4;
- tie(ed, inserted) = add_edge(d, e, g);
+ boost::tie(ed, inserted) = add_edge(d, e, g);
delay_map[ed] = 3.3;
}
Modified: trunk/libs/graph/example/quick_tour.cpp
==============================================================================
--- trunk/libs/graph/example/quick_tour.cpp (original)
+++ trunk/libs/graph/example/quick_tour.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -31,7 +31,7 @@
std::cout << "\tout-edges: ";
typename graph_traits<Graph>::out_edge_iterator out_i, out_end;
typename graph_traits<Graph>::edge_descriptor e;
- for (tie(out_i, out_end) = out_edges(v, g);
+ for (boost::tie(out_i, out_end) = out_edges(v, g);
out_i != out_end; ++out_i)
{
e = *out_i;
@@ -44,7 +44,7 @@
// Write out the incoming edges
std::cout << "\tin-edges: ";
typename graph_traits<Graph>::in_edge_iterator in_i, in_end;
- for (tie(in_i, in_end) = in_edges(v, g); in_i != in_end; ++in_i)
+ for (boost::tie(in_i, in_end) = in_edges(v, g); in_i != in_end; ++in_i)
{
e = *in_i;
Vertex src = source(e, g), targ = target(e, g);
@@ -56,7 +56,7 @@
// Write out all adjacent vertices
std::cout << "\tadjacent vertices: ";
typename graph_traits<Graph>::adjacency_iterator ai, ai_end;
- for (tie(ai,ai_end) = adjacent_vertices(v, g); ai != ai_end; ++ai)
+ for (boost::tie(ai,ai_end) = adjacent_vertices(v, g); ai != ai_end; ++ai)
std::cout << name[get(vertex_id, *ai)] << " ";
std::cout << std::endl;
}
@@ -93,7 +93,7 @@
property_map<Graph, edge_weight_t>::type weightmap = get(edge_weight, g);
for (std::size_t j = 0; j < num_edges; ++j) {
graph_traits<Graph>::edge_descriptor e; bool inserted;
- tie(e, inserted) = add_edge(edge_array[j].first, edge_array[j].second, g);
+ boost::tie(e, inserted) = add_edge(edge_array[j].first, edge_array[j].second, g);
weightmap[e] = transmission_delay[j];
}
#else
@@ -115,7 +115,7 @@
std::cout << "edges(g) = ";
graph_traits<Graph>::edge_iterator ei, ei_end;
- for (tie(ei,ei_end) = edges(g); ei != ei_end; ++ei)
+ for (boost::tie(ei,ei_end) = edges(g); ei != ei_end; ++ei)
std::cout << "(" << name[get(vertex_id, source(*ei, g))]
<< "," << name[get(vertex_id, target(*ei, g))] << ") ";
std::cout << std::endl;
Modified: trunk/libs/graph/example/reachable-loop-head.cpp
==============================================================================
--- trunk/libs/graph/example/reachable-loop-head.cpp (original)
+++ trunk/libs/graph/example/reachable-loop-head.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -38,7 +38,7 @@
vattr_map = get(vertex_attribute, g);
graph_traits < GraphvizDigraph >::vertex_iterator i, i_end;
- for (tie(i, i_end) = vertices(g); i != i_end; ++i)
+ for (boost::tie(i, i_end) = vertices(g); i != i_end; ++i)
if (reachable_from_head[*i] != Color::white()) {
vattr_map[*i]["color"] = "gray";
vattr_map[*i]["style"] = "filled";
@@ -52,7 +52,7 @@
<< "ratio=\"fill\"\n"
<< "shape=\"box\"\n";
graph_traits<GraphvizDigraph>::vertex_iterator vi, vi_end;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) {
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) {
loops_out << *vi << "[";
for (std::map<std::string,std::string>::iterator ai = vattr_map[*vi].begin();
ai != vattr_map[*vi].end(); ++ai) {
@@ -65,7 +65,7 @@
property_map<GraphvizDigraph, edge_attribute_t>::type
eattr_map = get(edge_attribute, g);
graph_traits<GraphvizDigraph>::edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = edges(g); ei != ei_end; ++ei) {
+ for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei) {
loops_out << source(*ei, g) << " -> " << target(*ei, g) << "[";
std::map<std::string,std::string>& attr_map = eattr_map[*ei];
for (std::map<std::string,std::string>::iterator eai = attr_map.begin();
Modified: trunk/libs/graph/example/reachable-loop-tail.cpp
==============================================================================
--- trunk/libs/graph/example/reachable-loop-tail.cpp (original)
+++ trunk/libs/graph/example/reachable-loop-tail.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -50,7 +50,7 @@
property_map<Graph, vertex_attribute_t>::type
vattr_map = get(vertex_attribute, g);
graph_traits < GraphvizDigraph >::vertex_iterator i, i_end;
- for (tie(i, i_end) = vertices(g_in); i != i_end; ++i) {
+ for (boost::tie(i, i_end) = vertices(g_in); i != i_end; ++i) {
loops_out << *i << "[label=\"" << vattr_map[*i]["label"]
<< "\"";
if (reachable_to_tail[*i] != Color::white()) {
@@ -59,7 +59,7 @@
loops_out << "]\n";
}
graph_traits < GraphvizDigraph >::edge_iterator e, e_end;
- for (tie(e, e_end) = edges(g_in); e != e_end; ++e)
+ for (boost::tie(e, e_end) = edges(g_in); e != e_end; ++e)
loops_out << source(*e, g) << " -> " << target(*e, g) << ";\n";
loops_out << "}\n";
return EXIT_SUCCESS;
Modified: trunk/libs/graph/example/read_write_dimacs-eg.cpp
==============================================================================
--- trunk/libs/graph/example/read_write_dimacs-eg.cpp (original)
+++ trunk/libs/graph/example/read_write_dimacs-eg.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -90,12 +90,12 @@
//we take the source node and check for each outgoing edge e which has a target(p) if we can augment that path
out_edge_iterator oei,oe_end;
- for(tie(oei, oe_end) = out_edges(s, g); oei != oe_end; ++oei){
+ for(boost::tie(oei, oe_end) = out_edges(s, g); oei != oe_end; ++oei){
edge_descriptor from_source = *oei;
vertex_descriptor v = target(from_source, g);
edge_descriptor to_sink;
bool is_there;
- tie(to_sink, is_there) = edge(v, t, g);
+ boost::tie(to_sink, is_there) = edge(v, t, g);
if( is_there ){
if( get(capacity, to_sink) > get(capacity, from_source) ){
tCapMapValue to_augment = get(capacity, from_source);
Modified: trunk/libs/graph/example/remove_edge_if_bidir.cpp
==============================================================================
--- trunk/libs/graph/example/remove_edge_if_bidir.cpp (original)
+++ trunk/libs/graph/example/remove_edge_if_bidir.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -79,7 +79,7 @@
int w = 0;
graph_traits<Graph>::edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
+ for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
weight[*ei] = ++w;
property_map<Graph, vertex_index_t>::type indexmap = get(vertex_index, g);
Modified: trunk/libs/graph/example/remove_edge_if_undir.cpp
==============================================================================
--- trunk/libs/graph/example/remove_edge_if_undir.cpp (original)
+++ trunk/libs/graph/example/remove_edge_if_undir.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -78,7 +78,7 @@
int w = 0;
graph_traits<Graph>::edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
+ for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
weight[*ei] = ++w;
std::cout << "original graph:" << std::endl;
Modified: trunk/libs/graph/example/roget_components.cpp
==============================================================================
--- trunk/libs/graph/example/roget_components.cpp (original)
+++ trunk/libs/graph/example/roget_components.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -72,12 +72,12 @@
// First add representative vertices to each component's list
graph_traits<Graph*>::vertex_iterator vi, vi_end;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
if (root[*vi] == *vi)
strong_comp[comp[index_map[*vi]]].push_back(*vi);
// Then add the other vertices of the component
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
if (root[*vi] != *vi)
strong_comp[comp[index_map[*vi]]].push_back(*vi);
@@ -117,7 +117,7 @@
for (i = 0; i < strong_comp[c].size(); ++i) {
vertex_t v = strong_comp[c][i];
graph_traits<Graph*>::out_edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = out_edges(v, g); ei != ei_end; ++ei) {
+ for (boost::tie(ei, ei_end) = out_edges(v, g); ei != ei_end; ++ei) {
vertex_t x = target(*ei, g);
int comp_x = comp[index_map[x]];
if (comp_x != c && mark[comp_x] != c) {
Modified: trunk/libs/graph/example/scc.cpp
==============================================================================
--- trunk/libs/graph/example/scc.cpp (original)
+++ trunk/libs/graph/example/scc.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -29,7 +29,7 @@
std::string color[] = {
"white", "gray", "black", "lightgray"};
graph_traits < GraphvizDigraph >::vertex_iterator vi, vi_end;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) {
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) {
vertex_attr_map[*vi]["color"] = color[component[*vi]];
vertex_attr_map[*vi]["style"] = "filled";
if (vertex_attr_map[*vi]["color"] == "black")
Modified: trunk/libs/graph/example/subgraph.cpp
==============================================================================
--- trunk/libs/graph/example/subgraph.cpp (original)
+++ trunk/libs/graph/example/subgraph.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -77,7 +77,7 @@
Graph::children_iterator ci, ci_end;
int num = 1;
- for (tie(ci, ci_end) = G0.children(); ci != ci_end; ++ci) {
+ for (boost::tie(ci, ci_end) = G0.children(); ci != ci_end; ++ci) {
std::cout << "G" << num++ << ":" << std::endl;
print_graph(*ci, get(vertex_index, *ci));
print_edges2(*ci, get(vertex_index, *ci), get(edge_index, *ci));
Modified: trunk/libs/graph/example/tiernan_girth_circumference.cpp
==============================================================================
--- trunk/libs/graph/example/tiernan_girth_circumference.cpp (original)
+++ trunk/libs/graph/example/tiernan_girth_circumference.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -29,7 +29,7 @@
// Compute the girth and circumference simulataneously
size_t girth, circ;
- tie(girth, circ) = tiernan_girth_and_circumference(g);
+ boost::tie(girth, circ) = tiernan_girth_and_circumference(g);
// Print the result
cout << "girth: " << girth << endl;
Modified: trunk/libs/graph/example/topo-sort-file-dep.cpp
==============================================================================
--- trunk/libs/graph/example/topo-sort-file-dep.cpp (original)
+++ trunk/libs/graph/example/topo-sort-file-dep.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -38,7 +38,7 @@
{
mark[u] = 1; // 1 means visited, 0 means not yet visited
graph_traits < file_dep_graph >::adjacency_iterator vi, vi_end;
- for (tie(vi, vi_end) = adjacent_vertices(u, g); vi != vi_end; ++vi)
+ for (boost::tie(vi, vi_end) = adjacent_vertices(u, g); vi != vi_end; ++vi)
if (mark[*vi] == 0)
topo_sort_dfs(g, *vi, topo_order, mark);
@@ -50,7 +50,7 @@
{
std::vector < int >mark(num_vertices(g), 0);
graph_traits < file_dep_graph >::vertex_iterator vi, vi_end;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
if (mark[*vi] == 0)
topo_sort_dfs(g, *vi, topo_order, &mark[0]);
}
@@ -70,7 +70,7 @@
file_dep_graph g(n_vertices);
while (input_begin != input_end) {
size_type i, j;
- tie(i, j) = *input_begin++;
+ boost::tie(i, j) = *input_begin++;
add_edge(i, j, g);
}
#else
@@ -80,7 +80,7 @@
std::vector < std::string > name(num_vertices(g));
std::ifstream name_in("makefile-target-names.dat");
graph_traits < file_dep_graph >::vertex_iterator vi, vi_end;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
name_in >> name[*vi];
std::vector < vertex_t > order(num_vertices(g));
Modified: trunk/libs/graph/example/topo-sort-file-dep2.cpp
==============================================================================
--- trunk/libs/graph/example/topo-sort-file-dep2.cpp (original)
+++ trunk/libs/graph/example/topo-sort-file-dep2.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -42,7 +42,7 @@
color[u] = gray_color;
vis.discover_vertex(u, g);
graph_traits < file_dep_graph >::out_edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei) {
+ for (boost::tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei) {
if (color[target(*ei, g)] == white_color) {
vis.tree_edge(*ei, g);
dfs_v1(g, target(*ei, g), color, vis);
@@ -60,7 +60,7 @@
{
std::vector < default_color_type > color(num_vertices(g), white_color);
graph_traits < file_dep_graph >::vertex_iterator vi, vi_end;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) {
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) {
if (color[*vi] == white_color)
dfs_v1(g, *vi, &color[0], vis);
}
@@ -130,7 +130,7 @@
file_dep_graph g(n_vertices);
while (input_begin != input_end) {
size_type i, j;
- tie(i, j) = *input_begin++;
+ boost::tie(i, j) = *input_begin++;
add_edge(i, j, g);
}
#else
@@ -140,7 +140,7 @@
std::vector < std::string > name(num_vertices(g));
std::ifstream name_in("makefile-target-names.dat");
graph_traits < file_dep_graph >::vertex_iterator vi, vi_end;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
name_in >> name[*vi];
std::vector < vertex_t > order(num_vertices(g));
Modified: trunk/libs/graph/example/transpose-example.cpp
==============================================================================
--- trunk/libs/graph/example/transpose-example.cpp (original)
+++ trunk/libs/graph/example/transpose-example.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -25,7 +25,7 @@
name_map = get(vertex_name, G);
char name = 'a';
graph_traits < graph_t >::vertex_iterator v, v_end;
- for (tie(v, v_end) = vertices(G); v != v_end; ++v, ++name)
+ for (boost::tie(v, v_end) = vertices(G); v != v_end; ++v, ++name)
name_map[*v] = name;
typedef std::pair < int, int >E;
@@ -44,7 +44,7 @@
print_graph(G_T, name_map);
graph_traits < graph_t >::edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = edges(G); ei != ei_end; ++ei)
+ for (boost::tie(ei, ei_end) = edges(G); ei != ei_end; ++ei)
assert(edge(target(*ei, G), source(*ei, G), G_T).second == true);
return 0;
}
Modified: trunk/libs/graph/example/undirected.cpp
==============================================================================
--- trunk/libs/graph/example/undirected.cpp (original)
+++ trunk/libs/graph/example/undirected.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -27,10 +27,10 @@
add_edge(one, two, undigraph);
std::cout << "out_edges(0): ";
- for (tie(out, out_end) = out_edges(zero, undigraph); out != out_end; ++out)
+ for (boost::tie(out, out_end) = out_edges(zero, undigraph); out != out_end; ++out)
std::cout << *out;
std::cout << std::endl << "in_edges(0): ";
- for (tie(in, in_end) = in_edges(zero, undigraph); in != in_end; ++in)
+ for (boost::tie(in, in_end) = in_edges(zero, undigraph); in != in_end; ++in)
std::cout << *in;
std::cout << std::endl;
}
@@ -51,8 +51,8 @@
v = vertex(1, digraph);
add_edge(u, v, Weight(1.2), digraph);
add_edge(v, u, Weight(2.4), digraph);
- tie(e1, found) = edge(u, v, digraph);
- tie(e2, found) = edge(v, u, digraph);
+ boost::tie(e1, found) = edge(u, v, digraph);
+ boost::tie(e2, found) = edge(v, u, digraph);
std::cout << "in a directed graph is ";
#ifdef __GNUC__
// no boolalpha
@@ -80,8 +80,8 @@
u = vertex(0, undigraph);
v = vertex(1, undigraph);
add_edge(u, v, Weight(3.1), undigraph);
- tie(e1, found) = edge(u, v, undigraph);
- tie(e2, found) = edge(v, u, undigraph);
+ boost::tie(e1, found) = edge(u, v, undigraph);
+ boost::tie(e2, found) = edge(v, u, undigraph);
std::cout << "in an undirected graph is ";
#ifdef __GNUC__
std::cout << "(u,v) == (v,u) ? " << (e1 == e2) << std::endl;
Modified: trunk/libs/graph/src/graphml.cpp
==============================================================================
--- trunk/libs/graph/src/graphml.cpp (original)
+++ trunk/libs/graph/src/graphml.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -168,7 +168,7 @@
any edge;
bool added;
- tie(edge, added) = m_g.do_add_edge(source, target);
+ boost::tie(edge, added) = m_g.do_add_edge(source, target);
if (!added) {
BOOST_THROW_EXCEPTION(bad_parallel_edge(u, v));
}
Modified: trunk/libs/graph/test/astar_search_test.cpp
==============================================================================
--- trunk/libs/graph/test/astar_search_test.cpp (original)
+++ trunk/libs/graph/test/astar_search_test.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -162,8 +162,8 @@
WeightMap weightmap = get(edge_weight, g);
for(std::size_t j = 0; j < num_edges; ++j) {
edge_descriptor e; bool inserted;
- tie(e, inserted) = add_edge(edge_array[j].first,
- edge_array[j].second, g);
+ boost::tie(e, inserted) = add_edge(edge_array[j].first,
+ edge_array[j].second, g);
weightmap[e] = weights[j];
}
Modified: trunk/libs/graph/test/betweenness_centrality_test.cpp
==============================================================================
--- trunk/libs/graph/test/betweenness_centrality_test.cpp (original)
+++ trunk/libs/graph/test/betweenness_centrality_test.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -45,7 +45,7 @@
{
vertex_iterator v, v_end;
int index = 0;
- for (tie(v, v_end) = boost::vertices(g); v != v_end; ++v, ++index) {
+ for (boost::tie(v, v_end) = boost::vertices(g); v != v_end; ++v, ++index) {
put(vertex_index, g, *v, index);
vertices[index] = *v;
}
@@ -93,7 +93,7 @@
{
vertex_iterator v, v_end;
int index = 0;
- for (tie(v, v_end) = boost::vertices(g); v != v_end; ++v, ++index) {
+ for (boost::tie(v, v_end) = boost::vertices(g); v != v_end; ++v, ++index) {
put(vertex_index, g, *v, index);
vertices[index] = *v;
}
@@ -186,7 +186,7 @@
{
vertex_iterator v, v_end;
int index = 0;
- for (tie(v, v_end) = boost::vertices(g); v != v_end; ++v, ++index) {
+ for (boost::tie(v, v_end) = boost::vertices(g); v != v_end; ++v, ++index) {
put(vertex_index, g, *v, index);
vertices[index] = *v;
if (*v != center) {
@@ -247,7 +247,7 @@
typedef typename graph_traits<MutableGraph>::vertex_descriptor vertex;
typename graph_traits<MutableGraph>::vertex_iterator vi, vi_end;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) {
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) {
vertex v = *vi;
typename graph_traits<MutableGraph>::vertex_iterator wi
= is_undirected? vi : vertices(g).first;
@@ -273,11 +273,11 @@
typedef typename boost::property_traits<CentralityMap>::value_type centrality_type;
vertex_iterator vi, vi_end;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
put(centrality, *vi, 0);
vertex_iterator si, si_end;
- for (tie(si, si_end) = vertices(g); si != si_end; ++si) {
+ for (boost::tie(si, si_end) = vertices(g); si != si_end; ++si) {
vertex s = *si;
// S <-- empty stack
@@ -313,7 +313,7 @@
S.push(v);
adjacency_iterator wi, wi_end;
- for (tie(wi, wi_end) = adjacent_vertices(v, g); wi != wi_end; ++wi) {
+ for (boost::tie(wi, wi_end) = adjacent_vertices(v, g); wi != wi_end; ++wi) {
vertex w = *wi;
// w found for the first time?
@@ -366,7 +366,7 @@
is_same<directed_category, undirected_tag>::value;
if (is_undirected) {
vertex_iterator v, v_end;
- for(tie(v, v_end) = vertices(g); v != v_end; ++v) {
+ for(boost::tie(v, v_end) = vertices(g); v != v_end; ++v) {
put(centrality, *v, get(centrality, *v) / centrality_type(2));
}
}
@@ -380,7 +380,7 @@
{
typename graph_traits<Graph>::vertex_iterator v, v_end;
int index = 0;
- for (tie(v, v_end) = boost::vertices(g); v != v_end; ++v, ++index) {
+ for (boost::tie(v, v_end) = boost::vertices(g); v != v_end; ++v, ++index) {
put(vertex_index, g, *v, index);
}
}
Modified: trunk/libs/graph/test/biconnected_components_test.cpp
==============================================================================
--- trunk/libs/graph/test/biconnected_components_test.cpp (original)
+++ trunk/libs/graph/test/biconnected_components_test.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -42,7 +42,7 @@
std::vector<Vertex> art_points_check;
typename graph_traits<Graph>::vertex_iterator vi, vi_end;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) {
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) {
Graph g_copy(g);
Vertex victim = vertex(get(vertex_index, g, *vi), g_copy);
clear_vertex(victim, g_copy);
@@ -121,7 +121,7 @@
}
graph_traits<Graph>::edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
+ for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
out << source(*ei, g) << " -- " << target(*ei, g)
<< "[label=\"" << g[*ei].component << "\"]\n";
out << "}\n";
Modified: trunk/libs/graph/test/bidir_remove_edge.cpp
==============================================================================
--- trunk/libs/graph/test/bidir_remove_edge.cpp (original)
+++ trunk/libs/graph/test/bidir_remove_edge.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -24,7 +24,7 @@
edge_prop p = { 42 };
edge e; bool b;
- tie(e, b) = add_edge(0, 1, p, g);
+ boost::tie(e, b) = add_edge(0, 1, p, g);
BOOST_TEST( num_edges(g) == 1 );
BOOST_TEST( g[e].weight == 42 );
remove_edge(e, g);
@@ -37,7 +37,7 @@
graph g(2);
edge e; bool b;
- tie(e, b) = add_edge(0, 1, g);
+ boost::tie(e, b) = add_edge(0, 1, g);
BOOST_TEST( num_edges(g) == 1 );
remove_edge(e, g);
BOOST_TEST( num_edges(g) == 0 );
Modified: trunk/libs/graph/test/bidir_vec_remove_edge.cpp
==============================================================================
--- trunk/libs/graph/test/bidir_vec_remove_edge.cpp (original)
+++ trunk/libs/graph/test/bidir_vec_remove_edge.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -40,7 +40,7 @@
// e2 has been invalidated, so grab it again
bool b2;
- tie(e2, b2) = boost::edge(1, 0, g);
+ boost::tie(e2, b2) = boost::edge(1, 0, g);
BOOST_CHECK( b2 );
BOOST_CHECK( g[e2].weight == 17 );
Modified: trunk/libs/graph/test/boykov_kolmogorov_max_flow_test.cpp
==============================================================================
--- trunk/libs/graph/test/boykov_kolmogorov_max_flow_test.cpp (original)
+++ trunk/libs/graph/test/boykov_kolmogorov_max_flow_test.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -68,7 +68,7 @@
//randomize edge-capacities
//randomize_property<edge_capacity, Graph, tIntGen> (g,int_gen); //we cannot use this, as we have no idea how properties are stored, right?
typename graph_traits<Graph>::edge_iterator ei, e_end;
- for(tie(ei,e_end) = edges(g); ei != e_end; ++ei)
+ for(boost::tie(ei,e_end) = edges(g); ei != e_end; ++ei)
cap[*ei] = int_gen();
//get source and sink node
@@ -79,7 +79,7 @@
//add reverse edges (ugly... how to do better?!)
std::list<edge_descriptor> edges_copy;
- tie(ei, e_end) = edges(g);
+ boost::tie(ei, e_end) = edges(g);
std::copy(ei, e_end, std::back_insert_iterator< std::list<edge_descriptor> >(edges_copy));
while(!edges_copy.empty()){
edge_descriptor old_edge = edges_copy.front();
@@ -88,7 +88,7 @@
vertex_descriptor target_vertex = source(old_edge, g);
bool inserted;
edge_descriptor new_edge;
- tie(new_edge,inserted) = add_edge(source_vertex, target_vertex, g);
+ boost::tie(new_edge,inserted) = add_edge(source_vertex, target_vertex, g);
assert(inserted);
rev[old_edge] = new_edge;
rev[new_edge] = old_edge ;
@@ -111,7 +111,7 @@
tVectorGraph g;
graph_traits<tVectorGraph>::vertex_descriptor src,sink;
- tie(src,sink) = fill_random_max_flow_graph(g, get(edge_capacity,g), get(edge_reverse, g), n_verts, n_edges, seed);
+ boost::tie(src,sink) = fill_random_max_flow_graph(g, get(edge_capacity,g), get(edge_reverse, g), n_verts, n_edges, seed);
return boykov_kolmogorov_max_flow(g, get(edge_capacity, g),
get(edge_residual_capacity, g),
@@ -137,12 +137,12 @@
tListGraph g;
graph_traits<tListGraph>::vertex_descriptor src,sink;
- tie(src,sink) = fill_random_max_flow_graph(g, get(edge_capacity,g), get(edge_reverse, g), n_verts, n_edges, seed);
+ boost::tie(src,sink) = fill_random_max_flow_graph(g, get(edge_capacity,g), get(edge_reverse, g), n_verts, n_edges, seed);
//initialize vertex indices
graph_traits<tListGraph>::vertex_iterator vi,v_end;
graph_traits<tListGraph>::vertices_size_type index = 0;
- for(tie(vi, v_end) = vertices(g); vi != v_end; ++vi){
+ for(boost::tie(vi, v_end) = vertices(g); vi != v_end; ++vi){
put(vertex_index, g, *vi, index++);
}
return boykov_kolmogorov_max_flow(g, get(edge_capacity, g),
@@ -178,7 +178,7 @@
tBundleGraph g;
graph_traits<tBundleGraph>::vertex_descriptor src,sink;
- tie(src,sink) = fill_random_max_flow_graph(g, get(&tEdge::edge_capacity,g), get(&tEdge::edge_reverse, g), n_verts, n_edges, seed);
+ boost::tie(src,sink) = fill_random_max_flow_graph(g, get(&tEdge::edge_capacity,g), get(&tEdge::edge_reverse, g), n_verts, n_edges, seed);
return boykov_kolmogorov_max_flow(g, get(&tEdge::edge_capacity, g),
get(&tEdge::edge_residual_capacity, g),
get(&tEdge::edge_reverse, g),
@@ -199,7 +199,7 @@
tGraph g;
graph_traits<tGraph>::vertex_descriptor src,sink;
- tie(src,sink) = fill_random_max_flow_graph(g, get(edge_capacity,g), get(edge_reverse, g), n_verts, n_edges, seed);
+ boost::tie(src,sink) = fill_random_max_flow_graph(g, get(edge_capacity,g), get(edge_reverse, g), n_verts, n_edges, seed);
std::vector<graph_traits<tGraph>::edge_descriptor> predecessor_vec(n_verts);
std::vector<default_color_type> color_vec(n_verts);
@@ -272,7 +272,7 @@
bool is_active = (tSuper::m_in_active_list_map[v] && (tSuper::has_parent(v) || it != tSuper::m_orphans.end() ));
if(this->get_tree(v) != tColorTraits::gray() && !is_active){
typename graph_traits<Graph>::out_edge_iterator ei,e_end;
- for(tie(ei, e_end) = out_edges(v, tSuper::m_g); ei != e_end; ++ei){
+ for(boost::tie(ei, e_end) = out_edges(v, tSuper::m_g); ei != e_end; ++ei){
const tVertex& other_node = target(*ei, tSuper::m_g);
if(this->get_tree(other_node) != this->get_tree(v)){
if(this->get_tree(v) == tColorTraits::black())
@@ -342,7 +342,7 @@
void check_invariants(){
tVertexIterator vi, v_end;
- for(tie(vi, v_end) = vertices(tSuper::m_g); vi != v_end; ++vi){
+ for(boost::tie(vi, v_end) = vertices(tSuper::m_g); vi != v_end; ++vi){
invariant_four(*vi);
invariant_five(*vi);
invariant_six(*vi);
@@ -359,7 +359,7 @@
while(true){
bool path_found;
tEdge connecting_edge;
- tie(connecting_edge, path_found) = this->grow(); //find a path from source to sink
+ boost::tie(connecting_edge, path_found) = this->grow(); //find a path from source to sink
if(!path_found){
//we're finished, no more paths were found
break;
@@ -375,13 +375,13 @@
//check if flow is the sum of outgoing edges of src
tOutEdgeIterator ei, e_end;
tEdgeVal src_sum = 0;
- for(tie(ei, e_end) = out_edges(this->m_source, this->m_g); ei != e_end; ++ei){
+ for(boost::tie(ei, e_end) = out_edges(this->m_source, this->m_g); ei != e_end; ++ei){
src_sum += this->m_cap_map[*ei] - this->m_res_cap_map[*ei];
}
BOOST_CHECK(this->m_flow == src_sum);
//check if flow is the sum of ingoing edges of sink
tEdgeVal sink_sum = 0;
- for(tie(ei, e_end) = out_edges(this->m_sink, this->m_g); ei != e_end; ++ei){
+ for(boost::tie(ei, e_end) = out_edges(this->m_sink, this->m_g); ei != e_end; ++ei){
tEdge in_edge = this->m_rev_edge_map[*ei];
sink_sum += this->m_cap_map[in_edge] - this->m_res_cap_map[in_edge];
}
@@ -405,7 +405,7 @@
tVectorGraph g;
graph_traits<tVectorGraph>::vertex_descriptor src, sink;
- tie(src,sink) = fill_random_max_flow_graph(g, get(edge_capacity,g), get(edge_reverse, g), n_verts, n_edges, seed);
+ boost::tie(src,sink) = fill_random_max_flow_graph(g, get(edge_capacity,g), get(edge_reverse, g), n_verts, n_edges, seed);
typedef property_map<tVectorGraph, edge_capacity_t>::type tEdgeCapMap;
typedef property_map<tVectorGraph, edge_residual_capacity_t>::type tEdgeResCapMap;
Modified: trunk/libs/graph/test/cycle_ratio_tests.cpp
==============================================================================
--- trunk/libs/graph/test/cycle_ratio_tests.cpp (original)
+++ trunk/libs/graph/test/cycle_ratio_tests.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -333,7 +333,7 @@
typedef graph_traits<GraphMInt>::vertex_iterator VertexItM;
typedef graph_traits<GraphMInt>::edge_descriptor EdgeM;
VertexItM vi1, vi2, vi_end;
- for (tie(vi1, vi_end) = vertices(gm); vi1 != vi_end; ++vi1)
+ for (boost::tie(vi1, vi_end) = vertices(gm); vi1 != vi_end; ++vi1)
{
for (vi2 = vertices(gm).first; vi2 != vi_end; ++vi2)
add_edge(*vi1, *vi2, gm);
Modified: trunk/libs/graph/test/dijkstra_heap_performance.cpp
==============================================================================
--- trunk/libs/graph/test/dijkstra_heap_performance.cpp (original)
+++ trunk/libs/graph/test/dijkstra_heap_performance.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -100,7 +100,7 @@
std::cout << n << " vertices, " << num_edges(g) << " edges.\n";
uniform_real<double> rand01(0.0, 1.0);
graph_traits<Graph>::edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
+ for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
put(edge_weight, g, *ei, rand01(gen));
std::vector<double> binary_heap_distances(n);
Modified: trunk/libs/graph/test/dominator_tree_test.cpp
==============================================================================
--- trunk/libs/graph/test/dominator_tree_test.cpp (original)
+++ trunk/libs/graph/test/dominator_tree_test.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -238,7 +238,7 @@
IndexMap indexMap(get(vertex_index, g));
graph_traits<G>::vertex_iterator uItr, uEnd;
int j = 0;
- for (tie(uItr, uEnd) = vertices(g); uItr != uEnd; ++uItr, ++j)
+ for (boost::tie(uItr, uEnd) = vertices(g); uItr != uEnd; ++uItr, ++j)
{
put(indexMap, *uItr, j);
}
@@ -252,7 +252,7 @@
lengauer_tarjan_dominator_tree(g, vertex(0, g), domTreePredMap);
vector<int> idom(num_vertices(g));
- for (tie(uItr, uEnd) = vertices(g); uItr != uEnd; ++uItr)
+ for (boost::tie(uItr, uEnd) = vertices(g); uItr != uEnd; ++uItr)
{
if (get(domTreePredMap, *uItr) != graph_traits<G>::null_vertex())
idom[get(indexMap, *uItr)] =
@@ -276,7 +276,7 @@
iterative_bit_vector_dominator_tree(g, vertex(0, g), domTreePredMap);
vector<int> idom2(num_vertices(g));
- for (tie(uItr, uEnd) = vertices(g); uItr != uEnd; ++uItr)
+ for (boost::tie(uItr, uEnd) = vertices(g); uItr != uEnd; ++uItr)
{
if (get(domTreePredMap, *uItr) != graph_traits<G>::null_vertex())
idom2[get(indexMap, *uItr)] =
Modified: trunk/libs/graph/test/graphml_test.cpp
==============================================================================
--- trunk/libs/graph/test/graphml_test.cpp (original)
+++ trunk/libs/graph/test/graphml_test.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -74,11 +74,11 @@
assert(num_edges(g) == num_edges(g2));
graph_traits<graph_t>::vertex_iterator v, v_end;
- for (tie(v,v_end) = vertices(g); v != v_end; ++v)
+ for (boost::tie(v,v_end) = vertices(g); v != v_end; ++v)
assert(get(vertex_color_t(), g, *v) == get(vertex_color_t(), g2, *v));
graph_traits<graph_t>::edge_iterator e, e_end;
- for (tie(e,e_end) = edges(g); e != e_end; ++e)
+ for (boost::tie(e,e_end) = edges(g); e != e_end; ++e)
assert(get(edge_weight_t(), g, *e) == get(edge_weight_t(), g2, *e));
return 0;
Modified: trunk/libs/graph/test/index_graph.cpp
==============================================================================
--- trunk/libs/graph/test/index_graph.cpp (original)
+++ trunk/libs/graph/test/index_graph.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -77,7 +77,7 @@
// Each vertex should be numbered correctly.
Iterator i, end;
- tie(i, end) = vertices(g);
+ boost::tie(i, end) = vertices(g);
for(size_t x = 0; i != end; ++i, ++x) {
BOOST_ASSERT(get_vertex_index(*i, g) == x);
}
Modified: trunk/libs/graph/test/layout_test.cpp
==============================================================================
--- trunk/libs/graph/test/layout_test.cpp (original)
+++ trunk/libs/graph/test/layout_test.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -41,7 +41,7 @@
typename graph_traits<Graph>::vertex_iterator vi, vi_end;
// Find vertex at this position
typename graph_traits<Graph>::vertices_size_type index = 0;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi, ++index) {
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi, ++index) {
if ((int)position[*vi][0] == x && (int)position[*vi][1] == y)
break;
}
@@ -60,14 +60,14 @@
out << "graph " << name << " {" << std::endl;
typename graph_traits<Graph>::vertex_iterator vi, vi_end;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) {
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) {
out << " n" << get(vertex_index, g, *vi) << "[ pos=\""
<< (int)position[*vi][0] + 25 << ", " << (int)position[*vi][1] + 25
<< "\" ];\n";
}
typename graph_traits<Graph>::edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = edges(g); ei != ei_end; ++ei) {
+ for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei) {
out << " n" << get(vertex_index, g, source(*ei, g)) << " -- n"
<< get(vertex_index, g, target(*ei, g)) << ";\n";
}
@@ -172,11 +172,11 @@
vertex_iterator vi, vi_end;
int i = 0;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
put(vertex_index, g, *vi, i++);
edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = edges(g); ei != ei_end; ++ei) {
+ for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei) {
put(edge_weight, g, *ei, 1.0);
std::cerr << "(" << (char)(get(vertex_index, g, source(*ei, g)) + 'A')
<< ", " << (char)(get(vertex_index, g, target(*ei, g)) + 'A')
@@ -241,11 +241,11 @@
vertex_iterator vi, vi_end;
int i = 0;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
put(vertex_index, g, *vi, i++);
edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = edges(g); ei != ei_end; ++ei) {
+ for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei) {
put(edge_weight, g, *ei, 1.0);
std::cerr << "(" << (char)(get(vertex_index, g, source(*ei, g)) + 'A')
<< ", " << (char)(get(vertex_index, g, target(*ei, g)) + 'A')
@@ -313,11 +313,11 @@
vertex_iterator vi, vi_end;
int i = 0;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
put(vertex_index, g, *vi, i++);
edge_iterator ei, ei_end;
- for (tie(ei, ei_end) = edges(g); ei != ei_end; ++ei) {
+ for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei) {
put(edge_weight, g, *ei, 1.0);
std::cerr << "(" << (char)(get(vertex_index, g, source(*ei, g)) + 'A')
<< ", " << (char)(get(vertex_index, g, target(*ei, g)) + 'A')
Modified: trunk/libs/graph/test/matching_test.cpp
==============================================================================
--- trunk/libs/graph/test/matching_test.cpp (original)
+++ trunk/libs/graph/test/matching_test.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -51,7 +51,7 @@
vertex_iterator_t vi, vi_end;
v_size_t i = 0;
- for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi, ++i)
+ for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi, ++i)
put(vertex_index, g, *vi, i);
}
};
@@ -66,8 +66,8 @@
g = Graph(n);
vertex_iterator_t vi, vi_end, wi;
- tie(vi,vi_end) = vertices(g);
- for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
+ boost::tie(vi,vi_end) = vertices(g);
+ for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
{
wi = vi;
++wi;
@@ -92,7 +92,7 @@
vertex_iterator_t vi, vi_end, ui, ui_end, halfway;
- tie(ui,ui_end) = vertices(g);
+ boost::tie(ui,ui_end) = vertices(g);
halfway = ui;
for(int i = 0; i < n; ++i)
@@ -111,7 +111,7 @@
++ui;
}
- tie(ui,ui_end) = vertices(g);
+ boost::tie(ui,ui_end) = vertices(g);
while(halfway != ui_end)
{
@@ -233,7 +233,7 @@
//Now remove an edge from the edmonds_mate matching.
vertex_iterator_t vi,vi_end;
- for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
+ for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
if (edmonds_mate[*vi] != graph_traits<Graph>::null_vertex())
break;
@@ -299,7 +299,7 @@
vertex_descriptor_t v = random_vertex(j,rand_num);
if (u != v)
{
- tie(tuples::ignore, success) = add_edge(u, v, j);
+ boost::tie(tuples::ignore, success) = add_edge(u, v, j);
if (success)
num_edges++;
}
@@ -316,7 +316,7 @@
}
//Now remove an edge from the random_mate matching.
- for(tie(vi,vi_end) = vertices(j); vi != vi_end; ++vi)
+ for(boost::tie(vi,vi_end) = vertices(j); vi != vi_end; ++vi)
if (random_mate[*vi] != graph_traits<Graph>::null_vertex())
break;
Modified: trunk/libs/graph/test/max_flow_test.cpp
==============================================================================
--- trunk/libs/graph/test/max_flow_test.cpp (original)
+++ trunk/libs/graph/test/max_flow_test.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -107,7 +107,7 @@
property_map < Graph, edge_capacity_t >::type cap = get(edge_capacity, g);
std::list<tEdge> edges_copy;
graph_traits<Graph>::edge_iterator ei, e_end;
- tie(ei, e_end) = edges(g);
+ boost::tie(ei, e_end) = edges(g);
std::copy(ei, e_end, std::back_insert_iterator< std::list<tEdge> >(edges_copy));
while( ! edges_copy.empty()){
tEdge old_edge=edges_copy.front();
@@ -116,7 +116,7 @@
tVertex target_vertex = source(old_edge, g);
bool inserted;
tEdge new_edge;
- tie(new_edge,inserted) = add_edge(source_vertex, target_vertex, g);
+ boost::tie(new_edge,inserted) = add_edge(source_vertex, target_vertex, g);
assert(inserted);
rev[old_edge] = new_edge;
rev[new_edge] = old_edge ;
Modified: trunk/libs/graph/test/metric_tsp_approx.cpp
==============================================================================
--- trunk/libs/graph/test/metric_tsp_approx.cpp (original)
+++ trunk/libs/graph/test/metric_tsp_approx.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -65,7 +65,7 @@
pow(static_cast<double>(points[vmap[*dest]].y -
points[vmap[*src]].y), 2.0)));
- tie(e, inserted) = add_edge(*src, *dest, g);
+ boost::tie(e, inserted) = add_edge(*src, *dest, g);
wmap[e] = weight;
}
@@ -152,7 +152,7 @@
//create vertex index map
VItr vi, ve;
int idx(0);
- for (tie(vi, ve) = vertices(g); vi != ve; ++vi)
+ for (boost::tie(vi, ve) = vertices(g); vi != ve; ++vi)
{
Vertex v(*vi);
v_pmap[v] = idx;
Modified: trunk/libs/graph/test/property_iter.cpp
==============================================================================
--- trunk/libs/graph/test/property_iter.cpp (original)
+++ trunk/libs/graph/test/property_iter.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -123,7 +123,7 @@
TLinkIterator itEdgeBegin, itEdgeEnd;
- tie(itEdgeBegin, itEdgeEnd) = get_property_iter_range(g, edge_id);
+ boost::tie(itEdgeBegin, itEdgeEnd) = get_property_iter_range(g, edge_id);
cout << "Edge iteration:" << endl;
for (; itEdgeBegin != itEdgeEnd; ++itEdgeBegin)
@@ -134,7 +134,7 @@
TNodeIterator itVertexBegin, itVertexEnd;
- tie(itVertexBegin, itVertexEnd) = get_property_iter_range(g, vertex_id);
+ boost::tie(itVertexBegin, itVertexEnd) = get_property_iter_range(g, vertex_id);
cout << "Vertex iteration:" << endl;
for (; itVertexBegin != itVertexEnd; ++itVertexBegin)
Modified: trunk/libs/graph/test/random_matching_test.cpp
==============================================================================
--- trunk/libs/graph/test/random_matching_test.cpp (original)
+++ trunk/libs/graph/test/random_matching_test.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -60,7 +60,7 @@
if (u != v)
{
if (!edge(u,v,g).second)
- tie(tuples::ignore, success) = add_edge(u, v, g);
+ boost::tie(tuples::ignore, success) = add_edge(u, v, g);
else
success = false;
@@ -79,13 +79,13 @@
std::cout << "Graph has edges: ";
typedef graph_traits<undirected_graph>::edge_iterator edge_iterator_t;
edge_iterator_t ei,ei_end;
- for(tie(ei,ei_end) = edges(g); ei != ei_end; ++ei)
+ for(boost::tie(ei,ei_end) = edges(g); ei != ei_end; ++ei)
std:: cout << *ei << ", ";
std::cout << std::endl;
std::cout << "Matching is: ";
vertex_iterator_t vi, vi_end;
- for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
+ for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
if (mate[*vi] != graph_traits<undirected_graph>::null_vertex() &&
*vi < mate[*vi])
std::cout << "{" << *vi << "," << mate[*vi] << "}, ";
@@ -94,7 +94,7 @@
//Now remove an edge from the random_mate matching.
vertex_iterator_t vi, vi_end;
- for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
+ for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
if (mate[*vi] != graph_traits<undirected_graph>::null_vertex())
break;
Modified: trunk/libs/graph/test/subgraph.cpp
==============================================================================
--- trunk/libs/graph/test/subgraph.cpp (original)
+++ trunk/libs/graph/test/subgraph.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -105,7 +105,7 @@
subgraph_t sub = g.create_subgraph(vertices(g).first, vertices(g).second);
graph_t::edge_iterator ei, ee;
- for (tie(ei, ee) = edges(sub); ei != ee; ++ei) {
+ for (boost::tie(ei, ee) = edges(sub); ei != ee; ++ei) {
// This used to segfault.
get(edge_weight, sub, *ei);
}
Modified: trunk/libs/graph/test/subgraph_bundled.cpp
==============================================================================
--- trunk/libs/graph/test/subgraph_bundled.cpp (original)
+++ trunk/libs/graph/test/subgraph_bundled.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -125,7 +125,7 @@
Subgraph sub = g.create_subgraph(vertices(g).first, vertices(g).second);
graph_traits<Graph>::edge_iterator ei, ee;
- for (tie(ei, ee) = edges(sub); ei != ee; ++ei) {
+ for (boost::tie(ei, ee) = edges(sub); ei != ee; ++ei) {
// This used to segfault.
get(edge_weight, sub, *ei);
}
Modified: trunk/libs/graph/test/transitive_closure_test.cpp
==============================================================================
--- trunk/libs/graph/test/transitive_closure_test.cpp (original)
+++ trunk/libs/graph/test/transitive_closure_test.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -42,7 +42,7 @@
{
typename graph_traits<Graph>::degree_size_type d = 0;
typename graph_traits<Graph>::out_edge_iterator i, i_end;
- for (tie(i, i_end) = out_edges(u, g); i != i_end; ++i)
+ for (boost::tie(i, i_end) = out_edges(u, g); i != i_end; ++i)
if (target(*i, g) == v)
++d;
return d;
@@ -57,13 +57,13 @@
bool check_transitive_closure(Graph& g, GraphTC& tc)
{
typename graph_traits<Graph>::vertex_iterator i, i_end;
- for (tie(i, i_end) = vertices(g); i != i_end; ++i) {
+ for (boost::tie(i, i_end) = vertices(g); i != i_end; ++i) {
typename graph_traits<Graph>::vertex_iterator j, j_end;
- for (tie(j, j_end) = vertices(g); j != j_end; ++j) {
+ for (boost::tie(j, j_end) = vertices(g); j != j_end; ++j) {
bool g_has_edge;
typename graph_traits<Graph>::edge_descriptor e_g;
typename graph_traits<Graph>::degree_size_type num_tc;
- tie (e_g, g_has_edge) = edge(*i, *j, g);
+ boost::tie (e_g, g_has_edge) = edge(*i, *j, g);
num_tc = num_incident(*i, *j, tc);
if (*i == *j) {
if (g_has_edge) {
@@ -72,7 +72,7 @@
} else {
bool can_reach = false;
typename graph_traits<Graph>::adjacency_iterator k, k_end;
- for (tie(k, k_end) = adjacent_vertices(*i, g); k != k_end; ++k) {
+ for (boost::tie(k, k_end) = adjacent_vertices(*i, g); k != k_end; ++k) {
std::vector<default_color_type> color_map_vec(num_vertices(g));
if (is_reachable(*k, *i, g, &color_map_vec[0])) {
can_reach = true;
Modified: trunk/libs/graph_parallel/test/adjlist_build_test.cpp
==============================================================================
--- trunk/libs/graph_parallel/test/adjlist_build_test.cpp (original)
+++ trunk/libs/graph_parallel/test/adjlist_build_test.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -127,8 +127,8 @@
// Check the in-degree and out-degree of each vertex
graph_traits<Graph>::vertex_iterator vfirst1, vlast1, vfirst2, vlast2;
- tie(vfirst1, vlast1) = vertices(g1);
- tie(vfirst2, vlast2) = vertices(g2);
+ boost::tie(vfirst1, vlast1) = vertices(g1);
+ boost::tie(vfirst2, vlast2) = vertices(g2);
for(; vfirst1 != vlast1 && vfirst2 != vlast2; ++vfirst1, ++vfirst2) {
if (out_degree(*vfirst1, g1) != out_degree(*vfirst2, g2)) {
std::cerr << g1.processor() << ": out-degree mismatch ("
@@ -216,8 +216,8 @@
}
// Check the in-degree and out-degree of each vertex
- tie(vfirst1, vlast1) = vertices(g1);
- tie(vfirst2, vlast2) = vertices(g3);
+ boost::tie(vfirst1, vlast1) = vertices(g1);
+ boost::tie(vfirst2, vlast2) = vertices(g3);
for(; vfirst1 != vlast1 && vfirst2 != vlast2; ++vfirst1, ++vfirst2) {
if (out_degree(*vfirst1, g1) != out_degree(*vfirst2, g3)) {
std::cerr << g1.processor() << ": out-degree mismatch ("
Modified: trunk/libs/graph_parallel/test/adjlist_redist_test.cpp
==============================================================================
--- trunk/libs/graph_parallel/test/adjlist_redist_test.cpp (original)
+++ trunk/libs/graph_parallel/test/adjlist_redist_test.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -149,7 +149,7 @@
// Randomly assign a new distribution
typename graph_traits<Graph>::vertex_iterator vi, vi_end;
- for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
+ for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
put(to_processor_map, *vi, gen() % num_processes(pg));
if (process_id(pg) == 0)
Modified: trunk/libs/graph_parallel/test/distributed_adjacency_list_test.cpp
==============================================================================
--- trunk/libs/graph_parallel/test/distributed_adjacency_list_test.cpp (original)
+++ trunk/libs/graph_parallel/test/distributed_adjacency_list_test.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -67,7 +67,7 @@
graph_traits<Graph1>::vertex_iterator v, v_end;
int counter = 0;
- for (tie(v, v_end) = vertices(g1); v != v_end; ++v) {
+ for (boost::tie(v, v_end) = vertices(g1); v != v_end; ++v) {
std::cout << "Processor #" << process_id(pg) << ": vertex " << ++counter
<< std::endl;
@@ -142,7 +142,7 @@
graph_traits<Graph2>::vertex_iterator v, v_end;
int counter = 0;
- for (tie(v, v_end) = vertices(g2); v != v_end; ++v) {
+ for (boost::tie(v, v_end) = vertices(g2); v != v_end; ++v) {
std::cout << "Processor #" << process_id(pg) << ": vertex " << ++counter
<< std::endl;
@@ -188,7 +188,7 @@
graph_traits<Graph3>::vertex_iterator v, v_end;
int counter = 0;
- for (tie(v, v_end) = vertices(g3); v != v_end; ++v) {
+ for (boost::tie(v, v_end) = vertices(g3); v != v_end; ++v) {
std::cout << "Processor #" << process_id(pg) << ": vertex " << ++counter
<< std::endl;
@@ -228,7 +228,7 @@
}
// Add some remote edges
- for (tie(v, v_end) = vertices(g3); v != v_end; ++v) {
+ for (boost::tie(v, v_end) = vertices(g3); v != v_end; ++v) {
graph_traits<Graph1>::vertex_descriptor other = *v;
other.owner = (other.owner + 1) % num_processes(pg);
other.local = 0;
Modified: trunk/libs/graph_parallel/test/distributed_betweenness_centrality_test.cpp
==============================================================================
--- trunk/libs/graph_parallel/test/distributed_betweenness_centrality_test.cpp (original)
+++ trunk/libs/graph_parallel/test/distributed_betweenness_centrality_test.cpp 2010-06-22 14:02:43 EDT (Tue, 22 Jun 2010)
@@ -248,7 +248,7 @@
typedef graph_traits<Graph>::vertex_iterator vertex_iterator;
vertex_iterator v, v_end;
- for (tie(v, v_end) = vertices(g); v != v_end; ++v) {
+ for (boost::tie(v, v_end) = vertices(g); v != v_end; ++v) {
if (get(centrality, *v) != seqCentralityS[(n/p) * get(owner, *v) + get(local, *v)]) {
std::cerr << " " << id << ": Error - centrality of " << get(local, *v) << "@" << get(owner, *v)
<< " does not match the sequential result (" << get(centrality, *v) << " vs. "
@@ -269,7 +269,7 @@
typedef graph_traits<seqGraph>::vertex_iterator vertex_iterator;
vertex_iterator v, v_end;
- for (tie(v, v_end) = vertices(sg); v != v_end; ++v) {
+ for (boost::tie(v, v_end) = vertices(sg); v != v_end; ++v) {
if (get(seqCentrality, *v) != get(nonDistributedCentrality, *v)) {
std::cerr << " " << id << ": Error - non-distributed centrality of " << *v
<< " does not match the sequential result (" << get(nonDistributedCentrality, *v)
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk