Ticket #10349: atomic_enum.patch
File atomic_enum.patch, 7.5 KB (added by , 8 years ago) |
---|
-
boost/atomic/detail/atomic_template.hpp
# HG changeset patch # User iloehken # Date 1407854747 -7200 # Tue Aug 12 16:45:47 2014 +0200 # Branch 1.56 # Node ID 1a6edcfda31d5c14b218d8ee9d5eadc7cb016148 # Parent 43ef1037b73e427d5193ef04c83e7b358c2d266f [boost] atomic : added facet to handle enums atomic as ints diff -r 43ef1037b73e -r 1a6edcfda31d boost/atomic/detail/atomic_template.hpp
a b 21 21 #include <boost/assert.hpp> 22 22 #include <boost/type_traits/is_signed.hpp> 23 23 #include <boost/type_traits/is_integral.hpp> 24 #include <boost/type_traits/is_enum.hpp> 24 25 #include <boost/atomic/detail/config.hpp> 25 26 #include <boost/atomic/detail/casts.hpp> 26 27 #include <boost/atomic/detail/operations_fwd.hpp> … … 56 57 return (failure_order & 15u) <= (success_order & 15u); 57 58 } 58 59 59 template< typename T, bool IsInt = boost::is_integral< T >::value > 60 struct classify 60 struct integral_type; 61 struct enum_type; 62 struct user_defined_type; 63 struct pointer_type; 64 65 template <typename T, bool bIsInt = boost::is_integral<T>::value> 66 struct classify_integral_or_other 61 67 { 62 typedef voidtype;68 typedef user_defined_type type; 63 69 }; 64 70 65 71 template< typename T > 66 struct classify< T, true > { typedef int type; }; 72 struct classify_integral_or_other<T,true> 73 { 74 typedef integral_type type; 75 }; 67 76 68 77 template< typename T > 69 struct classify< T*, false > { typedef void* type; }; 78 struct classify_integral_or_other<T*,false> 79 { 80 typedef pointer_type type; 81 }; 70 82 71 template< typename T, typename Kind > 83 template <typename T, bool bIsEnum = boost::is_enum<T>::value> 84 struct classify_enum_or_other 85 { 86 typedef enum_type type; 87 }; 88 89 template <typename T> 90 struct classify_enum_or_other<T,false> 91 : public classify_integral_or_other<T> 92 {}; 93 94 template <typename T> 95 struct classify 96 : public classify_enum_or_other<T> 97 {}; 98 99 100 template <typename T, typename Kind> 72 101 class base_atomic; 73 102 103 104 105 //! Implementation for enums ---> store as int 106 template <typename T> 107 class base_atomic<T,enum_type> 108 { 109 private: 110 typedef T value_type; 111 typedef T difference_type; 112 typedef atomics::detail::operations< storage_size_of<int >::value, boost::is_signed<int >::value > operations; 113 114 protected: 115 typedef value_type value_arg_type; 116 117 public: 118 typedef typename operations::storage_type storage_type; 119 120 protected: 121 storage_type m_storage; 122 123 public: 124 BOOST_DEFAULTED_FUNCTION(base_atomic(), {}) 125 BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : m_storage(v) {} 126 127 BOOST_FORCEINLINE void store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT 128 { 129 BOOST_ASSERT(order != memory_order_consume); 130 BOOST_ASSERT(order != memory_order_acquire); 131 BOOST_ASSERT(order != memory_order_acq_rel); 132 133 operations::store(m_storage, static_cast< storage_type >(v), order); 134 } 135 136 BOOST_FORCEINLINE value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT 137 { 138 BOOST_ASSERT(order != memory_order_release); 139 BOOST_ASSERT(order != memory_order_acq_rel); 140 141 return static_cast< value_type >(operations::load(m_storage, order)); 142 } 143 144 BOOST_FORCEINLINE value_type exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT 145 { 146 return static_cast< value_type >(operations::exchange(m_storage, static_cast< storage_type >(v), order)); 147 } 148 149 BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT 150 { 151 BOOST_ASSERT(failure_order != memory_order_release); 152 BOOST_ASSERT(failure_order != memory_order_acq_rel); 153 BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order)); 154 155 storage_type old_value = static_cast< storage_type >(expected); 156 const bool res = operations::compare_exchange_strong(m_storage, old_value, static_cast< storage_type >(desired), success_order, failure_order); 157 expected = static_cast< value_type >(old_value); 158 return res; 159 } 160 161 BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT 162 { 163 return compare_exchange_strong(expected, desired, order, atomics::detail::deduce_failure_order(order)); 164 } 165 166 BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT 167 { 168 BOOST_ASSERT(failure_order != memory_order_release); 169 BOOST_ASSERT(failure_order != memory_order_acq_rel); 170 BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order)); 171 172 storage_type old_value = static_cast< storage_type >(expected); 173 const bool res = operations::compare_exchange_weak(m_storage, old_value, static_cast< storage_type >(desired), success_order, failure_order); 174 expected = static_cast< value_type >(old_value); 175 return res; 176 } 177 178 BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT 179 { 180 return compare_exchange_weak(expected, desired, order, atomics::detail::deduce_failure_order(order)); 181 } 182 183 BOOST_FORCEINLINE bool is_lock_free() const volatile BOOST_NOEXCEPT 184 { 185 return operations::is_lock_free(m_storage); 186 } 187 188 BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) 189 BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) 190 }; 191 192 193 74 194 //! Implementation for integers 75 template < typename T>76 class base_atomic< T, int>195 template <typename T> 196 class base_atomic<T,integral_type> 77 197 { 78 198 private: 79 199 typedef T value_type; … … 228 348 BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) 229 349 }; 230 350 351 352 231 353 //! Implementation for bool 232 354 template< > 233 class base_atomic< bool, int>355 class base_atomic<bool,integral_type> 234 356 { 235 357 private: 236 358 typedef bool value_type; … … 315 437 }; 316 438 317 439 318 //! Implementation for user-defined types, such as structs and enums 319 template< typename T > 320 class base_atomic< T, void > 440 441 //! Implementation for user-defined types, such as structs 442 template <typename T> 443 class base_atomic<T,user_defined_type> 321 444 { 322 445 private: 323 446 typedef T value_type; … … 403 526 }; 404 527 405 528 529 406 530 //! Implementation for pointers 407 template < typename T>408 class base_atomic< T*, void*>531 template <typename T> 532 class base_atomic<T*,pointer_type> 409 533 { 410 534 private: 411 535 typedef T* value_type; … … 533 657 }; 534 658 535 659 660 536 661 //! Implementation for void pointers 537 template <>538 class base_atomic< void*, void*>662 template <> 663 class base_atomic<void*,pointer_type> 539 664 { 540 665 private: 541 666 typedef void* value_type; … … 664 789 665 790 } // namespace detail 666 791 667 template< typename T > 792 793 794 template <typename T> 668 795 class atomic : 669 public atomics::detail::base_atomic< T, typename atomics::detail::classify< T >::type>796 public atomics::detail::base_atomic<T,typename atomics::detail::classify<T>::type> 670 797 { 671 798 private: 672 799 typedef T value_type;