Reformat with clang-format

test/objects/cxx11_allocator.hpp

@@ -13,309 +13,332 @@
 #include "../helpers/fwd.hpp"
 #include "../helpers/memory.hpp"
 
-namespace test
+namespace test {
+struct allocator_false
 {
-    struct allocator_false
+    enum
     {
-        enum {
-            is_select_on_copy = 0,
-            is_propagate_on_swap = 0,
-            is_propagate_on_assign = 0,
-            is_propagate_on_move = 0,
-            cxx11_construct = 0
+        is_select_on_copy = 0,
+        is_propagate_on_swap = 0,
+        is_propagate_on_assign = 0,
+        is_propagate_on_move = 0,
+        cxx11_construct = 0
+    };
+};
+
+struct allocator_flags_all
+{
+    enum
+    {
+        is_select_on_copy = 1,
+        is_propagate_on_swap = 1,
+        is_propagate_on_assign = 1,
+        is_propagate_on_move = 1,
+        cxx11_construct = 1
+    };
+};
+
+struct select_copy : allocator_false
+{
+    enum
+    {
+        is_select_on_copy = 1
+    };
+};
+struct propagate_swap : allocator_false
+{
+    enum
+    {
+        is_propagate_on_swap = 1
+    };
+};
+struct propagate_assign : allocator_false
+{
+    enum
+    {
+        is_propagate_on_assign = 1
+    };
+};
+struct propagate_move : allocator_false
+{
+    enum
+    {
+        is_propagate_on_move = 1
+    };
+};
+
+struct no_select_copy : allocator_flags_all
+{
+    enum
+    {
+        is_select_on_copy = 0
+    };
+};
+struct no_propagate_swap : allocator_flags_all
+{
+    enum
+    {
+        is_propagate_on_swap = 0
+    };
+};
+struct no_propagate_assign : allocator_flags_all
+{
+    enum
+    {
+        is_propagate_on_assign = 0
+    };
+};
+struct no_propagate_move : allocator_flags_all
+{
+    enum
+    {
+        is_propagate_on_move = 0
+    };
+};
+
+template <typename Flag> struct swap_allocator_base
+{
+    struct propagate_on_container_swap
+    {
+        enum
+        {
+            value = Flag::is_propagate_on_swap
         };
     };
+};
 
-    struct allocator_flags_all
+template <typename Flag> struct assign_allocator_base
+{
+    struct propagate_on_container_copy_assignment
     {
-        enum {
-            is_select_on_copy = 1,
-            is_propagate_on_swap = 1,
-            is_propagate_on_assign = 1,
-            is_propagate_on_move = 1,
-            cxx11_construct = 1
+        enum
+        {
+            value = Flag::is_propagate_on_assign
         };
     };
-    
-    struct select_copy : allocator_false
-    { enum { is_select_on_copy = 1 }; };
-    struct propagate_swap : allocator_false
-    { enum { is_propagate_on_swap = 1 }; };
-    struct propagate_assign : allocator_false
-    { enum { is_propagate_on_assign = 1 }; };
-    struct propagate_move : allocator_false
-    { enum { is_propagate_on_move = 1 }; };
+};
 
-    struct no_select_copy : allocator_flags_all
-    { enum { is_select_on_copy = 0 }; };
-    struct no_propagate_swap : allocator_flags_all
-    { enum { is_propagate_on_swap = 0 }; };
-    struct no_propagate_assign : allocator_flags_all
-    { enum { is_propagate_on_assign = 0 }; };
-    struct no_propagate_move : allocator_flags_all
-    { enum { is_propagate_on_move = 0 }; };
-    
-    template <typename Flag>
-    struct swap_allocator_base
+template <typename Flag> struct move_allocator_base
+{
+    struct propagate_on_container_move_assignment
     {
-        struct propagate_on_container_swap {
-            enum { value = Flag::is_propagate_on_swap }; };
+        enum
+        {
+            value = Flag::is_propagate_on_move
+        };
     };
+};
 
-    template <typename Flag>
-    struct assign_allocator_base
-    {
-        struct propagate_on_container_copy_assignment {
-            enum { value = Flag::is_propagate_on_assign }; };
-    };
+namespace {
+// boostinspect:nounnamed
+bool force_equal_allocator_value = false;
+}
 
-    template <typename Flag>
-    struct move_allocator_base
-    {
-        struct propagate_on_container_move_assignment {
-            enum { value = Flag::is_propagate_on_move }; };
-    };
+struct force_equal_allocator
+{
+    bool old_value_;
 
-    namespace
+    explicit force_equal_allocator(bool value)
+        : old_value_(force_equal_allocator_value)
     {
-        // boostinspect:nounnamed
-        bool force_equal_allocator_value = false;
+        force_equal_allocator_value = value;
     }
 
-    struct force_equal_allocator
+    ~force_equal_allocator() { force_equal_allocator_value = old_value_; }
+};
+
+template <typename T> struct cxx11_allocator_base
+{
+    int tag_;
+    int selected_;
+
+    typedef std::size_t size_type;
+    typedef std::ptrdiff_t difference_type;
+    typedef T* pointer;
+    typedef T const* const_pointer;
+    typedef T& reference;
+    typedef T const& const_reference;
+    typedef T value_type;
+
+    explicit cxx11_allocator_base(int t) : tag_(t), selected_(0)
     {
-        bool old_value_;
-    
-        explicit force_equal_allocator(bool value)
-            : old_value_(force_equal_allocator_value)
-        { force_equal_allocator_value = value; }
-        
-        ~force_equal_allocator()
-        { force_equal_allocator_value = old_value_; }
-    };
+        detail::tracker.allocator_ref();
+    }
 
-    template <typename T>
-    struct cxx11_allocator_base
+    template <typename Y>
+    cxx11_allocator_base(cxx11_allocator_base<Y> const& x)
+        : tag_(x.tag_), selected_(x.selected_)
     {
-        int tag_;
-        int selected_;
+        detail::tracker.allocator_ref();
+    }
 
-        typedef std::size_t size_type;
-        typedef std::ptrdiff_t difference_type;
-        typedef T* pointer;
-        typedef T const* const_pointer;
-        typedef T& reference;
-        typedef T const& const_reference;
-        typedef T value_type;
+    cxx11_allocator_base(cxx11_allocator_base const& x)
+        : tag_(x.tag_), selected_(x.selected_)
+    {
+        detail::tracker.allocator_ref();
+    }
 
-        explicit cxx11_allocator_base(int t)
-            : tag_(t), selected_(0)
-        {
-            detail::tracker.allocator_ref();
-        }
-        
-        template <typename Y> cxx11_allocator_base(
-                cxx11_allocator_base<Y> const& x)
-            : tag_(x.tag_), selected_(x.selected_)
-        {
-            detail::tracker.allocator_ref();
-        }
+    ~cxx11_allocator_base() { detail::tracker.allocator_unref(); }
 
-        cxx11_allocator_base(cxx11_allocator_base const& x)
-            : tag_(x.tag_), selected_(x.selected_)
-        {
-            detail::tracker.allocator_ref();
-        }
+    pointer address(reference r) { return pointer(&r); }
 
-        ~cxx11_allocator_base()
-        {
-            detail::tracker.allocator_unref();
-        }
+    const_pointer address(const_reference r) { return const_pointer(&r); }
 
-        pointer address(reference r)
-        {
-            return pointer(&r);
-        }
+    pointer allocate(size_type n)
+    {
+        pointer ptr(static_cast<T*>(::operator new(n * sizeof(T))));
+        detail::tracker.track_allocate((void*)ptr, n, sizeof(T), tag_);
+        return ptr;
+    }
 
-        const_pointer address(const_reference r)
-        {
-            return const_pointer(&r);
-        }
+    pointer allocate(size_type n, void const*)
+    {
+        pointer ptr(static_cast<T*>(::operator new(n * sizeof(T))));
+        detail::tracker.track_allocate((void*)ptr, n, sizeof(T), tag_);
+        return ptr;
+    }
 
-        pointer allocate(size_type n) {
-            pointer ptr(static_cast<T*>(::operator new(n * sizeof(T))));
-            detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
-            return ptr;
-        }
+    void deallocate(pointer p, size_type n)
+    {
+        // Only checking tags when propagating swap.
+        // Note that tags will be tested
+        // properly in the normal allocator.
+        detail::tracker.track_deallocate(
+            (void*)p, n, sizeof(T), tag_, !force_equal_allocator_value);
+        ::operator delete((void*)p);
+    }
 
-        pointer allocate(size_type n, void const*)
-        {
-            pointer ptr(static_cast<T*>(::operator new(n * sizeof(T))));
-            detail::tracker.track_allocate((void*) ptr, n, sizeof(T), tag_);
-            return ptr;
-        }
-
-        void deallocate(pointer p, size_type n)
-        {
-            // Only checking tags when propagating swap.
-            // Note that tags will be tested
-            // properly in the normal allocator.
-            detail::tracker.track_deallocate((void*) p, n, sizeof(T), tag_,
-                 !force_equal_allocator_value);
-            ::operator delete((void*) p);
-        }
-
-        void construct(T* p, T const& t) {
-            detail::tracker.track_construct((void*) p, sizeof(T), tag_);
-            new(p) T(t);
-        }
+    void construct(T* p, T const& t)
+    {
+        detail::tracker.track_construct((void*)p, sizeof(T), tag_);
+        new (p) T(t);
+    }
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-        template<typename... Args> void construct(T* p, BOOST_FWD_REF(Args)... args) {
-            detail::tracker.track_construct((void*) p, sizeof(T), tag_);
-            new(p) T(boost::forward<Args>(args)...);
-        }
+    template <typename... Args>
+    void construct(T* p, BOOST_FWD_REF(Args)... args)
+    {
+        detail::tracker.track_construct((void*)p, sizeof(T), tag_);
+        new (p) T(boost::forward<Args>(args)...);
+    }
 #endif
 
-        void destroy(T* p) {
-            detail::tracker.track_destroy((void*) p, sizeof(T), tag_);
-            p->~T();
-        }
-
-        size_type max_size() const {
-            return (std::numeric_limits<size_type>::max)();
-        }
-    };
-
-    template <typename T, typename Flags = propagate_swap,
-        typename Enable = void>
-    struct cxx11_allocator;
-
-    template <typename T, typename Flags>
-    struct cxx11_allocator<
-        T, Flags,
-        typename boost::disable_if_c<Flags::is_select_on_copy>::type
-    > : public cxx11_allocator_base<T>,
-        public swap_allocator_base<Flags>,
-        public assign_allocator_base<Flags>,
-        public move_allocator_base<Flags>,
-        Flags
+    void destroy(T* p)
     {
+        detail::tracker.track_destroy((void*)p, sizeof(T), tag_);
+        p->~T();
+    }
+
+    size_type max_size() const
+    {
+        return (std::numeric_limits<size_type>::max)();
+    }
+};
+
+template <typename T, typename Flags = propagate_swap, typename Enable = void>
+struct cxx11_allocator;
+
+template <typename T, typename Flags>
+struct cxx11_allocator<T, Flags,
+    typename boost::disable_if_c<Flags::is_select_on_copy>::type>
+    : public cxx11_allocator_base<T>,
+      public swap_allocator_base<Flags>,
+      public assign_allocator_base<Flags>,
+      public move_allocator_base<Flags>,
+      Flags
+{
 #if BOOST_WORKAROUND(BOOST_GCC_VERSION, < 402000)
-        template <typename U> struct rebind {
-            typedef cxx11_allocator<U, Flags> other;
-        };
+    template <typename U> struct rebind
+    {
+        typedef cxx11_allocator<U, Flags> other;
+    };
 #endif
 
-        explicit cxx11_allocator(int t = 0)
-            : cxx11_allocator_base<T>(t)
-        {
-        }
-        
-        template <typename Y> cxx11_allocator(
-                cxx11_allocator<Y, Flags> const& x)
-            : cxx11_allocator_base<T>(x)
-        {
-        }
+    explicit cxx11_allocator(int t = 0) : cxx11_allocator_base<T>(t) {}
 
-        cxx11_allocator(cxx11_allocator const& x)
-            : cxx11_allocator_base<T>(x)
-        {
-        }
-
-        // When not propagating swap, allocators are always equal
-        // to avoid undefined behaviour.
-        bool operator==(cxx11_allocator const& x) const
-        {
-            return force_equal_allocator_value || (this->tag_ == x.tag_);
-        }
-
-        bool operator!=(cxx11_allocator const& x) const
-        {
-            return !(*this == x);
-        }
-    };
-
-    template <typename T, typename Flags>
-    struct cxx11_allocator<
-        T, Flags,
-        typename boost::enable_if_c<Flags::is_select_on_copy>::type
-    > : public cxx11_allocator_base<T>,
-        public swap_allocator_base<Flags>,
-        public assign_allocator_base<Flags>,
-        public move_allocator_base<Flags>,
-        Flags
+    template <typename Y>
+    cxx11_allocator(cxx11_allocator<Y, Flags> const& x)
+        : cxx11_allocator_base<T>(x)
     {
-        cxx11_allocator select_on_container_copy_construction() const
-        {
-            cxx11_allocator tmp(*this);
-            ++tmp.selected_;
-            return tmp;
-        }
+    }
+
+    cxx11_allocator(cxx11_allocator const& x) : cxx11_allocator_base<T>(x) {}
+
+    // When not propagating swap, allocators are always equal
+    // to avoid undefined behaviour.
+    bool operator==(cxx11_allocator const& x) const
+    {
+        return force_equal_allocator_value || (this->tag_ == x.tag_);
+    }
+
+    bool operator!=(cxx11_allocator const& x) const { return !(*this == x); }
+};
+
+template <typename T, typename Flags>
+struct cxx11_allocator<T, Flags,
+    typename boost::enable_if_c<Flags::is_select_on_copy>::type>
+    : public cxx11_allocator_base<T>,
+      public swap_allocator_base<Flags>,
+      public assign_allocator_base<Flags>,
+      public move_allocator_base<Flags>,
+      Flags
+{
+    cxx11_allocator select_on_container_copy_construction() const
+    {
+        cxx11_allocator tmp(*this);
+        ++tmp.selected_;
+        return tmp;
+    }
 
 #if BOOST_WORKAROUND(BOOST_GCC_VERSION, < 402000)
-        template <typename U> struct rebind {
-            typedef cxx11_allocator<U, Flags> other;
-        };
+    template <typename U> struct rebind
+    {
+        typedef cxx11_allocator<U, Flags> other;
+    };
 #endif
 
-        explicit cxx11_allocator(int t = 0)
-            : cxx11_allocator_base<T>(t)
-        {
-        }
-        
-        template <typename Y> cxx11_allocator(
-                cxx11_allocator<Y, Flags> const& x)
-            : cxx11_allocator_base<T>(x)
-        {
-        }
+    explicit cxx11_allocator(int t = 0) : cxx11_allocator_base<T>(t) {}
 
-        cxx11_allocator(cxx11_allocator const& x)
-            : cxx11_allocator_base<T>(x)
-        {
-        }
-
-        // When not propagating swap, allocators are always equal
-        // to avoid undefined behaviour.
-        bool operator==(cxx11_allocator const& x) const
-        {
-            return force_equal_allocator_value || (this->tag_ == x.tag_);
-        }
-
-        bool operator!=(cxx11_allocator const& x) const
-        {
-            return !(*this == x);
-        }
-    };
-
-    template <typename T, typename Flags>
-    bool equivalent_impl(
-            cxx11_allocator<T, Flags> const& x,
-            cxx11_allocator<T, Flags> const& y,
-            test::derived_type)
+    template <typename Y>
+    cxx11_allocator(cxx11_allocator<Y, Flags> const& x)
+        : cxx11_allocator_base<T>(x)
     {
-        return x.tag_ == y.tag_;
     }
 
