Chris@16: // Distributed under the Boost Software License, Version 1.0. (See
Chris@16: // accompanying file LICENSE_1_0.txt or copy at
Chris@16: // http://www.boost.org/LICENSE_1_0.txt)
Chris@16: // (C) Copyright 2007 Anthony Williams
Chris@16: #ifndef THREAD_HEAP_ALLOC_HPP
Chris@16: #define THREAD_HEAP_ALLOC_HPP
Chris@16: #include <new>
Chris@16: #include <boost/thread/detail/config.hpp>
Chris@16: #include <boost/thread/win32/thread_primitives.hpp>
Chris@16: #include <stdexcept>
Chris@16: #include <boost/assert.hpp>
Chris@16: #include <boost/throw_exception.hpp>
Chris@101: #include <boost/core/no_exceptions_support.hpp>
Chris@16: 
Chris@16: #if defined( BOOST_USE_WINDOWS_H )
Chris@16: # include <windows.h>
Chris@16: 
Chris@16: namespace boost
Chris@16: {
Chris@16:     namespace detail
Chris@16:     {
Chris@16:         namespace win32
Chris@16:         {
Chris@16:             using ::GetProcessHeap;
Chris@16:             using ::HeapAlloc;
Chris@16:             using ::HeapFree;
Chris@16:         }
Chris@16:     }
Chris@16: }
Chris@16: 
Chris@16: #else
Chris@16: 
Chris@16: # ifdef HeapAlloc
Chris@16: # undef HeapAlloc
Chris@16: # endif
Chris@16: 
Chris@16: namespace boost
Chris@16: {
Chris@16:     namespace detail
Chris@16:     {
Chris@16:         namespace win32
Chris@16:         {
Chris@16:             extern "C"
Chris@16:             {
Chris@16:                 __declspec(dllimport) handle __stdcall GetProcessHeap();
Chris@16:                 __declspec(dllimport) void* __stdcall HeapAlloc(handle,unsigned long,ulong_ptr);
Chris@16:                 __declspec(dllimport) int __stdcall HeapFree(handle,unsigned long,void*);
Chris@16:             }
Chris@16:         }
Chris@16:     }
Chris@16: }
Chris@16: 
Chris@16: #endif
Chris@16: 
Chris@16: #include <boost/config/abi_prefix.hpp>
Chris@16: 
Chris@16: namespace boost
Chris@16: {
Chris@16:     namespace detail
Chris@16:     {
Chris@16:         inline void* allocate_raw_heap_memory(unsigned size)
Chris@16:         {
Chris@16:             void* const heap_memory=detail::win32::HeapAlloc(detail::win32::GetProcessHeap(),0,size);
Chris@16:             if(!heap_memory)
Chris@16:             {
Chris@16:                 boost::throw_exception(std::bad_alloc());
Chris@16:             }
Chris@16:             return heap_memory;
Chris@16:         }
Chris@16: 
Chris@16:         inline void free_raw_heap_memory(void* heap_memory)
Chris@16:         {
Chris@16:             BOOST_VERIFY(detail::win32::HeapFree(detail::win32::GetProcessHeap(),0,heap_memory)!=0);
Chris@16:         }
Chris@16: 
Chris@16:         template<typename T>
Chris@16:         inline T* heap_new()
Chris@16:         {
Chris@16:             void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
Chris@16:             BOOST_TRY
Chris@16:             {
Chris@16:                 T* const data=new (heap_memory) T();
Chris@16:                 return data;
Chris@16:             }
Chris@16:             BOOST_CATCH(...)
Chris@16:             {
Chris@16:                 free_raw_heap_memory(heap_memory);
Chris@16:                 BOOST_RETHROW
Chris@16:             }
Chris@16:             BOOST_CATCH_END
Chris@16:         }
Chris@16: 
Chris@16: #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
Chris@16:         template<typename T,typename A1>
Chris@16:         inline T* heap_new(A1&& a1)
Chris@16:         {
Chris@16:             void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
Chris@16:             BOOST_TRY
Chris@16:             {
Chris@16:                 T* const data=new (heap_memory) T(static_cast<A1&&>(a1));
Chris@16:                 return data;
Chris@16:             }
Chris@16:             BOOST_CATCH(...)
Chris@16:             {
Chris@16:                 free_raw_heap_memory(heap_memory);
Chris@16:                 BOOST_RETHROW
Chris@16:             }
Chris@16:             BOOST_CATCH_END
Chris@16:         }
Chris@16:         template<typename T,typename A1,typename A2>
Chris@16:         inline T* heap_new(A1&& a1,A2&& a2)
Chris@16:         {
Chris@16:             void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
Chris@16:             BOOST_TRY
Chris@16:             {
Chris@16:                 T* const data=new (heap_memory) T(static_cast<A1&&>(a1),static_cast<A2&&>(a2));
Chris@16:                 return data;
Chris@16:             }
Chris@16:             BOOST_CATCH(...)
Chris@16:             {
Chris@16:                 free_raw_heap_memory(heap_memory);
Chris@16:                 BOOST_RETHROW
Chris@16:             }
Chris@16:             BOOST_CATCH_END
Chris@16:         }
Chris@16:         template<typename T,typename A1,typename A2,typename A3>
Chris@16:         inline T* heap_new(A1&& a1,A2&& a2,A3&& a3)
Chris@16:         {
Chris@16:             void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
Chris@16:             BOOST_TRY
Chris@16:             {
Chris@16:                 T* const data=new (heap_memory) T(static_cast<A1&&>(a1),static_cast<A2&&>(a2),
Chris@16:                                                   static_cast<A3&&>(a3));
Chris@16:                 return data;
Chris@16:             }
Chris@16:             BOOST_CATCH(...)
Chris@16:             {
Chris@16:                 free_raw_heap_memory(heap_memory);
Chris@16:                 BOOST_RETHROW
Chris@16:             }
Chris@16:             BOOST_CATCH_END
Chris@16:         }
Chris@16:         template<typename T,typename A1,typename A2,typename A3,typename A4>
Chris@16:         inline T* heap_new(A1&& a1,A2&& a2,A3&& a3,A4&& a4)
Chris@16:         {
Chris@16:             void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
Chris@16:             BOOST_TRY
Chris@16:             {
Chris@16:                 T* const data=new (heap_memory) T(static_cast<A1&&>(a1),static_cast<A2&&>(a2),
Chris@16:                                                   static_cast<A3&&>(a3),static_cast<A4&&>(a4));
Chris@16:                 return data;
Chris@16:             }
Chris@16:             BOOST_CATCH(...)
Chris@16:             {
Chris@16:                 free_raw_heap_memory(heap_memory);
Chris@16:                 BOOST_RETHROW
Chris@16:             }
Chris@16:             BOOST_CATCH_END
Chris@16:         }
Chris@16: #else
Chris@16:         template<typename T,typename A1>
Chris@16:         inline T* heap_new_impl(A1 a1)
Chris@16:         {
Chris@16:             void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
Chris@16:             BOOST_TRY
Chris@16:             {
Chris@16:                 T* const data=new (heap_memory) T(a1);
Chris@16:                 return data;
Chris@16:             }
Chris@16:             BOOST_CATCH(...)
Chris@16:             {
Chris@16:                 free_raw_heap_memory(heap_memory);
Chris@16:                 BOOST_RETHROW
Chris@16:             }
Chris@16:             BOOST_CATCH_END
Chris@16:         }
Chris@16: 
Chris@16:         template<typename T,typename A1,typename A2>
Chris@16:         inline T* heap_new_impl(A1 a1,A2 a2)
Chris@16:         {
Chris@16:             void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
Chris@16:             BOOST_TRY
Chris@16:             {
Chris@16:                 T* const data=new (heap_memory) T(a1,a2);
Chris@16:                 return data;
Chris@16:             }
Chris@16:             BOOST_CATCH(...)
Chris@16:             {
Chris@16:                 free_raw_heap_memory(heap_memory);
Chris@16:                 BOOST_RETHROW
Chris@16:             }
Chris@16:             BOOST_CATCH_END
Chris@16:         }
Chris@16: 
Chris@16:         template<typename T,typename A1,typename A2,typename A3>
Chris@16:         inline T* heap_new_impl(A1 a1,A2 a2,A3 a3)
Chris@16:         {
Chris@16:             void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
Chris@16:             BOOST_TRY
Chris@16:             {
Chris@16:                 T* const data=new (heap_memory) T(a1,a2,a3);
Chris@16:                 return data;
Chris@16:             }
Chris@16:             BOOST_CATCH(...)
Chris@16:             {
Chris@16:                 free_raw_heap_memory(heap_memory);
Chris@16:                 BOOST_RETHROW
Chris@16:             }
Chris@16:             BOOST_CATCH_END
Chris@16:         }
Chris@16: 
Chris@16:         template<typename T,typename A1,typename A2,typename A3,typename A4>
Chris@16:         inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4)
Chris@16:         {
Chris@16:             void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
Chris@16:             BOOST_TRY
Chris@16:             {
Chris@16:                 T* const data=new (heap_memory) T(a1,a2,a3,a4);
Chris@16:                 return data;
Chris@16:             }
Chris@16:             BOOST_CATCH(...)
Chris@16:             {
Chris@16:                 free_raw_heap_memory(heap_memory);
Chris@16:                 BOOST_RETHROW
Chris@16:             }
Chris@16:             BOOST_CATCH_END
Chris@16:         }
Chris@16: 
Chris@16: 
Chris@16:         template<typename T,typename A1>
Chris@16:         inline T* heap_new(A1 const& a1)
Chris@16:         {
Chris@16:             return heap_new_impl<T,A1 const&>(a1);
Chris@16:         }
Chris@16:         template<typename T,typename A1>
Chris@16:         inline T* heap_new(A1& a1)
Chris@16:         {
Chris@16:             return heap_new_impl<T,A1&>(a1);
Chris@16:         }
Chris@16: 
Chris@16:         template<typename T,typename A1,typename A2>
Chris@16:         inline T* heap_new(A1 const& a1,A2 const& a2)
Chris@16:         {
Chris@16:             return heap_new_impl<T,A1 const&,A2 const&>(a1,a2);
Chris@16:         }
Chris@16:         template<typename T,typename A1,typename A2>
Chris@16:         inline T* heap_new(A1& a1,A2 const& a2)
Chris@16:         {
Chris@16:             return heap_new_impl<T,A1&,A2 const&>(a1,a2);
Chris@16:         }
Chris@16:         template<typename T,typename A1,typename A2>
Chris@16:         inline T* heap_new(A1 const& a1,A2& a2)
Chris@16:         {
Chris@16:             return heap_new_impl<T,A1 const&,A2&>(a1,a2);
Chris@16:         }
Chris@16:         template<typename T,typename A1,typename A2>
Chris@16:         inline T* heap_new(A1& a1,A2& a2)
Chris@16:         {
Chris@16:             return heap_new_impl<T,A1&,A2&>(a1,a2);
Chris@16:         }
Chris@16: 
Chris@16:         template<typename T,typename A1,typename A2,typename A3>
Chris@16:         inline T* heap_new(A1 const& a1,A2 const& a2,A3 const& a3)
Chris@16:         {
Chris@16:             return heap_new_impl<T,A1 const&,A2 const&,A3 const&>(a1,a2,a3);
Chris@16:         }
Chris@16:         template<typename T,typename A1,typename A2,typename A3>
Chris@16:         inline T* heap_new(A1& a1,A2 const& a2,A3 const& a3)
Chris@16:         {
Chris@16:             return heap_new_impl<T,A1&,A2 const&,A3 const&>(a1,a2,a3);
Chris@16:         }
Chris@16:         template<typename T,typename A1,typename A2,typename A3>
Chris@16:         inline T* heap_new(A1 const& a1,A2& a2,A3 const& a3)
Chris@16:         {
Chris@16:             return heap_new_impl<T,A1 const&,A2&,A3 const&>(a1,a2,a3);
Chris@16:         }
Chris@16:         template<typename T,typename A1,typename A2,typename A3>
Chris@16:         inline T* heap_new(A1& a1,A2& a2,A3 const& a3)
Chris@16:         {
Chris@16:             return heap_new_impl<T,A1&,A2&,A3 const&>(a1,a2,a3);
Chris@16:         }
Chris@16: 
Chris@16:         template<typename T,typename A1,typename A2,typename A3>
Chris@16:         inline T* heap_new(A1 const& a1,A2 const& a2,A3& a3)
Chris@16:         {
Chris@16:             return heap_new_impl<T,A1 const&,A2 const&,A3&>(a1,a2,a3);
Chris@16:         }
Chris@16:         template<typename T,typename A1,typename A2,typename A3>
Chris@16:         inline T* heap_new(A1& a1,A2 const& a2,A3& a3)
Chris@16:         {
Chris@16:             return heap_new_impl<T,A1&,A2 const&,A3&>(a1,a2,a3);
Chris@16:         }
Chris@16:         template<typename T,typename A1,typename A2,typename A3>
Chris@16:         inline T* heap_new(A1 const& a1,A2& a2,A3& a3)
Chris@16:         {
Chris@16:             return heap_new_impl<T,A1 const&,A2&,A3&>(a1,a2,a3);
Chris@16:         }
Chris@16:         template<typename T,typename A1,typename A2,typename A3>
Chris@16:         inline T* heap_new(A1& a1,A2& a2,A3& a3)
Chris@16:         {
Chris@16:             return heap_new_impl<T,A1&,A2&,A3&>(a1,a2,a3);
Chris@16:         }
Chris@16: 
Chris@16:         template<typename T,typename A1,typename A2,typename A3,typename A4>
Chris@16:         inline T* heap_new(A1 const& a1,A2 const& a2,A3 const& a3,A4 const& a4)
Chris@16:         {
Chris@16:             return heap_new_impl<T,A1 const&,A2 const&,A3 const&,A4 const&>(a1,a2,a3,a4);
Chris@16:         }
Chris@16:         template<typename T,typename A1,typename A2,typename A3,typename A4>
Chris@16:         inline T* heap_new(A1& a1,A2 const& a2,A3 const& a3,A4 const& a4)
Chris@16:         {
Chris@16:             return heap_new_impl<T,A1&,A2 const&,A3 const&,A4 const&>(a1,a2,a3,a4);
Chris@16:         }
Chris@16:         template<typename T,typename A1,typename A2,typename A3,typename A4>
Chris@16:         inline T* heap_new(A1 const& a1,A2& a2,A3 const& a3,A4 const& a4)
Chris@16:         {
Chris@16:             return heap_new_impl<T,A1 const&,A2&,A3 const&,A4 const&>(a1,a2,a3,a4);
Chris@16:         }
Chris@16:         template<typename T,typename A1,typename A2,typename A3,typename A4>
Chris@16:         inline T* heap_new(A1& a1,A2& a2,A3 const& a3,A4 const& a4)
Chris@16:         {
Chris@16:             return heap_new_impl<T,A1&,A2&,A3 const&,A4 const&>(a1,a2,a3,a4);
Chris@16:         }
Chris@16: 
Chris@16:         template<typename T,typename A1,typename A2,typename A3,typename A4>
Chris@16:         inline T* heap_new(A1 const& a1,A2 const& a2,A3& a3,A4 const& a4)
Chris@16:         {
Chris@16:             return heap_new_impl<T,A1 const&,A2 const&,A3&,A4 const&>(a1,a2,a3,a4);
Chris@16:         }
Chris@16:         template<typename T,typename A1,typename A2,typename A3,typename A4>
Chris@16:         inline T* heap_new(A1& a1,A2 const& a2,A3& a3,A4 const& a4)
Chris@16:         {
Chris@16:             return heap_new_impl<T,A1&,A2 const&,A3&,A4 const&>(a1,a2,a3,a4);
Chris@16:         }
Chris@16:         template<typename T,typename A1,typename A2,typename A3,typename A4>
Chris@16:         inline T* heap_new(A1 const& a1,A2& a2,A3& a3,A4 const& a4)
Chris@16:         {
Chris@16:             return heap_new_impl<T,A1 const&,A2&,A3&,A4 const&>(a1,a2,a3,a4);
Chris@16:         }
Chris@16:         template<typename T,typename A1,typename A2,typename A3,typename A4>
Chris@16:         inline T* heap_new(A1& a1,A2& a2,A3& a3,A4 const& a4)
Chris@16:         {
Chris@16:             return heap_new_impl<T,A1&,A2&,A3&,A4 const&>(a1,a2,a3,a4);
Chris@16:         }
Chris@16:         template<typename T,typename A1,typename A2,typename A3,typename A4>
Chris@16:         inline T* heap_new(A1 const& a1,A2 const& a2,A3 const& a3,A4& a4)
Chris@16:         {
Chris@16:             return heap_new_impl<T,A1 const&,A2 const&,A3 const&,A4&>(a1,a2,a3,a4);
Chris@16:         }
Chris@16:         template<typename T,typename A1,typename A2,typename A3,typename A4>
Chris@16:         inline T* heap_new(A1& a1,A2 const& a2,A3 const& a3,A4& a4)
Chris@16:         {
Chris@16:             return heap_new_impl<T,A1&,A2 const&,A3 const&,A4&>(a1,a2,a3,a4);
Chris@16:         }
Chris@16:         template<typename T,typename A1,typename A2,typename A3,typename A4>
Chris@16:         inline T* heap_new(A1 const& a1,A2& a2,A3 const& a3,A4& a4)
Chris@16:         {
Chris@16:             return heap_new_impl<T,A1 const&,A2&,A3 const&,A4&>(a1,a2,a3,a4);
Chris@16:         }
Chris@16:         template<typename T,typename A1,typename A2,typename A3,typename A4>
Chris@16:         inline T* heap_new(A1& a1,A2& a2,A3 const& a3,A4& a4)
Chris@16:         {
Chris@16:             return heap_new_impl<T,A1&,A2&,A3 const&,A4&>(a1,a2,a3,a4);
Chris@16:         }
Chris@16: 
Chris@16:         template<typename T,typename A1,typename A2,typename A3,typename A4>
Chris@16:         inline T* heap_new(A1 const& a1,A2 const& a2,A3& a3,A4& a4)
Chris@16:         {
Chris@16:             return heap_new_impl<T,A1 const&,A2 const&,A3&,A4&>(a1,a2,a3,a4);
Chris@16:         }
Chris@16:         template<typename T,typename A1,typename A2,typename A3,typename A4>
Chris@16:         inline T* heap_new(A1& a1,A2 const& a2,A3& a3,A4& a4)
Chris@16:         {
Chris@16:             return heap_new_impl<T,A1&,A2 const&,A3&,A4&>(a1,a2,a3,a4);
Chris@16:         }
Chris@16:         template<typename T,typename A1,typename A2,typename A3,typename A4>
Chris@16:         inline T* heap_new(A1 const& a1,A2& a2,A3& a3,A4& a4)
Chris@16:         {
Chris@16:             return heap_new_impl<T,A1 const&,A2&,A3&,A4&>(a1,a2,a3,a4);
Chris@16:         }
Chris@16:         template<typename T,typename A1,typename A2,typename A3,typename A4>
Chris@16:         inline T* heap_new(A1& a1,A2& a2,A3& a3,A4& a4)
Chris@16:         {
Chris@16:             return heap_new_impl<T,A1&,A2&,A3&,A4&>(a1,a2,a3,a4);
Chris@16:         }
Chris@16: 
Chris@16: #endif
Chris@16:         template<typename T>
Chris@16:         inline void heap_delete(T* data)
Chris@16:         {
Chris@16:             data->~T();
Chris@16:             free_raw_heap_memory(data);
Chris@16:         }
Chris@16: 
Chris@16:         template<typename T>
Chris@16:         struct do_heap_delete
Chris@16:         {
Chris@16:             void operator()(T* data) const
Chris@16:             {
Chris@16:                 detail::heap_delete(data);
Chris@16:             }
Chris@16:         };
Chris@16:     }
Chris@16: }
Chris@16: 
Chris@16: #include <boost/config/abi_suffix.hpp>
Chris@16: 
Chris@16: 
Chris@16: #endif