Apply clang-format to folly/gen/ (template decls)

Summary: [Folly] Apply `clang-format` to `folly/gen/` (template decls).

Reviewed By: Orvid

Differential Revision: D5216229

fbshipit-source-id: 1659f1944ccde4de39bccd189bb6490395cf29c2

folly/gen/Combine-inl.h

@@ -33,7 +33,7 @@ namespace detail {
  * Alternate values from a sequence with values from a sequence container.
  * Stops once we run out of values from either source.
  */
-template<class Container>
+template <class Container>
 class Interleave : public Operator<Interleave<Container>> {
   // see comment about copies in CopiedSource
   const std::shared_ptr<const Container> container_;
@@ -41,8 +41,7 @@ class Interleave : public Operator<Interleave<Container>> {
   explicit Interleave(Container container)
     : container_(new Container(std::move(container))) {}
 
-  template<class Value,
-           class Source>
+  template <class Value, class Source>
   class Generator : public GenImpl<Value, Generator<Value, Source>> {
     Source source_;
     const std::shared_ptr<const Container> container_;
@@ -56,7 +55,7 @@ class Interleave : public Operator<Interleave<Container>> {
       : source_(std::move(source)),
         container_(container) { }
 
-    template<class Handler>
+    template <class Handler>
     bool apply(Handler&& handler) const {
       auto iter = container_->begin();
       return source_.apply([&](const Value& value) -> bool {
@@ -75,16 +74,12 @@ class Interleave : public Operator<Interleave<Container>> {
     }
   };
 
-  template<class Value2,
-           class Source,
-           class Gen = Generator<Value2,Source>>
+  template <class Value2, class Source, class Gen = Generator<Value2, Source>>
   Gen compose(GenImpl<Value2, Source>&& source) const {
     return Gen(std::move(source.self()), container_);
   }
 
-  template<class Value2,
-           class Source,
-           class Gen = Generator<Value2,Source>>
+  template <class Value2, class Source, class Gen = Generator<Value2, Source>>
   Gen compose(const GenImpl<Value2, Source>& source) const {
     return Gen(source.self(), container_);
   }
@@ -97,7 +92,7 @@ class Interleave : public Operator<Interleave<Container>> {
  * them into a tuple.
  *
  */
-template<class Container>
+template <class Container>
 class Zip : public Operator<Zip<Container>> {
   // see comment about copies in CopiedSource
   const std::shared_ptr<const Container> container_;
@@ -105,11 +100,13 @@ class Zip : public Operator<Zip<Container>> {
   explicit Zip(Container container)
     : container_(new Container(std::move(container))) {}
 
-  template<class Value1,
-           class Source,
-           class Value2 = decltype(*std::begin(*container_)),
-           class Result = std::tuple<typename std::decay<Value1>::type,
-                                     typename std::decay<Value2>::type>>
+  template <
+      class Value1,
+      class Source,
+      class Value2 = decltype(*std::begin(*container_)),
+      class Result = std::tuple<
+          typename std::decay<Value1>::type,
+          typename std::decay<Value2>::type>>
   class Generator : public GenImpl<Result,
                                    Generator<Value1,Source,Value2,Result>> {
     Source source_;
@@ -120,7 +117,7 @@ class Zip : public Operator<Zip<Container>> {
       : source_(std::move(source)),
         container_(container) { }
 
-    template<class Handler>
+    template <class Handler>
     bool apply(Handler&& handler) const {
       auto iter = container_->begin();
       return (source_.apply([&](Value1 value) -> bool {
@@ -136,30 +133,24 @@ class Zip : public Operator<Zip<Container>> {
     }
   };
 
-  template<class Source,
-           class Value,
-           class Gen = Generator<Value, Source>>
+  template <class Source, class Value, class Gen = Generator<Value, Source>>
   Gen compose(GenImpl<Value, Source>&& source) const {
     return Gen(std::move(source.self()), container_);
   }
 
-  template<class Source,
-           class Value,
-           class Gen = Generator<Value, Source>>
+  template <class Source, class Value, class Gen = Generator<Value, Source>>
   Gen compose(const GenImpl<Value, Source>& source) const {
     return Gen(source.self(), container_);
   }
 };
 
-template<class... Types1,
-         class... Types2>
+template <class... Types1, class... Types2>
 auto add_to_tuple(std::tuple<Types1...> t1, std::tuple<Types2...> t2) ->
 std::tuple<Types1..., Types2...> {
   return std::tuple_cat(std::move(t1), std::move(t2));
 }
 
-template<class... Types1,
-         class Type2>
+template <class... Types1, class Type2>
 auto add_to_tuple(std::tuple<Types1...> t1, Type2&& t2) ->
 decltype(std::tuple_cat(std::move(t1),
                         std::make_tuple(std::forward<Type2>(t2)))) {
@@ -167,8 +158,7 @@ decltype(std::tuple_cat(std::move(t1),
                         std::make_tuple(std::forward<Type2>(t2)));
 }
 
-template<class Type1,
-         class... Types2>
+template <class Type1, class... Types2>
 auto add_to_tuple(Type1&& t1, std::tuple<Types2...> t2) ->
 decltype(std::tuple_cat(std::make_tuple(std::forward<Type1>(t1)),
                         std::move(t2))) {
@@ -176,8 +166,7 @@ decltype(std::tuple_cat(std::make_tuple(std::forward<Type1>(t1)),
                         std::move(t2));
 }
 
-template<class Type1,
-         class Type2>
+template <class Type1, class Type2>
 auto add_to_tuple(Type1&& t1, Type2&& t2) ->
 decltype(std::make_tuple(std::forward<Type1>(t1),
                          std::forward<Type2>(t2))) {
@@ -188,7 +177,7 @@ decltype(std::make_tuple(std::forward<Type1>(t1),
 // Merges a 2-tuple into a single tuple (get<0> could already be a tuple)
 class MergeTuples {
  public:
-  template<class Tuple>
+  template <class Tuple>
   auto operator()(Tuple&& value) const ->
   decltype(add_to_tuple(std::get<0>(std::forward<Tuple>(value)),
                         std::get<1>(std::forward<Tuple>(value)))) {
@@ -205,8 +194,9 @@ class MergeTuples {
 
 // TODO(mcurtiss): support zip() for N>1 operands. Because of variadic problems,
 // this might not be easily possible until gcc4.8 is available.
-template<class Source,
-         class Zip = detail::Zip<typename std::decay<Source>::type>>
+template <
+    class Source,
+    class Zip = detail::Zip<typename std::decay<Source>::type>>
 Zip zip(Source&& source) {
   return Zip(std::forward<Source>(source));
 }

folly/gen/Combine.h

@@ -23,17 +23,18 @@ namespace folly {
 namespace gen {
 namespace detail {
 
-template<class Container>
+template <class Container>
 class Interleave;
 
-template<class Container>
+template <class Container>
 class Zip;
 
 } // namespace detail
 
-template<class Source2,
-         class Source2Decayed = typename std::decay<Source2>::type,
-         class Interleave = detail::Interleave<Source2Decayed>>
+template <
+    class Source2,
+    class Source2Decayed = typename std::decay<Source2>::type,
+    class Interleave = detail::Interleave<Source2Decayed>>
 Interleave interleave(Source2&& source2) {
   return Interleave(std::forward<Source2>(source2));
 }

folly/gen/Core.h

@@ -20,21 +20,21 @@
 namespace folly {
 namespace gen {
 
-template<class Value, class Self>
+template <class Value, class Self>
 class GenImpl;
 
-template<class Self>
+template <class Self>
 class Operator;
 
 namespace detail {
 
-template<class Self>
+template <class Self>
 struct FBounded;
 
-template<class First, class Second>
+template <class First, class Second>
 class Composed;
 
-template<class Value, class First, class Second>
+template <class Value, class First, class Second>
 class Chain;
 
 } // detail

folly/gen/Parallel-inl.h

@@ -132,11 +132,12 @@ class Sub : public Operator<Sub<Sink>> {
  public:
   explicit Sub(Sink sink) : sink_(sink) {}
 
-  template <class Value,
-            class Source,
-            class Result =
-                decltype(std::declval<Sink>().compose(std::declval<Source>())),
-            class Just = SingleCopy<typename std::decay<Result>::type>>
+  template <
+      class Value,
+      class Source,
+      class Result =
+          decltype(std::declval<Sink>().compose(std::declval<Source>())),
+      class Just = SingleCopy<typename std::decay<Result>::type>>
   Just compose(const GenImpl<Value, Source>& source) const {
     return Just(source | sink_);
   }
@@ -150,13 +151,14 @@ class Parallel : public Operator<Parallel<Ops>> {
  public:
   Parallel(Ops ops, size_t threads) : ops_(std::move(ops)), threads_(threads) {}
 
-  template <class Input,
-            class Source,
-            class InputDecayed = typename std::decay<Input>::type,
-            class Composed =
-                decltype(std::declval<Ops>().compose(Empty<InputDecayed&&>())),
-            class Output = typename Composed::ValueType,
-            class OutputDecayed = typename std::decay<Output>::type>
+  template <
+      class Input,
+      class Source,
+      class InputDecayed = typename std::decay<Input>::type,
+      class Composed =
+          decltype(std::declval<Ops>().compose(Empty<InputDecayed&&>())),
+      class Output = typename Composed::ValueType,
+      class OutputDecayed = typename std::decay<Output>::type>
   class Generator : public GenImpl<OutputDecayed&&,
                                    Generator<Input,
                                              Source,

folly/gen/Parallel.h

@@ -42,16 +42,18 @@ class ChunkedRangeSource;
  * Especially for use with 'parallel()', chunked can be used to process values
  * from a persistent container in chunks larger than one value at a time. The
  * values produced are generators for slices of the input container. */
-template <class Container,
-          class Iterator = typename Container::const_iterator,
-          class Chunked = detail::ChunkedRangeSource<Iterator>>
+template <
+    class Container,
+    class Iterator = typename Container::const_iterator,
+    class Chunked = detail::ChunkedRangeSource<Iterator>>
 Chunked chunked(const Container& container, int chunkSize = 256) {
   return Chunked(chunkSize, folly::range(container.begin(), container.end()));
 }
 
-template <class Container,
-          class Iterator = typename Container::iterator,
-          class Chunked = detail::ChunkedRangeSource<Iterator>>
+template <
+    class Container,
+    class Iterator = typename Container::iterator,
+    class Chunked = detail::ChunkedRangeSource<Iterator>>
 Chunked chunked(Container& container, int chunkSize = 256) {
   return Chunked(chunkSize, folly::range(container.begin(), container.end()));
 }

folly/gen/ParallelMap-inl.h

@@ -42,7 +42,7 @@ namespace detail {
  *
  *   auto squares = seq(1, 10) | pmap(fibonacci, 4) | sum;
  */
-template<class Predicate>
+template <class Predicate>
 class PMap : public Operator<PMap<Predicate>> {
   Predicate pred_;
   size_t nThreads_;
@@ -53,12 +53,12 @@ class PMap : public Operator<PMap<Predicate>> {
     : pred_(std::move(pred)),
       nThreads_(nThreads) { }
 
-  template<class Value,
-           class Source,
-           class Input = typename std::decay<Value>::type,
-           class Output = typename std::decay<
-             typename std::result_of<Predicate(Value)>::type
-             >::type>
+  template <
+      class Value,
+      class Source,
+      class Input = typename std::decay<Value>::type,
+      class Output = typename std::decay<
+          typename std::result_of<Predicate(Value)>::type>::type>
   class Generator :
     public GenImpl<Output, Generator<Value, Source, Input, Output>> {
     Source source_;
@@ -153,7 +153,7 @@ class PMap : public Operator<PMap<Predicate>> {
         nThreads_(nThreads ? nThreads : sysconf(_SC_NPROCESSORS_ONLN)) {
     }
 
-    template<class Body>
+    template <class Body>
     void foreach(Body&& body) const {
       ExecutionPipeline pipeline(pred_, nThreads_);
 
@@ -190,7 +190,7 @@ class PMap : public Operator<PMap<Predicate>> {
       }
     }
 
-    template<class Handler>
+    template <class Handler>
     bool apply(Handler&& handler) const {
       ExecutionPipeline pipeline(pred_, nThreads_);
 
@@ -238,16 +238,12 @@ class PMap : public Operator<PMap<Predicate>> {
     static constexpr bool infinite = Source::infinite;
   };
 
-  template<class Source,
-           class Value,
-           class Gen = Generator<Value, Source>>
+  template <class Source, class Value, class Gen = Generator<Value, Source>>
   Gen compose(GenImpl<Value, Source>&& source) const {
     return Gen(std::move(source.self()), pred_, nThreads_);
   }
 
-  template<class Source,
-           class Value,
-           class Gen = Generator<Value, Source>>
+  template <class Source, class Value, class Gen = Generator<Value, Source>>
   Gen compose(const GenImpl<Value, Source>& source) const {
     return Gen(source.self(), pred_, nThreads_);
   }

folly/gen/ParallelMap.h

@@ -24,7 +24,7 @@ namespace gen {
 
 namespace detail {
 
-template<class Predicate>
+template <class Predicate>
 class PMap;
 
 } // namespace detail
@@ -38,8 +38,7 @@ class PMap;
  *       generator and the rest of the pipeline is executed in the
  *       caller thread.
  */
-template<class Predicate,
-         class PMap = detail::PMap<Predicate>>
+template <class Predicate, class PMap = detail::PMap<Predicate>>
   PMap pmap(Predicate pred = Predicate(), size_t nThreads = 0) {
   return PMap(std::move(pred), nThreads);
 }

folly/gen/String-inl.h

@@ -258,16 +258,12 @@ class StringResplitter : public Operator<StringResplitter> {
     static constexpr bool infinite = Source::infinite;
   };
 
-  template<class Source,
-           class Value,
-           class Gen = Generator<Source>>
+  template <class Source, class Value, class Gen = Generator<Source>>
   Gen compose(GenImpl<Value, Source>&& source) const {
     return Gen(std::move(source.self()), delimiter_, keepDelimiter_);
   }
 
-  template<class Source,
-           class Value,
-           class Gen = Generator<Source>>
+  template <class Source, class Value, class Gen = Generator<Source>>
   Gen compose(const GenImpl<Value, Source>& source) const {
     return Gen(source.self(), delimiter_, keepDelimiter_);
   }
@@ -309,8 +305,7 @@ class SplitStringSource
  *
  * This type is primarily used through the 'unsplit' function.
  */
-template<class Delimiter,
-         class Output>
+template <class Delimiter, class Output>
 class Unsplit : public Operator<Unsplit<Delimiter, Output>> {
   Delimiter delimiter_;
  public:
@@ -318,8 +313,7 @@ class Unsplit : public Operator<Unsplit<Delimiter, Output>> {
     : delimiter_(delimiter) {
   }
 
-  template<class Source,
-           class Value>
+  template <class Source, class Value>
   Output compose(const GenImpl<Value, Source>& source) const {
     Output outputBuffer;
     UnsplitBuffer<Delimiter, Output> unsplitter(delimiter_, &outputBuffer);
@@ -334,8 +328,7 @@ class Unsplit : public Operator<Unsplit<Delimiter, Output>> {
  *
  * This type is primarily used through the 'unsplit' function.
  */
-template<class Delimiter,
-         class OutputBuffer>
+template <class Delimiter, class OutputBuffer>
 class UnsplitBuffer : public Operator<UnsplitBuffer<Delimiter, OutputBuffer>> {
   Delimiter delimiter_;
   OutputBuffer* outputBuffer_;
@@ -346,8 +339,7 @@ class UnsplitBuffer : public Operator<UnsplitBuffer<Delimiter, OutputBuffer>> {
     CHECK(outputBuffer);
   }
 
-  template<class Source,
-           class Value>
+  template <class Source, class Value>
   void compose(const GenImpl<Value, Source>& source) const {
     // If the output buffer is empty, we skip inserting the delimiter for the
     // first element.
@@ -367,7 +359,7 @@ class UnsplitBuffer : public Operator<UnsplitBuffer<Delimiter, OutputBuffer>> {
 /**
  * Hack for static for-like constructs
  */
-template<class Target, class=void>
+template <class Target, class = void>
 inline Target passthrough(Target target) { return target; }
 
 FOLLY_PUSH_WARNING
@@ -386,9 +378,7 @@ FOLLY_PUSH_WARNING
  *    | as<vector<tuple<int, string>>>();
  *
  */
-template<class TargetContainer,
-         class Delimiter,
-         class... Targets>
+template <class TargetContainer, class Delimiter, class... Targets>
 class SplitTo {
   Delimiter delimiter_;
  public:

folly/gen/String.h

@@ -27,18 +27,16 @@ namespace gen {
 namespace detail {
 class StringResplitter;
 
-template<class Delimiter>
+template <class Delimiter>
 class SplitStringSource;
 
-template<class Delimiter, class Output>
+template <class Delimiter, class Output>
 class Unsplit;
 
-template<class Delimiter, class OutputBuffer>
+template <class Delimiter, class OutputBuffer>
 class UnsplitBuffer;
 
-template<class TargetContainer,
-         class Delimiter,
-         class... Targets>
+template <class TargetContainer, class Delimiter, class... Targets>
 class SplitTo;
 
 } // namespace detail
@@ -97,15 +95,17 @@ S lines(StringPiece source) {
 
 // NOTE: The template arguments are reversed to allow the user to cleanly
 // specify the output type while still inferring the type of the delimiter.
-template<class Output = folly::fbstring,
-         class Delimiter,
-         class Unsplit = detail::Unsplit<Delimiter, Output>>
+template <
+    class Output = folly::fbstring,
+    class Delimiter,
+    class Unsplit = detail::Unsplit<Delimiter, Output>>
 Unsplit unsplit(const Delimiter& delimiter) {
   return Unsplit(delimiter);
 }
 
-template<class Output = folly::fbstring,
-         class Unsplit = detail::Unsplit<fbstring, Output>>
+template <
+    class Output = folly::fbstring,
+    class Unsplit = detail::Unsplit<fbstring, Output>>
 Unsplit unsplit(const char* delimiter) {
   return Unsplit(delimiter);
 }
@@ -124,21 +124,22 @@ Unsplit unsplit(const char* delimiter) {
  *   split("a,b,c", ",") | unsplit(",", &anotherbuffer);
  *   assert(anotherBuffer == "initial,a,b,c");
  */
-template<class Delimiter,
-         class OutputBuffer,
-         class UnsplitBuffer = detail::UnsplitBuffer<Delimiter, OutputBuffer>>
+template <
+    class Delimiter,
+    class OutputBuffer,
+    class UnsplitBuffer = detail::UnsplitBuffer<Delimiter, OutputBuffer>>
 UnsplitBuffer unsplit(Delimiter delimiter, OutputBuffer* outputBuffer) {
   return UnsplitBuffer(delimiter, outputBuffer);
 }
 
-template<class OutputBuffer,
-         class UnsplitBuffer = detail::UnsplitBuffer<fbstring, OutputBuffer>>
+template <
+    class OutputBuffer,
+    class UnsplitBuffer = detail::UnsplitBuffer<fbstring, OutputBuffer>>
 UnsplitBuffer unsplit(const char* delimiter, OutputBuffer* outputBuffer) {
   return UnsplitBuffer(delimiter, outputBuffer);
 }
 
-
-template<class... Targets>
+template <class... Targets>
 detail::Map<detail::SplitTo<std::tuple<Targets...>, char, Targets...>>
 eachToTuple(char delim) {
   return detail::Map<
@@ -146,7 +147,7 @@ eachToTuple(char delim) {
     detail::SplitTo<std::tuple<Targets...>, char, Targets...>(delim));
 }
 
-template<class... Targets>
+template <class... Targets>
 detail::Map<detail::SplitTo<std::tuple<Targets...>, fbstring, Targets...>>
 eachToTuple(StringPiece delim) {
   return detail::Map<
@@ -154,7 +155,7 @@ eachToTuple(StringPiece delim) {
     detail::SplitTo<std::tuple<Targets...>, fbstring, Targets...>(delim));
 }
 
-template<class First, class Second>
+template <class First, class Second>
 detail::Map<detail::SplitTo<std::pair<First, Second>, char, First, Second>>
 eachToPair(char delim) {
   return detail::Map<
@@ -162,7 +163,7 @@ eachToPair(char delim) {
     detail::SplitTo<std::pair<First, Second>, char, First, Second>(delim));
 }
 
-template<class First, class Second>
+template <class First, class Second>
 detail::Map<detail::SplitTo<std::pair<First, Second>, fbstring, First, Second>>
 eachToPair(StringPiece delim) {
   return detail::Map<

folly/gen/test/BaseBenchmark.cpp

@@ -174,7 +174,7 @@ BENCHMARK_RELATIVE(Fib_Sum_Gen, iters) {
 }
 
 struct FibYielder {
-  template<class Yield>
+  template <class Yield>
   void operator()(Yield&& yield) const {
     int a = 0;
     int b = 1;

folly/gen/test/BaseTest.cpp

@@ -48,12 +48,12 @@ EXPECT_SAME(int&, typename ArgumentReference<int&>::type);
 EXPECT_SAME(const int&, typename ArgumentReference<const int&>::type);
 EXPECT_SAME(const int&, typename ArgumentReference<const int>::type);
 
-template<typename T>
+template <typename T>
 ostream& operator<<(ostream& os, const set<T>& values) {
   return os << from(values);
 }
 
-template<typename T>
+template <typename T>
 ostream& operator<<(ostream& os, const vector<T>& values) {
   os << "[";
   for (auto& value : values) {
@@ -71,7 +71,7 @@ auto multiply = [](int a, int b) { return a * b; };
 
 auto product = foldl(1, multiply);
 
-template<typename A, typename B>
+template <typename A, typename B>
 ostream& operator<<(ostream& os, const pair<A, B>& pair) {
   return os << "(" << pair.first << ", " << pair.second << ")";
 }

folly/gen/test/ParallelTest.cpp

@@ -50,7 +50,7 @@ static auto isPrime = [](int n) {
 };
 
 struct {
-  template<class T>
+  template <class T>
   std::unique_ptr<T> operator()(T t) const {
     return std::unique_ptr<T>(new T(std::move(t)));
   }

folly/gen/test/StringTest.cpp

@@ -288,7 +288,7 @@ TEST(StringGen, ResplitMaxLength) {
   );
 }
 
-template<typename F>
+template <typename F>
 void runUnsplitSuite(F fn) {
   fn("hello, world");
   fn("hello,world,goodbye");