astyle

example/example.cpp

@@ -112,7 +112,8 @@ int main(int, char*[])
 
 // Example of user defined class with operator<<
 class some_class {};
-std::ostream& operator<<(std::ostream& os, const some_class&) {
+std::ostream& operator<<(std::ostream& os, const some_class&)
+{
     return os << "some_class";
 }
 

include/spdlog/details/async_log_helper.h

@@ -64,7 +64,7 @@ class async_log_helper
         async_msg() = default;
         ~async_msg() = default;
 
-        async_msg(async_msg&& other) SPDLOG_NOEXCEPT:
+async_msg(async_msg&& other) SPDLOG_NOEXCEPT:
         logger_name(std::move(other.logger_name)),
                     level(std::move(other.level)),
                     time(std::move(other.time)),

include/spdlog/details/format.h

@@ -49,10 +49,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifdef _MSC_VER
 # include <intrin.h>  // _BitScanReverse, _BitScanReverse64
 
-namespace fmt {
-namespace internal {
+namespace fmt
+{
+namespace internal
+{
 # pragma intrinsic(_BitScanReverse)
-inline uint32_t clz(uint32_t x) {
+inline uint32_t clz(uint32_t x)
+{
     unsigned long r = 0;
     _BitScanReverse(&r, x);
     return 31 - r;
@@ -63,7 +66,8 @@ inline uint32_t clz(uint32_t x) {
 #  pragma intrinsic(_BitScanReverse64)
 # endif
 
-inline uint32_t clzll(uint64_t x) {
+inline uint32_t clzll(uint64_t x)
+{
     unsigned long r = 0;
 # ifdef _WIN64
     _BitScanReverse64(&r, x);
@@ -174,7 +178,8 @@ inline uint32_t clzll(uint64_t x) {
     TypeName& operator=(const TypeName&)
 #endif
 
-namespace fmt {
+namespace fmt
+{
 
 // Fix the warning about long long on older versions of GCC
 // that don't support the diagnostic pragma.
@@ -223,7 +228,8 @@ format(std::string("{}"), 42);
 \endrst
 */
 template <typename Char>
-class BasicStringRef {
+class BasicStringRef
+{
 private:
     const Char *data_;
     std::size_t size_;
@@ -250,28 +256,33 @@ public:
     /**
     Converts a string reference to an `std::string` object.
     */
-    operator std::basic_string<Char>() const {
+    operator std::basic_string<Char>() const
+    {
         return std::basic_string<Char>(data_, size());
     }
 
     /**
     Returns the pointer to a C string.
     */
-    const Char *c_str() const {
+    const Char *c_str() const
+    {
         return data_;
     }
 
     /**
     Returns the string size.
     */
-    std::size_t size() const {
+    std::size_t size() const
+    {
         return size_;
     }
 
-    friend bool operator==(BasicStringRef lhs, BasicStringRef rhs) {
+    friend bool operator==(BasicStringRef lhs, BasicStringRef rhs)
+    {
         return lhs.data_ == rhs.data_;
     }
-    friend bool operator!=(BasicStringRef lhs, BasicStringRef rhs) {
+    friend bool operator!=(BasicStringRef lhs, BasicStringRef rhs)
+    {
         return lhs.data_ != rhs.data_;
     }
 };
@@ -282,13 +293,15 @@ typedef BasicStringRef<wchar_t> WStringRef;
 /**
 A formatting error such as invalid format string.
 */
-class FormatError : public std::runtime_error {
+class FormatError : public std::runtime_error
+{
 public:
     explicit FormatError(StringRef message)
         : std::runtime_error(message.c_str()) {}
 };
 
-namespace internal {
+namespace internal
+{
 
 // The number of characters to store in the MemoryBuffer object itself
 // to avoid dynamic memory allocation.
@@ -297,19 +310,22 @@ enum { INLINE_BUFFER_SIZE = 500 };
 #if _SECURE_SCL
 // Use checked iterator to avoid warnings on MSVC.
 template <typename T>
-inline stdext::checked_array_iterator<T*> make_ptr(T *ptr, std::size_t size) {
+inline stdext::checked_array_iterator<T*> make_ptr(T *ptr, std::size_t size)
+{
     return stdext::checked_array_iterator<T*>(ptr, size);
 }
 #else
 template <typename T>
-inline T *make_ptr(T *ptr, std::size_t) {
+inline T *make_ptr(T *ptr, std::size_t)
+{
     return ptr;
 }
 #endif
 
 // A buffer for POD types. It supports a subset of std::vector's operations.
 template <typename T>
-class Buffer {
+class Buffer
+{
 private:
     FMT_DISALLOW_COPY_AND_ASSIGN(Buffer);
 
@@ -327,31 +343,36 @@ public:
     virtual ~Buffer() {}
 
     // Returns the size of this buffer.
-    std::size_t size() const {
+    std::size_t size() const
+    {
         return size_;
     }
 
     // Returns the capacity of this buffer.
-    std::size_t capacity() const {
+    std::size_t capacity() const
+    {
         return capacity_;
     }
 
     // Resizes the buffer. If T is a POD type new elements are not initialized.
-    void resize(std::size_t new_size) {
+    void resize(std::size_t new_size)
+    {
         if (new_size > capacity_)
             grow(new_size);
         size_ = new_size;
     }
 
     // Reserves space to store at least capacity elements.
-    void reserve(std::size_t capacity) {
+    void reserve(std::size_t capacity)
+    {
         if (capacity > capacity_)
             grow(capacity);
     }
 
-    void clear() FMT_NOEXCEPT{ size_ = 0; }
+    void clear() FMT_NOEXCEPT { size_ = 0; }
 
-    void push_back(const T &value) {
+    void push_back(const T &value)
+    {
         if (size_ == capacity_)
             grow(size_ + 1);
         ptr_[size_++] = value;
@@ -360,16 +381,19 @@ public:
     // Appends data to the end of the buffer.
     void append(const T *begin, const T *end);
 
-    T &operator[](std::size_t index) {
+    T &operator[](std::size_t index)
+    {
         return ptr_[index];
     }
-    const T &operator[](std::size_t index) const {
+    const T &operator[](std::size_t index) const
+    {
         return ptr_[index];
     }
 };
 
 template <typename T>
-void Buffer<T>::append(const T *begin, const T *end) {
+void Buffer<T>::append(const T *begin, const T *end)
+{
     std::ptrdiff_t num_elements = end - begin;
     if (size_ + num_elements > capacity_)
         grow(size_ + num_elements);
@@ -380,12 +404,14 @@ void Buffer<T>::append(const T *begin, const T *end) {
 // A memory buffer for POD types with the first SIZE elements stored in
 // the object itself.
 template <typename T, std::size_t SIZE, typename Allocator = std::allocator<T> >
-class MemoryBuffer : private Allocator, public Buffer<T> {
+class MemoryBuffer : private Allocator, public Buffer<T>
+{
 private:
     T data_[SIZE];
 
     // Free memory allocated by the buffer.
-    void free() {
+    void free()
+    {
         if (this->ptr_ != data_) this->deallocate(this->ptr_, this->capacity_);
     }
 
@@ -395,24 +421,28 @@ protected:
 public:
     explicit MemoryBuffer(const Allocator &alloc = Allocator())
         : Allocator(alloc), Buffer<T>(data_, SIZE) {}
-    ~MemoryBuffer() {
+    ~MemoryBuffer()
+    {
         free();
     }
 
 #if FMT_USE_RVALUE_REFERENCES
 private:
     // Move data from other to this buffer.
-    void move(MemoryBuffer &other) {
+    void move(MemoryBuffer &other)
+    {
         Allocator &this_alloc = *this, &other_alloc = other;
         this_alloc = std::move(other_alloc);
         this->size_ = other.size_;
         this->capacity_ = other.capacity_;
-        if (other.ptr_ == other.data_) {
+        if (other.ptr_ == other.data_)
+        {
             this->ptr_ = data_;
             std::copy(other.data_,
                       other.data_ + this->size_, make_ptr(data_, this->capacity_));
         }
-        else {
+        else
+        {
             this->ptr_ = other.ptr_;
             // Set pointer to the inline array so that delete is not called
             // when freeing.
@@ -421,11 +451,13 @@ private:
     }
 
 public:
-    MemoryBuffer(MemoryBuffer &&other) {
+    MemoryBuffer(MemoryBuffer &&other)
+    {
         move(other);
     }
 
-    MemoryBuffer &operator=(MemoryBuffer &&other) {
+    MemoryBuffer &operator=(MemoryBuffer &&other)
+    {
         assert(this != &other);
         free();
         move(other);
@@ -434,13 +466,15 @@ public:
 #endif
 
     // Returns a copy of the allocator associated with this buffer.
-    Allocator get_allocator() const {
+    Allocator get_allocator() const
+    {
         return *this;
     }
 };
 
 template <typename T, std::size_t SIZE, typename Allocator>
-void MemoryBuffer<T, SIZE, Allocator>::grow(std::size_t size) {
+void MemoryBuffer<T, SIZE, Allocator>::grow(std::size_t size)
+{
     std::size_t new_capacity =
         (std::max)(size, this->capacity_ + this->capacity_ / 2);
     T *new_ptr = this->allocate(new_capacity);
@@ -460,7 +494,8 @@ void MemoryBuffer<T, SIZE, Allocator>::grow(std::size_t size) {
 
 #ifndef _MSC_VER
 // Portable version of signbit.
-inline int getsign(double x) {
+inline int getsign(double x)
+{
     // When compiled in C++11 mode signbit is no longer a macro but a function
     // defined in namespace std and the macro is undefined.
 # ifdef signbit
@@ -472,22 +507,27 @@ inline int getsign(double x) {
 
 // Portable version of isinf.
 # ifdef isinf
-inline int isinfinity(double x) {
+inline int isinfinity(double x)
+{
     return isinf(x);
 }
-inline int isinfinity(long double x) {
+inline int isinfinity(long double x)
+{
     return isinf(x);
 }
 # else
-inline int isinfinity(double x) {
+inline int isinfinity(double x)
+{
     return std::isinf(x);
 }
-inline int isinfinity(long double x) {
+inline int isinfinity(long double x)
+{
     return std::isinf(x);
 }
 # endif
 #else
-inline int getsign(double value) {
+inline int getsign(double value)
+{
     if (value < 0) return 1;
     if (value == value) return 0;
     int dec = 0, sign = 0;
@@ -495,16 +535,19 @@ inline int getsign(double value) {
     _ecvt_s(buffer, sizeof(buffer), value, 0, &dec, &sign);
     return sign;
 }
-inline int isinfinity(double x) {
+inline int isinfinity(double x)
+{
     return !_finite(x);
 }
-inline int isinfinity(long double x) {
+inline int isinfinity(long double x)
+{
     return !_finite(static_cast<double>(x));
 }
 #endif
 
 template <typename Char>
-class BasicCharTraits {
+class BasicCharTraits
+{
 public:
 #if _SECURE_SCL
     typedef stdext::checked_array_iterator<Char*> CharPtr;
@@ -517,13 +560,15 @@ template <typename Char>
 class CharTraits;
 
 template <>
-class CharTraits<char> : public BasicCharTraits<char> {
+class CharTraits<char> : public BasicCharTraits<char>
+{
 private:
     // Conversion from wchar_t to char is not allowed.
     static char convert(wchar_t);
 
 public:
-    static char convert(char value) {
+    static char convert(char value)
+    {
         return value;
     }
 
@@ -534,12 +579,15 @@ public:
 };
 
 template <>
-class CharTraits<wchar_t> : public BasicCharTraits<wchar_t> {
+class CharTraits<wchar_t> : public BasicCharTraits<wchar_t>
+{
 public:
-    static wchar_t convert(char value) {
+    static wchar_t convert(char value)
+    {
         return value;
     }
-    static wchar_t convert(wchar_t value) {
+    static wchar_t convert(wchar_t value)
+    {
         return value;
     }
 
@@ -550,17 +598,21 @@ public:
 
 // Checks if a number is negative - used to avoid warnings.
 template <bool IsSigned>
-struct SignChecker {
+struct SignChecker
+{
     template <typename T>
-    static bool is_negative(T value) {
+    static bool is_negative(T value)
+    {
         return value < 0;
     }
 };
 
 template <>
-struct SignChecker<false> {
+struct SignChecker<false>
+{
     template <typename T>
-    static bool is_negative(T) {
+    static bool is_negative(T)
+    {
         return false;
     }
 };
@@ -568,23 +620,27 @@ struct SignChecker<false> {
 // Returns true if value is negative, false otherwise.
 // Same as (value < 0) but doesn't produce warnings if T is an unsigned type.
 template <typename T>
-inline bool is_negative(T value) {
+inline bool is_negative(T value)
+{
     return SignChecker<std::numeric_limits<T>::is_signed>::is_negative(value);
 }
 
 // Selects uint32_t if FitsIn32Bits is true, uint64_t otherwise.
 template <bool FitsIn32Bits>
-struct TypeSelector {
+struct TypeSelector
+{
     typedef uint32_t Type;
 };
 
 template <>
-struct TypeSelector<false> {
+struct TypeSelector<false>
+{
     typedef uint64_t Type;
 };
 
 template <typename T>
-struct IntTraits {
+struct IntTraits
+{
     // Smallest of uint32_t and uint64_t that is large enough to represent
     // all values of T.
     typedef typename
@@ -593,7 +649,8 @@ struct IntTraits {
 
 // MakeUnsigned<T>::Type gives an unsigned type corresponding to integer type T.
 template <typename T>
-struct MakeUnsigned {
+struct MakeUnsigned
+{
     typedef T Type;
 };
 
@@ -613,7 +670,8 @@ void report_unknown_type(char code, const char *type);
 // Static data is placed in this class template to allow header-only
 // configuration.
 template <typename T = void>
-struct BasicData {
+struct BasicData
+{
     static const uint32_t POWERS_OF_10_32[];
     static const uint64_t POWERS_OF_10_64[];
     static const char DIGITS[];
@@ -632,7 +690,8 @@ typedef BasicData<> Data;
 #ifdef FMT_BUILTIN_CLZLL
 // Returns the number of decimal digits in n. Leading zeros are not counted
 // except for n == 0 in which case count_digits returns 1.
-inline unsigned count_digits(uint64_t n) {
+inline unsigned count_digits(uint64_t n)
+{
     // Based on http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10
     // and the benchmark https://github.com/localvoid/cxx-benchmark-count-digits.
     unsigned t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12;
@@ -640,9 +699,11 @@ inline unsigned count_digits(uint64_t n) {
 }
 #else
 // Fallback version of count_digits used when __builtin_clz is not available.
-inline unsigned count_digits(uint64_t n) {
+inline unsigned count_digits(uint64_t n)
+{
     unsigned count = 1;
-    for (;;) {
+    for (;;)
+    {
         // Integer division is slow so do it for a group of four digits instead
         // of for every digit. The idea comes from the talk by Alexandrescu
         // "Three Optimization Tips for C++". See speed-test for a comparison.
@@ -658,7 +719,8 @@ inline unsigned count_digits(uint64_t n) {
 
 #ifdef FMT_BUILTIN_CLZ
 // Optional version of count_digits for better performance on 32-bit platforms.
-inline unsigned count_digits(uint32_t n) {
+inline unsigned count_digits(uint32_t n)
+{
     uint32_t t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12;
     return t - (n < Data::POWERS_OF_10_32[t]) + 1;
 }
@@ -666,9 +728,11 @@ inline unsigned count_digits(uint32_t n) {
 
 // Formats a decimal unsigned integer value writing into buffer.
 template <typename UInt, typename Char>
-inline void format_decimal(Char *buffer, UInt value, unsigned num_digits) {
+inline void format_decimal(Char *buffer, UInt value, unsigned num_digits)
+{
     --num_digits;
-    while (value >= 100) {
+    while (value >= 100)
+    {
         // Integer division is slow so do it for a group of two digits instead
         // of for every digit. The idea comes from the talk by Alexandrescu
         // "Three Optimization Tips for C++". See speed-test for a comparison.
@@ -678,7 +742,8 @@ inline void format_decimal(Char *buffer, UInt value, unsigned num_digits) {
         buffer[num_digits - 1] = Data::DIGITS[index];
         num_digits -= 2;
     }
-    if (value < 10) {
+    if (value < 10)
+    {
         *buffer = static_cast<char>('0' + value);
         return;
     }
@@ -690,45 +755,55 @@ inline void format_decimal(Char *buffer, UInt value, unsigned num_digits) {
 #ifdef _WIN32
 // A converter from UTF-8 to UTF-16.
 // It is only provided for Windows since other systems support UTF-8 natively.
-class UTF8ToUTF16 {
+class UTF8ToUTF16
+{
 private:
     MemoryBuffer<wchar_t, INLINE_BUFFER_SIZE> buffer_;
 
 public:
     explicit UTF8ToUTF16(StringRef s);
-    operator WStringRef() const {
+    operator WStringRef() const
+    {
         return WStringRef(&buffer_[0], size());
     }
-    size_t size() const {
+    size_t size() const
+    {
         return buffer_.size() - 1;
     }
-    const wchar_t *c_str() const {
+    const wchar_t *c_str() const
+    {
         return &buffer_[0];
     }
-    std::wstring str() const {
+    std::wstring str() const
+    {
         return std::wstring(&buffer_[0], size());
     }
 };
 
 // A converter from UTF-16 to UTF-8.
 // It is only provided for Windows since other systems support UTF-8 natively.
-class UTF16ToUTF8 {
+class UTF16ToUTF8
+{
 private:
     MemoryBuffer<char, INLINE_BUFFER_SIZE> buffer_;
 
 public:
     UTF16ToUTF8() {}
     explicit UTF16ToUTF8(WStringRef s);
-    operator StringRef() const {
+    operator StringRef() const
+    {
         return StringRef(&buffer_[0], size());
     }
-    size_t size() const {
+    size_t size() const
+    {
         return buffer_.size() - 1;
     }
-    const char *c_str() const {
+    const char *c_str() const
+    {
         return &buffer_[0];
     }
-    std::string str() const {
+    std::string str() const
+    {
         return std::string(&buffer_[0], size());
     }
 
@@ -750,20 +825,24 @@ void format_windows_error(fmt::Writer &out, int error_code,
 // Computes max(Arg, 1) at compile time. It is used to avoid errors about
 // allocating an array of 0 size.
 template <unsigned Arg>
-struct NonZero {
+struct NonZero
+{
     enum { VALUE = Arg };
 };
 
 template <>
-struct NonZero<0> {
+struct NonZero<0>
+{
     enum { VALUE = 1 };
 };
 
 // The value of a formatting argument. It is a POD type to allow storage in
 // internal::MemoryBuffer.
-struct Value {
+struct Value
+{
     template <typename Char>
-    struct StringValue {
+    struct StringValue
+    {
         const Char *value;
         std::size_t size;
     };
@@ -771,12 +850,14 @@ struct Value {
     typedef void(*FormatFunc)(
         void *formatter, const void *arg, void *format_str_ptr);
 
-    struct CustomValue {
+    struct CustomValue
+    {
         const void *value;
         FormatFunc format;
     };
 
-    union {
+    union
+    {
         int int_value;
         unsigned uint_value;
         LongLong long_long_value;
@@ -792,8 +873,10 @@ struct Value {
     };
 };
 
-struct Arg : Value {
-    enum Type {
+struct Arg : Value
+{
+    enum Type
+    {
         NONE,
         // Integer types should go first,
         INT, UINT, LONG_LONG, ULONG_LONG, CHAR, LAST_INTEGER_TYPE = CHAR,
@@ -810,20 +893,23 @@ struct None {};
 // A helper class template to enable or disable overloads taking wide
 // characters and strings in MakeValue.
 template <typename T, typename Char>
-struct WCharHelper {
+struct WCharHelper
+{
     typedef None<T> Supported;
     typedef T Unsupported;
 };
 
 template <typename T>
-struct WCharHelper<T, wchar_t> {
+struct WCharHelper<T, wchar_t>
+{
     typedef T Supported;
     typedef None<T> Unsupported;
 };
 
 // Makes a Value object from any type.
 template <typename Char>
-class MakeValue : public Value {
+class MakeValue : public Value
+{
 private:
     // The following two methods are private to disallow formatting of
     // arbitrary pointers. If you want to output a pointer cast it to
@@ -845,12 +931,14 @@ private:
     MakeValue(typename WCharHelper<const std::wstring &, Char>::Unsupported);
     MakeValue(typename WCharHelper<WStringRef, Char>::Unsupported);
 
-    void set_string(StringRef str) {
+    void set_string(StringRef str)
+    {
         string.value = str.c_str();
         string.size = str.size();
     }
 
-    void set_string(WStringRef str) {
+    void set_string(WStringRef str)
+    {
         wstring.value = str.c_str();
         wstring.size = str.size();
     }
@@ -858,7 +946,8 @@ private:
     // Formats an argument of a custom type, such as a user-defined class.
     template <typename T>
     static void format_custom_arg(
-        void *formatter, const void *arg, void *format_str_ptr) {
+        void *formatter, const void *arg, void *format_str_ptr)
+    {
         format(*static_cast<BasicFormatter<Char>*>(formatter),
                *static_cast<const Char**>(format_str_ptr),
                *static_cast<const T*>(arg));
@@ -877,7 +966,8 @@ public:
     FMT_MAKE_VALUE(int, int_value, INT)
     FMT_MAKE_VALUE(unsigned, uint_value, UINT)
 
-    MakeValue(long value) {
+    MakeValue(long value)
+    {
         // To minimize the number of types we need to deal with, long is
         // translated either to int or to long long depending on its size.
         if (sizeof(long) == sizeof(int))
@@ -885,17 +975,20 @@ public:
         else
             long_long_value = value;
     }
-    static uint64_t type(long) {
+    static uint64_t type(long)
+    {
         return sizeof(long) == sizeof(int) ? Arg::INT : Arg::LONG_LONG;
     }
 
-    MakeValue(unsigned long value) {
+    MakeValue(unsigned long value)
+    {
         if (sizeof(unsigned long) == sizeof(unsigned))
             uint_value = static_cast<unsigned>(value);
         else
             ulong_long_value = value;
     }
-    static uint64_t type(unsigned long) {
+    static uint64_t type(unsigned long)
+    {
         return sizeof(unsigned long) == sizeof(unsigned) ?
                Arg::UINT : Arg::ULONG_LONG;
     }
@@ -909,10 +1002,12 @@ public:
     FMT_MAKE_VALUE(unsigned char, int_value, CHAR)
     FMT_MAKE_VALUE(char, int_value, CHAR)
 
-    MakeValue(typename WCharHelper<wchar_t, Char>::Supported value) {
+    MakeValue(typename WCharHelper<wchar_t, Char>::Supported value)
+    {
         int_value = value;
     }
-    static uint64_t type(wchar_t) {
+    static uint64_t type(wchar_t)
+    {
         return Arg::CHAR;
     }
 
@@ -942,12 +1037,14 @@ public:
     FMT_MAKE_VALUE(const void *, pointer, POINTER)
 
     template <typename T>
-    MakeValue(const T &value) {
+    MakeValue(const T &value)
+    {
         custom.value = &value;
         custom.format = &format_custom_arg<T>;
     }
     template <typename T>
-    static uint64_t type(const T &) {
+    static uint64_t type(const T &)
+    {
         return Arg::CUSTOM;
     }
 };
@@ -975,58 +1072,75 @@ public:
 // ArgVisitor uses the curiously recurring template pattern:
 // http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern
 template <typename Impl, typename Result>
-class ArgVisitor {
+class ArgVisitor
+{
 public:
-    Result visit_unhandled_arg() {
+    Result visit_unhandled_arg()
+    {
         return Result();
     }
 
-    Result visit_int(int value) {
+    Result visit_int(int value)
+    {
         return FMT_DISPATCH(visit_any_int(value));
     }
-    Result visit_long_long(LongLong value) {
+    Result visit_long_long(LongLong value)
+    {
         return FMT_DISPATCH(visit_any_int(value));
     }
-    Result visit_uint(unsigned value) {
+    Result visit_uint(unsigned value)
+    {
         return FMT_DISPATCH(visit_any_int(value));
     }
-    Result visit_ulong_long(ULongLong value) {
+    Result visit_ulong_long(ULongLong value)
+    {
         return FMT_DISPATCH(visit_any_int(value));
     }
-    Result visit_char(int value) {
+    Result visit_char(int value)
+    {
         return FMT_DISPATCH(visit_any_int(value));
     }
     template <typename T>
-    Result visit_any_int(T) {
+    Result visit_any_int(T)
+    {
         return FMT_DISPATCH(visit_unhandled_arg());
     }
 
-    Result visit_double(double value) {
+    Result visit_double(double value)
+    {
         return FMT_DISPATCH(visit_any_double(value));
     }
-    Result visit_long_double(long double value) {
+    Result visit_long_double(long double value)
+    {
         return FMT_DISPATCH(visit_any_double(value));
     }
     template <typename T>
-    Result visit_any_double(T) {
+    Result visit_any_double(T)
+    {
         return FMT_DISPATCH(visit_unhandled_arg());
     }
 
-    Result visit_string(Arg::StringValue<char>) {
+    Result visit_string(Arg::StringValue<char>)
+    {
         return FMT_DISPATCH(visit_unhandled_arg());
     }
-    Result visit_wstring(Arg::StringValue<wchar_t>) {
+    Result visit_wstring(Arg::StringValue<wchar_t>)
+    {
         return FMT_DISPATCH(visit_unhandled_arg());
     }
-    Result visit_pointer(const void *) {
+    Result visit_pointer(const void *)
+    {
         return FMT_DISPATCH(visit_unhandled_arg());
     }
-    Result visit_custom(Arg::CustomValue) {
+    Result visit_custom(Arg::CustomValue)
+    {
         return FMT_DISPATCH(visit_unhandled_arg());
     }
 
-    Result visit(const Arg &arg) {
-        switch (arg.type) {
+    Result visit(const Arg &arg)
+    {
+        switch (arg.type)
+        {
         default:
             assert(false);
             return Result();
@@ -1044,7 +1158,8 @@ public:
             return FMT_DISPATCH(visit_long_double(arg.long_double_value));
         case Arg::CHAR:
             return FMT_DISPATCH(visit_char(arg.int_value));
-        case Arg::CSTRING: {
+        case Arg::CSTRING:
+        {
             Value::StringValue<char> str = arg.string;
             str.size = 0;
             return FMT_DISPATCH(visit_string(str));
@@ -1061,7 +1176,8 @@ public:
     }
 };
 
-class RuntimeError : public std::runtime_error {
+class RuntimeError : public std::runtime_error
+{
 protected:
     RuntimeError() : std::runtime_error("") {}
 };
@@ -1073,7 +1189,8 @@ class ArgFormatter;
 /**
 An argument list.
 */
-class ArgList {
+class ArgList
+{
 private:
     uint64_t types_;
     const internal::Value *values_;
@@ -1089,10 +1206,12 @@ public:
     /**
     Returns the argument at specified index.
     */
-    internal::Arg operator[](unsigned index) const {
+    internal::Arg operator[](unsigned index) const
+    {
         using internal::Arg;
         Arg arg;
-        if (index >= MAX_ARGS) {
+        if (index >= MAX_ARGS)
+        {
             arg.type = Arg::NONE;
             return arg;
         }
@@ -1101,7 +1220,8 @@ public:
         Arg::Type type =
             static_cast<Arg::Type>((types_ & (mask << shift)) >> shift);
         arg.type = type;
-        if (type != Arg::NONE) {
+        if (type != Arg::NONE)
+        {
             internal::Value &value = arg;
             value = values_[index];
         }
@@ -1111,9 +1231,11 @@ public:
 
 struct FormatSpec;
 
-namespace internal {
+namespace internal
+{
 
-class FormatterBase {
+class FormatterBase
+{
 private:
     ArgList args_;
     int next_arg_index_;
@@ -1122,7 +1244,8 @@ private:
     Arg do_get_arg(unsigned arg_index, const char *&error);
 
 protected:
-    void set_args(const ArgList &args) {
+    void set_args(const ArgList &args)
+    {
         args_ = args;
         next_arg_index_ = 0;
     }
@@ -1135,7 +1258,8 @@ protected:
     Arg get_arg(unsigned arg_index, const char *&error);
 
     template <typename Char>
-    void write(BasicWriter<Char> &w, const Char *start, const Char *end) {
+    void write(BasicWriter<Char> &w, const Char *start, const Char *end)
+    {
         if (start != end)
             w << BasicStringRef<Char>(start, end - start);
     }
@@ -1143,7 +1267,8 @@ protected:
 
 // A printf formatter.
 template <typename Char>
-class PrintfFormatter : private FormatterBase {
+class PrintfFormatter : private FormatterBase
+{
 private:
     void parse_flags(FormatSpec &spec, const Char *&s);
 
@@ -1163,7 +1288,8 @@ public:
 
 // A formatter.
 template <typename Char>
-class BasicFormatter : private internal::FormatterBase {
+class BasicFormatter : private internal::FormatterBase
+{
 private:
     BasicWriter<Char> &writer_;
     const Char *start_;
@@ -1176,7 +1302,8 @@ private:
 public:
     explicit BasicFormatter(BasicWriter<Char> &w) : writer_(w) {}
 
-    BasicWriter<Char> &writer() {
+    BasicWriter<Char> &writer()
+    {
         return writer_;
     }
 
@@ -1185,12 +1312,14 @@ public:
     const Char *format(const Char *&format_str, const internal::Arg &arg);
 };
 
-enum Alignment {
+enum Alignment
+{
     ALIGN_DEFAULT, ALIGN_LEFT, ALIGN_RIGHT, ALIGN_CENTER, ALIGN_NUMERIC
 };
 
 // Flags.
-enum {
+enum
+{
     SIGN_FLAG = 1, PLUS_FLAG = 2, MINUS_FLAG = 4, HASH_FLAG = 8,
     CHAR_FLAG = 0x10  // Argument has char type - used in error reporting.
 };
@@ -1200,29 +1329,37 @@ struct EmptySpec {};
 
 // A type specifier.
 template <char TYPE>
-struct TypeSpec : EmptySpec {
-    Alignment align() const {
+struct TypeSpec : EmptySpec
+{
+    Alignment align() const
+    {
         return ALIGN_DEFAULT;
     }
-    unsigned width() const {
+    unsigned width() const
+    {
         return 0;
     }
-    int precision() const {
+    int precision() const
+    {
         return -1;
     }
-    bool flag(unsigned) const {
+    bool flag(unsigned) const
+    {
         return false;
     }
-    char type() const {
+    char type() const
+    {
         return TYPE;
     }
-    char fill() const {
+    char fill() const
+    {
         return ' ';
     }
 };
 
 // A width specifier.
-struct WidthSpec {
+struct WidthSpec
+{
     unsigned width_;
     // Fill is always wchar_t and cast to char if necessary to avoid having
     // two specialization of WidthSpec and its subclasses.
@@ -1230,45 +1367,54 @@ struct WidthSpec {
 
     WidthSpec(unsigned width, wchar_t fill) : width_(width), fill_(fill) {}
 
-    unsigned width() const {
+    unsigned width() const
+    {
         return width_;
     }
-    wchar_t fill() const {
+    wchar_t fill() const
+    {
         return fill_;
     }
 };
 
 // An alignment specifier.
-struct AlignSpec : WidthSpec {
+struct AlignSpec : WidthSpec
+{
     Alignment align_;
 
     AlignSpec(unsigned width, wchar_t fill, Alignment align = ALIGN_DEFAULT)
         : WidthSpec(width, fill), align_(align) {}
 
-    Alignment align() const {
+    Alignment align() const
+    {
         return align_;
     }
 
-    int precision() const {
+    int precision() const
+    {
         return -1;
     }
 };
 
 // An alignment and type specifier.
 template <char TYPE>
-struct AlignTypeSpec : AlignSpec {
+struct AlignTypeSpec : AlignSpec
+{
     AlignTypeSpec(unsigned width, wchar_t fill) : AlignSpec(width, fill) {}
 
-    bool flag(unsigned) const {
+    bool flag(unsigned) const
+    {
         return false;
     }
-    char type() const {
+    char type() const
+    {
         return TYPE;
     }
 };
 
 // A full format specifier.
-struct FormatSpec : AlignSpec {
+struct FormatSpec : AlignSpec
+{
     unsigned flags_;
     int precision_;
     char type_;
@@ -1277,20 +1423,24 @@ struct FormatSpec : AlignSpec {
         unsigned width = 0, char type = 0, wchar_t fill = ' ')
         : AlignSpec(width, fill), flags_(0), precision_(-1), type_(type) {}
 
-    bool flag(unsigned f) const {
+    bool flag(unsigned f) const
+    {
         return (flags_ & f) != 0;
     }
-    int precision() const {
+    int precision() const
+    {
         return precision_;
     }
-    char type() const {
+    char type() const
+    {
         return type_;
     }
 };
 
 // An integer format specifier.
 template <typename T, typename SpecT = TypeSpec<0>, typename Char = char>
-class IntFormatSpec : public SpecT {
+class IntFormatSpec : public SpecT
+{
 private:
     T value_;
 
@@ -1298,14 +1448,16 @@ public:
     IntFormatSpec(T val, const SpecT &spec = SpecT())
         : SpecT(spec), value_(val) {}
 
-    T value() const {
+    T value() const
+    {
         return value_;
     }
 };
 
 // A string format specifier.
 template <typename T>
-class StrFormatSpec : public AlignSpec {
+class StrFormatSpec : public AlignSpec
+{
 private:
     const T *str_;
 
@@ -1313,7 +1465,8 @@ public:
     StrFormatSpec(const T *str, unsigned width, wchar_t fill)
         : AlignSpec(width, fill), str_(str) {}
 
-    const T *str() const {
+    const T *str() const
+    {
         return str_;
     }
 };
@@ -1428,12 +1581,14 @@ std::string s = str(MemoryWriter() << pad("abc", 8));
 */
 template <typename Char>
 inline StrFormatSpec<Char> pad(
-    const Char *str, unsigned width, Char fill = ' ') {
+    const Char *str, unsigned width, Char fill = ' ')
+{
     return StrFormatSpec<Char>(str, width, fill);
 }
 
 inline StrFormatSpec<wchar_t> pad(
-    const wchar_t *str, unsigned width, char fill = ' ') {
+    const wchar_t *str, unsigned width, char fill = ' ')
+{
     return StrFormatSpec<wchar_t>(str, width, fill);
 }
 
@@ -1456,24 +1611,29 @@ inline StrFormatSpec<wchar_t> pad(
 # define FMT_GEN14(f) FMT_GEN13(f), f(13)
 # define FMT_GEN15(f) FMT_GEN14(f), f(14)
 
-namespace internal {
-inline uint64_t make_type() {
+namespace internal
+{
+inline uint64_t make_type()
+{
     return 0;
 }
 
 template <typename T>
-inline uint64_t make_type(const T &arg) {
+inline uint64_t make_type(const T &arg)
+{
     return MakeValue<char>::type(arg);
 }
 
 #if FMT_USE_VARIADIC_TEMPLATES
 template <typename Arg, typename... Args>
-inline uint64_t make_type(const Arg &first, const Args & ... tail) {
+inline uint64_t make_type(const Arg &first, const Args & ... tail)
+{
     return make_type(first) | (make_type(tail...) << 4);
 }
 #else
 
-struct ArgType {
+struct ArgType
+{
     uint64_t type;
 
     ArgType() : type(0) {}
@@ -1484,7 +1644,8 @@ struct ArgType {
 
 # define FMT_ARG_TYPE_DEFAULT(n) ArgType t##n = ArgType()
 
-inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) {
+inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT))
+{
     return t0.type | (t1.type << 4) | (t2.type << 8) | (t3.type << 12) |
            (t4.type << 16) | (t5.type << 20) | (t6.type << 24) | (t7.type << 28) |
            (t8.type << 32) | (t9.type << 36) | (t10.type << 40) | (t11.type << 44) |
@@ -1595,7 +1756,8 @@ inline uint64_t make_type(FMT_GEN15(FMT_ARG_TYPE_DEFAULT)) {
 An error returned by an operating system or a language runtime,
 for example a file opening error.
 */
-class SystemError : public internal::RuntimeError {
+class SystemError : public internal::RuntimeError
+{
 private:
     void init(int err_code, StringRef format_str, ArgList args);
 
@@ -1632,12 +1794,14 @@ public:
     throw fmt::SystemError(errno, "cannot open file '{}'", filename);
     \endrst
     */
-    SystemError(int error_code, StringRef message) {
+    SystemError(int error_code, StringRef message)
+    {
         init(error_code, message, ArgList());
     }
     FMT_VARIADIC_CTOR(SystemError, init, int, StringRef)
 
-    int error_code() const {
+    int error_code() const
+    {
         return error_code_;
     }
 };
@@ -1661,7 +1825,8 @@ You can use one of the following typedefs for common character types:
 \endrst
 */
 template <typename Char>
-class BasicWriter {
+class BasicWriter
+{
 private:
     // Output buffer.
     internal::Buffer<Char> &buffer_;
@@ -1672,11 +1837,13 @@ private:
 
 #if _SECURE_SCL
     // Returns pointer value.
-    static Char *get(CharPtr p) {
+    static Char *get(CharPtr p)
+    {
         return p.base();
     }
 #else
-    static Char *get(Char *p) {
+    static Char *get(Char *p)
+    {
         return p;
     }
 #endif
@@ -1688,7 +1855,8 @@ private:
 
     // Grows the buffer by n characters and returns a pointer to the newly
     // allocated area.
-    CharPtr grow_buffer(std::size_t n) {
+    CharPtr grow_buffer(std::size_t n)
+    {
         std::size_t size = buffer_.size();
         buffer_.resize(size + n);
         return internal::make_ptr(&buffer_[size], n);
@@ -1696,7 +1864,8 @@ private:
 
     // Prepare a buffer for integer formatting.
     CharPtr prepare_int_buffer(unsigned num_digits,
-                               const EmptySpec &, const char *prefix, unsigned prefix_size) {
+                               const EmptySpec &, const char *prefix, unsigned prefix_size)
+    {
         unsigned size = prefix_size + num_digits;
         CharPtr p = grow_buffer(size);
         std::copy(prefix, prefix + prefix_size, p);
@@ -1734,7 +1903,8 @@ private:
 
     // Appends floating-point length specifier to the format string.
     // The second argument is only used for overload resolution.
-    void append_float_length(Char *&format_ptr, long double) {
+    void append_float_length(Char *&format_ptr, long double)
+    {
         *format_ptr++ = 'L';
     }
 
@@ -1759,7 +1929,8 @@ public:
     /**
     Returns the total number of characters written.
     */
-    std::size_t size() const {
+    std::size_t size() const
+    {
         return buffer_.size();
     }
 
@@ -1767,7 +1938,8 @@ public:
     Returns a pointer to the output buffer content. No terminating null
     character is appended.
     */
-    const Char *data() const FMT_NOEXCEPT {
+    const Char *data() const FMT_NOEXCEPT
+    {
         return &buffer_[0];
     }
 
@@ -1775,7 +1947,8 @@ public:
     Returns a pointer to the output buffer content with terminating null
     character appended.
     */
-    const Char *c_str() const {
+    const Char *c_str() const
+    {
         std::size_t size = buffer_.size();
         buffer_.reserve(size + 1);
         buffer_[size] = '\0';
@@ -1785,7 +1958,8 @@ public:
     /**
     Returns the content of the output buffer as an `std::string`.
     */
-    std::basic_string<Char> str() const {
+    std::basic_string<Char> str() const
+    {
         return std::basic_string<Char>(&buffer_[0], buffer_.size());
     }
 
@@ -1814,35 +1988,43 @@ public:
     See also :ref:`syntax`.
     \endrst
     */
-    void write(BasicStringRef<Char> format, ArgList args) {
+    void write(BasicStringRef<Char> format, ArgList args)
+    {
         BasicFormatter<Char>(*this).format(format, args);
     }
     FMT_VARIADIC_VOID(write, BasicStringRef<Char>)
 
-    BasicWriter &operator<<(int value) {
+    BasicWriter &operator<<(int value)
+    {
         return *this << IntFormatSpec<int>(value);
     }
-    BasicWriter &operator<<(unsigned value) {
+    BasicWriter &operator<<(unsigned value)
+    {
         return *this << IntFormatSpec<unsigned>(value);
     }
-    BasicWriter &operator<<(long value) {
+    BasicWriter &operator<<(long value)
+    {
         return *this << IntFormatSpec<long>(value);
     }
-    BasicWriter &operator<<(unsigned long value) {
+    BasicWriter &operator<<(unsigned long value)
+    {
         return *this << IntFormatSpec<unsigned long>(value);
     }
-    BasicWriter &operator<<(LongLong value) {
+    BasicWriter &operator<<(LongLong value)
+    {
         return *this << IntFormatSpec<LongLong>(value);
     }
 
     /**
     Formats *value* and writes it to the stream.
     */
-    BasicWriter &operator<<(ULongLong value) {
+    BasicWriter &operator<<(ULongLong value)
+    {
         return *this << IntFormatSpec<ULongLong>(value);
     }
 
-    BasicWriter &operator<<(double value) {
+    BasicWriter &operator<<(double value)
+    {
         write_double(value, FormatSpec());
         return *this;
     }
@@ -1851,7 +2033,8 @@ public:
     Formats *value* using the general format for floating-point numbers
     (``'g'``) and writes it to the stream.
     */
-    BasicWriter &operator<<(long double value) {
+    BasicWriter &operator<<(long double value)
+    {
         write_double(value, FormatSpec());
         return *this;
     }
@@ -1859,13 +2042,15 @@ public:
     /**
     Writes a character to the stream.
     */
-    BasicWriter &operator<<(char value) {
+    BasicWriter &operator<<(char value)
+    {
         buffer_.push_back(value);
         return *this;
     }
 
     BasicWriter &operator<<(
-        typename internal::WCharHelper<wchar_t, Char>::Supported value) {
+        typename internal::WCharHelper<wchar_t, Char>::Supported value)
+    {
         buffer_.push_back(value);
         return *this;
     }
@@ -1873,50 +2058,59 @@ public:
     /**
     Writes *value* to the stream.
     */
-    BasicWriter &operator<<(fmt::BasicStringRef<Char> value) {
+    BasicWriter &operator<<(fmt::BasicStringRef<Char> value)
+    {
         const Char *str = value.c_str();
         buffer_.append(str, str + value.size());
         return *this;
     }
 
     template <typename T, typename Spec, typename FillChar>
-    BasicWriter &operator<<(IntFormatSpec<T, Spec, FillChar> spec) {
+    BasicWriter &operator<<(IntFormatSpec<T, Spec, FillChar> spec)
+    {
         internal::CharTraits<Char>::convert(FillChar());
         write_int(spec.value(), spec);
         return *this;
     }
 
     template <typename StrChar>
-    BasicWriter &operator<<(const StrFormatSpec<StrChar> &spec) {
+    BasicWriter &operator<<(const StrFormatSpec<StrChar> &spec)
+    {
         const StrChar *s = spec.str();
         // TODO: error if fill is not convertible to Char
         write_str(s, std::char_traits<Char>::length(s), spec);
         return *this;
     }
 
-    void clear() FMT_NOEXCEPT{ buffer_.clear(); }
+    void clear() FMT_NOEXCEPT { buffer_.clear(); }
 };
 
 template <typename Char>
 template <typename StrChar>
 typename BasicWriter<Char>::CharPtr BasicWriter<Char>::write_str(
-    const StrChar *s, std::size_t size, const AlignSpec &spec) {
+    const StrChar *s, std::size_t size, const AlignSpec &spec)
+{
     CharPtr out = CharPtr();
-    if (spec.width() > size) {
+    if (spec.width() > size)
+    {
         out = grow_buffer(spec.width());
         Char fill = static_cast<Char>(spec.fill());
-        if (spec.align() == ALIGN_RIGHT) {
+        if (spec.align() == ALIGN_RIGHT)
+        {
             std::fill_n(out, spec.width() - size, fill);
             out += spec.width() - size;
         }
-        else if (spec.align() == ALIGN_CENTER) {
+        else if (spec.align() == ALIGN_CENTER)
+        {
             out = fill_padding(out, spec.width(), size, fill);
         }
-        else {
+        else
+        {
             std::fill_n(out + size, spec.width() - size, fill);
         }
     }
-    else {
+    else
+    {
         out = grow_buffer(size);
     }
     std::copy(s, s + size, out);
@@ -1927,7 +2121,8 @@ template <typename Char>
 typename BasicWriter<Char>::CharPtr
 BasicWriter<Char>::fill_padding(
     CharPtr buffer, unsigned total_size,
-    std::size_t content_size, wchar_t fill) {
+    std::size_t content_size, wchar_t fill)
+{
     std::size_t padding = total_size - content_size;
     std::size_t left_padding = padding / 2;
     Char fill_char = static_cast<Char>(fill);
@@ -1943,11 +2138,13 @@ template <typename Spec>
 typename BasicWriter<Char>::CharPtr
 BasicWriter<Char>::prepare_int_buffer(
     unsigned num_digits, const Spec &spec,
-    const char *prefix, unsigned prefix_size) {
+    const char *prefix, unsigned prefix_size)
+{
     unsigned width = spec.width();
     Alignment align = spec.align();
     Char fill = static_cast<Char>(spec.fill());
-    if (spec.precision() > static_cast<int>(num_digits)) {
+    if (spec.precision() > static_cast<int>(num_digits))
+    {
         // Octal prefix '0' is counted as a digit, so ignore it if precision
         // is specified.
         if (prefix_size > 0 && prefix[prefix_size - 1] == '0')
@@ -1958,44 +2155,53 @@ BasicWriter<Char>::prepare_int_buffer(
             return prepare_int_buffer(num_digits, subspec, prefix, prefix_size);
         buffer_.reserve(width);
         unsigned fill_size = width - number_size;
-        if (align != ALIGN_LEFT) {
+        if (align != ALIGN_LEFT)
+        {
             CharPtr p = grow_buffer(fill_size);
             std::fill(p, p + fill_size, fill);
         }
         CharPtr result = prepare_int_buffer(
                              num_digits, subspec, prefix, prefix_size);
-        if (align == ALIGN_LEFT) {
+        if (align == ALIGN_LEFT)
+        {
             CharPtr p = grow_buffer(fill_size);
             std::fill(p, p + fill_size, fill);
         }
         return result;
     }
     unsigned size = prefix_size + num_digits;
-    if (width <= size) {
+    if (width <= size)
+    {
         CharPtr p = grow_buffer(size);
         std::copy(prefix, prefix + prefix_size, p);
         return p + size - 1;
     }
     CharPtr p = grow_buffer(width);
     CharPtr end = p + width;
-    if (align == ALIGN_LEFT) {
+    if (align == ALIGN_LEFT)
+    {
         std::copy(prefix, prefix + prefix_size, p);
         p += size;
         std::fill(p, end, fill);
     }
-    else if (align == ALIGN_CENTER) {
+    else if (align == ALIGN_CENTER)
+    {
         p = fill_padding(p, width, size, fill);
         std::copy(prefix, prefix + prefix_size, p);
         p += size;
     }
-    else {
-        if (align == ALIGN_NUMERIC) {
-            if (prefix_size != 0) {
+    else
+    {
+        if (align == ALIGN_NUMERIC)
+        {
+            if (prefix_size != 0)
+            {
                 p = std::copy(prefix, prefix + prefix_size, p);
                 size -= prefix_size;
             }
         }
-        else {
+        else
+        {
             std::copy(prefix, prefix + prefix_size, end - size);
         }
         std::fill(p, end - size, fill);
@@ -2006,23 +2212,28 @@ BasicWriter<Char>::prepare_int_buffer(
 
 template <typename Char>
 template <typename T, typename Spec>
-void BasicWriter<Char>::write_int(T value, Spec spec) {
+void BasicWriter<Char>::write_int(T value, Spec spec)
+{
     unsigned prefix_size = 0;
     typedef typename internal::IntTraits<T>::MainType UnsignedType;
     UnsignedType abs_value = value;
     char prefix[4] = "";
-    if (internal::is_negative(value)) {
+    if (internal::is_negative(value))
+    {
         prefix[0] = '-';
         ++prefix_size;
         abs_value = 0 - abs_value;
     }
-    else if (spec.flag(SIGN_FLAG)) {
+    else if (spec.flag(SIGN_FLAG))
+    {
         prefix[0] = spec.flag(PLUS_FLAG) ? '+' : ' ';
         ++prefix_size;
     }
-    switch (spec.type()) {
+    switch (spec.type())
+    {
     case 0:
-    case 'd': {
+    case 'd':
+    {
         unsigned num_digits = internal::count_digits(abs_value);
         CharPtr p = prepare_int_buffer(
                         num_digits, spec, prefix, prefix_size) + 1 - num_digits;
@@ -2030,57 +2241,74 @@ void BasicWriter<Char>::write_int(T value, Spec spec) {
         break;
     }
     case 'x':
-    case 'X': {
+    case 'X':
+    {
         UnsignedType n = abs_value;
-        if (spec.flag(HASH_FLAG)) {
+        if (spec.flag(HASH_FLAG))
+        {
             prefix[prefix_size++] = '0';
             prefix[prefix_size++] = spec.type();
         }
         unsigned num_digits = 0;
-        do {
+        do
+        {
             ++num_digits;
-        } while ((n >>= 4) != 0);
+        }
+        while ((n >>= 4) != 0);
         Char *p = get(prepare_int_buffer(
                           num_digits, spec, prefix, prefix_size));
         n = abs_value;
         const char *digits = spec.type() == 'x' ?
                              "0123456789abcdef" : "0123456789ABCDEF";
-        do {
+        do
+        {
             *p-- = digits[n & 0xf];
-        } while ((n >>= 4) != 0);
+        }
+        while ((n >>= 4) != 0);
         break;
     }
     case 'b':
-    case 'B': {
+    case 'B':
+    {
         UnsignedType n = abs_value;
-        if (spec.flag(HASH_FLAG)) {
+        if (spec.flag(HASH_FLAG))
+        {
             prefix[prefix_size++] = '0';
             prefix[prefix_size++] = spec.type();
         }
         unsigned num_digits = 0;
-        do {
+        do
+        {
             ++num_digits;
-        } while ((n >>= 1) != 0);
+        }
+        while ((n >>= 1) != 0);
         Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size));
         n = abs_value;
-        do {
+        do
+        {
             *p-- = '0' + (n & 1);
-        } while ((n >>= 1) != 0);
+        }
+        while ((n >>= 1) != 0);
         break;
     }
-    case 'o': {
+    case 'o':
+    {
         UnsignedType n = abs_value;
         if (spec.flag(HASH_FLAG))
             prefix[prefix_size++] = '0';
         unsigned num_digits = 0;
-        do {
+        do
+        {
             ++num_digits;
-        } while ((n >>= 3) != 0);
+        }
+        while ((n >>= 3) != 0);
         Char *p = get(prepare_int_buffer(num_digits, spec, prefix, prefix_size));
         n = abs_value;
-        do {
+        do
+        {
             *p-- = '0' + (n & 7);
-        } while ((n >>= 3) != 0);
+        }
+        while ((n >>= 3) != 0);
         break;
     }
     default:
@@ -2093,11 +2321,13 @@ void BasicWriter<Char>::write_int(T value, Spec spec) {
 template <typename Char>
 template <typename T>
 void BasicWriter<Char>::write_double(
-    T value, const FormatSpec &spec) {
+    T value, const FormatSpec &spec)
+{
     // Check type.
     char type = spec.type();
     bool upper = false;
-    switch (type) {
+    switch (type)
+    {
     case 0:
         type = 'g';
         break;
@@ -2125,20 +2355,24 @@ void BasicWriter<Char>::write_double(
     char sign = 0;
     // Use getsign instead of value < 0 because the latter is always
     // false for NaN.
-    if (internal::getsign(static_cast<double>(value))) {
+    if (internal::getsign(static_cast<double>(value)))
+    {
         sign = '-';
         value = -value;
     }
-    else if (spec.flag(SIGN_FLAG)) {
+    else if (spec.flag(SIGN_FLAG))
+    {
         sign = spec.flag(PLUS_FLAG) ? '+' : ' ';
     }
 
-    if (value != value) {
+    if (value != value)
+    {
         // Format NaN ourselves because sprintf's output is not consistent
         // across platforms.
         std::size_t nan_size = 4;
         const char *nan = upper ? " NAN" : " nan";
-        if (!sign) {
+        if (!sign)
+        {
             --nan_size;
             ++nan;
         }
@@ -2148,12 +2382,14 @@ void BasicWriter<Char>::write_double(
         return;
     }
 
-    if (internal::isinfinity(value)) {
+    if (internal::isinfinity(value))
+    {
         // Format infinity ourselves because sprintf's output is not consistent
         // across platforms.
         std::size_t inf_size = 4;
         const char *inf = upper ? " INF" : " inf";
-        if (!sign) {
+        if (!sign)
+        {
             --inf_size;
             ++inf;
         }
@@ -2165,7 +2401,8 @@ void BasicWriter<Char>::write_double(
 
     std::size_t offset = buffer_.size();
     unsigned width = spec.width();
-    if (sign) {
+    if (sign)
+    {
         buffer_.reserve(buffer_.size() + (std::max)(width, 1u));
         if (width > 0)
             --width;
@@ -2180,16 +2417,19 @@ void BasicWriter<Char>::write_double(
     unsigned width_for_sprintf = width;
     if (spec.flag(HASH_FLAG))
         *format_ptr++ = '#';
-    if (spec.align() == ALIGN_CENTER) {
+    if (spec.align() == ALIGN_CENTER)
+    {
         width_for_sprintf = 0;
     }
-    else {
+    else
+    {
         if (spec.align() == ALIGN_LEFT)
             *format_ptr++ = '-';
         if (width != 0)
             *format_ptr++ = '*';
     }
-    if (spec.precision() >= 0) {
+    if (spec.precision() >= 0)
+    {
         *format_ptr++ = '.';
         *format_ptr++ = '*';
     }
@@ -2200,13 +2440,15 @@ void BasicWriter<Char>::write_double(
 
     // Format using snprintf.
     Char fill = static_cast<Char>(spec.fill());
-    for (;;) {
+    for (;;)
+    {
         std::size_t buffer_size = buffer_.capacity() - offset;
 #if _MSC_VER
         // MSVC's vsnprintf_s doesn't work with zero size, so reserve
         // space for at least one extra character to make the size non-zero.
         // Note that the buffer's capacity will increase by more than 1.
-        if (buffer_size == 0) {
+        if (buffer_size == 0)
+        {
             buffer_.reserve(offset + 1);
             buffer_size = buffer_.capacity() - offset;
         }
@@ -2214,27 +2456,33 @@ void BasicWriter<Char>::write_double(
         Char *start = &buffer_[offset];
         int n = internal::CharTraits<Char>::format_float(
                     start, buffer_size, format, width_for_sprintf, spec.precision(), value);
-        if (n >= 0 && offset + n < buffer_.capacity()) {
-            if (sign) {
+        if (n >= 0 && offset + n < buffer_.capacity())
+        {
+            if (sign)
+            {
                 if ((spec.align() != ALIGN_RIGHT && spec.align() != ALIGN_DEFAULT) ||
-                        *start != ' ') {
+                        *start != ' ')
+                {
                     *(start - 1) = sign;
                     sign = 0;
                 }
-                else {
+                else
+                {
                     *(start - 1) = fill;
                 }
                 ++n;
             }
             if (spec.align() == ALIGN_CENTER &&
-                    spec.width() > static_cast<unsigned>(n)) {
+                    spec.width() > static_cast<unsigned>(n))
+            {
                 width = spec.width();
                 CharPtr p = grow_buffer(width);
                 std::copy(p, p + n, p + (width - n) / 2);
                 fill_padding(p, spec.width(), n, fill);
                 return;
             }
-            if (spec.fill() != ' ' || sign) {
+            if (spec.fill() != ' ' || sign)
+            {
                 while (*start == ' ')
                     *start++ = fill;
                 if (sign)
@@ -2284,7 +2532,8 @@ accessed as a C string with ``out.c_str()``.
 \endrst
 */
 template <typename Char, typename Allocator = std::allocator<Char> >
-class BasicMemoryWriter : public BasicWriter<Char> {
+class BasicMemoryWriter : public BasicWriter<Char>
+{
 private:
     internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE, Allocator> buffer_;
 
@@ -2298,13 +2547,15 @@ public:
     of the other object to it.
     */
     BasicMemoryWriter(BasicMemoryWriter &&other)
-        : BasicWriter<Char>(buffer_), buffer_(std::move(other.buffer_)) {
+        : BasicWriter<Char>(buffer_), buffer_(std::move(other.buffer_))
+    {
     }
 
     /**
     Moves the content of the other ``BasicMemoryWriter`` object to this one.
     */
-    BasicMemoryWriter &operator=(BasicMemoryWriter &&other) {
+    BasicMemoryWriter &operator=(BasicMemoryWriter &&other)
+    {
         buffer_ = std::move(other.buffer_);
         return *this;
     }
@@ -2316,7 +2567,8 @@ typedef BasicMemoryWriter<wchar_t> WMemoryWriter;
 
 // Formats a value.
 template <typename Char, typename T>
-void format(BasicFormatter<Char> &f, const Char *&format_str, const T &value) {
+void format(BasicFormatter<Char> &f, const Char *&format_str, const T &value)
+{
     std::basic_ostringstream<Char> os;
     os << value;
     internal::Arg arg;
@@ -2335,7 +2587,8 @@ void report_system_error(int error_code, StringRef message) FMT_NOEXCEPT;
 #ifdef _WIN32
 
 /** A Windows error. */
-class WindowsError : public SystemError {
+class WindowsError : public SystemError
+{
 private:
     void init(int error_code, StringRef format_str, ArgList args);
 
@@ -2368,7 +2621,8 @@ public:
     }
     \endrst
     */
-    WindowsError(int error_code, StringRef message) {
+    WindowsError(int error_code, StringRef message)
+    {
         init(error_code, message, ArgList());
     }
     FMT_VARIADIC_CTOR(WindowsError, init, int, StringRef)
@@ -2399,13 +2653,15 @@ Formats arguments and returns the result as a string.
 std::string message = format("The answer is {}", 42);
 \endrst
 */
-inline std::string format(StringRef format_str, ArgList args) {
+inline std::string format(StringRef format_str, ArgList args)
+{
     MemoryWriter w;
     w.write(format_str, args);
     return w.str();
 }
 
-inline std::wstring format(WStringRef format_str, ArgList args) {
+inline std::wstring format(WStringRef format_str, ArgList args)
+{
     WMemoryWriter w;
     w.write(format_str, args);
     return w.str();
@@ -2445,7 +2701,8 @@ print(cerr, "Don't {}!", "panic");
 void print(std::ostream &os, StringRef format_str, ArgList args);
 
 template <typename Char>
-void printf(BasicWriter<Char> &w, BasicStringRef<Char> format, ArgList args) {
+void printf(BasicWriter<Char> &w, BasicStringRef<Char> format, ArgList args)
+{
     internal::PrintfFormatter<Char>().format(w, format, args);
 }
 
@@ -2458,7 +2715,8 @@ Formats arguments and returns the result as a string.
 std::string message = fmt::sprintf("The answer is %d", 42);
 \endrst
 */
-inline std::string sprintf(StringRef format, ArgList args) {
+inline std::string sprintf(StringRef format, ArgList args)
+{
     MemoryWriter w;
     printf(w, format, args);
     return w.str();
@@ -2484,14 +2742,16 @@ Prints formatted data to ``stdout``.
 fmt::printf("Elapsed time: %.2f seconds", 1.23);
 \endrst
 */
-inline int printf(StringRef format, ArgList args) {
+inline int printf(StringRef format, ArgList args)
+{
     return fprintf(stdout, format, args);
 }
 
 /**
 Fast integer formatter.
 */
-class FormatInt {
+class FormatInt
+{
 private:
     // Buffer should be large enough to hold all digits (digits10 + 1),
     // a sign and a null character.
@@ -2500,9 +2760,11 @@ private:
     char *str_;
 
     // Formats value in reverse and returns the number of digits.
-    char *format_decimal(ULongLong value) {
+    char *format_decimal(ULongLong value)
+    {
         char *buffer_end = buffer_ + BUFFER_SIZE - 1;
-        while (value >= 100) {
+        while (value >= 100)
+        {
             // Integer division is slow so do it for a group of two digits instead
             // of for every digit. The idea comes from the talk by Alexandrescu
             // "Three Optimization Tips for C++". See speed-test for a comparison.
@@ -2511,7 +2773,8 @@ private:
             *--buffer_end = internal::Data::DIGITS[index + 1];
             *--buffer_end = internal::Data::DIGITS[index];
         }
-        if (value < 10) {
+        if (value < 10)
+        {
             *--buffer_end = static_cast<char>('0' + value);
             return buffer_end;
         }
@@ -2521,7 +2784,8 @@ private:
         return buffer_end;
     }
 
-    void FormatSigned(LongLong value) {
+    void FormatSigned(LongLong value)
+    {
         ULongLong abs_value = static_cast<ULongLong>(value);
         bool negative = value < 0;
         if (negative)
@@ -2532,13 +2796,16 @@ private:
     }
 
 public:
-    explicit FormatInt(int value) {
+    explicit FormatInt(int value)
+    {
         FormatSigned(value);
     }
-    explicit FormatInt(long value) {
+    explicit FormatInt(long value)
+    {
         FormatSigned(value);
     }
-    explicit FormatInt(LongLong value) {
+    explicit FormatInt(LongLong value)
+    {
         FormatSigned(value);
     }
     explicit FormatInt(unsigned value) : str_(format_decimal(value)) {}
@@ -2548,7 +2815,8 @@ public:
     /**
     Returns the number of characters written to the output buffer.
     */
-    std::size_t size() const {
+    std::size_t size() const
+    {
         return buffer_ - str_ + BUFFER_SIZE - 1;
     }
 
@@ -2556,7 +2824,8 @@ public:
     Returns a pointer to the output buffer content. No terminating null
     character is appended.
     */
-    const char *data() const {
+    const char *data() const
+    {
         return str_;
     }
 
@@ -2564,7 +2833,8 @@ public:
     Returns a pointer to the output buffer content with terminating null
     character appended.
     */
-    const char *c_str() const {
+    const char *c_str() const
+    {
         buffer_[BUFFER_SIZE - 1] = '\0';
         return str_;
     }
@@ -2572,7 +2842,8 @@ public:
     /**
     Returns the content of the output buffer as an `std::string`.
     */
-    std::string str() const {
+    std::string str() const
+    {
         return std::string(str_, size());
     }
 };
@@ -2581,14 +2852,18 @@ public:
 // a pointer to the end of the formatted string. This function doesn't
 // write a terminating null character.
 template <typename T>
-inline void format_decimal(char *&buffer, T value) {
+inline void format_decimal(char *&buffer, T value)
+{
     typename internal::IntTraits<T>::MainType abs_value = value;
-    if (internal::is_negative(value)) {
+    if (internal::is_negative(value))
+    {
         *buffer++ = '-';
         abs_value = 0 - abs_value;
     }
-    if (abs_value < 100) {
-        if (abs_value < 10) {
+    if (abs_value < 100)
+    {
+        if (abs_value < 10)
+        {
             *buffer++ = static_cast<char>('0' + abs_value);
             return;
         }
@@ -2708,7 +2983,8 @@ fmt::print(format, args...);
 #define FMT_VARIADIC_W(ReturnType, func, ...) \
   FMT_VARIADIC_(wchar_t, ReturnType, func, return func, __VA_ARGS__)
 
-namespace fmt {
+namespace fmt
+{
 FMT_VARIADIC(std::string, format, StringRef)
 FMT_VARIADIC_W(std::wstring, format, WStringRef)
 FMT_VARIADIC(void, print, StringRef)