Removed useless code [#CLICKHOUSE-31].

libs/libcommon/include/ext/map.h

 #pragma once
 
-#include <iterator>
 #include <type_traits>
+#include <boost/iterator/transform_iterator.hpp>
+
 
 namespace ext
 {
@@ -9,76 +10,42 @@ namespace ext
     template <typename T>
     using unqualified_t = std::remove_cv_t<std::remove_reference_t<T>>;
 
-    template <typename It, typename Mapper>
-    using apply_t = typename std::result_of<Mapper(typename It::reference)>::type;
-
-    template <typename It, typename Mapper>
-    struct map_iterator : std::iterator<
-        typename It::iterator_category,
-        std::remove_reference_t<apply_t<It, Mapper>>,
-        std::ptrdiff_t,
-        std::add_pointer_t<std::remove_reference_t<apply_t<It, Mapper>>>,
-        apply_t<It, Mapper>>
-    {
-        using base_iterator = std::iterator<
-            typename It::iterator_category,
-            std::remove_reference_t<apply_t<It, Mapper>>,
-            std::ptrdiff_t,
-            std::add_pointer<std::remove_reference_t<apply_t<It, Mapper>>>,
-            apply_t<It, Mapper>>;
-
-        It current;
-        Mapper mapper;
-
-        map_iterator(const It it, const Mapper mapper) : current{it}, mapper{mapper} {}
-
-        typename base_iterator::reference operator*() { return mapper(*current); }
-
-        map_iterator & operator++() { return ++current, *this; }
-        map_iterator & operator--() { return --current, *this; }
-
-        bool operator==(const map_iterator & other) { return current == other.current; }
-        bool operator!=(const map_iterator & other) { return current != other.current; }
-
-        typename base_iterator::difference_type operator-(const map_iterator & other) { return current - other.current; }
-    };
-
-    template <typename It, typename Mapper>
-    auto make_map_iterator(const It it, const Mapper mapper) -> ext::map_iterator<It, Mapper>
-    {
-        return { it, mapper };
-    }
-
     /** \brief Returns collection of the same container-type as the input collection,
-    *    with each element transformed by the application of `mapper`. */
+      *    with each element transformed by the application of `mapper`.
+      */
     template <template <typename...> class Collection, typename... Params, typename Mapper>
     auto map(const Collection<Params...> & collection, const Mapper mapper)
     {
         using value_type = unqualified_t<decltype(mapper(*std::begin(collection)))>;
 
-        return Collection<value_type>(ext::make_map_iterator(std::begin(collection), mapper),
-            ext::make_map_iterator(std::end(collection), mapper));
+        return Collection<value_type>(
+            boost::make_transform_iterator(std::begin(collection), mapper),
+            boost::make_transform_iterator(std::end(collection), mapper));
     };
 
     /** \brief Returns collection of specified container-type,
-    *    with each element transformed by the application of `mapper`.
-    *    Allows conversion between different container-types, e.g. std::vector to std::list */
+      *    with each element transformed by the application of `mapper`.
+      *    Allows conversion between different container-types, e.g. std::vector to std::list
+      */
     template <template <typename...> class ResultCollection, typename Collection, typename Mapper>
     auto map(const Collection & collection, const Mapper mapper)
     {
         using value_type = unqualified_t<decltype(mapper(*std::begin(collection)))>;
 
-        return ResultCollection<value_type>(ext::make_map_iterator(std::begin(collection), mapper),
-            ext::make_map_iterator(std::end(collection), mapper));
+        return ResultCollection<value_type>(
+            boost::make_transform_iterator(std::begin(collection), mapper),
+            boost::make_transform_iterator(std::end(collection), mapper));
     };
 
     /** \brief Returns collection of specified type,
-    *    with each element transformed by the application of `mapper`.
-    *    Allows leveraging implicit conversion between the result of applying `mapper` and R::value_type. */
+      *    with each element transformed by the application of `mapper`.
+      *    Allows leveraging implicit conversion between the result of applying `mapper` and R::value_type.
+      */
     template <typename ResultCollection, typename Collection, typename Mapper>
     auto map(const Collection & collection, const Mapper mapper)
     {
-        return ResultCollection(ext::make_map_iterator(std::begin(collection), mapper),
-            ext::make_map_iterator(std::end(collection), mapper));
+        return ResultCollection(
+            boost::make_transform_iterator(std::begin(collection), mapper),
+            boost::make_transform_iterator(std::end(collection), mapper));
     }
 }

libs/libcommon/include/ext/range.h

@@ -3,35 +3,24 @@
 #include <type_traits>
 #include <utility>
 #include <iterator>
+#include <boost/iterator/counting_iterator.hpp>
+
 
 /** \brief Numeric range iterator, used to represent a half-closed interval [begin, end).
  *    In conjunction with std::reverse_iterator allows for forward and backward iteration
  *    over corresponding interval. */
 namespace ext
 {
-    /// @todo check whether difference_type should be signed (make_signed_t<T>)
-    template<typename T> struct range_iterator : std::iterator<
-        std::bidirectional_iterator_tag, T, T, void, T>
-    {
-        T current{};
-
-        range_iterator() = default;
-        range_iterator(const T t) : current(t) {}
-
-        T operator*() const { return current; }
-
-        range_iterator & operator++() { return ++current, *this; }
-        range_iterator & operator--() { return --current, *this; }
-
-        bool operator==(const range_iterator & other) const { return current == other.current; }
-        bool operator!=(const range_iterator & other) const { return current != other.current; }
-    };
+    template <typename T>
+    using range_iterator = boost::counting_iterator<T>;
 
-    template<typename T> using reverse_range_iterator = std::reverse_iterator<range_iterator<T>>;
+    template <typename T>
+    using reverse_range_iterator = std::reverse_iterator<range_iterator<T>>;
 
     /** \brief Range-based for loop adapter for (reverse_)range_iterator.
      *  By and large should be in conjunction with ext::range and ext::reverse_range. */
-    template<typename T, bool forward> struct range_wrapper
+    template <typename T, bool forward>
+    struct range_wrapper
     {
         using value_type = typename std::remove_reference<T>::type;
         using range_iterator_t = ext::range_iterator<value_type>;