update sources to v12.2.3

[ceph.git] / ceph / src / boost / libs / align / test / aligned_allocator_adaptor_test.cpp

diff --git a/ceph/src/boost/libs/align/test/aligned_allocator_adaptor_test.cpp b/ceph/src/boost/libs/align/test/aligned_allocator_adaptor_test.cpp
index 91ea089b31aaeb1bb4fcd9875e88b6cce8e8c6c1..720cb6572a0cb3180cadce361a91319ea5e8bdfa 100644 (file)
--- a/ceph/src/boost/libs/align/test/aligned_allocator_adaptor_test.cpp
+++ b/ceph/src/boost/libs/align/test/aligned_allocator_adaptor_test.cpp
@@ -1,10 +1,9 @@
 /*
-(c) 2014 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/align/aligned_allocator_adaptor.hpp>
 #include <boost/align/is_aligned.hpp>
@@ -17,48 +16,55 @@ class A {
 public:
     typedef T value_type;
     typedef T* pointer;
-    typedef const T* const_pointer;
-    typedef void* void_pointer;
-    typedef const void* const_void_pointer;
     typedef std::size_t size_type;
     typedef std::ptrdiff_t difference_type;
-    typedef T& reference;
-    typedef const T& const_reference;
+
     template<class U>
     struct rebind {
         typedef A<U> other;
     };
-    A()
-        : state() { }
-    A(int value)
-        : state(value) { }
+
+    A(int state)
+        : state_(state) { }
+
     template<class U>
     A(const A<U>& other)
-        : state(other.state) { }
-    pointer allocate(size_type size, const_void_pointer = 0) {
+        : state_(other.state()) { }
+
+    T* allocate(std::size_t size, const void* = 0) {
         return static_cast<T*>(::operator new(sizeof(T) * size));
     }
-    void deallocate(pointer ptr, size_type) {
+
+    void deallocate(T* ptr, std::size_t) {
         ::operator delete(ptr);
     }
-    void construct(pointer ptr, const_reference value) {
+
+    void construct(T* ptr, const T& value) {
         ::new(static_cast<void*>(ptr)) T(value);
     }
-    void destroy(pointer ptr) {
-        (void)ptr;
+
+    void destroy(T* ptr) {
         ptr->~T();
     }
-    int state;
+
+    int state() const {
+        return state_;
+    }
+
+private:
+    int state_;
 };
 
-template<class T1, class T2>
-bool operator==(const A<T1>& a, const A<T2>& b)
+template<class T, class U>
+inline bool
+operator==(const A<T>& a, const A<U>& b)
 {
-    return a.state == b.state;
+    return a.state() == b.state();
 }
 
-template<class T1, class T2>
-bool operator!=(const A<T1>& a, const A<T2>& b)
+template<class T, class U>
+inline bool
+operator!=(const A<T>& a, const A<U>& b)
 {
     return !(a == b);
 }
@@ -67,8 +73,7 @@ template<std::size_t Alignment>
 void test_allocate()
 {
     {
-        boost::alignment::aligned_allocator_adaptor<A<int>,
-            Alignment> a(5);
+        boost::alignment::aligned_allocator_adaptor<A<int>, Alignment> a(5);
         int* p = a.allocate(1);
         BOOST_TEST(p != 0);
         BOOST_TEST(boost::alignment::is_aligned(p, Alignment));
@@ -76,19 +81,17 @@ void test_allocate()
         a.deallocate(p, 1);
     }
     {
-        boost::alignment::aligned_allocator_adaptor<A<int>,
-            Alignment> a(5);
-        int* p1 = a.allocate(1);
-        int* p2 = a.allocate(1, p1);
-        BOOST_TEST(p2 != 0);
-        BOOST_TEST(boost::alignment::is_aligned(p2, Alignment));
-        std::memset(p2, 0, 1);
-        a.deallocate(p2, 1);
-        a.deallocate(p1, 1);
+        boost::alignment::aligned_allocator_adaptor<A<int>, Alignment> a(5);
+        int* p = a.allocate(1);
+        int* q = a.allocate(1, p);
+        BOOST_TEST(q != 0);
+        BOOST_TEST(boost::alignment::is_aligned(q, Alignment));
+        std::memset(q, 0, 1);
+        a.deallocate(q, 1);
+        a.deallocate(p, 1);
     }
     {
-        boost::alignment::aligned_allocator_adaptor<A<int>,
-            Alignment> a(5);
+        boost::alignment::aligned_allocator_adaptor<A<int>, Alignment> a(5);
         int* p = a.allocate(0);
         a.deallocate(p, 0);
     }
@@ -97,8 +100,7 @@ void test_allocate()
 template<std::size_t Alignment>
 void test_construct()
 {
-    boost::alignment::aligned_allocator_adaptor<A<int>,
-        Alignment> a(5);
+    boost::alignment::aligned_allocator_adaptor<A<int>, Alignment> a(5);
     int* p = a.allocate(1);
     a.construct(p, 1);
     BOOST_TEST(*p == 1);
@@ -110,28 +112,24 @@ template<std::size_t Alignment>
 void test_constructor()
 {
     {
-        boost::alignment::aligned_allocator_adaptor<A<char>,
-            Alignment> a1(5);
-        boost::alignment::aligned_allocator_adaptor<A<int>,
-            Alignment> a2(a1);
-        BOOST_TEST(a2 == a1);
+        boost::alignment::aligned_allocator_adaptor<A<char>, Alignment> a(5);
+        boost::alignment::aligned_allocator_adaptor<A<int>, Alignment> b(a);
+        BOOST_TEST(b == a);
     }
     {
-        A<int> a1(5);
-        boost::alignment::aligned_allocator_adaptor<A<int>,
-            Alignment> a2(a1);
-        BOOST_TEST(a2.base() == a1);
+        A<int> a(5);
+        boost::alignment::aligned_allocator_adaptor<A<int>, Alignment> b(a);
+        BOOST_TEST(b.base() == a);
     }
 }
 
 template<std::size_t Alignment>
 void test_rebind()
 {
-    boost::alignment::aligned_allocator_adaptor<A<int>,
-        Alignment> a1(5);
+    boost::alignment::aligned_allocator_adaptor<A<int>, Alignment> a(5);
     typename boost::alignment::aligned_allocator_adaptor<A<int>,
-        Alignment>::template rebind<int>::other a2(a1);
-    BOOST_TEST(a2 == a1);
+        Alignment>::template rebind<int>::other b(a);
+    BOOST_TEST(b == a);
 }
 
 template<std::size_t Alignment>