Reformat with clang-format

test/objects/minimal.hpp

@@ -10,13 +10,13 @@
 #if !defined(BOOST_UNORDERED_OBJECTS_MINIMAL_HEADER)
 #define BOOST_UNORDERED_OBJECTS_MINIMAL_HEADER
 
-#include <cstddef>
 #include <boost/move/move.hpp>
+#include <cstddef>
 #include <utility>
 
 #if defined(BOOST_MSVC)
 #pragma warning(push)
-#pragma warning(disable:4100) // unreferenced formal parameter
+#pragma warning(disable : 4100) // unreferenced formal parameter
 #endif
 
 #if !BOOST_WORKAROUND(BOOST_MSVC, == 1500)
@@ -25,480 +25,494 @@
 #define BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED 0
 #endif
 
-namespace test
+namespace test {
+namespace minimal {
+class destructible;
+class copy_constructible;
+class copy_constructible_equality_comparable;
+class default_assignable;
+class assignable;
+
+struct ampersand_operator_used
 {
-namespace minimal
+    ampersand_operator_used() { BOOST_TEST(false); }
+};
+
+template <class T> class hash;
+template <class T> class equal_to;
+template <class T> class ptr;
+template <class T> class const_ptr;
+template <class T> class allocator;
+template <class T> class cxx11_allocator;
+
+struct constructor_param
 {
-    class destructible;
-    class copy_constructible;
-    class copy_constructible_equality_comparable;
-    class default_assignable;
-    class assignable;
+    operator int() const { return 0; }
+};
 
-    struct ampersand_operator_used {
-        ampersand_operator_used() { BOOST_TEST(false); }
-    };
+class destructible
+{
+  public:
+    destructible(constructor_param const&) {}
+    ~destructible() {}
+    void dummy_member() const {}
+  private:
+    destructible(destructible const&);
+    destructible& operator=(destructible const&);
+};
 
-    template <class T> class hash;
-    template <class T> class equal_to;
-    template <class T> class ptr;
-    template <class T> class const_ptr;
-    template <class T> class allocator;
-    template <class T> class cxx11_allocator;
+class copy_constructible
+{
+  public:
+    copy_constructible(constructor_param const&) {}
+    copy_constructible(copy_constructible const&) {}
+    ~copy_constructible() {}
+    void dummy_member() const {}
+  private:
+    copy_constructible& operator=(copy_constructible const&);
+    copy_constructible() {}
+};
 
-    struct constructor_param
+class copy_constructible_equality_comparable
+{
+  public:
+    copy_constructible_equality_comparable(constructor_param const&) {}
+
+    copy_constructible_equality_comparable(
+        copy_constructible_equality_comparable const&)
     {
-        operator int() const { return 0; }
-    };
-
-    class destructible
-    {
-    public:
-        destructible(constructor_param const&) {}
-        ~destructible() {}
-        void dummy_member() const {}
-    private:
-        destructible(destructible const&);
-        destructible& operator=(destructible const&);
-    };
-
-    class copy_constructible
-    {
-    public:
-        copy_constructible(constructor_param const&) {}
-        copy_constructible(copy_constructible const&) {}
-        ~copy_constructible() {}
-        void dummy_member() const {}
-    private:
-        copy_constructible& operator=(copy_constructible const&);
-        copy_constructible() {}
-    };
-
-    class copy_constructible_equality_comparable
-    {
-    public:
-        copy_constructible_equality_comparable(constructor_param const&) {}
-
-        copy_constructible_equality_comparable(
-            copy_constructible_equality_comparable const&)
-        {
-        }
-
-        ~copy_constructible_equality_comparable()
-        {
-        }
-
-        void dummy_member() const {}
-    private:
-        copy_constructible_equality_comparable& operator=(
-            copy_constructible_equality_comparable const&);
-        copy_constructible_equality_comparable() {}
-#if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
-        ampersand_operator_used operator&() const {
-            return ampersand_operator_used(); }
-#endif
-    };
-
-    bool operator==(
-        copy_constructible_equality_comparable,
-        copy_constructible_equality_comparable)
-    {
-        return true;
     }
 
-    bool operator!=(
-        copy_constructible_equality_comparable,
-        copy_constructible_equality_comparable)
+    ~copy_constructible_equality_comparable() {}
+
+    void dummy_member() const {}
+  private:
+    copy_constructible_equality_comparable& operator=(
+        copy_constructible_equality_comparable const&);
+    copy_constructible_equality_comparable() {}
+#if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
+    ampersand_operator_used operator&() const
     {
-        return false;
+        return ampersand_operator_used();
     }
+#endif
+};
 
-    class default_assignable
-    {
-    public:
-        default_assignable(constructor_param const&) {}
+bool operator==(copy_constructible_equality_comparable,
+    copy_constructible_equality_comparable)
+{
+    return true;
+}
 
-        default_assignable()
-        {
-        }
+bool operator!=(copy_constructible_equality_comparable,
+    copy_constructible_equality_comparable)
+{
+    return false;
+}
 
-        default_assignable(default_assignable const&)
-        {
-        }
+class default_assignable
+{
+  public:
+    default_assignable(constructor_param const&) {}
 
-        default_assignable& operator=(default_assignable const&)
-        {
-            return *this;
-        }
+    default_assignable() {}
 
-        ~default_assignable()
-        {
-        }
+    default_assignable(default_assignable const&) {}
 
-        void dummy_member() const {}
+    default_assignable& operator=(default_assignable const&) { return *this; }
+
+    ~default_assignable() {}
+
+    void dummy_member() const {}
 
 #if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
-        ampersand_operator_used operator&() const {
-            return ampersand_operator_used(); }
-#endif
-    };
-
-    class assignable
+    ampersand_operator_used operator&() const
     {
-    public:
-        assignable(constructor_param const&) {}
-        assignable(assignable const&) {}
-        assignable& operator=(assignable const&) { return *this; }
-        ~assignable() {}
-        void dummy_member() const {}
-    private:
-        assignable() {}
+        return ampersand_operator_used();
+    }
+#endif
+};
+
+class assignable
+{
+  public:
+    assignable(constructor_param const&) {}
+    assignable(assignable const&) {}
+    assignable& operator=(assignable const&) { return *this; }
+    ~assignable() {}
+    void dummy_member() const {}
+  private:
+    assignable() {}
 #if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
-        ampersand_operator_used operator&() const {
-            return ampersand_operator_used(); }
-#endif
-    };
-
-    struct movable_init {};
-
-    class movable1
+    ampersand_operator_used operator&() const
     {
-        BOOST_MOVABLE_BUT_NOT_COPYABLE(movable1)
+        return ampersand_operator_used();
+    }
+#endif
+};
 
-    public:
-        movable1(constructor_param const&) {}
-        movable1() {}
-        explicit movable1(movable_init) {}
-        movable1(BOOST_RV_REF(movable1)) {}
-        movable1& operator=(BOOST_RV_REF(movable1)) { return *this; }
-        ~movable1() {}
-        void dummy_member() const {}
-    };
+struct movable_init
+{
+};
+
+class movable1
+{
+    BOOST_MOVABLE_BUT_NOT_COPYABLE(movable1)
+
+  public:
+    movable1(constructor_param const&) {}
+    movable1() {}
+    explicit movable1(movable_init) {}
+    movable1(BOOST_RV_REF(movable1)) {}
+    movable1& operator=(BOOST_RV_REF(movable1)) { return *this; }
+    ~movable1() {}
+    void dummy_member() const {}
+};
 
 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    class movable2
