/* * Copyright 2008-2012 NVIDIA Corporation * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include <thrust/detail/config.h> #include <thrust/detail/allocator/allocator_traits.h> #include <thrust/detail/type_traits/has_member_function.h> #include <thrust/detail/type_traits/is_call_possible.h> #include <new> #include <limits> namespace thrust { namespace detail { namespace allocator_traits_detail { __THRUST_DEFINE_IS_CALL_POSSIBLE(has_member_allocate_with_hint_impl, allocate) template<typename Alloc> class has_member_allocate_with_hint { typedef typename allocator_traits<Alloc>::pointer pointer; typedef typename allocator_traits<Alloc>::size_type size_type; typedef typename allocator_traits<Alloc>::const_void_pointer const_void_pointer; public: typedef typename has_member_allocate_with_hint_impl<Alloc, pointer(size_type,const_void_pointer)>::type type; static const bool value = type::value; }; template<typename Alloc> typename enable_if< has_member_allocate_with_hint<Alloc>::value, typename allocator_traits<Alloc>::pointer >::type allocate(Alloc &a, typename allocator_traits<Alloc>::size_type n, typename allocator_traits<Alloc>::const_void_pointer hint) { return a.allocate(n,hint); } template<typename Alloc> typename disable_if< has_member_allocate_with_hint<Alloc>::value, typename allocator_traits<Alloc>::pointer >::type allocate(Alloc &a, typename allocator_traits<Alloc>::size_type n, typename allocator_traits<Alloc>::const_void_pointer) { return a.allocate(n); } __THRUST_DEFINE_IS_CALL_POSSIBLE(has_member_construct1_impl, construct) template<typename Alloc, typename T> struct has_member_construct1 : has_member_construct1_impl<Alloc, void(T*)> {}; template<typename Alloc, typename T> inline __host__ __device__ typename enable_if< has_member_construct1<Alloc,T>::value >::type construct(Alloc &a, T *p) { a.construct(p); } template<typename Alloc, typename T> inline __host__ __device__ typename disable_if< has_member_construct1<Alloc,T>::value >::type construct(Alloc &a, T *p) { ::new(static_cast<void*>(p)) T(); } __THRUST_DEFINE_IS_CALL_POSSIBLE(has_member_construct2_impl, construct) template<typename Alloc, typename T, typename Arg1> struct has_member_construct2 : has_member_construct2_impl<Alloc, void(T*,const Arg1 &)> {}; template<typename Alloc, typename T, typename Arg1> inline __host__ __device__ typename enable_if< has_member_construct2<Alloc,T,Arg1>::value >::type construct(Alloc &a, T *p, const Arg1 &arg1) { a.construct(p,arg1); } template<typename Alloc, typename T, typename Arg1> inline __host__ __device__ typename disable_if< has_member_construct2<Alloc,T,Arg1>::value >::type construct(Alloc &, T *p, const Arg1 &arg1) { ::new(static_cast<void*>(p)) T(arg1); } __THRUST_DEFINE_IS_CALL_POSSIBLE(has_member_destroy_impl, destroy) template<typename Alloc, typename T> struct has_member_destroy : has_member_destroy_impl<Alloc, void(T*)> {}; template<typename Alloc, typename T> inline __host__ __device__ typename enable_if< has_member_destroy<Alloc,T>::value >::type destroy(Alloc &a, T *p) { a.destroy(p); } template<typename Alloc, typename T> inline __host__ __device__ typename disable_if< has_member_destroy<Alloc,T>::value >::type destroy(Alloc &, T *p) { p->~T(); } __THRUST_DEFINE_IS_CALL_POSSIBLE(has_member_max_size_impl, max_size) template<typename Alloc> class has_member_max_size { typedef typename allocator_traits<Alloc>::size_type size_type; public: typedef typename has_member_max_size_impl<Alloc, size_type(void)>::type type; static const bool value = type::value; }; template<typename Alloc> typename enable_if< has_member_max_size<Alloc>::value, typename allocator_traits<Alloc>::size_type >::type max_size(const Alloc &a) { return a.max_size(); } template<typename Alloc> typename disable_if< has_member_max_size<Alloc>::value, typename allocator_traits<Alloc>::size_type >::type max_size(const Alloc &a) { typedef typename allocator_traits<Alloc>::size_type size_type; return std::numeric_limits<size_type>::max(); } __THRUST_DEFINE_HAS_MEMBER_FUNCTION(has_member_system_impl, system) template<typename Alloc> class has_member_system { typedef typename allocator_system<Alloc>::type system_type; public: typedef typename has_member_system_impl<Alloc, system_type&(void)>::type type; static const bool value = type::value; }; template<typename Alloc> typename enable_if< has_member_system<Alloc>::value, typename allocator_system<Alloc>::type & >::type system(Alloc &a) { return a.system(); } template<typename Alloc> typename disable_if< has_member_system<Alloc>::value, typename allocator_system<Alloc>::type & >::type system(Alloc &a) { // assumes the system is default-constructible static typename allocator_system<Alloc>::type state; return state; } } // end allocator_traits_detail template<typename Alloc> typename allocator_traits<Alloc>::pointer allocator_traits<Alloc> ::allocate(Alloc &a, typename allocator_traits<Alloc>::size_type n) { return a.allocate(n); } template<typename Alloc> typename allocator_traits<Alloc>::pointer allocator_traits<Alloc> ::allocate(Alloc &a, typename allocator_traits<Alloc>::size_type n, typename allocator_traits<Alloc>::const_void_pointer hint) { return allocator_traits_detail::allocate(a, n, hint); } template<typename Alloc> void allocator_traits<Alloc> ::deallocate(Alloc &a, typename allocator_traits<Alloc>::pointer p, typename allocator_traits<Alloc>::size_type n) { return a.deallocate(p,n); } template<typename Alloc> template<typename T> void allocator_traits<Alloc> ::construct(allocator_type &a, T *p) { return allocator_traits_detail::construct(a,p); } template<typename Alloc> template<typename T, typename Arg1> void allocator_traits<Alloc> ::construct(allocator_type &a, T *p, const Arg1 &arg1) { return allocator_traits_detail::construct(a,p,arg1); } template<typename Alloc> template<typename T> void allocator_traits<Alloc> ::destroy(allocator_type &a, T *p) { return allocator_traits_detail::destroy(a,p); } template<typename Alloc> typename allocator_traits<Alloc>::size_type allocator_traits<Alloc> ::max_size(const allocator_type &a) { return allocator_traits_detail::max_size(a); } template<typename Alloc> typename allocator_system<Alloc>::type & allocator_system<Alloc> ::get(Alloc &a) { return allocator_traits_detail::system(a); } } // end detail } // end thrust