clang-format

ryanhaining · Feb 20, 2017 · 1330973 · 1330973
1 parent cce0ce6
commit 1330973
Show file tree

Hide file tree

Showing 32 changed files with 272 additions and 277 deletions.
diff --git a/accumulate.hpp b/accumulate.hpp
@@ -1,14 +1,14 @@
 #ifndef ITER_ACCUMULATE_H_
 #define ITER_ACCUMULATE_H_
 
-#include "internal/iterbase.hpp"
 #include "internal/iterator_wrapper.hpp"
+#include "internal/iterbase.hpp"
 
-#include <utility>
-#include <iterator>
 #include <functional>
-#include <type_traits>
+#include <iterator>
 #include <memory>
+#include <type_traits>
+#include <utility>
 
 namespace iter {
   namespace impl {
@@ -46,8 +46,8 @@ class iter::impl::Accumulator {
     std::unique_ptr<AccumVal> acc_val;
 
    public:
-    Iterator(IteratorWrapper<Container>&& iter, IteratorWrapper<Container>&& end,
-        AccumulateFunc& in_accumulate_fun)
+    Iterator(IteratorWrapper<Container>&& iter,
+        IteratorWrapper<Container>&& end, AccumulateFunc& in_accumulate_fun)
         : sub_iter{std::move(iter)},
           sub_end{std::move(end)},
           accumulate_func(&in_accumulate_fun),

diff --git a/chain.hpp b/chain.hpp
@@ -1,9 +1,9 @@
 #ifndef ITER_CHAIN_HPP_
 #define ITER_CHAIN_HPP_
 
-#include "internal/iterbase.hpp"
-#include "internal/iterator_wrapper.hpp"
 #include "internal/iter_tuples.hpp"
+#include "internal/iterator_wrapper.hpp"
+#include "internal/iterbase.hpp"
 
 #include <array>
 #include <iterator>
@@ -156,19 +156,23 @@ class iter::impl::Chained {
 
 template <typename TupType, std::size_t... Is>
 constexpr std::array<typename iter::impl::Chained<TupType, Is...>::DerefFunc,
-    sizeof...(Is)> iter::impl::Chained<TupType, Is...>::derefers;
+    sizeof...(Is)>
+    iter::impl::Chained<TupType, Is...>::derefers;
 
 template <typename TupType, std::size_t... Is>
 constexpr std::array<typename iter::impl::Chained<TupType, Is...>::ArrowFunc,
-    sizeof...(Is)> iter::impl::Chained<TupType, Is...>::arrowers;
+    sizeof...(Is)>
+    iter::impl::Chained<TupType, Is...>::arrowers;
 
 template <typename TupType, std::size_t... Is>
 constexpr std::array<typename iter::impl::Chained<TupType, Is...>::IncFunc,
-    sizeof...(Is)> iter::impl::Chained<TupType, Is...>::incrementers;
+    sizeof...(Is)>
+    iter::impl::Chained<TupType, Is...>::incrementers;
 
 template <typename TupType, std::size_t... Is>
 constexpr std::array<typename iter::impl::Chained<TupType, Is...>::NeqFunc,
-    sizeof...(Is)> iter::impl::Chained<TupType, Is...>::neq_comparers;
+    sizeof...(Is)>
+    iter::impl::Chained<TupType, Is...>::neq_comparers;
 
 template <typename Container>
 class iter::impl::ChainedFromIterable {
@@ -208,8 +212,8 @@ class iter::impl::ChainedFromIterable {
     }
 
    public:
-    Iterator(
-        IteratorWrapper<Container>&& top_iter, IteratorWrapper<Container>&& top_end)
+    Iterator(IteratorWrapper<Container>&& top_iter,
+        IteratorWrapper<Container>&& top_end)
         : top_level_iter{std::move(top_iter)},
           top_level_end{std::move(top_end)},
           sub_iter_p{!(top_iter != top_end)

diff --git a/chunked.hpp b/chunked.hpp
@@ -1,16 +1,16 @@
 #ifndef ITER_CHUNKED_HPP_
 #define ITER_CHUNKED_HPP_
 
-#include "internal/iterbase.hpp"
-#include "internal/iteratoriterator.hpp"
 #include "internal/iterator_wrapper.hpp"
+#include "internal/iteratoriterator.hpp"
+#include "internal/iterbase.hpp"
 
-#include <vector>
 #include <algorithm>
-#include <type_traits>
 #include <functional>
-#include <utility>
 #include <iterator>
+#include <type_traits>
+#include <utility>
+#include <vector>
 
 namespace iter {
   namespace impl {

diff --git a/combinations.hpp b/combinations.hpp
@@ -1,12 +1,12 @@
 #ifndef ITER_COMBINATIONS_HPP_
 #define ITER_COMBINATIONS_HPP_
 
-#include "internal/iterbase.hpp"
 #include "internal/iteratoriterator.hpp"
+#include "internal/iterbase.hpp"
 
-#include <vector>
-#include <type_traits>
 #include <iterator>
+#include <type_traits>
+#include <vector>
 
 namespace iter {
   namespace impl {

diff --git a/combinations_with_replacement.hpp b/combinations_with_replacement.hpp
@@ -1,12 +1,12 @@
 #ifndef ITER_COMBINATIONS_WITH_REPLACEMENT_HPP_
 #define ITER_COMBINATIONS_WITH_REPLACEMENT_HPP_
 
-#include "internal/iterbase.hpp"
 #include "internal/iteratoriterator.hpp"
+#include "internal/iterbase.hpp"
 
 #include <iterator>
-#include <vector>
 #include <type_traits>
+#include <vector>
 
 namespace iter {
   namespace impl {

diff --git a/compress.hpp b/compress.hpp
@@ -1,11 +1,11 @@
 #ifndef ITER_COMPRESS_H_
 #define ITER_COMPRESS_H_
 
-#include "internal/iterbase.hpp"
 #include "internal/iterator_wrapper.hpp"
+#include "internal/iterbase.hpp"
 
-#include <utility>
 #include <iterator>
+#include <utility>
 
 namespace iter {
   namespace impl {
@@ -15,7 +15,6 @@ namespace iter {
 
   template <typename Container, typename Selector>
   impl::Compressed<Container, Selector> compress(Container&&, Selector&&);
-
 }
 
 template <typename Container, typename Selector>

diff --git a/cycle.hpp b/cycle.hpp
@@ -1,12 +1,12 @@
 #ifndef ITER_CYCLE_H_
 #define ITER_CYCLE_H_
 
-#include "internal/iterbase.hpp"
 #include "internal/iterator_wrapper.hpp"
+#include "internal/iterbase.hpp"
 
-#include <utility>
-#include <iterator>
 #include <initializer_list>
+#include <iterator>
+#include <utility>
 
 namespace iter {
   namespace impl {

diff --git a/dropwhile.hpp b/dropwhile.hpp
@@ -1,12 +1,12 @@
 #ifndef ITER_DROPWHILE_H_
 #define ITER_DROPWHILE_H_
 
-#include "internal/iterbase.hpp"
-#include "internal/iterator_wrapper.hpp"
 #include "filter.hpp"
+#include "internal/iterator_wrapper.hpp"
+#include "internal/iterbase.hpp"
 
-#include <utility>
 #include <iterator>
+#include <utility>
 
 namespace iter {
   namespace impl {
@@ -57,8 +57,8 @@ class iter::impl::Dropper {
     }
 
    public:
-    Iterator(IteratorWrapper<Container>&& iter, IteratorWrapper<Container>&& end,
-        FilterFunc& in_filter_func)
+    Iterator(IteratorWrapper<Container>&& iter,
+        IteratorWrapper<Container>&& end, FilterFunc& in_filter_func)
         : sub_iter{std::move(iter)},
           sub_end{std::move(end)},
           filter_func(&in_filter_func) {

diff --git a/enumerate.hpp b/enumerate.hpp
@@ -1,14 +1,14 @@
 #ifndef ITER_ENUMERATE_H_
 #define ITER_ENUMERATE_H_
 
-#include "internal/iterbase.hpp"
 #include "internal/iterator_wrapper.hpp"
+#include "internal/iterbase.hpp"
 
-#include <utility>
-#include <iterator>
 #include <functional>
 #include <initializer_list>
+#include <iterator>
 #include <type_traits>
+#include <utility>
 
 namespace iter {
   namespace impl {

diff --git a/filter.hpp b/filter.hpp
@@ -1,12 +1,12 @@
 #ifndef ITER_FILTER_H_
 #define ITER_FILTER_H_
 
-#include "internal/iterbase.hpp"
 #include "internal/iterator_wrapper.hpp"
+#include "internal/iterbase.hpp"
 
-#include <utility>
-#include <iterator>
 #include <initializer_list>
+#include <iterator>
+#include <utility>
 
 namespace iter {
   namespace impl {
@@ -69,9 +69,11 @@ class iter::impl::Filtered {
     }
 
    public:
-    Iterator(IteratorWrapper<Container>&& iter, IteratorWrapper<Container>&& end,
-        FilterFunc& in_filter_func)
-        : sub_iter{std::move(iter)}, sub_end{std::move(end)}, filter_func(&in_filter_func) {
+    Iterator(IteratorWrapper<Container>&& iter,
+        IteratorWrapper<Container>&& end, FilterFunc& in_filter_func)
+        : sub_iter{std::move(iter)},
+          sub_end{std::move(end)},
+          filter_func(&in_filter_func) {
       if (this->sub_iter != this->sub_end) {
         this->item.reset(*this->sub_iter);
       }

diff --git a/filterfalse.hpp b/filterfalse.hpp
@@ -1,8 +1,8 @@
 #ifndef ITER_FILTER_FALSE_HPP_
 #define ITER_FILTER_FALSE_HPP_
 
-#include "internal/iterbase.hpp"
 #include "filter.hpp"
+#include "internal/iterbase.hpp"
 
 #include <utility>
 

diff --git a/groupby.hpp b/groupby.hpp
@@ -3,13 +3,13 @@
 
 // this is easily the most functionally complex itertool
 
-#include "internal/iterbase.hpp"
 #include "internal/iterator_wrapper.hpp"
+#include "internal/iterbase.hpp"
 
-#include <type_traits>
+#include <iterator>
 #include <memory>
+#include <type_traits>
 #include <utility>
-#include <iterator>
 
 namespace iter {
   namespace impl {
@@ -193,9 +193,8 @@ class iter::impl::GroupProducer {
     }
 
     // move-constructible, non-copy-constructible, non-assignable
-    Group(Group&& other) noexcept : owner(other.owner),
-                                    key{other.key},
-                                    completed{other.completed} {
+    Group(Group&& other) noexcept
+        : owner(other.owner), key{other.key}, completed{other.completed} {
       other.completed = true;
     }
 

diff --git a/imap.hpp b/imap.hpp
@@ -1,8 +1,8 @@
 #ifndef ITER_IMAP_H_
 #define ITER_IMAP_H_
 
-#include "zip.hpp"
 #include "starmap.hpp"
+#include "zip.hpp"
 
 #include <utility>
 

diff --git a/internal/iter_tuples.hpp b/internal/iter_tuples.hpp
@@ -1,8 +1,8 @@
 #ifndef ITERTOOLS_ITER_TUPLES_HPP_
 #define ITERTOOLS_ITER_TUPLES_HPP_
 
-#include "iterbase.hpp"
 #include "iterator_wrapper.hpp"
+#include "iterbase.hpp"
 
 namespace iter {
   namespace impl {