removed deprecated in C++17 std::iterator

Author: karasikov

include/sdsl/cst_iterators.hpp

@@ -44,10 +44,15 @@ namespace sdsl
  */
 // TODO: implement operator--
 template<class Cst, uint32_t cache_size=128>
-class cst_dfs_const_forward_iterator: public std::iterator<std::forward_iterator_tag, typename Cst::node_type>
+class cst_dfs_const_forward_iterator
 {
     public:
-        typedef typename Cst::node_type value_type;
+        using iterator_category = std::forward_iterator_tag;
+        using value_type = typename Cst::node_type;
+        using difference_type = void;
+        using pointer = void;
+        using reference = void;
+
         typedef const value_type const_reference;
         typedef typename Cst::size_type size_type;
         typedef cst_dfs_const_forward_iterator<Cst> iterator;
@@ -177,10 +182,15 @@ class cst_dfs_const_forward_iterator: public std::iterator<std::forward_iterator
 
 //! A forward iterator for a bottom up traversal of a suffix tree
 template<class Cst>
-class cst_bottom_up_const_forward_iterator: public std::iterator<std::forward_iterator_tag, typename Cst::node_type>
+class cst_bottom_up_const_forward_iterator
 {
     public:
-        typedef typename Cst::node_type value_type;
+        using iterator_category = std::forward_iterator_tag;
+        using value_type = typename Cst::node_type;
+        using difference_type = void;
+        using pointer = void;
+        using reference = void;
+
         typedef const value_type const_reference;
         typedef typename Cst::size_type size_type;
         typedef cst_bottom_up_const_forward_iterator<Cst> iterator;
@@ -251,10 +261,15 @@ class cst_bottom_up_const_forward_iterator: public std::iterator<std::forward_it
  *                  you should use an external implementation of a queue.
  */
 template<class Cst, class Queue = std::queue<typename Cst::node_type> >
-class cst_bfs_iterator: public std::iterator<std::forward_iterator_tag, typename Cst::node_type>
+class cst_bfs_iterator
 {
     public:
-        typedef typename Cst::node_type 		value_type;
+        using iterator_category = std::forward_iterator_tag;
+        using value_type = typename Cst::node_type;
+        using difference_type = void;
+        using pointer = void;
+        using reference = void;
+
         typedef const value_type 				const_reference;
         typedef typename Cst::size_type 		size_type;
         typedef cst_bfs_iterator<Cst, Queue> 	iterator;

include/sdsl/int_vector.hpp

@@ -828,7 +828,7 @@ inline void swap(int_vector_reference<bit_vector> x,
 
 
 template<class t_int_vector>
-class int_vector_iterator_base: public std::iterator<std::random_access_iterator_tag, typename t_int_vector::value_type, typename t_int_vector::difference_type>
+class int_vector_iterator_base
 {
     public:
         typedef uint64_t  size_type;
@@ -849,12 +849,14 @@ class int_vector_iterator : public int_vector_iterator_base<t_int_vector>
 {
     public:
 
-        typedef int_vector_reference<t_int_vector>     reference;
-        typedef uint64_t                               value_type;
+        using iterator_category = std::random_access_iterator_tag;
+        using value_type = typename t_int_vector::value_type;
+        using difference_type = typename t_int_vector::difference_type;
+        using pointer = typename t_int_vector::value_type*;
+        using reference = int_vector_reference<t_int_vector>;
+
         typedef int_vector_iterator                    iterator;
-        typedef reference*                             pointer;
         typedef typename t_int_vector::size_type       size_type;
-        typedef typename t_int_vector::difference_type difference_type;
 
         friend class int_vector_const_iterator<t_int_vector>;
     private:
@@ -1011,11 +1013,14 @@ class int_vector_const_iterator : public int_vector_iterator_base<t_int_vector>
 {
     public:
 
-        typedef typename t_int_vector::value_type        const_reference;
-        typedef const typename t_int_vector::value_type* pointer;
+        using iterator_category = std::random_access_iterator_tag;
+        using value_type = const typename t_int_vector::value_type;
+        using difference_type = typename t_int_vector::difference_type;
+        using pointer = const typename t_int_vector::value_type*;
+        using reference = const typename t_int_vector::value_type;
+
         typedef int_vector_const_iterator                const_iterator;
         typedef typename t_int_vector::size_type         size_type;
-        typedef typename t_int_vector::difference_type   difference_type;
 
         template<class X>
         friend typename int_vector_const_iterator<X>::difference_type
@@ -1045,7 +1050,7 @@ class int_vector_const_iterator : public int_vector_iterator_base<t_int_vector>
             return *this;
         }
 
-        const_reference operator*() const
+        reference operator*() const
         {
             return bits::read_int(m_word, m_offset, m_len);
         }
@@ -1126,7 +1131,7 @@ class int_vector_const_iterator : public int_vector_iterator_base<t_int_vector>
             return it -= i;
         }
 
-        const_reference operator[](difference_type i) const
+        reference operator[](difference_type i) const
         {
             return *(*this + i);
         }

include/sdsl/int_vector_buffer.hpp

@@ -492,12 +492,17 @@ class int_vector_buffer
                 }
         };
 
-        class iterator: public std::iterator<std::random_access_iterator_tag, value_type, difference_type, value_type*, reference>
+        class iterator
         {
             private:
                 int_vector_buffer<t_width>& m_ivb;
                 uint64_t m_idx = 0;
             public:
+                using iterator_category = std::random_access_iterator_tag;
+                using value_type = int_vector_buffer<t_width>::value_type;
+                using difference_type = int_vector_buffer<t_width>::difference_type;
+                using pointer = value_type*;
+                using reference = int_vector_buffer<t_width>::reference;
 
                 iterator() = delete;
                 iterator(int_vector_buffer<t_width>& ivb, uint64_t idx=0) : m_ivb(ivb), m_idx(idx) {}

include/sdsl/iterators.hpp

@@ -30,13 +30,18 @@ namespace sdsl
 /*! \tparam t_rac Type of random access container.
  */
 template<class t_rac>
-class random_access_const_iterator: public std::iterator<std::random_access_iterator_tag, typename t_rac::value_type, typename t_rac::difference_type>
+class random_access_const_iterator
 {
     public:
+        using iterator_category = std::random_access_iterator_tag;
+        using value_type = typename t_rac::value_type;
+        using difference_type = typename t_rac::difference_type;
+        using pointer = void;
+        using reference = void;
+
         typedef const typename t_rac::value_type  const_reference;
         typedef typename t_rac::size_type size_type;
         typedef random_access_const_iterator<t_rac> iterator;
-        typedef typename t_rac::difference_type difference_type;
 
     private:
         const t_rac* m_rac;// pointer to the random access container

include/sdsl/lcp_byte.hpp

@@ -170,8 +170,8 @@ class lcp_byte
             if (m_small_lcp[i]!=255) {
                 return m_small_lcp[i];
             } else {
-                size_type idx = lower_bound(m_big_lcp_idx.begin(),
-                                            m_big_lcp_idx.end(),i)
+                size_type idx = std::lower_bound(m_big_lcp_idx.begin(),
+                                                 m_big_lcp_idx.end(),i)
                                 - m_big_lcp_idx.begin();
                 return m_big_lcp[idx];
             }

include/sdsl/sd_vector.hpp

@@ -278,11 +278,7 @@ class sd_vector
             m_size = builder.m_size;
             m_wl = builder.m_wl;
             m_low.swap(builder.m_low);
-            if constexpr(std::is_same<hi_bit_vector_type, bit_vector>::value) {
-                m_high.swap(builder.m_high);
-            } else {
-                util::assign(m_high, builder.m_high);
-            }
+            util::assign(m_high, builder.m_high);
             util::init_support(m_high_1_select, &m_high);
             util::init_support(m_high_0_select, &m_high);
 
@@ -445,6 +441,9 @@ class sd_vector
         }
 };
 
+//! Specialized constructor that is a bit more space-efficient than the default.
+template<> sd_vector<>::sd_vector(sd_vector_builder& builder);
+
 template<uint8_t t_b>
 struct rank_support_sd_trait {
     typedef bit_vector::size_type size_type;

include/sdsl/suffix_tree_helper.hpp

@@ -15,11 +15,16 @@ namespace sdsl
 
 
 template <class t_cst>
-class cst_node_child_proxy_iterator : public std::iterator<std::forward_iterator_tag, typename t_cst::node_type>
+class cst_node_child_proxy_iterator
 {
     public:
+        using iterator_category = std::forward_iterator_tag;
+        using value_type = typename t_cst::node_type;
+        using difference_type = void;
+        using pointer = void;
+        using reference = void;
+
         using node_type = typename t_cst::node_type;
-        using value_type = node_type;
         using const_reference = const node_type;
         using iterator_type =  cst_node_child_proxy_iterator<t_cst>;
     private:

include/sdsl/wt_gmr.hpp

@@ -22,6 +22,8 @@
 #ifndef INCLUDED_SDSL_WT_GMR
 #define INCLUDED_SDSL_WT_GMR
 
+#include <algorithm> // for lower_bound
+
 #include <sdsl/bit_vectors.hpp>
 #include <sdsl/int_vector.hpp>
 #include <sdsl/int_vector_buffer.hpp>
@@ -485,7 +487,7 @@ class wt_gmr_rs
                             ++search_begin;
                         }
                     } else {
-                        if (binary_search(m_e.begin()+search_begin, m_e.begin()+search_end, val)) {
+                        if (std::binary_search(m_e.begin()+search_begin, m_e.begin()+search_end, val)) {
                             return (block-1)/m_blocks;
                         }
                     }
@@ -520,7 +522,7 @@ class wt_gmr_rs
             if (end-begin<50) { // After a short test, this seems to be a good threshold
                 offset = std::find_if(begin, end, [&val](const decltype(*begin) x) { return x > val; }) - begin;
             } else {
-                offset = lower_bound(begin, end, val+1)-begin;
+                offset = std::lower_bound(begin, end, val+1)-begin;
             }
             return (begin-m_e.begin())+offset-ones_before_cblock;
         }
@@ -556,7 +558,7 @@ class wt_gmr_rs
                             ++search_begin;
                         }
                     } else {
-                        offset = lower_bound(m_e.begin()+search_begin, m_e.begin()+search_end, val)-m_e.begin();
+                        offset = std::lower_bound(m_e.begin()+search_begin, m_e.begin()+search_end, val)-m_e.begin();
                         if (offset<search_end) {
                             if (m_e[offset]==val) {
                                 value_type c = (block-1)/m_blocks;
@@ -875,7 +877,7 @@ class wt_gmr
             if (end-begin<50) { // After a short test, this seems to be a good threshold
                 c_ones_in_chunk = std::find_if(begin, end, [&val](const decltype(*begin) x) { return x > val; }) - begin;
             } else {
-                c_ones_in_chunk = lower_bound(begin, end, val+1) - begin;
+                c_ones_in_chunk = std::lower_bound(begin, end, val+1) - begin;
             }
             return c_ones_before_chunk+c_ones_in_chunk;
         }

lib/sd_vector.cpp

@@ -49,4 +49,23 @@ void sd_vector_builder::swap(sd_vector_builder& sdb)
     m_high.swap(sdb.m_high);
 }
 
+template<>
+sd_vector<>::sd_vector(sd_vector_builder& builder)
+{
+    if (builder.items() < builder.capacity()) {
+        throw std::runtime_error("sd_vector: the builder is not full.");
+    } else if (builder.items() > builder.capacity()) {
+        throw std::runtime_error("sd_vector: builder overflow.");
+    }
+
+    m_size = builder.m_size;
+    m_wl = builder.m_wl;
+    m_low.swap(builder.m_low);
+    m_high.swap(builder.m_high);
+    util::init_support(m_high_1_select, &m_high);
+    util::init_support(m_high_0_select, &m_high);
+
+    builder = sd_vector_builder();
+}
+
 } // end namespace

test/inv_perm_support_test.cpp

@@ -28,7 +28,7 @@ class inv_perm_support_test : public ::testing::Test
             for (size_t z=0; z < (1ULL<<20); z=(z+1)*2) {
                 sdsl::int_vector<> iv(z);
                 sdsl::util::set_to_id(iv);
-                random_shuffle(iv.begin(), iv.end());
+                std::random_shuffle(iv.begin(), iv.end());
                 perms.emplace_back(iv);
             }
             for (size_t i=0; i<perms.size(); ++i) {