refactor: apply clang-format

include/iterator/facade.h

@@ -249,9 +249,9 @@ template <typename I> struct std::iterator_traits<::iterator::facade<I>> {
 #define MAKE_ITERATOR_FACADE_TYPEDEFS(type)                                    \
   template <>                                                                  \
   struct std::iterator_traits<type>                                            \
-      : std::iterator_traits<::iterator::facade<type>> {};                     \
+      : std::iterator_traits<::iterator::facade<type>> {};
 
 #define MAKE_ITERATOR_FACADE_TYPEDEFS_T(type)                                  \
   template <typename... T>                                                     \
   struct std::iterator_traits<type<T...>>                                      \
-      : std::iterator_traits<::iterator::facade<type<T...>>> {};               \
+      : std::iterator_traits<::iterator::facade<type<T...>>> {};

include/iterator/indexed_iterator.hpp

@@ -15,17 +15,21 @@ namespace iterator {
   template <typename It>
   class indexed_iterator : public facade<indexed_iterator<It>> {
   public:
-    using reference = std::pair<size_t, typename std::iterator_traits<It>::reference>;
+    using reference =
+        std::pair<size_t, typename std::iterator_traits<It>::reference>;
     using difference_type = typename std::iterator_traits<It>::difference_type;
+
   public:
     indexed_iterator() = default;
-    explicit indexed_iterator(It base, size_t idx = 0) : _base(base), _index(idx) {}
+    explicit indexed_iterator(It base, size_t idx = 0)
+        : _base(base), _index(idx) {}
 
-    template <typename O> indexed_iterator(indexed_iterator<O> const & oiter)
+    template <typename O>
+    indexed_iterator(indexed_iterator<O> const & oiter)
         : _base(oiter._base), _index(oiter._index) {}
 
     reference dereference() const { return {_index, *_base}; }
-    
+
     void advance(difference_type off) {
       _base += off;
       _index += off;
@@ -33,7 +37,9 @@ namespace iterator {
 
     // SFINAE means that if Iterator is not random access, then this still works
     // TODO: Investigate using _index for comparisons instead of _base
-    bool equal_to(indexed_iterator const & other) const { return _base == other._base; }
+    bool equal_to(indexed_iterator const & other) const {
+      return _base == other._base;
+    }
     difference_type distance_to(indexed_iterator const & other) const {
       return other._base - _base;
     }

include/iterator/zip_iterator.hpp

@@ -6,51 +6,55 @@
 #include "facade.h"
 
 namespace iterator::detail {
-template <typename Tuple, typename IS> class zip_iterator_impl;
+  template <typename Tuple, typename IS> class zip_iterator_impl;
 
-template <typename... Ts, size_t... Is>
-class zip_iterator_impl<std::tuple<Ts...>, std::index_sequence<Is...>> {
-public:
-  using difference_type =
-      std::common_type_t<typename std::iterator_traits<Ts>::difference_type...>;
+  template <typename... Ts, size_t... Is>
+  class zip_iterator_impl<std::tuple<Ts...>, std::index_sequence<Is...>> {
+  public:
+    using difference_type = std::common_type_t<
+        typename std::iterator_traits<Ts>::difference_type...>;
+
+  public:
+    zip_iterator_impl() = default;
+    zip_iterator_impl(Ts... iters) : _data(iters...) {}
 
-public:
-  zip_iterator_impl() = default;
-  zip_iterator_impl(Ts... iters) : _data(iters...) {}
-  
-  auto dereference() const {
-    return std::forward_as_tuple(*std::get<Is>(_data)...);
-  }
+    auto dereference() const {
+      return std::forward_as_tuple(*std::get<Is>(_data)...);
+    }
 
-  void increment() {
-    [[maybe_unused]] auto l = {((++std::get<Is>(_data)), 0)...};
-  }
-  void decrement() {
-    [[maybe_unused]] auto l = {((++std::get<Is>(_data)), 0)...};
-  }
-  void advance(difference_type d) {
-    [[maybe_unused]] auto l = {((std::get<Is>(_data) += d), 0)...};
-  }
+    void increment() {
+      [[maybe_unused]] auto l = {((++std::get<Is>(_data)), 0)...};
+    }
+    void decrement() {
+      [[maybe_unused]] auto l = {((++std::get<Is>(_data)), 0)...};
+    }
+    void advance(difference_type d) {
+      [[maybe_unused]] auto l = {((std::get<Is>(_data) += d), 0)...};
+    }
 
-  bool equal_to(zip_iterator_impl const & other) const { return _data == other._data; }
-  
-  auto distance_to(zip_iterator_impl const & other) const {
-    return std::get<0>(other._data) - std::get<0>(_data);
-  }
-  
-private:
-  std::tuple<Ts...> _data;
-};
+    bool equal_to(zip_iterator_impl const & other) const {
+      return _data == other._data;
+    }
+
+    auto distance_to(zip_iterator_impl const & other) const {
+      return std::get<0>(other._data) - std::get<0>(_data);
+    }
+
+  private:
+    std::tuple<Ts...> _data;
+  };
 }
 
 namespace iterator {
   template <typename... Ts>
   using index_sequence = decltype(std::make_index_sequence<sizeof...(Ts)>{});
   template <typename... Ts>
-  using zip_impl = detail::zip_iterator_impl<std::tuple<Ts...>, index_sequence<Ts...>>;
+  using zip_impl =
+      detail::zip_iterator_impl<std::tuple<Ts...>, index_sequence<Ts...>>;
 
   template <typename... Iters>
-  class zip_iterator : public zip_impl<Iters...>, public facade<zip_iterator<Iters...>> {
+  class zip_iterator : public zip_impl<Iters...>,
+                       public facade<zip_iterator<Iters...>> {
   public:
     zip_iterator() = default;
     zip_iterator(Iters... iters) : zip_impl<Iters...>(iters...) {}

test/filter_iterator_test.cxx

@@ -47,7 +47,7 @@ TEST(FilterIteratorTest, IncrementOnEndIsUnsafe) {
   auto pred = [](int i) { return i % 2 == 0; };
   auto it = make_filter_iterator(pred, data);
   decltype(it) end = {};
-  ++++it;
+  ++ ++it;
   EXPECT_THAT(it, end);
   ++it;
   EXPECT_NE(it, end);