Ticket #6112: graph.patch

File graph.patch, 17.3 KB (added by Richard Webb <richard.webb@…>, 11 years ago)

patch to qualify calls to tie

  • boost/graph/chrobak_payne_drawing.hpp

     
    240240      (*ordering_begin,0,g,x,delta_x,left,right);
    241241
    242242    vertex_iterator_t vi, vi_end;
    243     for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
     243    for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
    244244      {
    245245        vertex_t v(*vi);
    246246        drawing[v].x = x[v];

  • boost/graph/closeness_centrality.hpp

     
    126126    typedef typename property_traits<CentralityMap>::value_type Centrality;
    127127
    128128    typename graph_traits<Graph>::vertex_iterator i, end;
    129     for(tie(i, end) = vertices(g); i != end; ++i) {
     129    for(boost::tie(i, end) = vertices(g); i != end; ++i) {
    130130        DistanceMap dm = get(dist, *i);
    131131        Centrality c = closeness_centrality(g, dm, measure);
    132132        put(cent, *i, c);

  • boost/graph/degree_centrality.hpp

     
    101101    typedef typename property_traits<CentralityMap>::value_type Centrality;
    102102
    103103    VertexIterator i, end;
    104     for(tie(i, end) = vertices(g); i != end; ++i) {
     104    for(boost::tie(i, end) = vertices(g); i != end; ++i) {
    105105        Centrality c = degree_centrality(g, *i, measure);
    106106        put(cent, *i, c);
    107107    }

  • boost/graph/detail/geodesic.hpp

     
    6565        // zero, so it shouldn't be too problematic.
    6666        Distance ret = init;
    6767        VertexIterator i, end;
    68         for(tie(i, end) = vertices(g); i != end; ++i) {
     68        for(boost::tie(i, end) = vertices(g); i != end; ++i) {
    6969            Vertex v = *i;
    7070            if(get(dist, v) != DistanceNumbers::infinity()) {
    7171                ret = combine(ret, get(dist, v));

  • boost/graph/geodesic_distance.hpp

     
    156156    Result inf = numeric_values<Result>::infinity();
    157157    Result sum = numeric_values<Result>::zero();
    158158    VertexIterator i, end;
    159     for(tie(i, end) = vertices(g); i != end; ++i) {
     159    for(boost::tie(i, end) = vertices(g); i != end; ++i) {
    160160        DistanceMap dm = get(dist, *i);
    161161        Result r = mean_geodesic(g, dm, measure);
    162162        put(geo, *i, r);

  • boost/graph/is_kuratowski_subgraph.hpp

     
    3333    {
    3434      typename graph_traits<Graph>::vertex_iterator vi, vi_end, inner_vi;
    3535      Graph K_5(5);
    36       for(tie(vi,vi_end) = vertices(K_5); vi != vi_end; ++vi)
     36      for(boost::tie(vi,vi_end) = vertices(K_5); vi != vi_end; ++vi)
    3737        for(inner_vi = next(vi); inner_vi != vi_end; ++inner_vi)
    3838          add_edge(*vi, *inner_vi, K_5);
    3939      return K_5;
    … …  
    4747        vi, vi_end, bipartition_start, inner_vi;
    4848      Graph K_3_3(6);
    4949      bipartition_start = next(next(next(vertices(K_3_3).first)));
    50       for(tie(vi, vi_end) = vertices(K_3_3); vi != bipartition_start; ++vi)
     50      for(boost::tie(vi, vi_end) = vertices(K_3_3); vi != bipartition_start; ++vi)
    5151        for(inner_vi= bipartition_start; inner_vi != vi_end; ++inner_vi)
    5252          add_edge(*vi, *inner_vi, K_3_3);
    5353      return K_3_3;
    … …  
    158158      {
    159159
    160160        vertex_iterator_t vi, vi_end;
    161         for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
     161        for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
    162162          {
    163163            vertex_t v(*vi);
    164164
    … …  
    242242        if (max_size == 3)
    243243          {
    244244            // check to see whether we should go on to find a K_5
    245             for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
     245            for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
    246246              if (neighbors[*vi].size() == 4)
    247247                {
    248248                  target_graph = detail::tg_k_5;
    … …  
    261261    v_list_t main_vertices;
    262262    vertex_iterator_t vi, vi_end;
    263263   
    264     for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
     264    for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
    265265      {
    266266        if (!neighbors[*vi].empty())
    267267          main_vertices.push_back(*vi);

  • boost/graph/is_straight_line_drawing.hpp

     
    126126    active_map_t active_edges;
    127127
    128128    edge_iterator_t ei, ei_end;
    129     for(tie(ei,ei_end) = edges(g); ei != ei_end; ++ei)
     129    for(boost::tie(ei,ei_end) = edges(g); ei != ei_end; ++ei)
    130130      {
    131131        edge_t e(*ei);
    132132        vertex_t s(source(e,g));

  • boost/graph/make_maximal_planar.hpp

     
    6262      degree(degree_vector.begin(), vm)
    6363    {
    6464      vertex_iterator_t vi, vi_end;
    65       for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
     65      for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
    6666        put(degree, *vi, out_degree(*vi, g));
    6767    }
    6868
    … …  
    117117
    118118      // Mark all of the min degree vertex's neighbors
    119119      adjacency_iterator_t ai, ai_end;
    120       for(tie(ai,ai_end) = adjacent_vertices(vertices_on_face.front(),g);
     120      for(boost::tie(ai,ai_end) = adjacent_vertices(vertices_on_face.front(),g);
    121121          ai != ai_end; ++ai
    122122          )
    123123        {

  • boost/graph/planar_canonical_ordering.hpp

     
    6767    vertex_t first_vertex = *vertices(g).first;
    6868    vertex_t second_vertex;
    6969    adjacency_iterator_t ai, ai_end;
    70     for(tie(ai,ai_end) = adjacent_vertices(first_vertex,g); ai != ai_end; ++ai)
     70    for(boost::tie(ai,ai_end) = adjacent_vertices(first_vertex,g); ai != ai_end; ++ai)
    7171      {
    7272        if (*ai == first_vertex)
    7373          continue;

  • boost/graph/planar_face_traversal.hpp

     
    9898    // PlanarEmbedding so that get(next_edge, e)[v] is the edge that comes
    9999    // after e in the clockwise embedding around vertex v.
    100100
    101     for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
     101    for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
    102102      {
    103103        vertex_t v(*vi);
    104104        pi_begin = embedding[v].begin();
    … …  
    122122    std::vector<edge_t> edges_cache;
    123123    std::vector<vertex_t> vertices_in_edge;
    124124
    125     for(tie(fi,fi_end) = edges(g); fi != fi_end; ++fi)
     125    for(boost::tie(fi,fi_end) = edges(g); fi != fi_end; ++fi)
    126126      {
    127127        edge_t e(*fi);
    128128        edges_cache.push_back(e);

  • boost/graph/tiernan_all_cycles.hpp

     
    193193            u = p.back(),
    194194            v = p.front();
    195195        OutIterator i, end;
    196         for(tie(i, end) = out_edges(u, g); i != end; ++i) {
     196        for(boost::tie(i, end) = out_edges(u, g); i != end; ++i) {
    197197            if((target(*i, g) == v)) {
    198198                return true;
    199199            }
    … …  
    220220
    221221        // AdjacencyIterator i, end;
    222222        OutIterator i, end;
    223         for(tie(i, end) = out_edges(u, g); i != end; ++i) {
     223        for(boost::tie(i, end) = out_edges(u, g); i != end; ++i) {
    224224            Vertex v = target(*i, g);
    225225
    226226            // if we can actually extend along this edge,
    … …  
    324324    typedef typename graph_traits<Graph>::vertex_iterator VertexIterator;
    325325
    326326    VertexIterator i, end;
    327     for(tie(i, end) = vertices(g); i != end; ++i) {
     327    for(boost::tie(i, end) = vertices(g); i != end; ++i) {
    328328        detail::all_cycles_from_vertex(g, *i, vis, minlen, maxlen);
    329329    }
    330330}

  • boost/graph/write_dimacs.hpp

     
    6464 
    6565  //output the edges
    6666  edge_iterator ei, e_end;
    67   for(tie(ei,e_end) = edges(g); ei!=e_end; ++ei){
     67  for(boost::tie(ei,e_end) = edges(g); ei!=e_end; ++ei){
    6868    out << "a " << idx[ source(*ei, g) ] + 1 << " " << idx[ target(*ei, g) ] + 1 << " " << get(capacity,*ei) << std::endl;
    6969  }
    7070}

  • libs/graph/test/all_planar_input_files_test.cpp

     
    137137  // Initialize the interior edge index
    138138  property_map<graph, edge_index_t>::type e_index = get(edge_index, g);
    139139  e_size_t edge_count = 0;
    140   for(tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
     140  for(boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
    141141    put(e_index, *ei, edge_count++);
    142142
    143143  // Initialize the interior vertex index - not needed if the vertices

  • libs/graph/test/basic_planarity_test.cpp

     
    2525    typename property_map<Graph, vertex_index_t>::type index = get(vertex_index, g);
    2626    typename graph_traits<Graph>::vertex_iterator vi, vi_end;
    2727    typename graph_traits<Graph>::vertices_size_type cnt = 0;
    28     for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
     28    for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
    2929      put(index, *vi, cnt++);
    3030  }
    3131};

  • libs/graph/test/bellman-test.cpp

     
    4242    weight_pmap = get(edge_weight, g);
    4343
    4444  int i = 0;
    45   for(tie(ei, ei_end) = edges(g); ei != ei_end; ++ei, ++i)
     45  for(boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei, ++i)
    4646    weight_pmap[*ei] = weight[i];
    4747
    4848  std::vector<int> parent(numVertex);

  • libs/graph/test/labeled_graph.cpp

     
    6262    typedef typename graph_traits<Graph>::vertex_iterator Iter;
    6363    Iter f, l;
    6464    int x = 0;
    65     for(tie(f, l) = vertices(g); f != l; ++f, ++x) {
     65    for(boost::tie(f, l) = vertices(g); f != l; ++f, ++x) {
    6666        label_vertex(*f, x, g);
    6767    }
    6868}

  • libs/graph/test/make_bicon_planar_test.cpp

     
    2525  typename property_map<Graph, edge_index_t>::type index = get(edge_index, g);
    2626  typename graph_traits<Graph>::edge_iterator ei, ei_end;
    2727  typename graph_traits<Graph>::edges_size_type cnt = 0;
    28   for(tie(ei,ei_end) = edges(g); ei != ei_end; ++ei)
     28  for(boost::tie(ei,ei_end) = edges(g); ei != ei_end; ++ei)
    2929    put(index, *ei, cnt++);
    3030}
    3131
    … …  
    5454    typename property_map<Graph, vertex_index_t>::type index = get(vertex_index, g);
    5555    typename graph_traits<Graph>::vertex_iterator vi, vi_end;
    5656    typename graph_traits<Graph>::vertices_size_type cnt = 0;
    57     for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
     57    for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
    5858      put(index, *vi, cnt++);
    5959  }
    6060};
    … …  
    8787  embedding_t embedding(embedding_storage.begin(), get(vertex_index, g));
    8888
    8989  typename graph_traits<Graph>::vertex_iterator vi, vi_end;
    90   for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
     90  for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
    9191    std::copy(out_edges(*vi,g).first, out_edges(*vi,g).second, std::back_inserter(embedding[*vi]));
    9292
    9393  BOOST_CHECK(biconnected_components(g, make_vector_property_map<int>(get(edge_index,g))) > 1);

  • libs/graph/test/make_connected_test.cpp

     
    2424  typename property_map<Graph, edge_index_t>::type index = get(edge_index, g);
    2525  typename graph_traits<Graph>::edge_iterator ei, ei_end;
    2626  typename graph_traits<Graph>::edges_size_type cnt = 0;
    27   for(tie(ei,ei_end) = edges(g); ei != ei_end; ++ei)
     27  for(boost::tie(ei,ei_end) = edges(g); ei != ei_end; ++ei)
    2828    put(index, *ei, cnt++);
    2929}
    3030
    … …  
    3636  typename property_map<Graph, vertex_index_t>::type index = get(vertex_index, g);
    3737  typename graph_traits<Graph>::vertex_iterator vi, vi_end;
    3838  typename graph_traits<Graph>::vertices_size_type cnt = 0;
    39   for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
     39  for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
    4040    put(index, *vi, cnt++);
    4141}
    4242

  • libs/graph/test/make_maximal_planar_test.cpp

     
    2424  typename property_map<Graph, edge_index_t>::type index = get(edge_index, g);
    2525  typename graph_traits<Graph>::edge_iterator ei, ei_end;
    2626  typename graph_traits<Graph>::edges_size_type cnt = 0;
    27   for(tie(ei,ei_end) = edges(g); ei != ei_end; ++ei)
     27  for(boost::tie(ei,ei_end) = edges(g); ei != ei_end; ++ei)
    2828    put(index, *ei, cnt++);
    2929}
    3030
    … …  
    5656    typename property_map<Graph, vertex_index_t>::type index = get(vertex_index, g);
    5757    typename graph_traits<Graph>::vertex_iterator vi, vi_end;
    5858    typename graph_traits<Graph>::vertices_size_type cnt = 0;
    59     for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
     59    for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
    6060      put(index, *vi, cnt++);
    6161  }
    6262};
    … …  
    8989  embedding_t embedding(embedding_storage.begin(), get(vertex_index, g));
    9090
    9191  typename graph_traits<Graph>::vertex_iterator vi, vi_end;
    92   for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
     92  for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
    9393    std::copy(out_edges(*vi,g).first, out_edges(*vi,g).second, std::back_inserter(embedding[*vi]));
    9494
    9595  BOOST_CHECK(boyer_myrvold_planarity_test(g));

  • libs/graph/test/parallel_edges_loops_test.cpp

     
    111111          vertex_iterator_t vi, vi_end;
    112112          long count = 0;
    113113          long mult_count = 0;
    114           for(tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
     114          for(boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
    115115            {
    116116              if (count % vertex_stride == 0)
    117117                {
    … …  
    210210  // Initialize the interior edge index
    211211  property_map<graph, edge_index_t>::type e_index = get(edge_index, g);
    212212  e_size_t edge_count = 0;
    213   for(tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
     213  for(boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
    214214    put(e_index, *ei, edge_count++);
    215215
    216216  // Initialize the interior vertex index - not needed if the vertices

  • libs/graph/test/test_construction.hpp

     
    9393
    9494    std::cout << "...connect_normal\n";
    9595    Pair *f, *l;
    96     for(tie(f, l) = edge_pairs(); f != l; ++f) {
     96    for(boost::tie(f, l) = edge_pairs(); f != l; ++f) {
    9797        Pair const& e = *f;
    9898        add_edge(verts[e.first], verts[e.second], g);
    9999    }

  • libs/graph/test/transitive_closure_test2.cpp

     
    2929       << endl;
    3030  cout << "transitive closure: ";
    3131  graph_t::edge_iterator i,iend;
    32   for(tie(i,iend) = edges(g_TC);i!=iend;++i) {
     32  for(boost::tie(i,iend) = edges(g_TC);i!=iend;++i) {
    3333    cout << source(*i,g_TC) << "->" << target(*i,g_TC) << " ";
    3434  }
    3535  cout << endl;