Applied clang-format to the source.

include/gsl_util.h

@@ -19,11 +19,11 @@
 #ifndef GSL_UTIL_H
 #define GSL_UTIL_H
 
-#include "gsl_assert.h"  // Ensures/Expects
+#include "gsl_assert.h" // Ensures/Expects
 #include <array>
-#include <utility>
-#include <type_traits>
 #include <exception>
+#include <type_traits>
+#include <utility>
 
 #ifdef _MSC_VER
 
@@ -32,7 +32,7 @@
 #define constexpr
 
 #pragma warning(push)
-#pragma warning(disable: 4127) // conditional expression is constant
+#pragma warning(disable : 4127) // conditional expression is constant
 
 // MSVC 2013 workarounds
 #if _MSC_VER <= 1800
@@ -42,13 +42,12 @@
 
 // turn off some misguided warnings
 #pragma warning(push)
-#pragma warning(disable: 4351) // warns about newly introduced aggregate initializer behavior
+#pragma warning(disable : 4351) // warns about newly introduced aggregate initializer behavior
 
 #endif // _MSC_VER <= 1800
 
 #endif // _MSC_VER
 
-
 namespace gsl
 {
 //
@@ -60,18 +59,20 @@ template <class F>
 class final_act
 {
 public:
-    explicit final_act(F f) noexcept
-    : f_(std::move(f)), invoke_(true)
-    {}
+    explicit final_act(F f) noexcept : f_(std::move(f)), invoke_(true) {}
 
-    final_act(final_act&& other) noexcept
-    : f_(std::move(other.f_)), invoke_(other.invoke_)
-    { other.invoke_ = false; }
+    final_act(final_act&& other) noexcept : f_(std::move(other.f_)), invoke_(other.invoke_)
+    {
+        other.invoke_ = false;
+    }
 
     final_act(const final_act&) = delete;
     final_act& operator=(const final_act&) = delete;
 
-    ~final_act() noexcept { if (invoke_) f_(); }
+    ~final_act() noexcept
+    {
+        if (invoke_) f_();
+    }
 
 private:
     F f_;
@@ -80,35 +81,44 @@ private:
 
 // finally() - convenience function to generate a final_act
 template <class F>
-inline final_act<F> finally(const F &f)
-noexcept { return final_act<F>(f); }
+inline final_act<F> finally(const F& f) noexcept
+{
+    return final_act<F>(f);
+}
 
 template <class F>
-inline final_act<F> finally(F &&f) noexcept
-{ return final_act<F>(std::forward<F>(f)); }
+inline final_act<F> finally(F&& f) noexcept
+{
+    return final_act<F>(std::forward<F>(f));
+}
 
 // narrow_cast(): a searchable way to do narrowing casts of values
-template<class T, class U>
+template <class T, class U>
 inline constexpr T narrow_cast(U u) noexcept
-{ return static_cast<T>(u); }
+{
+    return static_cast<T>(u);
+}
 
-struct narrowing_error : public std::exception {};
+struct narrowing_error : public std::exception
+{
+};
 
 namespace details
 {
-    template<class T, class U>
-    struct is_same_signedness : public std::integral_constant<bool, std::is_signed<T>::value == std::is_signed<U>::value>
-    {};
+    template <class T, class U>
+    struct is_same_signedness
+        : public std::integral_constant<bool, std::is_signed<T>::value == std::is_signed<U>::value>
+    {
+    };
 }
 
 // narrow() : a checked version of narrow_cast() that throws if the cast changed the value
-template<class T, class U>
+template <class T, class U>
 inline T narrow(U u)
 {
     T t = narrow_cast<T>(u);
-    if (static_cast<U>(t) != u)
-        throw narrowing_error();
-#pragma warning(suppress:4127) // suppress warning from MSVC compiler about constant in if-test
+    if (static_cast<U>(t) != u) throw narrowing_error();
+#pragma warning(suppress : 4127) // suppress warning from MSVC compiler about constant in if-test
     if (!details::is_same_signedness<T, U>::value && ((t < T{}) != (u < U{})))
         throw narrowing_error();
     return t;
@@ -118,24 +128,35 @@ inline T narrow(U u)
 // at() - Bounds-checked way of accessing static arrays, std::array, std::vector
 //
 template <class T, size_t N>
-constexpr T& at(T(&arr)[N], size_t index)
-{ Expects(index < N); return arr[index]; }
+constexpr T& at(T (&arr)[N], size_t index)
+{
+    Expects(index < N);
+    return arr[index];
+}
 
 template <class T, size_t N>
 constexpr T& at(std::array<T, N>& arr, size_t index)
-{ Expects(index < N); return arr[index]; }
+{
+    Expects(index < N);
+    return arr[index];
+}
 
 template <class Cont>
 constexpr typename Cont::value_type& at(Cont& cont, size_t index)
-{ Expects(index < cont.size()); return cont[index]; }
+{
+    Expects(index < cont.size());
+    return cont[index];
+}
 
 template <class T>
 constexpr const T& at(std::initializer_list<T> cont, size_t index)
-{ Expects(index < cont.size()); return *(cont.begin() + index); }
+{
+    Expects(index < cont.size());
+    return *(cont.begin() + index);
+}
 
 } // namespace gsl
 
-
 #ifdef _MSC_VER
 
 #pragma warning(pop)