ceph/src/boost/boost/thread/pthread/thread_heap_alloc.hpp

   1 // Distributed under the Boost Software License, Version 1.0. (See
   2 // accompanying file LICENSE_1_0.txt or copy at
   3 // http://www.boost.org/LICENSE_1_0.txt)
   4 // (C) Copyright 2008 Anthony Williams
   5 #ifndef THREAD_HEAP_ALLOC_PTHREAD_HPP
   6 #define THREAD_HEAP_ALLOC_PTHREAD_HPP
   7
   8 #include <boost/config/abi_prefix.hpp>
   9
  10 namespace boost
  11 {
  12     namespace detail
  13     {
  14         template<typename T>
  15         inline T* heap_new()
  16         {
  17             return new T();
  18         }
  19 #if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) && ! defined (BOOST_NO_CXX11_RVALUE_REFERENCES)
  20         template<typename T,typename... Args>
  21         inline T* heap_new(Args&&... args)
  22         {
  23             return new T(static_cast<Args&&>(args)...);
  24         }
  25 #elif ! defined BOOST_NO_CXX11_RVALUE_REFERENCES
  26         template<typename T,typename A1>
  27         inline T* heap_new(A1&& a1)
  28         {
  29             return new T(static_cast<A1&&>(a1));
  30         }
  31         template<typename T,typename A1,typename A2>
  32         inline T* heap_new(A1&& a1,A2&& a2)
  33         {
  34             return new T(static_cast<A1&&>(a1),static_cast<A2&&>(a2));
  35         }
  36         template<typename T,typename A1,typename A2,typename A3>
  37         inline T* heap_new(A1&& a1,A2&& a2,A3&& a3)
  38         {
  39             return new T(static_cast<A1&&>(a1),static_cast<A2&&>(a2),
  40                          static_cast<A3&&>(a3));
  41         }
  42         template<typename T,typename A1,typename A2,typename A3,typename A4>
  43         inline T* heap_new(A1&& a1,A2&& a2,A3&& a3,A4&& a4)
  44         {
  45             return new T(static_cast<A1&&>(a1),static_cast<A2&&>(a2),
  46                          static_cast<A3&&>(a3),static_cast<A4&&>(a4));
  47         }
  48 #else
  49         template<typename T,typename A1>
  50         inline T* heap_new_impl(A1 a1)
  51         {
  52             return new T(a1);
  53         }
  54         template<typename T,typename A1,typename A2>
  55         inline T* heap_new_impl(A1 a1,A2 a2)
  56         {
  57             return new T(a1,a2);
  58         }
  59         template<typename T,typename A1,typename A2,typename A3>
  60         inline T* heap_new_impl(A1 a1,A2 a2,A3 a3)
  61         {
  62             return new T(a1,a2,a3);
  63         }
  64         template<typename T,typename A1,typename A2,typename A3,typename A4>
  65         inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4)
  66         {
  67             return new T(a1,a2,a3,a4);
  68         }
  69         template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5>
  70         inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5)
  71         {
  72             return new T(a1,a2,a3,a4,a5);
  73         }
  74         template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5,typename A6>
  75         inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6)
  76         {
  77             return new T(a1,a2,a3,a4,a5,a6);
  78         }
  79         template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5,typename A6,typename A7>
  80         inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7)
  81         {
  82             return new T(a1,a2,a3,a4,a5,a6,a7);
  83         }
  84         template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5,typename A6,typename A7,typename A8>
  85         inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8)
  86         {
  87             return new T(a1,a2,a3,a4,a5,a6,a7,a8);
  88         }
  89         template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5,typename A6,typename A7,typename A8,typename A9>
  90         inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8,A9 a9)
  91         {
  92             return new T(a1,a2,a3,a4,a5,a6,a7,a8,a9);
  93         }
  94
  95         template<typename T,typename A1>
  96         inline T* heap_new(A1 const& a1)
  97         {
  98             return heap_new_impl<T,A1 const&>(a1);
  99         }
 100         template<typename T,typename A1>
 101         inline T* heap_new(A1& a1)
 102         {
 103             return heap_new_impl<T,A1&>(a1);
 104         }
 105
 106         template<typename T,typename A1,typename A2>
 107         inline T* heap_new(A1 const& a1,A2 const& a2)
 108         {
 109             return heap_new_impl<T,A1 const&,A2 const&>(a1,a2);
 110         }
 111         template<typename T,typename A1,typename A2>
 112         inline T* heap_new(A1& a1,A2 const& a2)
 113         {
 114             return heap_new_impl<T,A1&,A2 const&>(a1,a2);
 115         }
 116         template<typename T,typename A1,typename A2>
 117         inline T* heap_new(A1 const& a1,A2& a2)
 118         {
 119             return heap_new_impl<T,A1 const&,A2&>(a1,a2);
 120         }
 121         template<typename T,typename A1,typename A2>
 122         inline T* heap_new(A1& a1,A2& a2)
 123         {
 124             return heap_new_impl<T,A1&,A2&>(a1,a2);
 125         }
 126
 127         template<typename T,typename A1,typename A2,typename A3>
 128         inline T* heap_new(A1 const& a1,A2 const& a2,A3 const& a3)
 129         {
 130             return heap_new_impl<T,A1 const&,A2 const&,A3 const&>(a1,a2,a3);
 131         }
 132         template<typename T,typename A1,typename A2,typename A3>
 133         inline T* heap_new(A1& a1,A2 const& a2,A3 const& a3)
 134         {
 135             return heap_new_impl<T,A1&,A2 const&,A3 const&>(a1,a2,a3);
 136         }
 137         template<typename T,typename A1,typename A2,typename A3>
 138         inline T* heap_new(A1 const& a1,A2& a2,A3 const& a3)
 139         {
 140             return heap_new_impl<T,A1 const&,A2&,A3 const&>(a1,a2,a3);
 141         }
 142         template<typename T,typename A1,typename A2,typename A3>
 143         inline T* heap_new(A1& a1,A2& a2,A3 const& a3)
 144         {
 145             return heap_new_impl<T,A1&,A2&,A3 const&>(a1,a2,a3);
 146         }
 147
 148         template<typename T,typename A1,typename A2,typename A3>
 149         inline T* heap_new(A1 const& a1,A2 const& a2,A3& a3)
 150         {
 151             return heap_new_impl<T,A1 const&,A2 const&,A3&>(a1,a2,a3);
 152         }
 153         template<typename T,typename A1,typename A2,typename A3>
 154         inline T* heap_new(A1& a1,A2 const& a2,A3& a3)
 155         {
 156             return heap_new_impl<T,A1&,A2 const&,A3&>(a1,a2,a3);
 157         }
 158         template<typename T,typename A1,typename A2,typename A3>
 159         inline T* heap_new(A1 const& a1,A2& a2,A3& a3)
 160         {
 161             return heap_new_impl<T,A1 const&,A2&,A3&>(a1,a2,a3);
 162         }
 163         template<typename T,typename A1,typename A2,typename A3>
 164         inline T* heap_new(A1& a1,A2& a2,A3& a3)
 165         {
 166             return heap_new_impl<T,A1&,A2&,A3&>(a1,a2,a3);
 167         }
 168
 169         template<typename T,typename A1,typename A2,typename A3,typename A4>
 170         inline T* heap_new(A1 const& a1,A2 const& a2,A3 const& a3,A4 const& a4)
 171         {
 172             return heap_new_impl<T,A1 const&,A2 const&,A3 const&,A4 const&>(a1,a2,a3,a4);
 173         }
 174         template<typename T,typename A1,typename A2,typename A3,typename A4>
 175         inline T* heap_new(A1& a1,A2 const& a2,A3 const& a3,A4 const& a4)
 176         {
 177             return heap_new_impl<T,A1&,A2 const&,A3 const&,A4 const&>(a1,a2,a3,a4);
 178         }
 179         template<typename T,typename A1,typename A2,typename A3,typename A4>
 180         inline T* heap_new(A1 const& a1,A2& a2,A3 const& a3,A4 const& a4)
 181         {
 182             return heap_new_impl<T,A1 const&,A2&,A3 const&,A4 const&>(a1,a2,a3,a4);
 183         }
 184         template<typename T,typename A1,typename A2,typename A3,typename A4>
 185         inline T* heap_new(A1& a1,A2& a2,A3 const& a3,A4 const& a4)
 186         {
 187             return heap_new_impl<T,A1&,A2&,A3 const&,A4 const&>(a1,a2,a3,a4);
 188         }
 189
 190         template<typename T,typename A1,typename A2,typename A3,typename A4>
 191         inline T* heap_new(A1 const& a1,A2 const& a2,A3& a3,A4 const& a4)
 192         {
 193             return heap_new_impl<T,A1 const&,A2 const&,A3&,A4 const&>(a1,a2,a3,a4);
 194         }
 195         template<typename T,typename A1,typename A2,typename A3,typename A4>
 196         inline T* heap_new(A1& a1,A2 const& a2,A3& a3,A4 const& a4)
 197         {
 198             return heap_new_impl<T,A1&,A2 const&,A3&,A4 const&>(a1,a2,a3,a4);
 199         }
 200         template<typename T,typename A1,typename A2,typename A3,typename A4>
 201         inline T* heap_new(A1 const& a1,A2& a2,A3& a3,A4 const& a4)
 202         {
 203             return heap_new_impl<T,A1 const&,A2&,A3&,A4 const&>(a1,a2,a3,a4);
 204         }
 205         template<typename T,typename A1,typename A2,typename A3,typename A4>
 206         inline T* heap_new(A1& a1,A2& a2,A3& a3,A4 const& a4)
 207         {
 208             return heap_new_impl<T,A1&,A2&,A3&,A4 const&>(a1,a2,a3,a4);
 209         }
 210         template<typename T,typename A1,typename A2,typename A3,typename A4>
 211         inline T* heap_new(A1 const& a1,A2 const& a2,A3 const& a3,A4& a4)
 212         {
 213             return heap_new_impl<T,A1 const&,A2 const&,A3 const&,A4&>(a1,a2,a3,a4);
 214         }
 215         template<typename T,typename A1,typename A2,typename A3,typename A4>
 216         inline T* heap_new(A1& a1,A2 const& a2,A3 const& a3,A4& a4)
 217         {
 218             return heap_new_impl<T,A1&,A2 const&,A3 const&,A4&>(a1,a2,a3,a4);
 219         }
 220         template<typename T,typename A1,typename A2,typename A3,typename A4>
 221         inline T* heap_new(A1 const& a1,A2& a2,A3 const& a3,A4& a4)
 222         {
 223             return heap_new_impl<T,A1 const&,A2&,A3 const&,A4&>(a1,a2,a3,a4);
 224         }
 225         template<typename T,typename A1,typename A2,typename A3,typename A4>
 226         inline T* heap_new(A1& a1,A2& a2,A3 const& a3,A4& a4)
 227         {
 228             return heap_new_impl<T,A1&,A2&,A3 const&,A4&>(a1,a2,a3,a4);
 229         }
 230
 231         template<typename T,typename A1,typename A2,typename A3,typename A4>
 232         inline T* heap_new(A1 const& a1,A2 const& a2,A3& a3,A4& a4)
 233         {
 234             return heap_new_impl<T,A1 const&,A2 const&,A3&,A4&>(a1,a2,a3,a4);
 235         }
 236         template<typename T,typename A1,typename A2,typename A3,typename A4>
 237         inline T* heap_new(A1& a1,A2 const& a2,A3& a3,A4& a4)
 238         {
 239             return heap_new_impl<T,A1&,A2 const&,A3&,A4&>(a1,a2,a3,a4);
 240         }
 241         template<typename T,typename A1,typename A2,typename A3,typename A4>
 242         inline T* heap_new(A1 const& a1,A2& a2,A3& a3,A4& a4)
 243         {
 244             return heap_new_impl<T,A1 const&,A2&,A3&,A4&>(a1,a2,a3,a4);
 245         }
 246         template<typename T,typename A1,typename A2,typename A3,typename A4>
 247         inline T* heap_new(A1& a1,A2& a2,A3& a3,A4& a4)
 248         {
 249             return heap_new_impl<T,A1&,A2&,A3&,A4&>(a1,a2,a3,a4);
 250         }
 251
 252 #endif
 253         template<typename T>
 254         inline void heap_delete(T* data)
 255         {
 256             delete data;
 257         }
 258
 259         template<typename T>
 260         struct do_heap_delete
 261         {
 262             void operator()(T* data) const
 263             {
 264                 detail::heap_delete(data);
 265             }
 266         };
 267     }
 268 }
 269
 270 #include <boost/config/abi_suffix.hpp>
 271
 272 #endif