| /* |
| Copyright 2012-2019 Glen Joseph Fernandes |
| (glenjofe@gmail.com) |
| |
| Distributed under the Boost Software License, Version 1.0. |
| (http://www.boost.org/LICENSE_1_0.txt) |
| */ |
| #ifndef BOOST_SMART_PTR_ALLOCATE_SHARED_ARRAY_HPP |
| #define BOOST_SMART_PTR_ALLOCATE_SHARED_ARRAY_HPP |
| |
| #include <boost/core/allocator_access.hpp> |
| #include <boost/core/alloc_construct.hpp> |
| #include <boost/core/first_scalar.hpp> |
| #include <boost/smart_ptr/shared_ptr.hpp> |
| #include <boost/type_traits/alignment_of.hpp> |
| #include <boost/type_traits/enable_if.hpp> |
| #include <boost/type_traits/extent.hpp> |
| #include <boost/type_traits/is_bounded_array.hpp> |
| #include <boost/type_traits/is_unbounded_array.hpp> |
| #include <boost/type_traits/remove_cv.hpp> |
| #include <boost/type_traits/remove_extent.hpp> |
| #include <boost/type_traits/type_with_alignment.hpp> |
| |
| namespace boost { |
| namespace detail { |
| |
| template<class T> |
| struct sp_array_element { |
| typedef typename boost::remove_cv<typename |
| boost::remove_extent<T>::type>::type type; |
| }; |
| |
| template<class T> |
| struct sp_array_count { |
| enum { |
| value = 1 |
| }; |
| }; |
| |
| template<class T, std::size_t N> |
| struct sp_array_count<T[N]> { |
| enum { |
| value = N * sp_array_count<T>::value |
| }; |
| }; |
| |
| template<std::size_t N, std::size_t M> |
| struct sp_max_size { |
| enum { |
| value = N < M ? M : N |
| }; |
| }; |
| |
| template<std::size_t N, std::size_t M> |
| struct sp_align_up { |
| enum { |
| value = (N + M - 1) & ~(M - 1) |
| }; |
| }; |
| |
| template<class T> |
| BOOST_CONSTEXPR inline std::size_t |
| sp_objects(std::size_t size) BOOST_SP_NOEXCEPT |
| { |
| return (size + sizeof(T) - 1) / sizeof(T); |
| } |
| |
| template<class A> |
| class sp_array_state { |
| public: |
| typedef A type; |
| |
| template<class U> |
| sp_array_state(const U& _allocator, std::size_t _size) BOOST_SP_NOEXCEPT |
| : allocator_(_allocator), |
| size_(_size) { } |
| |
| A& allocator() BOOST_SP_NOEXCEPT { |
| return allocator_; |
| } |
| |
| std::size_t size() const BOOST_SP_NOEXCEPT { |
| return size_; |
| } |
| |
| private: |
| A allocator_; |
| std::size_t size_; |
| }; |
| |
| template<class A, std::size_t N> |
| class sp_size_array_state { |
| public: |
| typedef A type; |
| |
| template<class U> |
| sp_size_array_state(const U& _allocator, std::size_t) BOOST_SP_NOEXCEPT |
| : allocator_(_allocator) { } |
| |
| A& allocator() BOOST_SP_NOEXCEPT { |
| return allocator_; |
| } |
| |
| BOOST_CONSTEXPR std::size_t size() const BOOST_SP_NOEXCEPT { |
| return N; |
| } |
| |
| private: |
| A allocator_; |
| }; |
| |
| template<class T, class U> |
| struct sp_array_alignment { |
| enum { |
| value = sp_max_size<boost::alignment_of<T>::value, |
| boost::alignment_of<U>::value>::value |
| }; |
| }; |
| |
| template<class T, class U> |
| struct sp_array_offset { |
| enum { |
| value = sp_align_up<sizeof(T), sp_array_alignment<T, U>::value>::value |
| }; |
| }; |
| |
| template<class U, class T> |
| inline U* |
| sp_array_start(T* base) BOOST_SP_NOEXCEPT |
| { |
| enum { |
| size = sp_array_offset<T, U>::value |
| }; |
| return reinterpret_cast<U*>(reinterpret_cast<char*>(base) + size); |
| } |
| |
| template<class A, class T> |
| class sp_array_creator { |
| typedef typename A::value_type element; |
| |
| enum { |
| offset = sp_array_offset<T, element>::value |
| }; |
| |
| typedef typename boost::type_with_alignment<sp_array_alignment<T, |
| element>::value>::type type; |
| |
| public: |
| template<class U> |
| sp_array_creator(const U& other, std::size_t size) BOOST_SP_NOEXCEPT |
| : other_(other), |
| size_(sp_objects<type>(offset + sizeof(element) * size)) { } |
| |
| T* create() { |
| return reinterpret_cast<T*>(other_.allocate(size_)); |
| } |
| |
| void destroy(T* base) { |
| other_.deallocate(reinterpret_cast<type*>(base), size_); |
| } |
| |
| private: |
| typename boost::allocator_rebind<A, type>::type other_; |
| std::size_t size_; |
| }; |
| |
| template<class T> |
| class BOOST_SYMBOL_VISIBLE sp_array_base |
| : public sp_counted_base { |
| typedef typename T::type allocator; |
| |
| public: |
| typedef typename allocator::value_type type; |
| |
| template<class A> |
| sp_array_base(const A& other, type* start, std::size_t size) |
| : state_(other, size) { |
| boost::alloc_construct_n(state_.allocator(), |
| boost::first_scalar(start), |
| state_.size() * sp_array_count<type>::value); |
| } |
| |
| template<class A, class U> |
| sp_array_base(const A& other, type* start, std::size_t size, const U& list) |
| : state_(other, size) { |
| enum { |
| count = sp_array_count<type>::value |
| }; |
| boost::alloc_construct_n(state_.allocator(), |
| boost::first_scalar(start), state_.size() * count, |
| boost::first_scalar(&list), count); |
| } |
| |
| T& state() BOOST_SP_NOEXCEPT { |
| return state_; |
| } |
| |
| void dispose() BOOST_SP_NOEXCEPT BOOST_OVERRIDE { |
| boost::alloc_destroy_n(state_.allocator(), |
| boost::first_scalar(sp_array_start<type>(this)), |
| state_.size() * sp_array_count<type>::value); |
| } |
| |
| void destroy() BOOST_SP_NOEXCEPT BOOST_OVERRIDE { |
| sp_array_creator<allocator, sp_array_base> other(state_.allocator(), |
| state_.size()); |
| this->~sp_array_base(); |
| other.destroy(this); |
| } |
| |
| void* get_deleter(const sp_typeinfo_&) BOOST_SP_NOEXCEPT BOOST_OVERRIDE { |
| return 0; |
| } |
| |
| void* get_local_deleter(const sp_typeinfo_&) |
| BOOST_SP_NOEXCEPT BOOST_OVERRIDE { |
| return 0; |
| } |
| |
| void* get_untyped_deleter() BOOST_SP_NOEXCEPT BOOST_OVERRIDE { |
| return 0; |
| } |
| |
| private: |
| T state_; |
| }; |
| |
| template<class A, class T> |
| struct sp_array_result { |
| public: |
| template<class U> |
| sp_array_result(const U& other, std::size_t size) |
| : creator_(other, size), |
| result_(creator_.create()) { } |
| |
| ~sp_array_result() { |
| if (result_) { |
| creator_.destroy(result_); |
| } |
| } |
| |
| T* get() const BOOST_SP_NOEXCEPT { |
| return result_; |
| } |
| |
| void release() BOOST_SP_NOEXCEPT { |
| result_ = 0; |
| } |
| |
| private: |
| sp_array_result(const sp_array_result&); |
| sp_array_result& operator=(const sp_array_result&); |
| |
| sp_array_creator<A, T> creator_; |
| T* result_; |
| }; |
| |
| } /* detail */ |
| |
| template<class T, class A> |
| inline typename enable_if_<is_unbounded_array<T>::value, shared_ptr<T> >::type |
| allocate_shared(const A& allocator, std::size_t count) |
| { |
| typedef typename detail::sp_array_element<T>::type element; |
| typedef typename allocator_rebind<A, element>::type other; |
| typedef detail::sp_array_state<other> state; |
| typedef detail::sp_array_base<state> base; |
| detail::sp_array_result<other, base> result(allocator, count); |
| base* node = result.get(); |
| element* start = detail::sp_array_start<element>(node); |
| ::new(static_cast<void*>(node)) base(allocator, start, count); |
| result.release(); |
| return shared_ptr<T>(detail::sp_internal_constructor_tag(), start, |
| detail::shared_count(static_cast<detail::sp_counted_base*>(node))); |
| } |
| |
| template<class T, class A> |
| inline typename enable_if_<is_bounded_array<T>::value, shared_ptr<T> >::type |
| allocate_shared(const A& allocator) |
| { |
| enum { |
| count = extent<T>::value |
| }; |
| typedef typename detail::sp_array_element<T>::type element; |
| typedef typename allocator_rebind<A, element>::type other; |
| typedef detail::sp_size_array_state<other, extent<T>::value> state; |
| typedef detail::sp_array_base<state> base; |
| detail::sp_array_result<other, base> result(allocator, count); |
| base* node = result.get(); |
| element* start = detail::sp_array_start<element>(node); |
| ::new(static_cast<void*>(node)) base(allocator, start, count); |
| result.release(); |
| return shared_ptr<T>(detail::sp_internal_constructor_tag(), start, |
| detail::shared_count(static_cast<detail::sp_counted_base*>(node))); |
| } |
| |
| template<class T, class A> |
| inline typename enable_if_<is_unbounded_array<T>::value, shared_ptr<T> >::type |
| allocate_shared(const A& allocator, std::size_t count, |
| const typename remove_extent<T>::type& value) |
| { |
| typedef typename detail::sp_array_element<T>::type element; |
| typedef typename allocator_rebind<A, element>::type other; |
| typedef detail::sp_array_state<other> state; |
| typedef detail::sp_array_base<state> base; |
| detail::sp_array_result<other, base> result(allocator, count); |
| base* node = result.get(); |
| element* start = detail::sp_array_start<element>(node); |
| ::new(static_cast<void*>(node)) base(allocator, start, count, value); |
| result.release(); |
| return shared_ptr<T>(detail::sp_internal_constructor_tag(), start, |
| detail::shared_count(static_cast<detail::sp_counted_base*>(node))); |
| } |
| |
| template<class T, class A> |
| inline typename enable_if_<is_bounded_array<T>::value, shared_ptr<T> >::type |
| allocate_shared(const A& allocator, |
| const typename remove_extent<T>::type& value) |
| { |
| enum { |
| count = extent<T>::value |
| }; |
| typedef typename detail::sp_array_element<T>::type element; |
| typedef typename allocator_rebind<A, element>::type other; |
| typedef detail::sp_size_array_state<other, extent<T>::value> state; |
| typedef detail::sp_array_base<state> base; |
| detail::sp_array_result<other, base> result(allocator, count); |
| base* node = result.get(); |
| element* start = detail::sp_array_start<element>(node); |
| ::new(static_cast<void*>(node)) base(allocator, start, count, value); |
| result.release(); |
| return shared_ptr<T>(detail::sp_internal_constructor_tag(), start, |
| detail::shared_count(static_cast<detail::sp_counted_base*>(node))); |
| } |
| |
| template<class T, class A> |
| inline typename enable_if_<is_unbounded_array<T>::value, shared_ptr<T> >::type |
| allocate_shared_noinit(const A& allocator, std::size_t count) |
| { |
| return boost::allocate_shared<T>(boost::noinit_adapt(allocator), count); |
| } |
| |
| template<class T, class A> |
| inline typename enable_if_<is_bounded_array<T>::value, shared_ptr<T> >::type |
| allocate_shared_noinit(const A& allocator) |
| { |
| return boost::allocate_shared<T>(boost::noinit_adapt(allocator)); |
| } |
| |
| } /* boost */ |
| |
| #endif |