Enhancement proposal: verices() and edges() returning boost::iterator_range

[mkatliar]

Currently the vertices() and edges() functions in BGL return an std::pair of iterators. To iterate over vertices, a code like following is usually written:

typename graph_traits<Graph>::vertices_size_type b = 0;
typename graph_traits<Graph>::vertex_iterator i, end;
for (boost::tie(i, end) = vertices(g); i != end; ++i)
    do_something(*i);

If vertices() and edges() returned a boost::iterator_range, a cleaner code could be written:

for (auto v : vertices(g))
    do_something(v);

[anadon]

It would be a massive improvement, but would also require a fair bit of work since the old way is used all over graph. I'm working on a replacement that addresses that off of a from scratch code base which will do this. It has been on my radar.

[mkatliar]

@anadon I could work on that change if it is approved and will be integrated in the library.

[anadon]

If you don't break the macros and existing code, I'll buy you a drink. It would be a welcomed improvement.

[mkatliar]

@anadon my concern is that it will break user's code relying on the old semantics. To keep it compatible, we probably need new names for these functions.

Or, those functions should return an object which has both old std::pair and the new boost::iterator_range semantics. Then the existing code relying on the old semantics can remain unchanged.

What do you think?

[anadon]

There are a few macros which would have to be preserved as well. One of the reasons why it is a big task.

[jeremy-murphy]

std::pair of iterators satisfies the Boost Range concept: https://www.boost.org/doc/libs/master/libs/range/doc/html/range/introduction.html

So whilst it is true that you cannot use it in a C++11 range-for loop, you can use it with any Boost.Range algorithm.
E.g.:

#include <boost/range.hpp>
#include <boost/range/for_each.hpp>

// ...

boost::for_each(vertices(g), do_something);

Also, adapting std::pair to a standard readable range is not as difficult as you think, you can just wrap it in a call to boost::make_iterator_range like so:

for (auto const &vertex : boost::make_iterator_range(vertices(g)))
  do_something(vertex);

I agree that it would be nice if the result of vertices(g) were a standard readable range... but in my opinion it's a fairly low priority given what I have demonstrated above.

[mkatliar]

I discovered that there are some issues with using boost::iterator_range in combination with boost::counting_iterator: boostorg/range#82, boostorg/range#83. boost::counting_iterator is used as an implementation for some iterators in BGL.