-    {
-    public:
-        movable2(constructor_param const&) {}
-        explicit movable2(movable_init) {}
-        movable2(movable2&&) {}
-        ~movable2() {}
-        movable2& operator=(movable2&&) { return *this; }
-        void dummy_member() const {}
-    private:
-        movable2() {}
-        movable2(movable2 const&);
-        movable2& operator=(movable2 const&);
-    };
+class movable2
+{
+  public:
+    movable2(constructor_param const&) {}
+    explicit movable2(movable_init) {}
+    movable2(movable2&&) {}
+    ~movable2() {}
+    movable2& operator=(movable2&&) { return *this; }
+    void dummy_member() const {}
+  private:
+    movable2() {}
+    movable2(movable2 const&);
+    movable2& operator=(movable2 const&);
+};
 #else
-    typedef movable1 movable2;
+typedef movable1 movable2;
 #endif
 
-    template <class T>
-    class hash
-    {
-    public:
-        hash(constructor_param const&) {}
-        hash() {}
-        hash(hash const&) {}
-        hash& operator=(hash const&) { return *this; }
-        ~hash() {}
+template <class T> class hash
+{
+  public:
+    hash(constructor_param const&) {}
+    hash() {}
+    hash(hash const&) {}
+    hash& operator=(hash const&) { return *this; }
+    ~hash() {}
 
-        std::size_t operator()(T const&) const { return 0; }
+    std::size_t operator()(T const&) const { return 0; }
 #if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
-        ampersand_operator_used operator&() const {
-            return ampersand_operator_used(); }
-#endif
-    };
-
-    template <class T>
-    class equal_to
+    ampersand_operator_used operator&() const
     {
-    public:
-        equal_to(constructor_param const&) {}
-        equal_to() {}
-        equal_to(equal_to const&) {}
-        equal_to& operator=(equal_to const&) { return *this; }
-        ~equal_to() {}
+        return ampersand_operator_used();
+    }
+#endif
+};
 
