make clang-format using clang-format-3.6

1 files changed, 24 insertions, 57 deletions

diff --git a/src/array_fun.h b/src/array_fun.h
index 9a749c01..6a934b3f 100644
--- a/src/array_fun.h
+++ b/src/array_fun.h
@@ -42,123 +42,90 @@
 
 namespace aria2 {
 
-template<typename T, size_t N>
-constexpr size_t arraySize(T (&)[N])
+template <typename T, size_t N> constexpr size_t arraySize(T(&)[N])
 {
   return N;
 }
 
-template<typename T, size_t N>
-class array_wrapper {
+template <typename T, size_t N> class array_wrapper {
 private:
   T array_[N];
+
 public:
   array_wrapper() {}
 
-  operator T*()
-  {
-    return array_;
-  }
+  operator T*() { return array_; }
 
-  operator const T*() const
-  {
-    return array_;
-  }
+  operator const T*() const { return array_; }
 
-  size_t size() const
-  {
-    return N;
-  }
+  size_t size() const { return N; }
 };
 
 // Expression Template for array
 
 namespace expr {
 
-template<typename L, typename R, typename Op>
-struct BinExpr {
+template <typename L, typename R, typename Op> struct BinExpr {
   typedef typename Op::result_type value_type;
 
   BinExpr(L lhs, R rhs, Op op)
-    : lhs(std::move(lhs)), rhs(std::move(rhs)), op(std::move(op))
-  {}
-
-  value_type operator[](size_t i) const
+      : lhs(std::move(lhs)), rhs(std::move(rhs)), op(std::move(op))
   {
-    return op(lhs[i], rhs[i]);
   }
 
+  value_type operator[](size_t i) const { return op(lhs[i], rhs[i]); }
+
   L lhs;
   R rhs;
   Op op;
 };
 
-template<typename L, typename R,
-         typename Op = std::bit_and<typename L::value_type>>
+template <typename L, typename R,
+          typename Op = std::bit_and<typename L::value_type>>
 BinExpr<L, R, Op> operator&(L lhs, R rhs)
 {
   return BinExpr<L, R, Op>(std::forward<L>(lhs), std::forward<R>(rhs), Op());
 }
 
-template<typename L, typename R,
-         typename Op = std::bit_or<typename L::value_type>>
+template <typename L, typename R,
+          typename Op = std::bit_or<typename L::value_type>>
 BinExpr<L, R, Op> operator|(L lhs, R rhs)
 {
   return BinExpr<L, R, Op>(std::forward<L>(lhs), std::forward<R>(rhs), Op());
 }
 
-template<typename Arg, typename Op>
-struct UnExpr {
+template <typename Arg, typename Op> struct UnExpr {
   typedef typename Op::result_type value_type;
 
-  UnExpr(Arg arg, Op op)
-    : arg(std::move(arg)), op(std::move(op))
-  {}
+  UnExpr(Arg arg, Op op) : arg(std::move(arg)), op(std::move(op)) {}
 
-  value_type operator[](size_t i) const
-  {
-    return op(arg[i]);
-  }
+  value_type operator[](size_t i) const { return op(arg[i]); }
 
   Arg arg;
   Op op;
 };
 
-template<typename T>
-struct bit_neg : std::function<T(T)> {
-  T operator()(T t) const
-  {
-    return ~t;
-  }
+template <typename T> struct bit_neg : std::function<T(T)> {
+  T operator()(T t) const { return ~t; }
 };
 
-template<typename Arg, typename Op = bit_neg<typename Arg::value_type>>
+template <typename Arg, typename Op = bit_neg<typename Arg::value_type>>
 UnExpr<Arg, Op> operator~(Arg arg)
 {
   return UnExpr<Arg, Op>(std::forward<Arg>(arg), Op());
 }
 
-template<typename T>
-struct Array {
+template <typename T> struct Array {
   typedef T value_type;
 
-  Array(T* t)
-    : t(t)
-  {}
+  Array(T* t) : t(t) {}
 
-  T operator[](size_t i) const
-  {
-    return t[i];
-  }
+  T operator[](size_t i) const { return t[i]; }
 
   T* t;
 };
 
-template<typename T>
-Array<T> array(T *t)
-{
-  return Array<T>(t);
-}
+template <typename T> Array<T> array(T* t) { return Array<T>(t); }
 
 } // namespace expr