ryanhaining · ryanhaining · Mar 5, 2018 · Mar 5, 2018 · Mar 5, 2018
diff --git a/accumulate.hpp b/accumulate.hpp
@@ -39,7 +39,7 @@ class iter::impl::Accumulator {
   Accumulator(Accumulator&&) = default;
 
   template <typename ContainerT>
-  class Iterator : public std::iterator<std::input_iterator_tag, AccumVal> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
@@ -49,6 +49,12 @@ class iter::impl::Accumulator {
     std::unique_ptr<AccumVal> acc_val_;
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = AccumVal;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IteratorWrapper<ContainerT>&& sub_iter,
         IteratorWrapper<ContainerT>&& sub_end, AccumulateFunc& accumulate_fun)
         : sub_iter_{std::move(sub_iter)},

diff --git a/chain.hpp b/chain.hpp
@@ -100,8 +100,7 @@ class iter::impl::Chained {
   Chained(Chained&&) = default;
 
   template <typename TupTypeT>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       typename IteratorData<TupTypeT>::TraitsValue> {
+  class Iterator {
    private:
     using IterData = IteratorData<TupTypeT>;
     std::size_t index_;
@@ -116,6 +115,12 @@ class iter::impl::Chained {
     }
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = typename IteratorData<TupTypeT>::TraitsValue;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(std::size_t i, typename IterData::IterTupType&& iters,
         typename IterData::IterTupType&& ends)
         : index_{i}, iters_(std::move(iters)), ends_(std::move(ends)) {
@@ -224,8 +229,7 @@ class iter::impl::ChainedFromIterable {
  public:
   ChainedFromIterable(ChainedFromIterable&&) = default;
   template <typename ContainerT>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       iterator_traits_deref<iterator_deref<ContainerT>>> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
@@ -257,6 +261,12 @@ class iter::impl::ChainedFromIterable {
     }
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = iterator_traits_deref<iterator_deref<ContainerT>>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IteratorWrapper<ContainerT>&& top_iter,
         IteratorWrapper<ContainerT>&& top_end)
         : top_level_iter_{std::move(top_iter)},

diff --git a/chunked.hpp b/chunked.hpp
@@ -41,8 +41,7 @@ class iter::impl::Chunker {
  public:
   Chunker(Chunker&&) = default;
   template <typename ContainerT>
-  class Iterator
-      : public std::iterator<std::input_iterator_tag, DerefVec<ContainerT>> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
@@ -66,6 +65,12 @@ class iter::impl::Chunker {
     }
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = DerefVec<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IteratorWrapper<ContainerT>&& sub_iter,
         IteratorWrapper<ContainerT>&& sub_end, std::size_t s)
         : sub_iter_{std::move(sub_iter)},

diff --git a/combinations.hpp b/combinations.hpp
@@ -37,8 +37,7 @@ class iter::impl::Combinator {
  public:
   Combinator(Combinator&&) = default;
   template <typename ContainerT>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       CombIteratorDeref<ContainerT>> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
@@ -48,6 +47,12 @@ class iter::impl::Combinator {
     int steps_{};
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = CombIteratorDeref<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(ContainerT& container, std::size_t n)
         : container_p_{&container}, indices_{n} {
       if (n == 0) {

diff --git a/combinations_with_replacement.hpp b/combinations_with_replacement.hpp
@@ -37,8 +37,7 @@ class iter::impl::CombinatorWithReplacement {
  public:
   CombinatorWithReplacement(CombinatorWithReplacement&&) = default;
   template <typename ContainerT>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       CombIteratorDeref<ContainerT>> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
@@ -48,6 +47,12 @@ class iter::impl::CombinatorWithReplacement {
     int steps_;
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = CombIteratorDeref<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(ContainerT& in_container, std::size_t n)
         : container_p_{&in_container},
           indices_(n, get_begin(in_container)),

diff --git a/compress.hpp b/compress.hpp
@@ -33,8 +33,7 @@ class iter::impl::Compressed {
  public:
   Compressed(Compressed&&) = default;
   template <typename ContainerT, typename SelectorT>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       iterator_traits_deref<ContainerT>> {
+  class Iterator {
    private:
     template <typename, typename>
     friend class Iterator;
@@ -57,6 +56,12 @@ class iter::impl::Compressed {
     }
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = iterator_traits_deref<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IteratorWrapper<ContainerT>&& cont_iter,
         IteratorWrapper<ContainerT>&& cont_end,
         IteratorWrapper<SelectorT>&& sel_iter,

diff --git a/cycle.hpp b/cycle.hpp
@@ -31,8 +31,7 @@ class iter::impl::Cycler {
  public:
   Cycler(Cycler&&) = default;
   template <typename ContainerT>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       iterator_traits_deref<ContainerT>> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
@@ -41,6 +40,12 @@ class iter::impl::Cycler {
     IteratorWrapper<ContainerT> sub_end_;
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = iterator_traits_deref<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IteratorWrapper<ContainerT>&& sub_iter,
         IteratorWrapper<ContainerT>&& sub_end)
         : sub_iter_{sub_iter},

diff --git a/dropwhile.hpp b/dropwhile.hpp
@@ -33,8 +33,7 @@ class iter::impl::Dropper {
  public:
   Dropper(Dropper&&) = default;
   template <typename ContainerT>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       iterator_traits_deref<ContainerT>> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
@@ -59,6 +58,12 @@ class iter::impl::Dropper {
     }
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = iterator_traits_deref<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IteratorWrapper<ContainerT>&& sub_iter,
         IteratorWrapper<ContainerT>&& sub_end, FilterFunc& filter_func)
         : sub_iter_{std::move(sub_iter)},

diff --git a/enumerate.hpp b/enumerate.hpp
@@ -68,15 +68,20 @@ class iter::impl::Enumerable {
   //  index_.  Each call to ++ increments both of these data members.
   //  Each dereference returns an IterYield.
   template <typename ContainerT>
-  class Iterator
-      : public std::iterator<std::input_iterator_tag, IterYield<ContainerT>> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
     IteratorWrapper<ContainerT> sub_iter_;
     Index index_;
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = IterYield<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IteratorWrapper<ContainerT>&& sub_iter, Index start)
         : sub_iter_{std::move(sub_iter)}, index_{start} {}
 

diff --git a/filter.hpp b/filter.hpp
@@ -44,8 +44,7 @@ class iter::impl::Filtered {
   Filtered(Filtered&&) = default;
 
   template <typename ContainerT>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       iterator_traits_deref<ContainerT>> {
+  class Iterator {
    protected:
     template <typename>
     friend class Iterator;
@@ -71,6 +70,12 @@ class iter::impl::Filtered {
     }
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = iterator_traits_deref<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IteratorWrapper<ContainerT>&& sub_iter,
         IteratorWrapper<ContainerT>&& sub_end, FilterFunc& filter_func)
         : sub_iter_{std::move(sub_iter)},

diff --git a/groupby.hpp b/groupby.hpp
@@ -58,8 +58,7 @@ class iter::impl::GroupProducer {
 
  public:
   template <typename ContainerT>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       KeyGroupPair<ContainerT>> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
@@ -70,6 +69,12 @@ class iter::impl::GroupProducer {
     std::unique_ptr<KeyGroupPair<ContainerT>> current_key_group_pair_;
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = KeyGroupPair<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IteratorWrapper<ContainerT>&& sub_iter,
         IteratorWrapper<ContainerT>&& sub_end, KeyFunc& key_func)
         : sub_iter_{std::move(sub_iter)},
@@ -208,8 +213,7 @@ class iter::impl::GroupProducer {
       other.completed = true;
     }
 
-    class GroupIterator : public std::iterator<std::input_iterator_tag,
-                              iterator_traits_deref<ContainerT>> {
+    class GroupIterator {
      private:
       std::remove_reference_t<key_func_ret<ContainerT>>* key_;
       Group* group_p_;
@@ -220,6 +224,12 @@ class iter::impl::GroupProducer {
       }
 
      public:
+      using iterator_category = std::input_iterator_tag;
+      using value_type = iterator_traits_deref<ContainerT>;
+      using difference_type = std::ptrdiff_t;
+      using pointer = value_type*;
+      using reference = value_type&;
+
       // TODO template this? idk if it's relevant here
       GroupIterator(Group* group_p, key_func_ret<ContainerT>& key)
           : key_{&key}, group_p_{group_p} {}

diff --git a/internal/iteratoriterator.hpp b/internal/iteratoriterator.hpp
@@ -23,10 +23,7 @@ namespace iter {
         : std::true_type {};
 
     template <typename TopIter>
-    class IteratorIterator
-        : public std::iterator<std::random_access_iterator_tag,
-              typename std::remove_reference<decltype(
-                  **std::declval<TopIter>())>::type> {
+    class IteratorIterator {
       template <typename> friend class IteratorIterator;
       using Diff = std::ptrdiff_t;
       static_assert(
@@ -39,6 +36,11 @@ namespace iter {
       TopIter sub_iter;
 
      public:
+      using iterator_category = std::random_access_iterator_tag;
+      using value_type = std::remove_reference_t<decltype(**std::declval<TopIter>())>;
+      using difference_type = std::ptrdiff_t;
+      using pointer = value_type*;
+      using reference = value_type&;
       IteratorIterator() = default;
       IteratorIterator(const TopIter& it) : sub_iter{it} {}
 

diff --git a/permutations.hpp b/permutations.hpp
@@ -38,8 +38,7 @@ class iter::impl::Permuter {
   Permuter(Permuter&&) = default;
 
   template <typename ContainerT>
-  class Iterator
-      : public std::iterator<std::input_iterator_tag, Permutable<ContainerT>> {
+  class Iterator {
    private:
     template <typename>
     friend class Iterator;
@@ -53,6 +52,12 @@ class iter::impl::Permuter {
     int steps_{};
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = Permutable<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(IteratorWrapper<ContainerT>&& sub_iter,
         IteratorWrapper<ContainerT>&& sub_end)
         : steps_{sub_iter != sub_end ? 0 : COMPLETE} {

diff --git a/powerset.hpp b/powerset.hpp
@@ -37,8 +37,7 @@ class iter::impl::Powersetter {
   Powersetter(Powersetter&&) = default;
 
   template <typename ContainerT>
-  class Iterator : public std::iterator<std::input_iterator_tag,
-                       CombinatorType<ContainerT>> {
+  class Iterator {
    private:
 #if 0
     template <typename> friend class Iterator;
@@ -50,6 +49,12 @@ class iter::impl::Powersetter {
     iterator_type<CombinatorType<ContainerT>> comb_end_;
 
    public:
+    using iterator_category = std::input_iterator_tag;
+    using value_type = CombinatorType<ContainerT>;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
     Iterator(ContainerT& container, std::size_t sz)
         : container_p_{&container},
           set_size_{sz},