-        bool operator()(T const&, T const&) const { return true; }
+template <class T> class equal_to
+{
+  public:
+    equal_to(constructor_param const&) {}
+    equal_to() {}
+    equal_to(equal_to const&) {}
+    equal_to& operator=(equal_to const&) { return *this; }
+    ~equal_to() {}
+
+    bool operator()(T const&, T const&) const { return true; }
 #if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
-        ampersand_operator_used operator&() const {
-            return ampersand_operator_used(); }
-#endif
-    };
-
-    template <class T> class ptr;
-    template <class T> class const_ptr;
-
-    struct void_ptr
+    ampersand_operator_used operator&() const
     {
+        return ampersand_operator_used();
+    }
+#endif
+};
+
+template <class T> class ptr;
+template <class T> class const_ptr;
+
+struct void_ptr
+{
 #if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
-        template <typename T>
-        friend class ptr;
-    private:
+    template <typename T> friend class ptr;
+
+  private:
 #endif
 
-        void* ptr_;
+    void* ptr_;
 
-    public:
-        void_ptr() : ptr_(0) {}
+  public:
+    void_ptr() : ptr_(0) {}
 
-        template <typename T>
-        explicit void_ptr(ptr<T> const& x) : ptr_(x.ptr_) {}
+    template <typename T> explicit void_ptr(ptr<T> const& x) : ptr_(x.ptr_) {}
 
-        // I'm not using the safe bool idiom because the containers should be
-        // able to cope with bool conversions.
-        operator bool() const { return !!ptr_; }
+    // I'm not using the safe bool idiom because the containers should be
+    // able to cope with bool conversions.
+    operator bool() const { return !!ptr_; }
 
-        bool operator==(void_ptr const& x) const { return ptr_ == x.ptr_; }
-        bool operator!=(void_ptr const& x) const { return ptr_ != x.ptr_; }
-    };
+    bool operator==(void_ptr const& x) const { return ptr_ == x.ptr_; }
+    bool operator!=(void_ptr const& x) const { return ptr_ != x.ptr_; }
+};
 
