Back to home page

EIC code displayed by LXR
 
 

    

File indexing completed on 2025-12-16 10:10:04 

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 2007 Anthony Williams
0005 #ifndef THREAD_HEAP_ALLOC_HPP
0006 #define THREAD_HEAP_ALLOC_HPP
0007 #include <new>
0008 #include <boost/thread/detail/config.hpp>
0009 #include <boost/thread/win32/thread_primitives.hpp>
0010 #include <stdexcept>
0011 #include <boost/assert.hpp>
0012 #include <boost/throw_exception.hpp>
0013 #include <boost/core/no_exceptions_support.hpp>
0014 
0015 #include <boost/winapi/heap_memory.hpp>
0016 
0017 #include <boost/config/abi_prefix.hpp>
0018 
0019 namespace boost
0020 {
0021     namespace detail
0022     {
0023         inline void* allocate_raw_heap_memory(unsigned size)
0024         {
0025             void* const heap_memory=winapi::HeapAlloc(winapi::GetProcessHeap(),0,size);
0026             if(!heap_memory)
0027             {
0028                 boost::throw_exception(std::bad_alloc());
0029             }
0030             return heap_memory;
0031         }
0032 
0033         inline void free_raw_heap_memory(void* heap_memory)
0034         {
0035             BOOST_VERIFY(winapi::HeapFree(winapi::GetProcessHeap(),0,heap_memory)!=0);
0036         }
0037 #if defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD) && ! defined (BOOST_NO_CXX11_RVALUE_REFERENCES)
0038         template<typename T,typename... Args>
0039         inline T* heap_new(Args&&... args)
0040         {
0041           void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
0042           BOOST_TRY
0043           {
0044               T* const data=new (heap_memory) T(static_cast<Args&&>(args)...);
0045               return data;
0046           }
0047           BOOST_CATCH(...)
0048           {
0049               free_raw_heap_memory(heap_memory);
0050               BOOST_RETHROW
0051           }
0052           BOOST_CATCH_END
0053         }
0054 #else
0055         template<typename T>
0056         inline T* heap_new()
0057         {
0058             void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
0059             BOOST_TRY
0060             {
0061                 T* const data=new (heap_memory) T();
0062                 return data;
0063             }
0064             BOOST_CATCH(...)
0065             {
0066                 free_raw_heap_memory(heap_memory);
0067                 BOOST_RETHROW
0068             }
0069             BOOST_CATCH_END
0070         }
0071 
0072 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
0073         template<typename T,typename A1>
0074         inline T* heap_new(A1&& a1)
0075         {
0076             void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
0077             BOOST_TRY
0078             {
0079                 T* const data=new (heap_memory) T(static_cast<A1&&>(a1));
0080                 return data;
0081             }
0082             BOOST_CATCH(...)
0083             {
0084                 free_raw_heap_memory(heap_memory);
0085                 BOOST_RETHROW
0086             }
0087             BOOST_CATCH_END
0088         }
0089         template<typename T,typename A1,typename A2>
0090         inline T* heap_new(A1&& a1,A2&& a2)
0091         {
0092             void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
0093             BOOST_TRY
0094             {
0095                 T* const data=new (heap_memory) T(static_cast<A1&&>(a1),static_cast<A2&&>(a2));
0096                 return data;
0097             }
0098             BOOST_CATCH(...)
0099             {
0100                 free_raw_heap_memory(heap_memory);
0101                 BOOST_RETHROW
0102             }
0103             BOOST_CATCH_END
0104         }
0105         template<typename T,typename A1,typename A2,typename A3>
0106         inline T* heap_new(A1&& a1,A2&& a2,A3&& a3)
0107         {
0108             void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
0109             BOOST_TRY
0110             {
0111                 T* const data=new (heap_memory) T(static_cast<A1&&>(a1),static_cast<A2&&>(a2),
0112                                                   static_cast<A3&&>(a3));
0113                 return data;
0114             }
0115             BOOST_CATCH(...)
0116             {
0117                 free_raw_heap_memory(heap_memory);
0118                 BOOST_RETHROW
0119             }
0120             BOOST_CATCH_END
0121         }
0122         template<typename T,typename A1,typename A2,typename A3,typename A4>
0123         inline T* heap_new(A1&& a1,A2&& a2,A3&& a3,A4&& a4)
0124         {
0125             void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
0126             BOOST_TRY
0127             {
0128                 T* const data=new (heap_memory) T(static_cast<A1&&>(a1),static_cast<A2&&>(a2),
0129                                                   static_cast<A3&&>(a3),static_cast<A4&&>(a4));
0130                 return data;
0131             }
0132             BOOST_CATCH(...)
0133             {
0134                 free_raw_heap_memory(heap_memory);
0135                 BOOST_RETHROW
0136             }
0137             BOOST_CATCH_END
0138         }
0139 #else
0140         template<typename T,typename A1>
0141         inline T* heap_new_impl(A1 a1)
0142         {
0143             void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
0144             BOOST_TRY
0145             {
0146                 T* const data=new (heap_memory) T(a1);
0147                 return data;
0148             }
0149             BOOST_CATCH(...)
0150             {
0151                 free_raw_heap_memory(heap_memory);
0152                 BOOST_RETHROW
0153             }
0154             BOOST_CATCH_END
0155         }
0156 
0157         template<typename T,typename A1,typename A2>
0158         inline T* heap_new_impl(A1 a1,A2 a2)
0159         {
0160             void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
0161             BOOST_TRY
0162             {
0163                 T* const data=new (heap_memory) T(a1,a2);
0164                 return data;
0165             }
0166             BOOST_CATCH(...)
0167             {
0168                 free_raw_heap_memory(heap_memory);
0169                 BOOST_RETHROW
0170             }
0171             BOOST_CATCH_END
0172         }
0173 
0174         template<typename T,typename A1,typename A2,typename A3>
0175         inline T* heap_new_impl(A1 a1,A2 a2,A3 a3)
0176         {
0177             void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
0178             BOOST_TRY
0179             {
0180                 T* const data=new (heap_memory) T(a1,a2,a3);
0181                 return data;
0182             }
0183             BOOST_CATCH(...)
0184             {
0185                 free_raw_heap_memory(heap_memory);
0186                 BOOST_RETHROW
0187             }
0188             BOOST_CATCH_END
0189         }
0190 
0191         template<typename T,typename A1,typename A2,typename A3,typename A4>
0192         inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4)
0193         {
0194             void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
0195             BOOST_TRY
0196             {
0197                 T* const data=new (heap_memory) T(a1,a2,a3,a4);
0198                 return data;
0199             }
0200             BOOST_CATCH(...)
0201             {
0202                 free_raw_heap_memory(heap_memory);
0203                 BOOST_RETHROW
0204             }
0205             BOOST_CATCH_END
0206         }
0207         template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5>
0208         inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5)
0209         {
0210             void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
0211             BOOST_TRY
0212             {
0213                 T* const data=new (heap_memory) T(a1,a2,a3,a4,a5);
0214                 return data;
0215             }
0216             BOOST_CATCH(...)
0217             {
0218                 free_raw_heap_memory(heap_memory);
0219                 BOOST_RETHROW
0220             }
0221             BOOST_CATCH_END
0222         }
0223         template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5,typename A6>
0224         inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6)
0225         {
0226             void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
0227             BOOST_TRY
0228             {
0229                 T* const data=new (heap_memory) T(a1,a2,a3,a4,a5,a6);
0230                 return data;
0231             }
0232             BOOST_CATCH(...)
0233             {
0234                 free_raw_heap_memory(heap_memory);
0235                 BOOST_RETHROW
0236             }
0237             BOOST_CATCH_END
0238         }
0239         template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5,typename A6,typename A7>
0240         inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7)
0241         {
0242             void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
0243             BOOST_TRY
0244             {
0245                 T* const data=new (heap_memory) T(a1,a2,a3,a4,a5,a6,a7);
0246                 return data;
0247             }
0248             BOOST_CATCH(...)
0249             {
0250                 free_raw_heap_memory(heap_memory);
0251                 BOOST_RETHROW
0252             }
0253             BOOST_CATCH_END
0254         }
0255         template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5,typename A6,typename A7,typename A8>
0256         inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8)
0257         {
0258             void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
0259             BOOST_TRY
0260             {
0261                 T* const data=new (heap_memory) T(a1,a2,a3,a4,a5,a6,a7,a8);
0262                 return data;
0263             }
0264             BOOST_CATCH(...)
0265             {
0266                 free_raw_heap_memory(heap_memory);
0267                 BOOST_RETHROW
0268             }
0269             BOOST_CATCH_END
0270         }
0271         template<typename T,typename A1,typename A2,typename A3,typename A4,typename A5,typename A6,typename A7,typename A8,typename A9>
0272         inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8,A9 a9)
0273         {
0274             void* const heap_memory=allocate_raw_heap_memory(sizeof(T));
0275             BOOST_TRY
0276             {
0277                 T* const data=new (heap_memory) T(a1,a2,a3,a4,a5,a6,a7,a8,a9);
0278                 return data;
0279             }
0280             BOOST_CATCH(...)
0281             {
0282                 free_raw_heap_memory(heap_memory);
0283                 BOOST_RETHROW
0284             }
0285             BOOST_CATCH_END
0286         }
0287 
0288 
0289         template<typename T,typename A1>
0290         inline T* heap_new(A1 const& a1)
0291         {
0292             return heap_new_impl<T,A1 const&>(a1);
0293         }
0294         template<typename T,typename A1>
0295         inline T* heap_new(A1& a1)
0296         {
0297             return heap_new_impl<T,A1&>(a1);
0298         }
0299 
0300         template<typename T,typename A1,typename A2>
0301         inline T* heap_new(A1 const& a1,A2 const& a2)
0302         {
0303             return heap_new_impl<T,A1 const&,A2 const&>(a1,a2);
0304         }
0305         template<typename T,typename A1,typename A2>
0306         inline T* heap_new(A1& a1,A2 const& a2)
0307         {
0308             return heap_new_impl<T,A1&,A2 const&>(a1,a2);
0309         }
0310         template<typename T,typename A1,typename A2>
0311         inline T* heap_new(A1 const& a1,A2& a2)
0312         {
0313             return heap_new_impl<T,A1 const&,A2&>(a1,a2);
0314         }
0315         template<typename T,typename A1,typename A2>
0316         inline T* heap_new(A1& a1,A2& a2)
0317         {
0318             return heap_new_impl<T,A1&,A2&>(a1,a2);
0319         }
0320 
0321         template<typename T,typename A1,typename A2,typename A3>
0322         inline T* heap_new(A1 const& a1,A2 const& a2,A3 const& a3)
0323         {
0324             return heap_new_impl<T,A1 const&,A2 const&,A3 const&>(a1,a2,a3);
0325         }
0326         template<typename T,typename A1,typename A2,typename A3>
0327         inline T* heap_new(A1& a1,A2 const& a2,A3 const& a3)
0328         {
0329             return heap_new_impl<T,A1&,A2 const&,A3 const&>(a1,a2,a3);
0330         }
0331         template<typename T,typename A1,typename A2,typename A3>
0332         inline T* heap_new(A1 const& a1,A2& a2,A3 const& a3)
0333         {
0334             return heap_new_impl<T,A1 const&,A2&,A3 const&>(a1,a2,a3);
0335         }
0336         template<typename T,typename A1,typename A2,typename A3>
0337         inline T* heap_new(A1& a1,A2& a2,A3 const& a3)
0338         {
0339             return heap_new_impl<T,A1&,A2&,A3 const&>(a1,a2,a3);
0340         }
0341 
0342         template<typename T,typename A1,typename A2,typename A3>
0343         inline T* heap_new(A1 const& a1,A2 const& a2,A3& a3)
0344         {
0345             return heap_new_impl<T,A1 const&,A2 const&,A3&>(a1,a2,a3);
0346         }
0347         template<typename T,typename A1,typename A2,typename A3>
0348         inline T* heap_new(A1& a1,A2 const& a2,A3& a3)
0349         {
0350             return heap_new_impl<T,A1&,A2 const&,A3&>(a1,a2,a3);
0351         }
0352         template<typename T,typename A1,typename A2,typename A3>
0353         inline T* heap_new(A1 const& a1,A2& a2,A3& a3)
0354         {
0355             return heap_new_impl<T,A1 const&,A2&,A3&>(a1,a2,a3);
0356         }
0357         template<typename T,typename A1,typename A2,typename A3>
0358         inline T* heap_new(A1& a1,A2& a2,A3& a3)
0359         {
0360             return heap_new_impl<T,A1&,A2&,A3&>(a1,a2,a3);
0361         }
0362 
0363         template<typename T,typename A1,typename A2,typename A3,typename A4>
0364         inline T* heap_new(A1 const& a1,A2 const& a2,A3 const& a3,A4 const& a4)
0365         {
0366             return heap_new_impl<T,A1 const&,A2 const&,A3 const&,A4 const&>(a1,a2,a3,a4);
0367         }
0368         template<typename T,typename A1,typename A2,typename A3,typename A4>
0369         inline T* heap_new(A1& a1,A2 const& a2,A3 const& a3,A4 const& a4)
0370         {
0371             return heap_new_impl<T,A1&,A2 const&,A3 const&,A4 const&>(a1,a2,a3,a4);
0372         }
0373         template<typename T,typename A1,typename A2,typename A3,typename A4>
0374         inline T* heap_new(A1 const& a1,A2& a2,A3 const& a3,A4 const& a4)
0375         {
0376             return heap_new_impl<T,A1 const&,A2&,A3 const&,A4 const&>(a1,a2,a3,a4);
0377         }
0378         template<typename T,typename A1,typename A2,typename A3,typename A4>
0379         inline T* heap_new(A1& a1,A2& a2,A3 const& a3,A4 const& a4)
0380         {
0381             return heap_new_impl<T,A1&,A2&,A3 const&,A4 const&>(a1,a2,a3,a4);
0382         }
0383 
0384         template<typename T,typename A1,typename A2,typename A3,typename A4>
0385         inline T* heap_new(A1 const& a1,A2 const& a2,A3& a3,A4 const& a4)
0386         {
0387             return heap_new_impl<T,A1 const&,A2 const&,A3&,A4 const&>(a1,a2,a3,a4);
0388         }
0389         template<typename T,typename A1,typename A2,typename A3,typename A4>
0390         inline T* heap_new(A1& a1,A2 const& a2,A3& a3,A4 const& a4)
0391         {
0392             return heap_new_impl<T,A1&,A2 const&,A3&,A4 const&>(a1,a2,a3,a4);
0393         }
0394         template<typename T,typename A1,typename A2,typename A3,typename A4>
0395         inline T* heap_new(A1 const& a1,A2& a2,A3& a3,A4 const& a4)
0396         {
0397             return heap_new_impl<T,A1 const&,A2&,A3&,A4 const&>(a1,a2,a3,a4);
0398         }
0399         template<typename T,typename A1,typename A2,typename A3,typename A4>
0400         inline T* heap_new(A1& a1,A2& a2,A3& a3,A4 const& a4)
0401         {
0402             return heap_new_impl<T,A1&,A2&,A3&,A4 const&>(a1,a2,a3,a4);
0403         }
0404         template<typename T,typename A1,typename A2,typename A3,typename A4>
0405         inline T* heap_new(A1 const& a1,A2 const& a2,A3 const& a3,A4& a4)
0406         {
0407             return heap_new_impl<T,A1 const&,A2 const&,A3 const&,A4&>(a1,a2,a3,a4);
0408         }
0409         template<typename T,typename A1,typename A2,typename A3,typename A4>
0410         inline T* heap_new(A1& a1,A2 const& a2,A3 const& a3,A4& a4)
0411         {
0412             return heap_new_impl<T,A1&,A2 const&,A3 const&,A4&>(a1,a2,a3,a4);
0413         }
0414         template<typename T,typename A1,typename A2,typename A3,typename A4>
0415         inline T* heap_new(A1 const& a1,A2& a2,A3 const& a3,A4& a4)
0416         {
0417             return heap_new_impl<T,A1 const&,A2&,A3 const&,A4&>(a1,a2,a3,a4);
0418         }
0419         template<typename T,typename A1,typename A2,typename A3,typename A4>
0420         inline T* heap_new(A1& a1,A2& a2,A3 const& a3,A4& a4)
0421         {
0422             return heap_new_impl<T,A1&,A2&,A3 const&,A4&>(a1,a2,a3,a4);
0423         }
0424 
0425         template<typename T,typename A1,typename A2,typename A3,typename A4>
0426         inline T* heap_new(A1 const& a1,A2 const& a2,A3& a3,A4& a4)
0427         {
0428             return heap_new_impl<T,A1 const&,A2 const&,A3&,A4&>(a1,a2,a3,a4);
0429         }
0430         template<typename T,typename A1,typename A2,typename A3,typename A4>
0431         inline T* heap_new(A1& a1,A2 const& a2,A3& a3,A4& a4)
0432         {
0433             return heap_new_impl<T,A1&,A2 const&,A3&,A4&>(a1,a2,a3,a4);
0434         }
0435         template<typename T,typename A1,typename A2,typename A3,typename A4>
0436         inline T* heap_new(A1 const& a1,A2& a2,A3& a3,A4& a4)
0437         {
0438             return heap_new_impl<T,A1 const&,A2&,A3&,A4&>(a1,a2,a3,a4);
0439         }
0440         template<typename T,typename A1,typename A2,typename A3,typename A4>
0441         inline T* heap_new(A1& a1,A2& a2,A3& a3,A4& a4)
0442         {
0443             return heap_new_impl<T,A1&,A2&,A3&,A4&>(a1,a2,a3,a4);
0444         }
0445 
0446 #endif
0447 #endif
0448         template<typename T>
0449         inline void heap_delete(T* data)
0450         {
0451             data->~T();
0452             free_raw_heap_memory(data);
0453         }
0454 
0455         template<typename T>
0456         struct do_heap_delete
0457         {
0458             void operator()(T* data) const
0459             {
0460                 detail::heap_delete(data);
0461             }
0462         };
0463     }
0464 }
0465 
0466 #include <boost/config/abi_suffix.hpp>
0467 
0468 
0469 #endif
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!