refactor: replace Boost.Iterator with Boost.STLInterfaces

.ci/get-boost.sh

@@ -45,6 +45,7 @@ git submodule --quiet update --init $GIT_SUBMODULE_OPTS \
  libs/mp11 \
  libs/mpl \
  libs/preprocessor \
+ libs/stl_interfaces \
  libs/type_traits \
  libs/variant2
 # Transitive (of GIL tests too)

.github/workflows/coverage.yml

@@ -21,7 +21,7 @@ jobs:
  - name: install packages
  run: |
  sudo apt update
- sudo apt install g++ libpng-dev libjpeg-dev libtiff5-dev libraw-dev lcov python -y
+ sudo apt install g++ libpng-dev libjpeg-dev libtiff5-dev libraw-dev lcov python-is-python3 -y
 
  - name: Setup Boost
  run: |

example/interleaved_ptr.hpp

@@ -14,6 +14,8 @@
 
 #include <type_traits>
 
+#include <boost/stl_interfaces/iterator_interface.hpp>
+
 #include "interleaved_ref.hpp"
 
 // Example on how to create a pixel iterator
@@ -34,25 +36,25 @@ namespace boost { namespace gil {
 
 template <typename ChannelPtr, // Models Channel Iterator (examples: unsigned char* or const unsigned char*)
  typename Layout> // A layout (includes the color space and channel ordering)
-struct interleaved_ptr : boost::iterator_facade
+struct interleaved_ptr : stl_interfaces::iterator_interface
  <
+#if !BOOST_STL_INTERFACES_USE_DEDUCED_THIS
  interleaved_ptr<ChannelPtr, Layout>,
- pixel<typename std::iterator_traits<ChannelPtr>::value_type, Layout>,
- boost::random_access_traversal_tag,
+#endif
+ std::random_access_iterator_tag,
+ pixel<typename std::iterator_traits<ChannelPtr>::value_type, Layout>, 
  interleaved_ref<typename std::iterator_traits<ChannelPtr>::reference, Layout> const
  >
 {
 private:
- using parent_t = boost::iterator_facade
+ using parent_t = stl_interfaces::iterator_interface
  <
+#if !BOOST_STL_INTERFACES_USE_DEDUCED_THIS
  interleaved_ptr<ChannelPtr, Layout>,
+#endif
+ std::random_access_iterator_tag,
  pixel<typename std::iterator_traits<ChannelPtr>::value_type, Layout>,
- boost::random_access_traversal_tag,
- interleaved_ref
- <
- typename std::iterator_traits<ChannelPtr>::reference,
- Layout
- > const
+ interleaved_ref<typename std::iterator_traits<ChannelPtr>::reference, Layout> const
  >;
 
  using channel_t = typename std::iterator_traits<ChannelPtr>::value_type;
@@ -61,6 +63,9 @@ struct interleaved_ptr : boost::iterator_facade
  using reference = typename parent_t::reference;
  using difference_type = typename parent_t::difference_type;
 
+ using parent_t::operator++;
+ using parent_t::operator--;
+
  interleaved_ptr() {}
  interleaved_ptr(const interleaved_ptr& ptr) : _channels(ptr._channels) {}
  template <typename CP> interleaved_ptr(const interleaved_ptr<CP,Layout>& ptr) : _channels(ptr._channels) {}
@@ -71,24 +76,29 @@ struct interleaved_ptr : boost::iterator_facade
  interleaved_ptr(reference* pix) : _channels(&((*pix)[0])) {}
  interleaved_ptr& operator=(reference* pix) { _channels=&((*pix)[0]); return *this; }
 
- /// For some reason operator[] provided by boost::iterator_facade returns a custom class that is convertible to reference
- /// We require our own reference because it is registered in iterator_traits
- reference operator[](difference_type d) const { return memunit_advanced_ref(*this,d*sizeof(channel_t));}
-
- // Put this for every iterator whose reference is a proxy type
- reference operator->() const { return **this; }
-
  // Channels accessor (not required by any concept)
  const ChannelPtr& channels() const { return _channels; }
  ChannelPtr& channels() { return _channels; }
 
  // Not required by concepts but useful
  static const std::size_t num_channels = mp11::mp_size<typename Layout::color_space_t>::value;
+
+ constexpr auto operator*() const noexcept { return dereference(); }
+
+ constexpr auto operator+=(difference_type d) -> interleaved_ptr& { advance(d); return *this; }
+
+ constexpr auto operator++() noexcept -> interleaved_ptr& { increment(); return *this; }
+ constexpr auto operator--() noexcept -> interleaved_ptr& { decrement(); return *this; }
+
+ constexpr auto operator-(interleaved_ptr other) const noexcept { return -distance_to(other); }
+
+ constexpr bool operator==(interleaved_ptr other) const noexcept { return equal(other); }
+
 private:
  ChannelPtr _channels;
- friend class boost::iterator_core_access;
  template <typename CP, typename L> friend struct interleaved_ptr;
 
+ friend struct boost::stl_interfaces::access;
  void increment() { _channels+=num_channels; }
  void decrement() { _channels-=num_channels; }
  void advance(std::ptrdiff_t d) { _channels+=num_channels*d; }

include/boost/gil/algorithm.hpp

@@ -189,7 +189,11 @@ namespace detail {
 /// \ingroup CopyPixels
 template <typename I, typename O>
 struct copier_n {
- BOOST_FORCEINLINE void operator()(I src, typename std::iterator_traits<I>::difference_type n, O dst) const { std::copy(src,src+n, dst); }
+ BOOST_FORCEINLINE void operator()(I src, typename std::iterator_traits<I>::difference_type n, O dst) const {
+ if (n < 0)
+ return;
+ std::copy(src, src + n, dst);
+ }
 };
 
 /// Source range is delimited by image iterators

include/boost/gil/bit_aligned_pixel_iterator.hpp

@@ -12,7 +12,7 @@
 #include <boost/gil/pixel_iterator.hpp>
 
 #include <boost/config.hpp>
-#include <boost/iterator/iterator_facade.hpp>
+#include <boost/stl_interfaces/iterator_interface.hpp>
 
 #include <functional>
 #include <type_traits>
@@ -34,20 +34,31 @@ namespace boost { namespace gil {
 /// \ingroup PixelIteratorNonAlignedPixelIterator PixelBasedModel
 
 template <typename NonAlignedPixelReference>
-struct bit_aligned_pixel_iterator : public iterator_facade<bit_aligned_pixel_iterator<NonAlignedPixelReference>,
- typename NonAlignedPixelReference::value_type,
- std::random_access_iterator_tag,
- const NonAlignedPixelReference,
- typename NonAlignedPixelReference::bit_range_t::difference_type> {
+class bit_aligned_pixel_iterator : public stl_interfaces::iterator_interface<
+#if !BOOST_STL_INTERFACES_USE_DEDUCED_THIS
+ bit_aligned_pixel_iterator<NonAlignedPixelReference>,
+#endif
+ std::random_access_iterator_tag,
+ typename NonAlignedPixelReference::value_type,
+ const NonAlignedPixelReference,
+ typename NonAlignedPixelReference::value_type*,
+ typename NonAlignedPixelReference::bit_range_t::difference_type>
+{
 private:
- using parent_t = iterator_facade<bit_aligned_pixel_iterator<NonAlignedPixelReference>,
- typename NonAlignedPixelReference::value_type,
- std::random_access_iterator_tag,
- const NonAlignedPixelReference,
- typename NonAlignedPixelReference::bit_range_t::difference_type>;
- template <typename Ref> friend struct bit_aligned_pixel_iterator;
+ using parent_t = stl_interfaces::iterator_interface<
+#if !BOOST_STL_INTERFACES_USE_DEDUCED_THIS
+ bit_aligned_pixel_iterator<NonAlignedPixelReference>,
+#endif
+ std::random_access_iterator_tag,
+ typename NonAlignedPixelReference::value_type,
+ const NonAlignedPixelReference,
+ typename NonAlignedPixelReference::value_type*,
+ typename NonAlignedPixelReference::bit_range_t::difference_type>;
+
+ template <typename Ref> friend class bit_aligned_pixel_iterator;
 
  using bit_range_t = typename NonAlignedPixelReference::bit_range_t;
+
 public:
  using difference_type = typename parent_t::difference_type;
  using reference = typename parent_t::reference;
@@ -61,21 +72,20 @@ struct bit_aligned_pixel_iterator : public iterator_facade<bit_aligned_pixel_ite
  bit_aligned_pixel_iterator(reference* ref) : _bit_range(ref->bit_range()) {}
  explicit bit_aligned_pixel_iterator(typename bit_range_t::byte_t* data, int bit_offset=0) : _bit_range(data,bit_offset) {}
 
- /// For some reason operator[] provided by iterator_adaptor returns a custom class that is convertible to reference
- /// We require our own reference because it is registered in iterator_traits
- auto operator[](difference_type d) const -> reference { bit_aligned_pixel_iterator it=*this; it.advance(d); return *it; }
+ constexpr auto operator*() const noexcept -> reference { return dereference(); }
+
+ constexpr auto operator+=(difference_type i) noexcept -> bit_aligned_pixel_iterator& { advance(i); return *this; }
+
+ constexpr auto operator-(bit_aligned_pixel_iterator other) const noexcept { return -distance_to(other); }
 
- auto operator->() const -> reference { return **this; }
  auto bit_range() const -> bit_range_t const& { return _bit_range; }
- auto bit_range() -> bit_range_t& { return _bit_range; }
+ auto bit_range() -> bit_range_t& { return _bit_range; }
+
 private:
  bit_range_t _bit_range;
  static constexpr int bit_size = NonAlignedPixelReference::bit_size;
 
- friend class boost::iterator_core_access;
  auto dereference() const -> reference { return NonAlignedPixelReference(_bit_range); }
- void increment() { ++_bit_range; }
- void decrement() { --_bit_range; }
  void advance(difference_type d) { _bit_range.bit_advance(d*bit_size); }
 
  auto distance_to(bit_aligned_pixel_iterator const& it) const -> difference_type { return _bit_range.bit_distance_to(it._bit_range) / bit_size; }

include/boost/gil/concepts/image_view.hpp

@@ -120,13 +120,13 @@ struct RandomAccessNDImageViewConcept
  static const std::size_t N=View::num_dimensions;
 
  gil_function_requires<RandomAccessNDLocatorConcept<locator>>();
- gil_function_requires<boost_concepts::RandomAccessTraversalConcept<iterator>>();
- gil_function_requires<boost_concepts::RandomAccessTraversalConcept<reverse_iterator>>();
+ gil_function_requires<RandomAccessIterator<iterator>>();
+ gil_function_requires<RandomAccessIterator<reverse_iterator>>();
 
  using first_it_type = typename View::template axis<0>::iterator;
  using last_it_type = typename View::template axis<N-1>::iterator;
- gil_function_requires<boost_concepts::RandomAccessTraversalConcept<first_it_type>>();
- gil_function_requires<boost_concepts::RandomAccessTraversalConcept<last_it_type>>();
+ gil_function_requires<RandomAccessIterator<first_it_type>>();
+ gil_function_requires<RandomAccessIterator<last_it_type>>();
 
 // static_assert(typename std::iterator_traits<first_it_type>::difference_type, typename point_t::template axis<0>::coord_t>::value, "");
 // static_assert(typename std::iterator_traits<last_it_type>::difference_type, typename point_t::template axis<N-1>::coord_t>::value, "");
@@ -399,19 +399,19 @@ struct RandomAccessNDImageViewIsMutableConcept
  {
  gil_function_requires<detail::RandomAccessNDLocatorIsMutableConcept<typename View::locator>>();
 
- gil_function_requires<detail::RandomAccessIteratorIsMutableConcept<typename View::iterator>>();
+ gil_function_requires<Mutable_RandomAccessIterator<typename View::iterator>>();
 
- gil_function_requires<detail::RandomAccessIteratorIsMutableConcept
+ gil_function_requires<Mutable_RandomAccessIterator
  <
  typename View::reverse_iterator
  >>();
 
- gil_function_requires<detail::RandomAccessIteratorIsMutableConcept
+ gil_function_requires<Mutable_RandomAccessIterator
  <
  typename View::template axis<0>::iterator
  >>();
 
- gil_function_requires<detail::RandomAccessIteratorIsMutableConcept
+ gil_function_requires<Mutable_RandomAccessIterator
  <
  typename View::template axis<View::num_dimensions - 1>::iterator
  >>();