-    class void_const_ptr
-    {
+class void_const_ptr
+{
 #if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
-        template <typename T>
-        friend class const_ptr;
-    private:
+    template <typename T> friend class const_ptr;
+
+  private:
 #endif
 
-        void* ptr_;
+    void* ptr_;
 
-    public:
-        void_const_ptr() : ptr_(0) {}
+  public:
+    void_const_ptr() : ptr_(0) {}
 
-        template <typename T>
-        explicit void_const_ptr(const_ptr<T> const& x) : ptr_(x.ptr_) {}
-
-        // I'm not using the safe bool idiom because the containers should be
-        // able to cope with bool conversions.
-        operator bool() const { return !!ptr_; }
-
-        bool operator==(void_const_ptr const& x) const { return ptr_ == x.ptr_; }
-        bool operator!=(void_const_ptr const& x) const { return ptr_ != x.ptr_; }
-    };
-
-    template <class T>
-    class ptr
+    template <typename T>
+    explicit void_const_ptr(const_ptr<T> const& x) : ptr_(x.ptr_)
     {
-        friend class allocator<T>;
-        friend class const_ptr<T>;
-        friend struct void_ptr;
+    }
 
-        T* ptr_;
+    // I'm not using the safe bool idiom because the containers should be
+    // able to cope with bool conversions.
+    operator bool() const { return !!ptr_; }
 
-        ptr(T* x) : ptr_(x) {}
-    public:
-        ptr() : ptr_(0) {}
-        explicit ptr(void_ptr const& x) : ptr_((T*) x.ptr_) {}
+    bool operator==(void_const_ptr const& x) const { return ptr_ == x.ptr_; }
+    bool operator!=(void_const_ptr const& x) const { return ptr_ != x.ptr_; }
+};
 
-        T& operator*() const { return *ptr_; }
-        T* operator->() const { return ptr_; }
-        ptr& operator++() { ++ptr_; return *this; }
-        ptr operator++(int) { ptr tmp(*this); ++ptr_; return tmp; }
-        ptr operator+(std::ptrdiff_t s) const { return ptr<T>(ptr_ + s); }
-        friend ptr operator+(std::ptrdiff_t s, ptr p)
-            { return ptr<T>(s + p.ptr_); }
-        T& operator[](std::ptrdiff_t s) const { return ptr_[s]; }
-        bool operator!() const { return !ptr_; }
-        
-        // I'm not using the safe bool idiom because the containers should be
-        // able to cope with bool conversions.
-        operator bool() const { return !!ptr_; }
+template <class T> class ptr
+{
+    friend class allocator<T>;
+    friend class const_ptr<T>;
+    friend struct void_ptr;
 
-        bool operator==(ptr const& x) const { return ptr_ == x.ptr_; }
-        bool operator!=(ptr const& x) const { return ptr_ != x.ptr_; }
-        bool operator<(ptr const& x) const { return ptr_ < x.ptr_; }
-        bool operator>(ptr const& x) const { return ptr_ > x.ptr_; }
-        bool operator<=(ptr const& x) const { return ptr_ <= x.ptr_; }
-        bool operator>=(ptr const& x) const { return ptr_ >= x.ptr_; }
+    T* ptr_;
+
+    ptr(T* x) : ptr_(x) {}
+  public:
+    ptr() : ptr_(0) {}
+    explicit ptr(void_ptr const& x) : ptr_((T*)x.ptr_) {}
+
+    T& operator*() const { return *ptr_; }
+    T* operator->() const { return ptr_; }
+    ptr& operator++()
+    {
+        ++ptr_;
+        return *this;
+    }
+    ptr operator++(int)
+    {
+        ptr tmp(*this);
+        ++ptr_;
+        return tmp;
+    }
+    ptr operator+(std::ptrdiff_t s) const { return ptr<T>(ptr_ + s); }
+    friend ptr operator+(std::ptrdiff_t s, ptr p) { return ptr<T>(s + p.ptr_); }
+    T& operator[](std::ptrdiff_t s) const { return ptr_[s]; }
+    bool operator!() const { return !ptr_; }
+
+    // I'm not using the safe bool idiom because the containers should be
+    // able to cope with bool conversions.
+    operator bool() const { return !!ptr_; }
+
+    bool operator==(ptr const& x) const { return ptr_ == x.ptr_; }
+    bool operator!=(ptr const& x) const { return ptr_ != x.ptr_; }
+    bool operator<(ptr const& x) const { return ptr_ < x.ptr_; }
+    bool operator>(ptr const& x) const { return ptr_ > x.ptr_; }
+    bool operator<=(ptr const& x) const { return ptr_ <= x.ptr_; }
+    bool operator>=(ptr const& x) const { return ptr_ >= x.ptr_; }
 #if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
-        ampersand_operator_used operator&() const {
-            return ampersand_operator_used(); }
-#endif
-    };
-
-    template <class T>
-    class const_ptr
+    ampersand_operator_used operator&() const
     {
-        friend class allocator<T>;
-        friend struct const_void_ptr;
+        return ampersand_operator_used();
+    }
+#endif
+};
 
