FM / smart

/usr/include/boost/smart_ptr

Name	Size	Mode	Actions
detail/	-	0755	rm
allocate_local_shared_array.hpp	5655	0644	edit dl rm
allocate_shared_array.hpp	9959	0644	edit dl rm
allocate_unique.hpp	12369	0644	edit dl rm
atomic_shared_ptr.hpp	5815	0644	edit dl rm
bad_weak_ptr.hpp	1744	0644	edit dl rm
enable_shared_from.hpp	1184	0644	edit dl rm
enable_shared_from_raw.hpp	4479	0644	edit dl rm
enable_shared_from_this.hpp	2175	0644	edit dl rm
intrusive_ptr.hpp	9427	0644	edit dl rm
intrusive_ref_counter.hpp	5817	0644	edit dl rm
local_shared_ptr.hpp	19377	0644	edit dl rm
make_local_shared.hpp	576	0644	edit dl rm
make_local_shared_array.hpp	2179	0644	edit dl rm
make_local_shared_object.hpp	4787	0644	edit dl rm
make_shared.hpp	707	0644	edit dl rm
make_shared_array.hpp	1996	0644	edit dl rm
make_shared_object.hpp	24622	0644	edit dl rm
make_unique.hpp	1783	0644	edit dl rm
owner_equal_to.hpp	671	0644	edit dl rm
owner_hash.hpp	600	0644	edit dl rm
owner_less.hpp	853	0644	edit dl rm
scoped_array.hpp	3301	0644	edit dl rm
scoped_ptr.hpp	4082	0644	edit dl rm
shared_array.hpp	7252	0644	edit dl rm
shared_ptr.hpp	31199	0644	edit dl rm
weak_ptr.hpp	7582	0644	edit dl rm

Edit: /usr/include/boost/smart_ptr/allocate_unique.hpp (12369B)