-    // Function to check how many times an allocator has been selected,
-    // return 0 for other allocators.
+    cxx11_allocator(cxx11_allocator const& x) : cxx11_allocator_base<T>(x) {}
 
-    struct convert_from_anything
+    // When not propagating swap, allocators are always equal
+    // to avoid undefined behaviour.
+    bool operator==(cxx11_allocator const& x) const
     {
-        template <typename T>
-        convert_from_anything(T const&) {}
-    };
-
-    inline int selected_count(convert_from_anything)
-    {
-        return 0;
+        return force_equal_allocator_value || (this->tag_ == x.tag_);
     }
 
-    template <typename T, typename Flags>
-    int selected_count(cxx11_allocator<T, Flags> const& x)
-    {
-        return x.selected_;
-    }
+    bool operator!=(cxx11_allocator const& x) const { return !(*this == x); }
+};
+
+template <typename T, typename Flags>
+bool equivalent_impl(cxx11_allocator<T, Flags> const& x,
+    cxx11_allocator<T, Flags> const& y, test::derived_type)
+{
+    return x.tag_ == y.tag_;
+}
+
+// Function to check how many times an allocator has been selected,
+// return 0 for other allocators.
+
+struct convert_from_anything
+{
+    template <typename T> convert_from_anything(T const&) {}
+};
+
+inline int selected_count(convert_from_anything) { return 0; }
+
+template <typename T, typename Flags>
+int selected_count(cxx11_allocator<T, Flags> const& x)
+{
+    return x.selected_;
+}
 }
 
 #endif