-        T const* ptr_;
+template <class T> class const_ptr
+{
+    friend class allocator<T>;
+    friend struct const_void_ptr;
 
-        const_ptr(T const* ptr) : ptr_(ptr) {}
-    public:
-        const_ptr() : ptr_(0) {}
-        const_ptr(ptr<T> const& x) : ptr_(x.ptr_) {}
-        explicit const_ptr(void_const_ptr const& x) : ptr_((T const*) x.ptr_) {}
+    T const* ptr_;
 
-        T const& operator*() const { return *ptr_; }
-        T const* operator->() const { return ptr_; }
-        const_ptr& operator++() { ++ptr_; return *this; }
-        const_ptr operator++(int) { const_ptr tmp(*this); ++ptr_; return tmp; }
-        const_ptr operator+(std::ptrdiff_t s) const
-            { return const_ptr(ptr_ + s); }
-        friend const_ptr operator+(std::ptrdiff_t s, const_ptr p)
-            { return ptr<T>(s + p.ptr_); }
-        T const& operator[](int s) const { return ptr_[s]; }
-        bool operator!() const { return !ptr_; }
-        operator bool() const { return !!ptr_; }
+    const_ptr(T const* ptr) : ptr_(ptr) {}
+  public:
+    const_ptr() : ptr_(0) {}
+    const_ptr(ptr<T> const& x) : ptr_(x.ptr_) {}
+    explicit const_ptr(void_const_ptr const& x) : ptr_((T const*)x.ptr_) {}
 
-        bool operator==(const_ptr const& x) const { return ptr_ == x.ptr_; }
-        bool operator!=(const_ptr const& x) const { return ptr_ != x.ptr_; }
-        bool operator<(const_ptr const& x) const { return ptr_ < x.ptr_; }
-        bool operator>(const_ptr const& x) const { return ptr_ > x.ptr_; }
-        bool operator<=(const_ptr const& x) const { return ptr_ <= x.ptr_; }
-        bool operator>=(const_ptr const& x) const { return ptr_ >= x.ptr_; }
+    T const& operator*() const { return *ptr_; }
+    T const* operator->() const { return ptr_; }
+    const_ptr& operator++()
+    {
+        ++ptr_;
+        return *this;
+    }
+    const_ptr operator++(int)
+    {
+        const_ptr tmp(*this);
+        ++ptr_;
+        return tmp;
+    }
+    const_ptr operator+(std::ptrdiff_t s) const { return const_ptr(ptr_ + s); }
+    friend const_ptr operator+(std::ptrdiff_t s, const_ptr p)
+    {
+        return ptr<T>(s + p.ptr_);
+    }
+    T const& operator[](int s) const { return ptr_[s]; }
+    bool operator!() const { return !ptr_; }
+    operator bool() const { return !!ptr_; }
+
+    bool operator==(const_ptr const& x) const { return ptr_ == x.ptr_; }
+    bool operator!=(const_ptr const& x) const { return ptr_ != x.ptr_; }
+    bool operator<(const_ptr const& x) const { return ptr_ < x.ptr_; }
+    bool operator>(const_ptr const& x) const { return ptr_ > x.ptr_; }
+    bool operator<=(const_ptr const& x) const { return ptr_ <= x.ptr_; }
+    bool operator>=(const_ptr const& x) const { return ptr_ >= x.ptr_; }
 #if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
-        ampersand_operator_used operator&() const {
-            return ampersand_operator_used(); }
+    ampersand_operator_used operator&() const
+    {
+        return ampersand_operator_used();
+    }
 #endif
+};
+
+template <class T> class allocator
+{
+  public:
+    typedef std::size_t size_type;
+    typedef std::ptrdiff_t difference_type;
+    typedef void_ptr void_pointer;
+    typedef void_const_ptr const_void_pointer;
+    typedef ptr<T> pointer;
+    typedef const_ptr<T> const_pointer;
+    typedef T& reference;
+    typedef T const& const_reference;
+    typedef T value_type;
+
+    template <class U> struct rebind
+    {
+        typedef allocator<U> other;
     };
 
-    template <class T>
-    class allocator
+    allocator() {}
+    template <class Y> allocator(allocator<Y> const&) {}
+    allocator(allocator const&) {}
+    ~allocator() {}
+
+    pointer address(reference r) { return pointer(&r); }
+    const_pointer address(const_reference r) { return const_pointer(&r); }
+
+    pointer allocate(size_type n)
     {
-    public:
-        typedef std::size_t size_type;
-        typedef std::ptrdiff_t difference_type;
-        typedef void_ptr void_pointer;
-        typedef void_const_ptr const_void_pointer;
-        typedef ptr<T> pointer;
-        typedef const_ptr<T> const_pointer;
-        typedef T& reference;
-        typedef T const& const_reference;
-        typedef T value_type;
+        return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
+    }
 
-        template <class U> struct rebind { typedef allocator<U> other; };
+    template <class Y> pointer allocate(size_type n, const_ptr<Y>)
+    {
+        return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
+    }
 
-        allocator() {}
-        template <class Y> allocator(allocator<Y> const&) {}
-        allocator(allocator const&) {}
-        ~allocator() {}
+    void deallocate(pointer p, size_type) { ::operator delete((void*)p.ptr_); }
 
-        pointer address(reference r) { return pointer(&r); }
-        const_pointer address(const_reference r) { return const_pointer(&r); }
-
-        pointer allocate(size_type n) {
-            return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
-        }
-
-        template <class Y>
-        pointer allocate(size_type n, const_ptr<Y>)
-        {
-            return pointer(static_cast<T*>(::operator new(n * sizeof(T))));
-        }
-
-        void deallocate(pointer p, size_type)
-        {
-            ::operator delete((void*) p.ptr_);
-        }
-
-        void construct(T* p, T const& t) { new((void*)p) T(t); }
+    void construct(T* p, T const& t) { new ((void*)p) T(t); }
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-        template<class... Args> void construct(T* p, BOOST_FWD_REF(Args)... args) {
-            new((void*)p) T(boost::forward<Args>(args)...);
-        }
+    template <class... Args> void construct(T* p, BOOST_FWD_REF(Args)... args)
+    {
+        new ((void*)p) T(boost::forward<Args>(args)...);
+    }
 #endif
 
-        void destroy(T* p) { p->~T(); }
+    void destroy(T* p) { p->~T(); }
 
-        size_type max_size() const { return 1000; }
+    size_type max_size() const { return 1000; }
 
-#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP) || \
-        BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
-    public: allocator& operator=(allocator const&) { return *this;}
+#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP) ||                             \
+    BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+  public:
+    allocator& operator=(allocator const&) { return *this; }
 #else
-    private: allocator& operator=(allocator const&);
+  private:
+    allocator& operator=(allocator const&);
 #endif
 #if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
-        ampersand_operator_used operator&() const {
-            return ampersand_operator_used(); }
+    ampersand_operator_used operator&() const
+    {
+        return ampersand_operator_used();
+    }
 #endif
-    };
+};
 