/*
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 BOOST_SMART_PTR_ALLOCATE_UNIQUE_HPP
#define BOOST_SMART_PTR_ALLOCATE_UNIQUE_HPP

#include <boost/smart_ptr/detail/sp_noexcept.hpp>
#include <boost/smart_ptr/detail/sp_nullptr_t.hpp>
#include <boost/core/allocator_access.hpp>
#include <boost/core/alloc_construct.hpp>
#include <boost/core/empty_value.hpp>
#include <boost/core/first_scalar.hpp>
#include <boost/core/noinit_adaptor.hpp>
#include <boost/core/pointer_traits.hpp>
#include <boost/type_traits/enable_if.hpp>
#include <boost/type_traits/extent.hpp>
#include <boost/type_traits/is_array.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_identity.hpp>
#include <boost/config.hpp>
#include <memory>
#include <utility>

namespace boost {
namespace detail {

template<class T>
struct sp_alloc_size {
    BOOST_STATIC_CONSTEXPR std::size_t value = 1;
};

template<class T>
struct sp_alloc_size<T[]> {
    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]> {
    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() BOOST_SP_NOEXCEPT
        : p_() { }

#if defined(BOOST_MSVC) && BOOST_MSVC == 1600
    sp_alloc_ptr(T* p) BOOST_SP_NOEXCEPT
        : p_(const_cast<typename boost::remove_cv<T>::type*>(p)) { }
#endif

sp_alloc_ptr(std::size_t, P p) BOOST_SP_NOEXCEPT
        : p_(p) { }

#if !defined(BOOST_NO_CXX11_NULLPTR)
    sp_alloc_ptr(detail::sp_nullptr_t) BOOST_SP_NOEXCEPT
        : p_() { }
#endif

T& operator*() const {
        return *p_;
    }

T* operator->() const BOOST_SP_NOEXCEPT {
        return boost::to_address(p_);
    }

#if !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
    explicit operator bool() const BOOST_SP_NOEXCEPT {
        return !!p_;
    }
#endif

bool operator!() const BOOST_SP_NOEXCEPT {
        return !p_;
    }

P ptr() const BOOST_SP_NOEXCEPT {
        return p_;
    }

BOOST_STATIC_CONSTEXPR std::size_t size() BOOST_SP_NOEXCEPT {
        return 1;
    }

#if defined(BOOST_MSVC) && 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() BOOST_SP_NOEXCEPT
        : p_() { }

sp_alloc_ptr(std::size_t n, P p) BOOST_SP_NOEXCEPT
        : p_(p)
        , n_(n) { }

#if !defined(BOOST_NO_CXX11_NULLPTR)
    sp_alloc_ptr(detail::sp_nullptr_t) BOOST_SP_NOEXCEPT
        : p_() { }
#endif

T& operator[](std::size_t i) const {
        return p_[i];
    }

#if !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
    explicit operator bool() const BOOST_SP_NOEXCEPT {
        return !!p_;
    }
#endif

bool operator!() const BOOST_SP_NOEXCEPT {
        return !p_;
    }

P ptr() const BOOST_SP_NOEXCEPT {
        return p_;
    }

std::size_t size() const BOOST_SP_NOEXCEPT {
        return n_;
    }

#if defined(BOOST_MSVC) && 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() BOOST_SP_NOEXCEPT
        : p_() { }

sp_alloc_ptr(std::size_t, P p) BOOST_SP_NOEXCEPT
        : p_(p) { }

#if !defined(BOOST_NO_CXX11_NULLPTR)
    sp_alloc_ptr(detail::sp_nullptr_t) BOOST_SP_NOEXCEPT
        : p_() { }
#endif

T& operator[](std::size_t i) const {
        return p_[i];
    }

#if !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
    explicit operator bool() const BOOST_SP_NOEXCEPT {
        return !!p_;
    }
#endif

bool operator!() const BOOST_SP_NOEXCEPT {
        return !p_;
    }

P ptr() const BOOST_SP_NOEXCEPT {
        return p_;
    }

BOOST_STATIC_CONSTEXPR std::size_t size() BOOST_SP_NOEXCEPT {
        return N;
    }

#if defined(BOOST_MSVC) && 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(BOOST_NO_CXX11_NULLPTR)
template<class T, class P>
inline bool
operator==(const sp_alloc_ptr<T, P>& lhs,
    detail::sp_nullptr_t) 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) 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) 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) 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(BOOST_MSVC) && 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) 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(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 BOOST_SP_NOEXCEPT {
        return boost::to_address(p_);
    }

allocator& state() BOOST_SP_NOEXCEPT {
        return a_;
    }

type release() 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(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

/* 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 BOOST_SMART_PTR_ALLOCATE_UNIQUE_HPP #define BOOST_SMART_PTR_ALLOCATE_UNIQUE_HPP #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace boost { namespace detail { template struct sp_alloc_size { BOOST_STATIC_CONSTEXPR std::size_t value = 1; }; template struct sp_alloc_size { BOOST_STATIC_CONSTEXPR std::size_t value = sp_alloc_size::value; }; template struct sp_alloc_size { BOOST_STATIC_CONSTEXPR std::size_t value = N * sp_alloc_size::value; }; template struct sp_alloc_result { typedef T type; }; template struct sp_alloc_result { typedef T type[]; }; template struct sp_alloc_value { typedef typename boost::remove_cv::type>::type type; }; template class sp_alloc_ptr { public: typedef T element_type; sp_alloc_ptr() BOOST_SP_NOEXCEPT : p_() { } #if defined(BOOST_MSVC) && BOOST_MSVC == 1600 sp_alloc_ptr(T* p) BOOST_SP_NOEXCEPT : p_(const_cast::type*>(p)) { } #endif sp_alloc_ptr(std::size_t, P p) BOOST_SP_NOEXCEPT : p_(p) { } #if !defined(BOOST_NO_CXX11_NULLPTR) sp_alloc_ptr(detail::sp_nullptr_t) BOOST_SP_NOEXCEPT : p_() { } #endif T& operator*() const { return *p_; } T* operator->() const BOOST_SP_NOEXCEPT { return boost::to_address(p_); } #if !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS) explicit operator bool() const BOOST_SP_NOEXCEPT { return !!p_; } #endif bool operator!() const BOOST_SP_NOEXCEPT { return !p_; } P ptr() const BOOST_SP_NOEXCEPT { return p_; } BOOST_STATIC_CONSTEXPR std::size_t size() BOOST_SP_NOEXCEPT { return 1; } #if defined(BOOST_MSVC) && BOOST_MSVC < 1910 static sp_alloc_ptr pointer_to(T& v) { return sp_alloc_ptr(1, std::pointer_traits

::pointer_to(const_cast::type&>(v))); } #endif private: P p_; }; template class sp_alloc_ptr { public: typedef T element_type; sp_alloc_ptr() BOOST_SP_NOEXCEPT : p_() { } sp_alloc_ptr(std::size_t n, P p) BOOST_SP_NOEXCEPT : p_(p) , n_(n) { } #if !defined(BOOST_NO_CXX11_NULLPTR) sp_alloc_ptr(detail::sp_nullptr_t) BOOST_SP_NOEXCEPT : p_() { } #endif T& operator[](std::size_t i) const { return p_[i]; } #if !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS) explicit operator bool() const BOOST_SP_NOEXCEPT { return !!p_; } #endif bool operator!() const BOOST_SP_NOEXCEPT { return !p_; } P ptr() const BOOST_SP_NOEXCEPT { return p_; } std::size_t size() const BOOST_SP_NOEXCEPT { return n_; } #if defined(BOOST_MSVC) && BOOST_MSVC < 1910 static sp_alloc_ptr pointer_to(T& v) { return sp_alloc_ptr(n_, std::pointer_traits

::pointer_to(const_cast::type&>(v))); } #endif private: P p_; std::size_t n_; }; template class sp_alloc_ptr { public: typedef T element_type; sp_alloc_ptr() BOOST_SP_NOEXCEPT : p_() { } sp_alloc_ptr(std::size_t, P p) BOOST_SP_NOEXCEPT : p_(p) { } #if !defined(BOOST_NO_CXX11_NULLPTR) sp_alloc_ptr(detail::sp_nullptr_t) BOOST_SP_NOEXCEPT : p_() { } #endif T& operator[](std::size_t i) const { return p_[i]; } #if !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS) explicit operator bool() const BOOST_SP_NOEXCEPT { return !!p_; } #endif bool operator!() const BOOST_SP_NOEXCEPT { return !p_; } P ptr() const BOOST_SP_NOEXCEPT { return p_; } BOOST_STATIC_CONSTEXPR std::size_t size() BOOST_SP_NOEXCEPT { return N; } #if defined(BOOST_MSVC) && BOOST_MSVC < 1910 static sp_alloc_ptr pointer_to(T& v) { return sp_alloc_ptr(N, std::pointer_traits

::pointer_to(const_cast::type&>(v))); } #endif private: P p_; }; template inline bool operator==(const sp_alloc_ptr& lhs, const sp_alloc_ptr& rhs) { return lhs.ptr() == rhs.ptr(); } template inline bool operator!=(const sp_alloc_ptr& lhs, const sp_alloc_ptr& rhs) { return !(lhs == rhs); } #if !defined(BOOST_NO_CXX11_NULLPTR) template inline bool operator==(const sp_alloc_ptr& lhs, detail::sp_nullptr_t) BOOST_SP_NOEXCEPT { return !lhs.ptr(); } template inline bool operator==(detail::sp_nullptr_t, const sp_alloc_ptr& rhs) BOOST_SP_NOEXCEPT { return !rhs.ptr(); } template inline bool operator!=(const sp_alloc_ptr& lhs, detail::sp_nullptr_t) BOOST_SP_NOEXCEPT { return !!lhs.ptr(); } template inline bool operator!=(detail::sp_nullptr_t, const sp_alloc_ptr& rhs) BOOST_SP_NOEXCEPT { return !!rhs.ptr(); } #endif template inline void sp_alloc_clear(A& a, typename boost::allocator_pointer::type p, std::size_t, boost::false_type) { boost::alloc_destroy(a, boost::to_address(p)); } template inline void sp_alloc_clear(A& a, typename boost::allocator_pointer ::type p, std::size_t n, boost::true_type) { #if defined(BOOST_MSVC) && BOOST_MSVC < 1800 if (!p) { return; } #endif boost::alloc_destroy_n(a, boost::first_scalar(boost::to_address(p)), n * sp_alloc_size::value); } } /* detail */ template class alloc_deleter : empty_value::type>::type> { typedef typename allocator_rebind::type>::type allocator; typedef empty_value base; public: typedef detail::sp_alloc_ptr::type> pointer; explicit alloc_deleter(const allocator& a) BOOST_SP_NOEXCEPT : base(empty_init_t(), a) { } void operator()(pointer p) { detail::sp_alloc_clear(base::get(), p.ptr(), p.size(), is_array()); base::get().deallocate(p.ptr(), p.size()); } }; #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) template using alloc_noinit_deleter = alloc_deleter >; #endif namespace detail { template class sp_alloc_make { public: typedef typename boost::allocator_rebind::type>::type allocator; private: typedef boost::alloc_deleter deleter; public: typedef std::unique_ptr::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 BOOST_SP_NOEXCEPT { return boost::to_address(p_); } allocator& state() BOOST_SP_NOEXCEPT { return a_; } type release() BOOST_SP_NOEXCEPT { pointer p = p_; p_ = pointer(); return type(typename deleter::pointer(n_, p), deleter(a_)); } private: typedef typename boost::allocator_pointer::type pointer; allocator a_; std::size_t n_; pointer p_; }; } /* detail */ template inline typename enable_if_::value, std::unique_ptr > >::type allocate_unique(const A& alloc) { detail::sp_alloc_make c(alloc, 1); boost::alloc_construct(c.state(), c.get()); return c.release(); } #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) template inline typename enable_if_::value, std::unique_ptr > >::type allocate_unique(const A& alloc, Args&&... args) { detail::sp_alloc_make c(alloc, 1); boost::alloc_construct(c.state(), c.get(), std::forward(args)...); return c.release(); } #endif template inline typename enable_if_::value, std::unique_ptr > >::type allocate_unique(const A& alloc, typename type_identity::type&& value) { detail::sp_alloc_make c(alloc, 1); boost::alloc_construct(c.state(), c.get(), std::move(value)); return c.release(); } template inline typename enable_if_::value, std::unique_ptr > > >::type allocate_unique_noinit(const A& alloc) { return boost::allocate_unique >(alloc); } template inline typename enable_if_::value, std::unique_ptr > >::type allocate_unique(const A& alloc, std::size_t size) { detail::sp_alloc_make c(alloc, size); boost::alloc_construct_n(c.state(), boost::first_scalar(c.get()), size * detail::sp_alloc_size::value); return c.release(); } template inline typename enable_if_::value, std::unique_ptr::type, alloc_deleter > >::type allocate_unique(const A& alloc) { detail::sp_alloc_make c(alloc, extent::value); boost::alloc_construct_n(c.state(), boost::first_scalar(c.get()), detail::sp_alloc_size::value); return c.release(); } template inline typename enable_if_::value, std::unique_ptr > > >::type allocate_unique_noinit(const A& alloc, std::size_t size) { return boost::allocate_unique >(alloc, size); } template inline typename enable_if_::value, std::unique_ptr::type, alloc_deleter > > >::type allocate_unique_noinit(const A& alloc) { return boost::allocate_unique >(alloc); } template inline typename enable_if_::value, std::unique_ptr > >::type allocate_unique(const A& alloc, std::size_t size, const typename remove_extent::type& value) { detail::sp_alloc_make c(alloc, size); boost::alloc_construct_n(c.state(), boost::first_scalar(c.get()), size * detail::sp_alloc_size::value, boost::first_scalar(&value), detail::sp_alloc_size::type>::value); return c.release(); } template inline typename enable_if_::value, std::unique_ptr::type, alloc_deleter > >::type allocate_unique(const A& alloc, const typename remove_extent::type& value) { detail::sp_alloc_make c(alloc, extent::value); boost::alloc_construct_n(c.state(), boost::first_scalar(c.get()), detail::sp_alloc_size::value, boost::first_scalar(&value), detail::sp_alloc_size::type>::value); return c.release(); } } /* boost */ #endif