Divide range by range of overlapping ranges

Question

I am trying to use the Ranges-V3 library to slice a container of values ​​into a range of ranges, so that neighboring ranges share boundary elements.

Consider the following:

using namespace ranges; std::vector<int> v = { 1, 2, 3, 0, 4, 0, 5, 0, 6, 7, 8, 0, 0, 9 }; auto myRanges = v | /* something like adjacent split */ for_each( myRanges, []( auto&& range ){ std::cout << range << std::endl;} ); 

I would like to divide the range into overlapping subranges based on whether the region fills two criteria:

• does the element have a value of zero
• or adjacent to one or more elements with a value of zero

Required Conclusion:

 [1,2,3] [3,0,4,0,5,0,6] [6,7,8] [8,0,0,9] 

my attempt:

 auto degenerate = []( auto&& arg ){ return distance( arg ) < 2; }; auto myRanges = v | view::split(0) | view::remove_if( degenerate ); for_each( myRanges, []( auto&& range ){ std::cout << range << std::endl;} ); 

Output:

 [1,2,3] [6,7,8] 

I do not understand how I can

• insert range from 3 to 6
• add range from 8 to 9

Answer 1

If I understand your requirements correctly, you can implement the generator in terms of adjacent_find :

 template<typename IterT> struct seg_generator_ { IterT it_, end_; bool fz_ = true; ranges::iterator_range<IterT> operator ()() { if (it_ == end_) { return {it_, end_}; } auto n = ranges::adjacent_find( it_, end_, [fz = std::exchange(fz_, !fz_)](auto const a, auto const b) { return a && !b == fz; } ); return { std::exchange(it_, n), n != end_ ? ranges::next(std::move(n)) : std::move(n) }; } }; template<typename RngT> auto seg_generator(RngT&& rng) -> seg_generator_<decltype(ranges::begin(rng))> { return {ranges::begin(rng), ranges::end(rng)}; } int main() { std::vector<int> const v{1, 2, 3, 0, 4, 0, 5, 0, 6, 7, 8, 0, 0, 9}; auto myRanges = ranges::view::generate(seg_generator(v)) | ranges::view::take_while([](auto const& r) { return !r.empty(); }); ranges::copy(myRanges, ranges::ostream_iterator<>{std::cout, "\n"}); } 

Online demo

_{Not quite as one would hope ...: - [}