-    template <class T>
-    inline bool operator==(allocator<T> const&, allocator<T> const&)
+template <class T>
+inline bool operator==(allocator<T> const&, allocator<T> const&)
+{
+    return true;
+}
+
+template <class T>
+inline bool operator!=(allocator<T> const&, allocator<T> const&)
+{
+    return false;
+}
+
+template <class T> void swap(allocator<T>&, allocator<T>&) {}
+
+// C++11 allocator
+//
+// Not a fully minimal C++11 allocator, just what I support. Hopefully will
+// cut down further in the future.
+
+template <class T> class cxx11_allocator
+{
+  public:
+    typedef T value_type;
+    // template <class U> struct rebind { typedef cxx11_allocator<U> other; };
+
+    cxx11_allocator() {}
+    template <class Y> cxx11_allocator(cxx11_allocator<Y> const&) {}
+    cxx11_allocator(cxx11_allocator const&) {}
+    ~cxx11_allocator() {}
+
+    T* address(T& r) { return &r; }
+    T const* address(T const& r) { return &r; }
+
+    T* allocate(std::size_t n)
     {
-        return true;
+        return static_cast<T*>(::operator new(n * sizeof(T)));
     }
 
-    template <class T>
-    inline bool operator!=(allocator<T> const&, allocator<T> const&)
+    template <class Y> T* allocate(std::size_t n, const_ptr<Y>)
     {
-        return false;
+        return static_cast<T*>(::operator new(n * sizeof(T)));
     }
 
-    template <class T>
-    void swap(allocator<T>&, allocator<T>&)
-    {
-    }
+    void deallocate(T* p, std::size_t) { ::operator delete((void*)p); }
 
-    // C++11 allocator
-    //
-    // Not a fully minimal C++11 allocator, just what I support. Hopefully will
-    // cut down further in the future.
-
-    template <class T>
-    class cxx11_allocator
-    {
-    public:
-        typedef T value_type;
-        //template <class U> struct rebind { typedef cxx11_allocator<U> other; };
-
-        cxx11_allocator() {}
-        template <class Y> cxx11_allocator(cxx11_allocator<Y> const&) {}
-        cxx11_allocator(cxx11_allocator const&) {}
-        ~cxx11_allocator() {}
-
-        T* address(T& r) { return &r; }
-        T const* address(T const& r) { return &r; }
-
-        T* allocate(std::size_t n) {
-            return static_cast<T*>(::operator new(n * sizeof(T)));
-        }
-
-        template <class Y>
-        T* allocate(std::size_t n, const_ptr<Y>) {
-            return static_cast<T*>(::operator new(n * sizeof(T)));
-        }
-
-        void deallocate(T* p, std::size_t) {
-            ::operator delete((void*) p);
-        }
-
-        void construct(T* p, T const& t) { new((void*)p) T(t); }
+    void construct(T* p, T const& t) { new ((void*)p) T(t); }
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-        template<class... Args> void construct(T* p, BOOST_FWD_REF(Args)... args) {
-            new((void*)p) T(boost::forward<Args>(args)...);
-        }
+    template <class... Args> void construct(T* p, BOOST_FWD_REF(Args)... args)
+    {
+        new ((void*)p) T(boost::forward<Args>(args)...);
+    }
 #endif
 
-        void destroy(T* p) { p->~T(); }
+    void destroy(T* p) { p->~T(); }
 
-        std::size_t max_size() const { return 1000u; }
-    };
+    std::size_t max_size() const { return 1000u; }
+};
 
