style: Format source code and support grouping client

compress/jsoncpp/allocator.h

@@ -12,76 +12,93 @@
 #pragma pack(push)
 #pragma pack()
 
-namespace Json {
-template <typename T> class SecureAllocator {
+namespace Json
+{
+template <typename T> class SecureAllocator
+{
 public:
-  // Type definitions
-  using value_type = T;
-  using pointer = T*;
-  using const_pointer = const T*;
-  using reference = T&;
-  using const_reference = const T&;
-  using size_type = std::size_t;
-  using difference_type = std::ptrdiff_t;
+    // Type definitions
+    using value_type = T;
+    using pointer = T*;
+    using const_pointer = const T*;
+    using reference = T&;
+    using const_reference = const T&;
+    using size_type = std::size_t;
+    using difference_type = std::ptrdiff_t;
 
-  /**
-   * Allocate memory for N items using the standard allocator.
-   */
-  pointer allocate(size_type n) {
-    // allocate using "global operator new"
-    return static_cast<pointer>(::operator new(n * sizeof(T)));
-  }
+    /**
+     * Allocate memory for N items using the standard allocator.
+     */
+    pointer allocate(size_type n)
+    {
+        // allocate using "global operator new"
+        return static_cast<pointer>(::operator new(n * sizeof(T)));
+    }
 
-  /**
-   * Release memory which was allocated for N items at pointer P.
-   *
-   * The memory block is filled with zeroes before being released.
-   */
-  void deallocate(pointer p, size_type n) {
-    // memset_s is used because memset may be optimized away by the compiler
-    memset_s(p, n * sizeof(T), 0, n * sizeof(T));
-    // free using "global operator delete"
-    ::operator delete(p);
-  }
+    /**
+     * Release memory which was allocated for N items at pointer P.
+     *
+     * The memory block is filled with zeroes before being released.
+     */
+    void deallocate(pointer p, size_type n)
+    {
+        // memset_s is used because memset may be optimized away by the compiler
+        memset_s(p, n * sizeof(T), 0, n * sizeof(T));
+        // free using "global operator delete"
+        ::operator delete(p);
+    }
 
-  /**
-   * Construct an item in-place at pointer P.
-   */
-  template <typename... Args> void construct(pointer p, Args&&... args) {
-    // construct using "placement new" and "perfect forwarding"
-    ::new (static_cast<void*>(p)) T(std::forward<Args>(args)...);
-  }
+    /**
+     * Construct an item in-place at pointer P.
+     */
+    template <typename... Args> void construct(pointer p, Args&&... args)
+    {
+        // construct using "placement new" and "perfect forwarding"
+        ::new (static_cast<void*>(p)) T(std::forward<Args>(args)...);
+    }
 
-  size_type max_size() const { return size_t(-1) / sizeof(T); }
+    size_type max_size() const
+    {
+        return size_t(-1) / sizeof(T);
+    }
 
-  pointer address(reference x) const { return std::addressof(x); }
+    pointer address(reference x) const
+    {
+        return std::addressof(x);
+    }
 
-  const_pointer address(const_reference x) const { return std::addressof(x); }
+    const_pointer address(const_reference x) const
+    {
+        return std::addressof(x);
+    }
 
-  /**
-   * Destroy an item in-place at pointer P.
-   */
-  void destroy(pointer p) {
-    // destroy using "explicit destructor"
-    p->~T();
-  }
+    /**
+     * Destroy an item in-place at pointer P.
+     */
+    void destroy(pointer p)
+    {
+        // destroy using "explicit destructor"
+        p->~T();
+    }
 
-  // Boilerplate
-  SecureAllocator() {}
-  template <typename U> SecureAllocator(const SecureAllocator<U>&) {}
-  template <typename U> struct rebind {
-    using other = SecureAllocator<U>;
-  };
+    // Boilerplate
+    SecureAllocator() {}
+    template <typename U> SecureAllocator(const SecureAllocator<U>&) {}
+    template <typename U> struct rebind {
+        using other = SecureAllocator<U>;
+    };
 };
 
 template <typename T, typename U>
-bool operator==(const SecureAllocator<T>&, const SecureAllocator<U>&) {
-  return true;
+bool operator==(const SecureAllocator<T>&, const SecureAllocator<U>&)
+{
+    return true;
 }
 
 template <typename T, typename U>
-bool operator!=(const SecureAllocator<T>&, const SecureAllocator<U>&) {
-  return false;
+bool operator!=(const SecureAllocator<T>&, const SecureAllocator<U>&)
+{
+    return false;
 }
 
 } // namespace Json