thread/pthread/thread_heap_alloc.hpp

0001 // Distributed under the Boost Software License, Version 1.0. (See
0002 // accompanying file LICENSE_1_0.txt or copy at
0003 // http://www.boost.org/LICENSE_1_0.txt)
0004 // (C) Copyright 2008 Anthony Williams
0005 #ifndef THREAD_HEAP_ALLOC_PTHREAD_HPP
0006 #define THREAD_HEAP_ALLOC_PTHREAD_HPP
0007
0008 #include <boost/config/abi_prefix.hpp>
0009
0010 namespace boost
0011 {
0012     namespace detail
0013     {
0014         template<typename T>
0015         inline T* heap_new()
0016         {
0017             return new T();
0018         }
0019 #if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) && ! defined (BOOST_NO_CXX11_RVALUE_REFERENCES)
0020         template<typename T,typename... Args>
0021         inline T* heap_new(Args&&... args)
0022         {
0023             return new T(static_cast<Args&&>(args)...);
0024         }
0025 #elif ! defined BOOST_NO_CXX11_RVALUE_REFERENCES
0026         template<typename T,typename A1>
0027         inline T* heap_new(A1&& a1)
0028         {
0029             return new T(static_cast<A1&&>(a1));
0030         }
0031         template<typename T,typename A1,typename A2>
0032         inline T* heap_new(A1&& a1,A2&& a2)
0033         {
0034             return new T(static_cast<A1&&>(a1),static_cast<A2&&>(a2));
0035         }
0036         template<typename T,typename A1,typename A2,typename A3>
0037         inline T* heap_new(A1&& a1,A2&& a2,A3&& a3)
0038         {
0039             return new T(static_cast<A1&&>(a1),static_cast<A2&&>(a2),
0040                          static_cast<A3&&>(a3));
0041         }
0042         template<typename T,typename A1,typename A2,typename A3,typename A4>
0043         inline T* heap_new(A1&& a1,A2&& a2,A3&& a3,A4&& a4)
0044         {
0045             return new T(static_cast<A1&&>(a1),static_cast<A2&&>(a2),
0046                          static_cast<A3&&>(a3),static_cast<A4&&>(a4));
0047         }
0048 #else
0049         template<typename T,typename A1>
0050         inline T* heap_new_impl(A1 a1)
0051         {
0052             return new T(a1);
0053         }
0054         template<typename T,typename A1,typename A2>
0055         inline T* heap_new_impl(A1 a1,A2 a2)
0056         {
0057             return new T(a1,a2);
0058         }
0059         template<typename T,typename A1,typename A2,typename A3>
0060         inline T* heap_new_impl(A1 a1,A2 a2,A3 a3)
0061         {
0062             return new T(a1,a2,a3);
0063         }
0064         template<typename T,typename A1,typename A2,typename A3,typename A4>
0065         inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4)
0066         {
0067             return new T(a1,a2,a3,a4);
0068         }
0069         template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5>
0070         inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5)
0071         {
0072             return new T(a1,a2,a3,a4,a5);
0073         }
0074         template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5,typename A6>
0075         inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6)
0076         {
0077             return new T(a1,a2,a3,a4,a5,a6);
0078         }
0079         template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5,typename A6,typename A7>
0080         inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7)
0081         {
0082             return new T(a1,a2,a3,a4,a5,a6,a7);
0083         }
0084         template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5,typename A6,typename A7,typename A8>
0085         inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8)
0086         {
0087             return new T(a1,a2,a3,a4,a5,a6,a7,a8);
0088         }
0089         template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5,typename A6,typename A7,typename A8,typename A9>
0090         inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8,A9 a9)
0091         {
0092             return new T(a1,a2,a3,a4,a5,a6,a7,a8,a9);
0093         }
0094
0095         template<typename T,typename A1>
0096         inline T* heap_new(A1 const& a1)
0097         {
0098             return heap_new_impl<T,A1 const&>(a1);
0099         }
0100         template<typename T,typename A1>
0101         inline T* heap_new(A1& a1)
0102         {
0103             return heap_new_impl<T,A1&>(a1);
0104         }
0105
0106         template<typename T,typename A1,typename A2>
0107         inline T* heap_new(A1 const& a1,A2 const& a2)
0108         {
0109             return heap_new_impl<T,A1 const&,A2 const&>(a1,a2);
0110         }
0111         template<typename T,typename A1,typename A2>
0112         inline T* heap_new(A1& a1,A2 const& a2)
0113         {
0114             return heap_new_impl<T,A1&,A2 const&>(a1,a2);
0115         }
0116         template<typename T,typename A1,typename A2>
0117         inline T* heap_new(A1 const& a1,A2& a2)
0118         {
0119             return heap_new_impl<T,A1 const&,A2&>(a1,a2);
0120         }
0121         template<typename T,typename A1,typename A2>
0122         inline T* heap_new(A1& a1,A2& a2)
0123         {
0124             return heap_new_impl<T,A1&,A2&>(a1,a2);
0125         }
0126
0127         template<typename T,typename A1,typename A2,typename A3>
0128         inline T* heap_new(A1 const& a1,A2 const& a2,A3 const& a3)
0129         {
0130             return heap_new_impl<T,A1 const&,A2 const&,A3 const&>(a1,a2,a3);
0131         }
0132         template<typename T,typename A1,typename A2,typename A3>
0133         inline T* heap_new(A1& a1,A2 const& a2,A3 const& a3)
0134         {
0135             return heap_new_impl<T,A1&,A2 const&,A3 const&>(a1,a2,a3);
0136         }
0137         template<typename T,typename A1,typename A2,typename A3>
0138         inline T* heap_new(A1 const& a1,A2& a2,A3 const& a3)
0139         {
0140             return heap_new_impl<T,A1 const&,A2&,A3 const&>(a1,a2,a3);
0141         }
0142         template<typename T,typename A1,typename A2,typename A3>
0143         inline T* heap_new(A1& a1,A2& a2,A3 const& a3)
0144         {
0145             return heap_new_impl<T,A1&,A2&,A3 const&>(a1,a2,a3);
0146         }
0147
0148         template<typename T,typename A1,typename A2,typename A3>
0149         inline T* heap_new(A1 const& a1,A2 const& a2,A3& a3)
0150         {
0151             return heap_new_impl<T,A1 const&,A2 const&,A3&>(a1,a2,a3);
0152         }
0153         template<typename T,typename A1,typename A2,typename A3>
0154         inline T* heap_new(A1& a1,A2 const& a2,A3& a3)
0155         {
0156             return heap_new_impl<T,A1&,A2 const&,A3&>(a1,a2,a3);
0157         }
0158         template<typename T,typename A1,typename A2,typename A3>
0159         inline T* heap_new(A1 const& a1,A2& a2,A3& a3)
0160         {
0161             return heap_new_impl<T,A1 const&,A2&,A3&>(a1,a2,a3);
0162         }
0163         template<typename T,typename A1,typename A2,typename A3>
0164         inline T* heap_new(A1& a1,A2& a2,A3& a3)
0165         {
0166             return heap_new_impl<T,A1&,A2&,A3&>(a1,a2,a3);
0167         }
0168
0169         template<typename T,typename A1,typename A2,typename A3,typename A4>
0170         inline T* heap_new(A1 const& a1,A2 const& a2,A3 const& a3,A4 const& a4)
0171         {
0172             return heap_new_impl<T,A1 const&,A2 const&,A3 const&,A4 const&>(a1,a2,a3,a4);
0173         }
0174         template<typename T,typename A1,typename A2,typename A3,typename A4>
0175         inline T* heap_new(A1& a1,A2 const& a2,A3 const& a3,A4 const& a4)
0176         {
0177             return heap_new_impl<T,A1&,A2 const&,A3 const&,A4 const&>(a1,a2,a3,a4);
0178         }
0179         template<typename T,typename A1,typename A2,typename A3,typename A4>
0180         inline T* heap_new(A1 const& a1,A2& a2,A3 const& a3,A4 const& a4)
0181         {
0182             return heap_new_impl<T,A1 const&,A2&,A3 const&,A4 const&>(a1,a2,a3,a4);
0183         }
0184         template<typename T,typename A1,typename A2,typename A3,typename A4>
0185         inline T* heap_new(A1& a1,A2& a2,A3 const& a3,A4 const& a4)
0186         {
0187             return heap_new_impl<T,A1&,A2&,A3 const&,A4 const&>(a1,a2,a3,a4);
0188         }
0189
0190         template<typename T,typename A1,typename A2,typename A3,typename A4>
0191         inline T* heap_new(A1 const& a1,A2 const& a2,A3& a3,A4 const& a4)
0192         {
0193             return heap_new_impl<T,A1 const&,A2 const&,A3&,A4 const&>(a1,a2,a3,a4);
0194         }
0195         template<typename T,typename A1,typename A2,typename A3,typename A4>
0196         inline T* heap_new(A1& a1,A2 const& a2,A3& a3,A4 const& a4)
0197         {
0198             return heap_new_impl<T,A1&,A2 const&,A3&,A4 const&>(a1,a2,a3,a4);
0199         }
0200         template<typename T,typename A1,typename A2,typename A3,typename A4>
0201         inline T* heap_new(A1 const& a1,A2& a2,A3& a3,A4 const& a4)
0202         {
0203             return heap_new_impl<T,A1 const&,A2&,A3&,A4 const&>(a1,a2,a3,a4);
0204         }
0205         template<typename T,typename A1,typename A2,typename A3,typename A4>
0206         inline T* heap_new(A1& a1,A2& a2,A3& a3,A4 const& a4)
0207         {
0208             return heap_new_impl<T,A1&,A2&,A3&,A4 const&>(a1,a2,a3,a4);
0209         }
0210         template<typename T,typename A1,typename A2,typename A3,typename A4>
0211         inline T* heap_new(A1 const& a1,A2 const& a2,A3 const& a3,A4& a4)
0212         {
0213             return heap_new_impl<T,A1 const&,A2 const&,A3 const&,A4&>(a1,a2,a3,a4);
0214         }
0215         template<typename T,typename A1,typename A2,typename A3,typename A4>
0216         inline T* heap_new(A1& a1,A2 const& a2,A3 const& a3,A4& a4)
0217         {
0218             return heap_new_impl<T,A1&,A2 const&,A3 const&,A4&>(a1,a2,a3,a4);
0219         }
0220         template<typename T,typename A1,typename A2,typename A3,typename A4>
0221         inline T* heap_new(A1 const& a1,A2& a2,A3 const& a3,A4& a4)
0222         {
0223             return heap_new_impl<T,A1 const&,A2&,A3 const&,A4&>(a1,a2,a3,a4);
0224         }
0225         template<typename T,typename A1,typename A2,typename A3,typename A4>
0226         inline T* heap_new(A1& a1,A2& a2,A3 const& a3,A4& a4)
0227         {
0228             return heap_new_impl<T,A1&,A2&,A3 const&,A4&>(a1,a2,a3,a4);
0229         }
0230
0231         template<typename T,typename A1,typename A2,typename A3,typename A4>
0232         inline T* heap_new(A1 const& a1,A2 const& a2,A3& a3,A4& a4)
0233         {
0234             return heap_new_impl<T,A1 const&,A2 const&,A3&,A4&>(a1,a2,a3,a4);
0235         }
0236         template<typename T,typename A1,typename A2,typename A3,typename A4>
0237         inline T* heap_new(A1& a1,A2 const& a2,A3& a3,A4& a4)
0238         {
0239             return heap_new_impl<T,A1&,A2 const&,A3&,A4&>(a1,a2,a3,a4);
0240         }
0241         template<typename T,typename A1,typename A2,typename A3,typename A4>
0242         inline T* heap_new(A1 const& a1,A2& a2,A3& a3,A4& a4)
0243         {
0244             return heap_new_impl<T,A1 const&,A2&,A3&,A4&>(a1,a2,a3,a4);
0245         }
0246         template<typename T,typename A1,typename A2,typename A3,typename A4>
0247         inline T* heap_new(A1& a1,A2& a2,A3& a3,A4& a4)
0248         {
0249             return heap_new_impl<T,A1&,A2&,A3&,A4&>(a1,a2,a3,a4);
0250         }
0251
0252 #endif
0253         template<typename T>
0254         inline void heap_delete(T* data)
0255         {
0256             delete data;
0257         }
0258
0259         template<typename T>
0260         struct do_heap_delete
0261         {
0262             void operator()(T* data) const
0263             {
0264                 detail::heap_delete(data);
0265             }
0266         };
0267     }
0268 }
0269
0270 #include <boost/config/abi_suffix.hpp>
0271
0272 #endif