boost::transform_iterator and std::iter_swap

Question

I am trying to generalize a function I have which used to take two iterators to a vector of a specific data-structure, and re-arrange the elements in a certain way using std::iter_swap (like std::sort does).

Since this function only actually needs a subset of the data, and I will need to use it in other contexts in the future, I thought about removing the dependency on the data structure, and use boost::transform_iterator at the point of call to handle the transformation.

Unfortunately, it seems that boost::transform_iterator is not happy with this change. I can imagine why: std::iter_swap is usually implemented as std::swap(*lhs, *rhs), and dereferencing the transform_iterator does not yield the original element to swap in the correct way.

I was wondering if there was a way to handle this case. I am open to use boost::range or the experimental std::ranges ts if it needed.

This question is probably similar to this one, but even there the solution ends up modifying the subset of data the algorithm needs, rather than the outside structure.

Here is an MWE:

#include <boost/iterator/transform_iterator.hpp>
#include <vector>
#include <algorithm>
#include <iostream>

struct A {
    int x;
    int y;
};

template <typename It>
void my_invert(It begin, It end) {
    while (begin < end) {
        std::iter_swap(begin++, --end);
    }
}

template <typename It>
void my_print(It begin, It end) {
    for (; begin != end; ++begin)
        std::cout << (*begin) << ' ';
    std::cout << '\n';
}

int main() {
    std::vector<int> x{7,6,5,4,3,2};

    my_invert(std::begin(x), std::end(x));
    my_print(std::begin(x), std::end(x));

    auto unwrap = +[](const A & a) { return a.x; };

    std::vector<A> y{{9,8}, {7,6}, {5,4}, {3,2}};

    auto begin = boost::make_transform_iterator(std::begin(y), unwrap);
    auto end = boost::make_transform_iterator(std::end(y), unwrap);

    //my_invert(begin, end); // Does not work.
    my_print(begin, end);

    return 0;
}

Answer 1

Accessing the underlying iterator

You could access the base() property of transform_iterator (inherited publicly from iterator_adaptor) to implement your custom transform_iter_swap, for swapping the underlying data of the wrapped iterator.

E.g.:

template<class IteratorAdaptor>
void transform_iter_swap(IteratorAdaptor a, IteratorAdaptor b)
{
   std::swap(*a.base(), *b.base());
}

template <typename It>
void my_invert(It begin, It end) {
    while (begin < end) {
        transform_iter_swap(begin++, --end);
    }
}

After which your example (omitting the std::vector part) runs as expected:

my_invert(begin, end); // OK
my_print(begin, end);  // 3 5 7 9

If you want a general function template to cover both the boost (adaptor) iterators as well as typical iterators, you could e.g. use if constexpr (C++17) based on whether the iterators public typedef iterator_category derives from boost::iterators::no_traversal_tag or not:

// expand includes with
#include <boost/iterator/iterator_categories.hpp>

template <class It>
void iter_swap(It a, It b) {
  if constexpr(std::is_base_of<
        boost::iterators::no_traversal_tag,
        typename It::iterator_category>::value) {
      std::swap(*a.base(), *b.base());
    }
  else {
    std::swap(*a, *b);
  }
}

template <typename It>
void my_invert(It begin, It end) {
    while (begin < end) {
        iter_swap(begin++, --end);
    }
}

Answer 2

The problem comes from the unary predicate you've passed. Notice, that since you allow the return type to be deduced, the return type is deduced to be an int, a copy is returned, and the compilation fails when you try to swap two unmodifiable ints. However, if you were to specify the return type to be int&, like so:

 auto unwrap = [](A & a)->int& { return a.x; }; // explicitly demand to return ref

It will compile, and reverse the elements. Tested on gcc 8.1.0 and clang 6.0.0.