Files

483 lines
12 KiB
C++

/*
Copyright 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 ACTIV_BOOST_SMART_PTR_ALLOCATE_UNIQUE_HPP
#define ACTIV_BOOST_SMART_PTR_ALLOCATE_UNIQUE_HPP
#include <ActivBoost/smart_ptr/detail/sp_noexcept.hpp>
#include <ActivBoost/smart_ptr/detail/sp_nullptr_t.hpp>
#include <ActivBoost/core/allocator_access.hpp>
#include <ActivBoost/core/alloc_construct.hpp>
#include <ActivBoost/core/empty_value.hpp>
#include <ActivBoost/core/first_scalar.hpp>
#include <ActivBoost/core/noinit_adaptor.hpp>
#include <ActivBoost/core/pointer_traits.hpp>
#include <ActivBoost/type_traits/enable_if.hpp>
#include <ActivBoost/type_traits/extent.hpp>
#include <ActivBoost/type_traits/is_array.hpp>
#include <ActivBoost/type_traits/is_bounded_array.hpp>
#include <ActivBoost/type_traits/is_unbounded_array.hpp>
#include <ActivBoost/type_traits/remove_cv.hpp>
#include <ActivBoost/type_traits/remove_extent.hpp>
#include <ActivBoost/type_traits/type_identity.hpp>
#include <ActivBoost/config.hpp>
#include <memory>
#include <utility>
namespace Boost {
namespace detail {
template<class T>
struct sp_alloc_size {
ACTIV_BOOST_STATIC_CONSTEXPR std::size_t value = 1;
};
template<class T>
struct sp_alloc_size<T[]> {
ACTIV_BOOST_STATIC_CONSTEXPR std::size_t value = sp_alloc_size<T>::value;
};
template<class T, std::size_t N>
struct sp_alloc_size<T[N]> {
ACTIV_BOOST_STATIC_CONSTEXPR std::size_t value = N * sp_alloc_size<T>::value;
};
template<class T>
struct sp_alloc_result {
typedef T type;
};
template<class T, std::size_t N>
struct sp_alloc_result<T[N]> {
typedef T type[];
};
template<class T>
struct sp_alloc_value {
typedef typename Boost::remove_cv<typename
Boost::remove_extent<T>::type>::type type;
};
template<class T, class P>
class sp_alloc_ptr {
public:
typedef T element_type;
sp_alloc_ptr() ACTIV_BOOST_SP_NOEXCEPT
: p_() { }
#if defined(ACTIV_BOOST_MSVC) && ACTIV_BOOST_MSVC == 1600
sp_alloc_ptr(T* p) ACTIV_BOOST_SP_NOEXCEPT
: p_(const_cast<typename Boost::remove_cv<T>::type*>(p)) { }
#endif
sp_alloc_ptr(std::size_t, P p) ACTIV_BOOST_SP_NOEXCEPT
: p_(p) { }
#if !defined(ACTIV_BOOST_NO_CXX11_NULLPTR)
sp_alloc_ptr(detail::sp_nullptr_t) ACTIV_BOOST_SP_NOEXCEPT
: p_() { }
#endif
T& operator*() const {
return *p_;
}
T* operator->() const ACTIV_BOOST_SP_NOEXCEPT {
return Boost::to_address(p_);
}
#if !defined(ACTIV_BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
explicit operator bool() const ACTIV_BOOST_SP_NOEXCEPT {
return !!p_;
}
#endif
bool operator!() const ACTIV_BOOST_SP_NOEXCEPT {
return !p_;
}
P ptr() const ACTIV_BOOST_SP_NOEXCEPT {
return p_;
}
ACTIV_BOOST_STATIC_CONSTEXPR std::size_t size() ACTIV_BOOST_SP_NOEXCEPT {
return 1;
}
#if defined(ACTIV_BOOST_MSVC) && ACTIV_BOOST_MSVC < 1910
static sp_alloc_ptr pointer_to(T& v) {
return sp_alloc_ptr(1,
std::pointer_traits<P>::pointer_to(const_cast<typename
Boost::remove_cv<T>::type&>(v)));
}
#endif
private:
P p_;
};
template<class T, class P>
class sp_alloc_ptr<T[], P> {
public:
typedef T element_type;
sp_alloc_ptr() ACTIV_BOOST_SP_NOEXCEPT
: p_() { }
sp_alloc_ptr(std::size_t n, P p) ACTIV_BOOST_SP_NOEXCEPT
: p_(p)
, n_(n) { }
#if !defined(ACTIV_BOOST_NO_CXX11_NULLPTR)
sp_alloc_ptr(detail::sp_nullptr_t) ACTIV_BOOST_SP_NOEXCEPT
: p_() { }
#endif
T& operator[](std::size_t i) const {
return p_[i];
}
#if !defined(ACTIV_BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
explicit operator bool() const ACTIV_BOOST_SP_NOEXCEPT {
return !!p_;
}
#endif
bool operator!() const ACTIV_BOOST_SP_NOEXCEPT {
return !p_;
}
P ptr() const ACTIV_BOOST_SP_NOEXCEPT {
return p_;
}
std::size_t size() const ACTIV_BOOST_SP_NOEXCEPT {
return n_;
}
#if defined(ACTIV_BOOST_MSVC) && ACTIV_BOOST_MSVC < 1910
static sp_alloc_ptr pointer_to(T& v) {
return sp_alloc_ptr(n_,
std::pointer_traits<P>::pointer_to(const_cast<typename
Boost::remove_cv<T>::type&>(v)));
}
#endif
private:
P p_;
std::size_t n_;
};
template<class T, std::size_t N, class P>
class sp_alloc_ptr<T[N], P> {
public:
typedef T element_type;
sp_alloc_ptr() ACTIV_BOOST_SP_NOEXCEPT
: p_() { }
sp_alloc_ptr(std::size_t, P p) ACTIV_BOOST_SP_NOEXCEPT
: p_(p) { }
#if !defined(ACTIV_BOOST_NO_CXX11_NULLPTR)
sp_alloc_ptr(detail::sp_nullptr_t) ACTIV_BOOST_SP_NOEXCEPT
: p_() { }
#endif
T& operator[](std::size_t i) const {
return p_[i];
}
#if !defined(ACTIV_BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
explicit operator bool() const ACTIV_BOOST_SP_NOEXCEPT {
return !!p_;
}
#endif
bool operator!() const ACTIV_BOOST_SP_NOEXCEPT {
return !p_;
}
P ptr() const ACTIV_BOOST_SP_NOEXCEPT {
return p_;
}
ACTIV_BOOST_STATIC_CONSTEXPR std::size_t size() ACTIV_BOOST_SP_NOEXCEPT {
return N;
}
#if defined(ACTIV_BOOST_MSVC) && ACTIV_BOOST_MSVC < 1910
static sp_alloc_ptr pointer_to(T& v) {
return sp_alloc_ptr(N,
std::pointer_traits<P>::pointer_to(const_cast<typename
Boost::remove_cv<T>::type&>(v)));
}
#endif
private:
P p_;
};
template<class T, class P>
inline bool
operator==(const sp_alloc_ptr<T, P>& lhs, const sp_alloc_ptr<T, P>& rhs)
{
return lhs.ptr() == rhs.ptr();
}
template<class T, class P>
inline bool
operator!=(const sp_alloc_ptr<T, P>& lhs, const sp_alloc_ptr<T, P>& rhs)
{
return !(lhs == rhs);
}
#if !defined(ACTIV_BOOST_NO_CXX11_NULLPTR)
template<class T, class P>
inline bool
operator==(const sp_alloc_ptr<T, P>& lhs,
detail::sp_nullptr_t) ACTIV_BOOST_SP_NOEXCEPT
{
return !lhs.ptr();
}
template<class T, class P>
inline bool
operator==(detail::sp_nullptr_t,
const sp_alloc_ptr<T, P>& rhs) ACTIV_BOOST_SP_NOEXCEPT
{
return !rhs.ptr();
}
template<class T, class P>
inline bool
operator!=(const sp_alloc_ptr<T, P>& lhs,
detail::sp_nullptr_t) ACTIV_BOOST_SP_NOEXCEPT
{
return !!lhs.ptr();
}
template<class T, class P>
inline bool
operator!=(detail::sp_nullptr_t,
const sp_alloc_ptr<T, P>& rhs) ACTIV_BOOST_SP_NOEXCEPT
{
return !!rhs.ptr();
}
#endif
template<class A>
inline void
sp_alloc_clear(A& a, typename Boost::allocator_pointer<A>::type p, std::size_t,
Boost::false_type)
{
Boost::alloc_destroy(a, Boost::to_address(p));
}
template<class A>
inline void
sp_alloc_clear(A& a, typename Boost::allocator_pointer<A>::type p,
std::size_t n, Boost::true_type)
{
#if defined(ACTIV_BOOST_MSVC) && ACTIV_BOOST_MSVC < 1800
if (!p) {
return;
}
#endif
Boost::alloc_destroy_n(a, Boost::first_scalar(Boost::to_address(p)),
n * sp_alloc_size<typename A::value_type>::value);
}
} /* detail */
template<class T, class A>
class alloc_deleter
: empty_value<typename allocator_rebind<A,
typename detail::sp_alloc_value<T>::type>::type> {
typedef typename allocator_rebind<A,
typename detail::sp_alloc_value<T>::type>::type allocator;
typedef empty_value<allocator> base;
public:
typedef detail::sp_alloc_ptr<T,
typename allocator_pointer<allocator>::type> pointer;
explicit alloc_deleter(const allocator& a) ACTIV_BOOST_SP_NOEXCEPT
: base(empty_init_t(), a) { }
void operator()(pointer p) {
detail::sp_alloc_clear(base::get(), p.ptr(), p.size(), is_array<T>());
base::get().deallocate(p.ptr(), p.size());
}
};
#if !defined(ACTIV_BOOST_NO_CXX11_TEMPLATE_ALIASES)
template<class T, class A>
using alloc_noinit_deleter = alloc_deleter<T, noinit_adaptor<A> >;
#endif
namespace detail {
template<class T, class A>
class sp_alloc_make {
public:
typedef typename Boost::allocator_rebind<A,
typename sp_alloc_value<T>::type>::type allocator;
private:
typedef Boost::alloc_deleter<T, A> deleter;
public:
typedef std::unique_ptr<typename sp_alloc_result<T>::type, deleter> type;
sp_alloc_make(const A& a, std::size_t n)
: a_(a)
, n_(n)
, p_(a_.allocate(n)) { }
~sp_alloc_make() {
if (p_) {
a_.deallocate(p_, n_);
}
}
typename allocator::value_type* get() const ACTIV_BOOST_SP_NOEXCEPT {
return Boost::to_address(p_);
}
allocator& state() ACTIV_BOOST_SP_NOEXCEPT {
return a_;
}
type release() ACTIV_BOOST_SP_NOEXCEPT {
pointer p = p_;
p_ = pointer();
return type(typename deleter::pointer(n_, p), deleter(a_));
}
private:
typedef typename Boost::allocator_pointer<allocator>::type pointer;
allocator a_;
std::size_t n_;
pointer p_;
};
} /* detail */
template<class T, class A>
inline typename enable_if_<!is_array<T>::value,
std::unique_ptr<T, alloc_deleter<T, A> > >::type
allocate_unique(const A& alloc)
{
detail::sp_alloc_make<T, A> c(alloc, 1);
Boost::alloc_construct(c.state(), c.get());
return c.release();
}
#if !defined(ACTIV_BOOST_NO_CXX11_VARIADIC_TEMPLATES)
template<class T, class A, class... Args>
inline typename enable_if_<!is_array<T>::value,
std::unique_ptr<T, alloc_deleter<T, A> > >::type
allocate_unique(const A& alloc, Args&&... args)
{
detail::sp_alloc_make<T, A> c(alloc, 1);
Boost::alloc_construct(c.state(), c.get(), std::forward<Args>(args)...);
return c.release();
}
#endif
template<class T, class A>
inline typename enable_if_<!is_array<T>::value,
std::unique_ptr<T, alloc_deleter<T, A> > >::type
allocate_unique(const A& alloc, typename type_identity<T>::type&& value)
{
detail::sp_alloc_make<T, A> c(alloc, 1);
Boost::alloc_construct(c.state(), c.get(), std::move(value));
return c.release();
}
template<class T, class A>
inline typename enable_if_<!is_array<T>::value,
std::unique_ptr<T, alloc_deleter<T, noinit_adaptor<A> > > >::type
allocate_unique_noinit(const A& alloc)
{
return Boost::allocate_unique<T, noinit_adaptor<A> >(alloc);
}
template<class T, class A>
inline typename enable_if_<is_unbounded_array<T>::value,
std::unique_ptr<T, alloc_deleter<T, A> > >::type
allocate_unique(const A& alloc, std::size_t size)
{
detail::sp_alloc_make<T, A> c(alloc, size);
Boost::alloc_construct_n(c.state(), Boost::first_scalar(c.get()),
size * detail::sp_alloc_size<T>::value);
return c.release();
}
template<class T, class A>
inline typename enable_if_<is_bounded_array<T>::value,
std::unique_ptr<typename detail::sp_alloc_result<T>::type,
alloc_deleter<T, A> > >::type
allocate_unique(const A& alloc)
{
detail::sp_alloc_make<T, A> c(alloc, extent<T>::value);
Boost::alloc_construct_n(c.state(), Boost::first_scalar(c.get()),
detail::sp_alloc_size<T>::value);
return c.release();
}
template<class T, class A>
inline typename enable_if_<is_unbounded_array<T>::value,
std::unique_ptr<T, alloc_deleter<T, noinit_adaptor<A> > > >::type
allocate_unique_noinit(const A& alloc, std::size_t size)
{
return Boost::allocate_unique<T, noinit_adaptor<A> >(alloc, size);
}
template<class T, class A>
inline typename enable_if_<is_bounded_array<T>::value,
std::unique_ptr<typename detail::sp_alloc_result<T>::type,
alloc_deleter<T, noinit_adaptor<A> > > >::type
allocate_unique_noinit(const A& alloc)
{
return Boost::allocate_unique<T, noinit_adaptor<A> >(alloc);
}
template<class T, class A>
inline typename enable_if_<is_unbounded_array<T>::value,
std::unique_ptr<T, alloc_deleter<T, A> > >::type
allocate_unique(const A& alloc, std::size_t size,
const typename remove_extent<T>::type& value)
{
detail::sp_alloc_make<T, A> c(alloc, size);
Boost::alloc_construct_n(c.state(), Boost::first_scalar(c.get()),
size * detail::sp_alloc_size<T>::value, Boost::first_scalar(&value),
detail::sp_alloc_size<typename remove_extent<T>::type>::value);
return c.release();
}
template<class T, class A>
inline typename enable_if_<is_bounded_array<T>::value,
std::unique_ptr<typename detail::sp_alloc_result<T>::type,
alloc_deleter<T, A> > >::type
allocate_unique(const A& alloc,
const typename remove_extent<T>::type& value)
{
detail::sp_alloc_make<T, A> c(alloc, extent<T>::value);
Boost::alloc_construct_n(c.state(), Boost::first_scalar(c.get()),
detail::sp_alloc_size<T>::value, Boost::first_scalar(&value),
detail::sp_alloc_size<typename remove_extent<T>::type>::value);
return c.release();
}
} /* boost */
#endif