-    template <class T>
-    inline bool operator==(cxx11_allocator<T> const&, cxx11_allocator<T> const&)
-    {
-        return true;
-    }
+template <class T>
+inline bool operator==(cxx11_allocator<T> const&, cxx11_allocator<T> const&)
+{
+    return true;
+}
 
-    template <class T>
-    inline bool operator!=(cxx11_allocator<T> const&, cxx11_allocator<T> const&)
-    {
-        return false;
-    }
+template <class T>
+inline bool operator!=(cxx11_allocator<T> const&, cxx11_allocator<T> const&)
+{
+    return false;
+}
 
-    template <class T>
-    void swap(cxx11_allocator<T>&, cxx11_allocator<T>&)
-    {
-    }
+template <class T> void swap(cxx11_allocator<T>&, cxx11_allocator<T>&) {}
 }
 }
 
@@ -508,18 +522,17 @@ namespace boost {
 namespace test {
 namespace minimal {
 #endif
-    std::size_t hash_value(
-        test::minimal::copy_constructible_equality_comparable)
-    {
-        return 1;
-    }
+std::size_t hash_value(test::minimal::copy_constructible_equality_comparable)
+{
+    return 1;
+}
 #if !defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)
-}}
+}
+}
 #else
 }
 #endif
 
-
 #if defined(BOOST_MSVC)
 #pragma warning(pop)
 #endif