1 /////////////////////////////////////////////////////////////////////////////// 2 // 3 // (C) Copyright Ion Gaztanaga 2005-2013. Distributed under the Boost 4 // Software License, Version 1.0. (See accompanying file 5 // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 6 // 7 // See http://www.boost.org/libs/container for documentation. 8 // 9 /////////////////////////////////////////////////////////////////////////////// 10 11 #ifndef BOOST_CONTAINER_DUMMY_TEST_ALLOCATOR_HPP 12 #define BOOST_CONTAINER_DUMMY_TEST_ALLOCATOR_HPP 13 14 #ifndef BOOST_CONFIG_HPP 15 # include <boost/config.hpp> 16 #endif 17 18 #if defined(BOOST_HAS_PRAGMA_ONCE) 19 # pragma once 20 #endif 21 22 #include <boost/container/detail/config_begin.hpp> 23 #include <boost/container/detail/workaround.hpp> 24 #include <boost/container/container_fwd.hpp> 25 26 #include <boost/container/throw_exception.hpp> 27 28 #include <boost/container/detail/addressof.hpp> 29 #include <boost/container/detail/allocation_type.hpp> 30 #include <boost/container/detail/mpl.hpp> 31 #include <boost/container/detail/multiallocation_chain.hpp> 32 #include <boost/container/detail/type_traits.hpp> 33 #include <boost/container/detail/version_type.hpp> 34 35 #include <boost/move/utility_core.hpp> 36 #include <boost/move/adl_move_swap.hpp> 37 38 #include <boost/assert.hpp> 39 40 #include <memory> 41 #include <algorithm> 42 #include <cstddef> 43 #include <cassert> 44 45 namespace boost { 46 namespace container { 47 namespace test { 48 49 //Very simple version 1 allocator 50 template<class T> 51 class simple_allocator 52 { 53 public: 54 typedef T value_type; 55 simple_allocator()56 simple_allocator() 57 {} 58 59 template<class U> simple_allocator(const simple_allocator<U> &)60 simple_allocator(const simple_allocator<U> &) 61 {} 62 allocate(std::size_t n)63 T* allocate(std::size_t n) 64 { return (T*)::new char[sizeof(T)*n]; } 65 deallocate(T * p,std::size_t)66 void deallocate(T*p, std::size_t) 67 { delete[] ((char*)p);} 68 operator ==(const simple_allocator &,const simple_allocator &)69 friend bool operator==(const simple_allocator &, const simple_allocator &) 70 { return true; } 71 operator !=(const simple_allocator &,const simple_allocator &)72 friend bool operator!=(const simple_allocator &, const simple_allocator &) 73 { return false; } 74 }; 75 76 template< class T 77 , bool PropagateOnContCopyAssign 78 , bool PropagateOnContMoveAssign 79 , bool PropagateOnContSwap 80 , bool CopyOnPropagateOnContSwap 81 , bool EqualIfEqualIds 82 > 83 class propagation_test_allocator 84 { 85 BOOST_COPYABLE_AND_MOVABLE(propagation_test_allocator) 86 87 public: 88 typedef T value_type; 89 typedef boost::container::dtl::bool_<PropagateOnContCopyAssign> 90 propagate_on_container_copy_assignment; 91 typedef boost::container::dtl::bool_<PropagateOnContMoveAssign> 92 propagate_on_container_move_assignment; 93 typedef boost::container::dtl::bool_<PropagateOnContSwap> 94 propagate_on_container_swap; 95 96 template<class T2> 97 struct rebind 98 { typedef propagation_test_allocator 99 < T2 100 , PropagateOnContCopyAssign 101 , PropagateOnContMoveAssign 102 , PropagateOnContSwap 103 , CopyOnPropagateOnContSwap 104 , EqualIfEqualIds> other; 105 }; 106 select_on_container_copy_construction() const107 propagation_test_allocator select_on_container_copy_construction() const 108 { return CopyOnPropagateOnContSwap ? propagation_test_allocator(*this) : propagation_test_allocator(); } 109 propagation_test_allocator()110 explicit propagation_test_allocator() 111 : id_(++unique_id_) 112 , ctr_copies_(0) 113 , ctr_moves_(0) 114 , assign_copies_(0) 115 , assign_moves_(0) 116 , swaps_(0) 117 {} 118 propagation_test_allocator(const propagation_test_allocator & x)119 propagation_test_allocator(const propagation_test_allocator &x) 120 : id_(x.id_) 121 , ctr_copies_(x.ctr_copies_+1) 122 , ctr_moves_(x.ctr_moves_) 123 , assign_copies_(x.assign_copies_) 124 , assign_moves_(x.assign_moves_) 125 , swaps_(x.swaps_) 126 {} 127 128 template<class U> propagation_test_allocator(const propagation_test_allocator<U,PropagateOnContCopyAssign,PropagateOnContMoveAssign,PropagateOnContSwap,CopyOnPropagateOnContSwap,EqualIfEqualIds> & x)129 propagation_test_allocator(const propagation_test_allocator 130 < U 131 , PropagateOnContCopyAssign 132 , PropagateOnContMoveAssign 133 , PropagateOnContSwap 134 , CopyOnPropagateOnContSwap 135 , EqualIfEqualIds> &x) 136 : id_(x.id_) 137 , ctr_copies_(x.ctr_copies_+1) 138 , ctr_moves_(0) 139 , assign_copies_(0) 140 , assign_moves_(0) 141 , swaps_(0) 142 {} 143 propagation_test_allocator(BOOST_RV_REF (propagation_test_allocator)x)144 propagation_test_allocator(BOOST_RV_REF(propagation_test_allocator) x) 145 : id_(x.id_) 146 , ctr_copies_(x.ctr_copies_) 147 , ctr_moves_(x.ctr_moves_ + 1) 148 , assign_copies_(x.assign_copies_) 149 , assign_moves_(x.assign_moves_) 150 , swaps_(x.swaps_) 151 {} 152 operator =(BOOST_COPY_ASSIGN_REF (propagation_test_allocator)x)153 propagation_test_allocator &operator=(BOOST_COPY_ASSIGN_REF(propagation_test_allocator) x) 154 { 155 id_ = x.id_; 156 ctr_copies_ = x.ctr_copies_; 157 ctr_moves_ = x.ctr_moves_; 158 assign_copies_ = x.assign_copies_+1; 159 assign_moves_ = x.assign_moves_; 160 swaps_ = x.swaps_; 161 return *this; 162 } 163 operator =(BOOST_RV_REF (propagation_test_allocator)x)164 propagation_test_allocator &operator=(BOOST_RV_REF(propagation_test_allocator) x) 165 { 166 id_ = x.id_; 167 ctr_copies_ = x.ctr_copies_; 168 ctr_moves_ = x.ctr_moves_; 169 assign_copies_ = x.assign_copies_; 170 assign_moves_ = x.assign_moves_+1; 171 swaps_ = x.swaps_; 172 return *this; 173 } 174 reset_unique_id(unsigned id=0)175 static void reset_unique_id(unsigned id = 0) 176 { unique_id_ = id; } 177 allocate(std::size_t n)178 T* allocate(std::size_t n) 179 { return (T*)::new char[sizeof(T)*n]; } 180 deallocate(T * p,std::size_t)181 void deallocate(T*p, std::size_t) 182 { delete[] ((char*)p);} 183 operator ==(const propagation_test_allocator & a,const propagation_test_allocator & b)184 friend bool operator==(const propagation_test_allocator &a, const propagation_test_allocator &b) 185 { return EqualIfEqualIds ? a.id_ == b.id_ : true; } 186 operator !=(const propagation_test_allocator & a,const propagation_test_allocator & b)187 friend bool operator!=(const propagation_test_allocator &a, const propagation_test_allocator &b) 188 { return EqualIfEqualIds ? a.id_ != b.id_ : false; } 189 swap(propagation_test_allocator & r)190 void swap(propagation_test_allocator &r) 191 { 192 ++this->swaps_; ++r.swaps_; 193 boost::adl_move_swap(this->id_, r.id_); 194 boost::adl_move_swap(this->ctr_copies_, r.ctr_copies_); 195 boost::adl_move_swap(this->ctr_moves_, r.ctr_moves_); 196 boost::adl_move_swap(this->assign_copies_, r.assign_copies_); 197 boost::adl_move_swap(this->assign_moves_, r.assign_moves_); 198 boost::adl_move_swap(this->swaps_, r.swaps_); 199 } 200 swap(propagation_test_allocator & l,propagation_test_allocator & r)201 friend void swap(propagation_test_allocator &l, propagation_test_allocator &r) 202 { 203 l.swap(r); 204 } 205 206 unsigned int id_; 207 unsigned int ctr_copies_; 208 unsigned int ctr_moves_; 209 unsigned int assign_copies_; 210 unsigned int assign_moves_; 211 unsigned int swaps_; 212 static unsigned unique_id_; 213 }; 214 215 template< class T 216 , bool PropagateOnContCopyAssign 217 , bool PropagateOnContMoveAssign 218 , bool PropagateOnContSwap 219 , bool CopyOnPropagateOnContSwap 220 , bool EqualIfEqualIds 221 > 222 unsigned int propagation_test_allocator< T 223 , PropagateOnContCopyAssign 224 , PropagateOnContMoveAssign 225 , PropagateOnContSwap 226 , CopyOnPropagateOnContSwap 227 , EqualIfEqualIds 228 >::unique_id_ = 0; 229 230 231 } //namespace test { 232 } //namespace container { 233 } //namespace boost { 234 235 #include <boost/container/detail/config_end.hpp> 236 237 #endif //BOOST_CONTAINER_DUMMY_TEST_ALLOCATOR_HPP 238 239