feedc0de/boost_smart_ptr
1
0
Fork 0
forked from boostorg/smart_ptr
Code Pull Requests Activity

Merge pull request #35 from boostorg/develop

Browse Source 
Merge develop
This commit is contained in:
Glen Fernandes
2017-03-03 13:23:35 -05:00
committed by GitHub
parent 609de5d711 7beb91fd0e
commit 3f21bac34f
12 changed files with 1221 additions and 1071 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1175
include/boost/smart_ptr/allocate_shared_array.hpp
View File

File diff suppressed because it is too large Load Diff

318
include/boost/smart_ptr/detail/array_allocator.hpp
View File

@ -1,318 +0,0 @@
/*
* Copyright (c) 2012-2014 Glen Joseph Fernandes
* glenfe at live dot com
*
* Distributed under the Boost Software License,
* Version 1.0. (See accompanying file LICENSE_1_0.txt
* or copy at http://boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_SMART_PTR_DETAIL_ARRAY_ALLOCATOR_HPP
#define BOOST_SMART_PTR_DETAIL_ARRAY_ALLOCATOR_HPP
#include <boost/align/align.hpp>
#include <boost/smart_ptr/detail/array_traits.hpp>
#include <boost/smart_ptr/detail/array_utility.hpp>
#include <boost/type_traits/alignment_of.hpp>
namespace boost {
namespace detail {
struct ms_init_tag { };
struct ms_noinit_tag { };
template<class T>
struct ms_allocator_state;
template<class T>
struct ms_allocator_state<T[]> {
typedef typename array_base<T>::type type;
ms_allocator_state(std::size_t size_,
type** result_)
: size(size_ * array_total<T>::size),
result(result_) {
}
std::size_t size;
union {
type** result;
type* object;
};
};
template<class T, std::size_t N>
struct ms_allocator_state<T[N]> {
typedef typename array_base<T>::type type;
ms_allocator_state(type** result_)
: result(result_) {
}
enum {
size = array_total<T[N]>::size
};
union {
type** result;
type* object;
};
};
template<class A, class T, class R>
class as_allocator
: public A {
template<class A_, class T_, class R_>
friend class as_allocator;
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
typedef std::allocator_traits<A> AT;
typedef typename AT::template rebind_alloc<char> CA;
typedef typename AT::template rebind_traits<char> CT;
#else
typedef typename A::template rebind<char>::other CA;
#endif
public:
typedef A allocator_type;
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
typedef typename AT::value_type value_type;
typedef typename AT::pointer pointer;
typedef typename AT::const_pointer const_pointer;
typedef typename AT::void_pointer void_pointer;
typedef typename AT::const_void_pointer const_void_pointer;
typedef typename AT::size_type size_type;
typedef typename AT::difference_type difference_type;
#else
typedef typename A::value_type value_type;
typedef typename A::pointer pointer;
typedef typename A::const_pointer const_pointer;
typedef typename A::size_type size_type;
typedef typename A::difference_type difference_type;
typedef typename A::reference reference;
typedef typename A::const_reference const_reference;
typedef void* void_pointer;
typedef const void* const_void_pointer;
#endif
template<class U>
struct rebind {
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
typedef as_allocator<typename AT::
template rebind_alloc<U>, T, R> other;
#else
typedef as_allocator<typename A::
template rebind<U>::other, T, R> other;
#endif
};
typedef typename array_base<T>::type type;
as_allocator(const A& allocator_, type** result)
: A(allocator_),
data(result) {
}
as_allocator(const A& allocator_, std::size_t size,
type** result)
: A(allocator_),
data(size, result) {
}
template<class U>
as_allocator(const as_allocator<U, T, R>& other)
: A(other.allocator()),
data(other.data) {
}
pointer allocate(size_type count, const_void_pointer = 0) {
enum {
M = boost::alignment_of<type>::value
};
std::size_t n1 = count * sizeof(value_type);
std::size_t n2 = data.size * sizeof(type);
std::size_t n3 = n2 + M;
CA ca(allocator());
void* p1 = ca.allocate(n1 + n3);
void* p2 = static_cast<char*>(p1) + n1;
(void)boost::alignment::align(M, n2, p2, n3);
*data.result = static_cast<type*>(p2);
return static_cast<value_type*>(p1);
}
void deallocate(pointer memory, size_type count) {
enum {
M = boost::alignment_of<type>::value
};
std::size_t n1 = count * sizeof(value_type);
std::size_t n2 = data.size * sizeof(type) + M;
char* p1 = reinterpret_cast<char*>(memory);
CA ca(allocator());
ca.deallocate(p1, n1 + n2);
}
const A& allocator() const {
return static_cast<const A&>(*this);
}
A& allocator() {
return static_cast<A&>(*this);
}
void set(type* memory) {
data.object = memory;
}
void operator()() {
if (data.object) {
R tag;
release(tag);
}
}
private:
void release(ms_init_tag) {
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
as_destroy(allocator(), data.object, data.size);
#else
ms_destroy(data.object, data.size);
#endif
}
void release(ms_noinit_tag) {
ms_destroy(data.object, data.size);
}
ms_allocator_state<T> data;
};
template<class A1, class A2, class T, class R>
bool operator==(const as_allocator<A1, T, R>& a1,
const as_allocator<A2, T, R>& a2) {
return a1.allocator() == a2.allocator();
}
template<class A1, class A2, class T, class R>
bool operator!=(const as_allocator<A1, T, R>& a1,
const as_allocator<A2, T, R>& a2) {
return a1.allocator() != a2.allocator();
}
template<class T, class Y = char>
class ms_allocator;
template<class T, class Y>
class ms_allocator {
template<class T_, class Y_>
friend class ms_allocator;
public:
typedef typename array_base<T>::type type;
typedef Y value_type;
typedef Y* pointer;
typedef const Y* const_pointer;
typedef std::size_t size_type;
typedef std::ptrdiff_t difference_type;
typedef Y& reference;
typedef const Y& const_reference;
template<class U>
struct rebind {
typedef ms_allocator<T, U> other;
};
ms_allocator(type** result)
: data(result) {
}
ms_allocator(std::size_t size, type** result)
: data(size, result) {
}
template<class U>
ms_allocator(const ms_allocator<T, U>& other)
: data(other.data) {
}
pointer allocate(size_type count, const void* = 0) {
enum {
M = boost::alignment_of<type>::value
};
std::size_t n1 = count * sizeof(Y);
std::size_t n2 = data.size * sizeof(type);
std::size_t n3 = n2 + M;
void* p1 = ::operator new(n1 + n3);
void* p2 = static_cast<char*>(p1) + n1;
(void)boost::alignment::align(M, n2, p2, n3);
*data.result = static_cast<type*>(p2);
return static_cast<Y*>(p1);
}
void deallocate(pointer memory, size_type) {
void* p1 = memory;
::operator delete(p1);
}
#if defined(BOOST_NO_CXX11_ALLOCATOR)
pointer address(reference value) const {
return &value;
}
const_pointer address(const_reference value) const {
return &value;
}
size_type max_size() const {
enum {
N = static_cast<std::size_t>(-1) / sizeof(Y)
};
return N;
}
void construct(pointer memory, const_reference value) {
void* p1 = memory;
::new(p1) Y(value);
}
void destroy(pointer memory) {
(void)memory;
memory->~Y();
}
#endif
void set(type* memory) {
data.object = memory;
}
void operator()() {
if (data.object) {
ms_destroy(data.object, data.size);
}
}
private:
ms_allocator_state<T> data;
};
template<class T, class Y1, class Y2>
bool operator==(const ms_allocator<T, Y1>&,
const ms_allocator<T, Y2>&) {
return true;
}
template<class T, class Y1, class Y2>
bool operator!=(const ms_allocator<T, Y1>&,
const ms_allocator<T, Y2>&) {
return false;
}
class ms_in_allocator_tag {
public:
void operator()(const void*) {
}
};
}
}
#endif

67
include/boost/smart_ptr/detail/array_count_impl.hpp
View File

@ -1,67 +0,0 @@
/*
* Copyright (c) 2014 Glen Joseph Fernandes
* glenfe at live dot com
*
* Distributed under the Boost Software License,
* Version 1.0. (See accompanying file LICENSE_1_0.txt
* or copy at http://boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_SMART_PTR_DETAIL_ARRAY_COUNT_IMPL_HPP
#define BOOST_SMART_PTR_DETAIL_ARRAY_COUNT_IMPL_HPP
#include <boost/smart_ptr/detail/array_allocator.hpp>
#include <boost/smart_ptr/detail/sp_counted_impl.hpp>
namespace boost {
namespace detail {
template<class P, class A>
class sp_counted_impl_pda<P, ms_in_allocator_tag, A>
: public sp_counted_base {
typedef ms_in_allocator_tag D;
typedef sp_counted_impl_pda<P, D, A> Y;
public:
sp_counted_impl_pda(P, D, const A& allocator_)
: allocator(allocator_) {
}
virtual void dispose() {
allocator();
}
virtual void destroy() {
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
typedef typename std::allocator_traits<A>::
template rebind_alloc<Y> YA;
typedef typename std::allocator_traits<A>::
template rebind_traits<Y> YT;
#else
typedef typename A::template rebind<Y>::other YA;
#endif
YA a1(allocator);
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
YT::destroy(a1, this);
YT::deallocate(a1, this, 1);
#else
this->~Y();
a1.deallocate(this, 1);
#endif
}
virtual void* get_deleter(const sp_typeinfo&) {
return &reinterpret_cast<char&>(allocator);
}
virtual void* get_untyped_deleter() {
return &reinterpret_cast<char&>(allocator);
}
private:
sp_counted_impl_pda(const sp_counted_impl_pda&);
sp_counted_impl_pda& operator=(const sp_counted_impl_pda&);
A allocator;
};
}
}
#endif

60
include/boost/smart_ptr/detail/array_traits.hpp
View File

@ -1,60 +0,0 @@
/*
* Copyright (c) 2012-2014 Glen Joseph Fernandes
* glenfe at live dot com
*
* Distributed under the Boost Software License,
* Version 1.0. (See accompanying file LICENSE_1_0.txt
* or copy at http://boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_SMART_PTR_DETAIL_ARRAY_TRAITS_HPP
#define BOOST_SMART_PTR_DETAIL_ARRAY_TRAITS_HPP
#include <boost/type_traits/remove_cv.hpp>
namespace boost {
namespace detail {
template<class T>
struct array_base {
typedef typename boost::remove_cv<T>::type type;
};
template<class T>
struct array_base<T[]> {
typedef typename array_base<T>::type type;
};
template<class T, std::size_t N>
struct array_base<T[N]> {
typedef typename array_base<T>::type type;
};
template<class T>
struct array_total {
enum {
size = 1
};
};
template<class T, std::size_t N>
struct array_total<T[N]> {
enum {
size = N * array_total<T>::size
};
};
template<class T>
struct array_inner;
template<class T>
struct array_inner<T[]> {
typedef T type;
};
template<class T, std::size_t N>
struct array_inner<T[N]> {
typedef T type;
};
}
}
#endif

214
include/boost/smart_ptr/detail/array_utility.hpp
View File

@ -1,214 +0,0 @@
/*
* Copyright (c) 2012-2014 Glen Joseph Fernandes
* glenfe at live dot com
*
* Distributed under the Boost Software License,
* Version 1.0. (See accompanying file LICENSE_1_0.txt
* or copy at http://boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_SMART_PTR_DETAIL_ARRAY_UTILITY_HPP
#define BOOST_SMART_PTR_DETAIL_ARRAY_UTILITY_HPP
#include <boost/config.hpp>
#include <boost/type_traits/has_trivial_constructor.hpp>
#include <boost/type_traits/has_trivial_destructor.hpp>
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
#include <memory>
#endif
namespace boost {
namespace detail {
typedef boost::true_type ms_is_trivial;
typedef boost::false_type ms_no_trivial;
template<class T>
inline void ms_destroy(T*, std::size_t, ms_is_trivial) {
}
template<class T>
inline void ms_destroy(T* memory, std::size_t size, ms_no_trivial) {
for (std::size_t i = size; i > 0;) {
memory[--i].~T();
}
}
template<class T>
inline void ms_destroy(T* memory, std::size_t size) {
boost::has_trivial_destructor<T> trivial;
ms_destroy(memory, size, trivial);
}
template<class T>
inline void ms_init(T* memory, std::size_t size, ms_is_trivial) {
for (std::size_t i = 0; i < size; i++) {
void* p1 = memory + i;
::new(p1) T();
}
}
template<class T>
inline void ms_init(T* memory, std::size_t size, ms_no_trivial) {
#if !defined(BOOST_NO_EXCEPTIONS)
std::size_t i = 0;
try {
for (; i < size; i++) {
void* p1 = memory + i;
::new(p1) T();
}
} catch (...) {
ms_destroy(memory, i);
throw;
}
#else
for (std::size_t i = 0; i < size; i++) {
void* p1 = memory + i;
::new(p1) T();
}
#endif
}
template<class T>
inline void ms_init(T* memory, std::size_t size) {
boost::has_trivial_default_constructor<T> trivial;
ms_init(memory, size, trivial);
}
template<class T, std::size_t N>
inline void ms_init(T* memory, std::size_t size, const T* list) {
#if !defined(BOOST_NO_EXCEPTIONS)
std::size_t i = 0;
try {
for (; i < size; i++) {
void* p1 = memory + i;
::new(p1) T(list[i % N]);
}
} catch (...) {
ms_destroy(memory, i);
throw;
}
#else
for (std::size_t i = 0; i < size; i++) {
void* p1 = memory + i;
::new(p1) T(list[i % N]);
}
#endif
}
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
template<class T, class A>
inline void as_destroy(const A& allocator, T* memory,
std::size_t size) {
typedef typename std::allocator_traits<A>::
template rebind_alloc<T> TA;
typedef typename std::allocator_traits<A>::
template rebind_traits<T> TT;
TA a2(allocator);
for (std::size_t i = size; i > 0;) {
TT::destroy(a2, &memory[--i]);
}
}
template<class T, class A>
inline void as_init(const A& allocator, T* memory, std::size_t size,
ms_is_trivial) {
typedef typename std::allocator_traits<A>::
template rebind_alloc<T> TA;
typedef typename std::allocator_traits<A>::
template rebind_traits<T> TT;
TA a2(allocator);
for (std::size_t i = 0; i < size; i++) {
TT::construct(a2, memory + i);
}
}
template<class T, class A>
inline void as_init(const A& allocator, T* memory, std::size_t size,
ms_no_trivial) {
typedef typename std::allocator_traits<A>::
template rebind_alloc<T> TA;
typedef typename std::allocator_traits<A>::
template rebind_traits<T> TT;
TA a2(allocator);
#if !defined(BOOST_NO_EXCEPTIONS)
std::size_t i = 0;
try {
for (; i < size; i++) {
TT::construct(a2, memory + i);
}
} catch (...) {
as_destroy(a2, memory, i);
throw;
}
#else
for (std::size_t i = 0; i < size; i++) {
TT::construct(a2, memory + i);
}
#endif
}
template<class T, class A>
inline void as_init(const A& allocator, T* memory, std::size_t size) {
boost::has_trivial_default_constructor<T> trivial;
as_init(allocator, memory, size, trivial);
}
template<class T, class A, std::size_t N>
inline void as_init(const A& allocator, T* memory, std::size_t size,
const T* list) {
typedef typename std::allocator_traits<A>::
template rebind_alloc<T> TA;
typedef typename std::allocator_traits<A>::
template rebind_traits<T> TT;
TA a2(allocator);
#if !defined(BOOST_NO_EXCEPTIONS)
std::size_t i = 0;
try {
for (; i < size; i++) {
TT::construct(a2, memory + i, list[i % N]);
}
} catch (...) {
as_destroy(a2, memory, i);
throw;
}
#else
for (std::size_t i = 0; i < size; i++) {
TT::construct(a2, memory + i, list[i % N]);
}
#endif
}
#endif
template<class T>
inline void ms_noinit(T*, std::size_t, ms_is_trivial) {
}
template<class T>
inline void ms_noinit(T* memory, std::size_t size, ms_no_trivial) {
#if !defined(BOOST_NO_EXCEPTIONS)
std::size_t i = 0;
try {
for (; i < size; i++) {
void* p1 = memory + i;
::new(p1) T;
}
} catch (...) {
ms_destroy(memory, i);
throw;
}
#else
for (std::size_t i = 0; i < size; i++) {
void* p1 = memory + i;
::new(p1) T;
}
#endif
}
template<class T>
inline void ms_noinit(T* memory, std::size_t size) {
boost::has_trivial_default_constructor<T> trivial;
ms_noinit(memory, size, trivial);
}
}
}
#endif

62
include/boost/smart_ptr/detail/shared_count.hpp
View File

@ -249,18 +249,8 @@ public:
try
{
#if !defined( BOOST_NO_CXX11_ALLOCATOR )
impl_type * pi = std::allocator_traits<A2>::allocate( a2, 1 );
pi_ = pi;
std::allocator_traits<A2>::construct( a2, pi, p, d, a );
#else
pi_ = a2.allocate( 1, static_cast< impl_type* >( 0 ) );
pi_ = a2.allocate( 1 );
::new( static_cast< void* >( pi_ ) ) impl_type( p, d, a );
#endif
}
catch(...)
{
@ -276,28 +266,11 @@ public:
#else
#if !defined( BOOST_NO_CXX11_ALLOCATOR )
impl_type * pi = std::allocator_traits<A2>::allocate( a2, 1 );
pi_ = pi;
#else
pi_ = a2.allocate( 1, static_cast< impl_type* >( 0 ) );
#endif
pi_ = a2.allocate( 1 );
if( pi_ != 0 )
{
#if !defined( BOOST_NO_CXX11_ALLOCATOR )
std::allocator_traits<A2>::construct( a2, pi, p, d, a );
#else
::new( static_cast< void* >( pi_ ) ) impl_type( p, d, a );
#endif
}
else
{
@ -333,18 +306,8 @@ public:
try
{
#if !defined( BOOST_NO_CXX11_ALLOCATOR )
impl_type * pi = std::allocator_traits<A2>::allocate( a2, 1 );
pi_ = pi;
std::allocator_traits<A2>::construct( a2, pi, p, a );
#else
pi_ = a2.allocate( 1, static_cast< impl_type* >( 0 ) );
pi_ = a2.allocate( 1 );
::new( static_cast< void* >( pi_ ) ) impl_type( p, a );
#endif
}
catch(...)
{
@ -360,28 +323,11 @@ public:
#else
#if !defined( BOOST_NO_CXX11_ALLOCATOR )
impl_type * pi = std::allocator_traits<A2>::allocate( a2, 1 );
pi_ = pi;
#else
pi_ = a2.allocate( 1, static_cast< impl_type* >( 0 ) );
#endif
pi_ = a2.allocate( 1 );
if( pi_ != 0 )
{
#if !defined( BOOST_NO_CXX11_ALLOCATOR )
std::allocator_traits<A2>::construct( a2, pi, p, a );
#else
::new( static_cast< void* >( pi_ ) ) impl_type( p, a );
#endif
}
else
{

8
include/boost/smart_ptr/detail/sp_counted_impl.hpp
View File

@ -236,16 +236,8 @@ public:
A2 a2( a_ );
#if !defined( BOOST_NO_CXX11_ALLOCATOR )
std::allocator_traits<A2>::destroy( a2, this );
#else
this->~this_type();
#endif
a2.deallocate( this, 1 );
}

34
include/boost/smart_ptr/detail/sp_if_array.hpp
View File

@ -1,34 +0,0 @@
/*
* Copyright (c) 2012-2014 Glen Joseph Fernandes
* glenfe at live dot com
*
* Distributed under the Boost Software License,
* Version 1.0. (See accompanying file LICENSE_1_0.txt
* or copy at http://boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_SMART_PTR_DETAIL_SP_IF_ARRAY_HPP
#define BOOST_SMART_PTR_DETAIL_SP_IF_ARRAY_HPP
#include <boost/smart_ptr/shared_ptr.hpp>
namespace boost {
namespace detail {
template<class T>
struct sp_if_array;
template<class T>
struct sp_if_array<T[]> {
typedef boost::shared_ptr<T[]> type;
};
template<class T>
struct sp_if_size_array;
template<class T, std::size_t N>
struct sp_if_size_array<T[N]> {
typedef boost::shared_ptr<T[N]> type;
};
}
}
#endif

204
include/boost/smart_ptr/make_shared_array.hpp
View File

@ -1,158 +1,66 @@
/*
* Copyright (c) 2012-2014 Glen Joseph Fernandes
* glenfe at live dot com
*
* Distributed under the Boost Software License,
* Version 1.0. (See accompanying file LICENSE_1_0.txt
* or copy at http://boost.org/LICENSE_1_0.txt)
*/
Copyright 2012-2017 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_MAKE_SHARED_ARRAY_HPP
#define BOOST_SMART_PTR_MAKE_SHARED_ARRAY_HPP
#include <boost/smart_ptr/detail/array_count_impl.hpp>
#include <boost/smart_ptr/detail/sp_if_array.hpp>
#include <boost/smart_ptr/allocate_shared_array.hpp>
namespace boost {
template<class T>
inline typename boost::detail::sp_if_array<T>::type
make_shared(std::size_t size) {
typedef typename boost::detail::array_inner<T>::type T1;
typedef typename boost::detail::array_base<T1>::type T2;
typedef boost::detail::ms_allocator<T> A1;
typedef boost::detail::ms_in_allocator_tag D1;
std::size_t n1 = size * boost::detail::array_total<T1>::size;
T1* p1 = 0;
T2* p2 = 0;
D1 d1;
A1 a1(size, &p2);
shared_ptr<T> s1(p1, d1, a1);
A1* a2 = static_cast<A1*>(s1._internal_get_untyped_deleter());
a2->set(0);
boost::detail::ms_init(p2, n1);
a2->set(p2);
p1 = reinterpret_cast<T1*>(p2);
return shared_ptr<T>(s1, p1);
}
template<class T>
inline typename boost::detail::sp_if_size_array<T>::type
make_shared() {
typedef typename boost::detail::array_inner<T>::type T1;
typedef typename boost::detail::array_base<T1>::type T2;
typedef boost::detail::ms_allocator<T> A1;
typedef boost::detail::ms_in_allocator_tag D1;
enum {
N = boost::detail::array_total<T>::size
};
T1* p1 = 0;
T2* p2 = 0;
D1 d1;
A1 a1(&p2);
shared_ptr<T> s1(p1, d1, a1);
A1* a2 = static_cast<A1*>(s1._internal_get_untyped_deleter());
a2->set(0);
boost::detail::ms_init(p2, N);
a2->set(p2);
p1 = reinterpret_cast<T1*>(p2);
return shared_ptr<T>(s1, p1);
}
template<class T>
inline typename boost::detail::sp_if_array<T>::type
make_shared(std::size_t size,
const typename boost::detail::array_inner<T>::type& value) {
typedef typename boost::detail::array_inner<T>::type T1;
typedef typename boost::detail::array_base<T1>::type T2;
typedef const T2 T3;
typedef boost::detail::ms_allocator<T> A1;
typedef boost::detail::ms_in_allocator_tag D1;
enum {
M = boost::detail::array_total<T1>::size
};
std::size_t n1 = M * size;
T1* p1 = 0;
T2* p2 = 0;
T3* p3 = reinterpret_cast<T3*>(&value);
D1 d1;
A1 a1(size, &p2);
shared_ptr<T> s1(p1, d1, a1);
A1* a2 = static_cast<A1*>(s1._internal_get_untyped_deleter());
a2->set(0);
boost::detail::ms_init<T2, M>(p2, n1, p3);
a2->set(p2);
p1 = reinterpret_cast<T1*>(p2);
return shared_ptr<T>(s1, p1);
}
template<class T>
inline typename boost::detail::sp_if_size_array<T>::type
make_shared(const typename boost::detail::array_inner<T>::type& value) {
typedef typename boost::detail::array_inner<T>::type T1;
typedef typename boost::detail::array_base<T1>::type T2;
typedef const T2 T3;
typedef boost::detail::ms_allocator<T> A1;
typedef boost::detail::ms_in_allocator_tag D1;
enum {
M = boost::detail::array_total<T1>::size,
N = boost::detail::array_total<T>::size
};
T1* p1 = 0;
T2* p2 = 0;
T3* p3 = reinterpret_cast<T3*>(&value);
D1 d1;
A1 a1(&p2);
shared_ptr<T> s1(p1, d1, a1);
A1* a2 = static_cast<A1*>(s1._internal_get_untyped_deleter());
a2->set(0);
boost::detail::ms_init<T2, M>(p2, N, p3);
a2->set(p2);
p1 = reinterpret_cast<T1*>(p2);
return shared_ptr<T>(s1, p1);
}
template<class T>
inline typename boost::detail::sp_if_array<T>::type
make_shared_noinit(std::size_t size) {
typedef typename boost::detail::array_inner<T>::type T1;
typedef typename boost::detail::array_base<T1>::type T2;
typedef boost::detail::ms_allocator<T> A1;
typedef boost::detail::ms_in_allocator_tag D1;
std::size_t n1 = size * boost::detail::array_total<T1>::size;
T1* p1 = 0;
T2* p2 = 0;
D1 d1;
A1 a1(size, &p2);
shared_ptr<T> s1(p1, d1, a1);
A1* a2 = static_cast<A1*>(s1._internal_get_untyped_deleter());
a2->set(0);
boost::detail::ms_noinit(p2, n1);
a2->set(p2);
p1 = reinterpret_cast<T1*>(p2);
return shared_ptr<T>(s1, p1);
}
template<class T>
inline typename boost::detail::sp_if_size_array<T>::type
make_shared_noinit() {
typedef typename boost::detail::array_inner<T>::type T1;
typedef typename boost::detail::array_base<T1>::type T2;
typedef boost::detail::ms_allocator<T> A1;
typedef boost::detail::ms_in_allocator_tag D1;
enum {
N = boost::detail::array_total<T>::size
};
T1* p1 = 0;
T2* p2 = 0;
D1 d1;
A1 a1(&p2);
shared_ptr<T> s1(p1, d1, a1);
A1* a2 = static_cast<A1*>(s1._internal_get_untyped_deleter());
a2->set(0);
boost::detail::ms_noinit(p2, N);
a2->set(p2);
p1 = reinterpret_cast<T1*>(p2);
return shared_ptr<T>(s1, p1);
}
template<class T>
inline typename detail::sp_if_size_array<T>::type
make_shared()
{
return boost::allocate_shared<T>(std::allocator<typename
detail::sp_array_scalar<T>::type>());
}
template<class T>
inline typename detail::sp_if_size_array<T>::type
make_shared(const typename detail::sp_array_element<T>::type& value)
{
return boost::allocate_shared<T>(std::allocator<typename
detail::sp_array_scalar<T>::type>(), value);
}
template<class T>
inline typename detail::sp_if_array<T>::type
make_shared(std::size_t size)
{
return boost::allocate_shared<T>(std::allocator<typename
detail::sp_array_scalar<T>::type>(), size);
}
template<class T>
inline typename detail::sp_if_array<T>::type
make_shared(std::size_t size,
const typename detail::sp_array_element<T>::type& value)
{
return boost::allocate_shared<T>(std::allocator<typename
detail::sp_array_scalar<T>::type>(), size, value);
}
template<class T>
inline typename detail::sp_if_size_array<T>::type
make_shared_noinit()
{
return allocate_shared_noinit<T>(std::allocator<typename
detail::sp_array_scalar<T>::type>());
}
template<class T>
inline typename detail::sp_if_array<T>::type
make_shared_noinit(std::size_t size)
{
return allocate_shared_noinit<T>(std::allocator<typename
detail::sp_array_scalar<T>::type>(), size);
}
} /* boost */
#endif

3
test/Jamfile.v2
View File

@ -84,6 +84,7 @@ import testing ;
[ run sa_nullptr_test.cpp ]
[ run shared_ptr_alloc3_test.cpp ]
[ run shared_ptr_alloc11_test.cpp ]
[ run shared_ptr_alloc_construct11_test.cpp ]
[ run allocate_shared_alloc11_test.cpp ]
[ run allocate_shared_construct11_test.cpp ]
[ run sp_interlocked_test.cpp ]
@ -205,5 +206,7 @@ import testing ;
[ compile-fail pointer_cast_dy_fail3.cpp ]
[ run sp_nothrow_test.cpp ]
[ compile make_shared_msvc_test.cpp ]
;
}

19
test/make_shared_msvc_test.cpp Normal file
View File

@ -0,0 +1,19 @@
//
// make_shared_msvc_test.cpp
//
// Copyright 2017 Peter Dimov
//
// Distributed under the Boost Software License, Version 1.0.
// See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt
//
template<class T> struct value
{
};
#include <boost/make_shared.hpp>
int main()
{
}

128
test/shared_ptr_alloc_construct11_test.cpp Normal file
View File

@ -0,0 +1,128 @@
/*
Copyright 2017 Glen Joseph Fernandes
(glenjofe@gmail.com)
Distributed under the Boost Software License, Version 1.0.
(http://www.boost.org/LICENSE_1_0.txt)
*/
#include <boost/core/lightweight_test.hpp>
#include <boost/make_shared.hpp>
#if !defined(BOOST_NO_CXX11_ALLOCATOR)
struct counters {
unsigned allocate;
unsigned construct;
};
template<class T>
class creator {
public:
typedef T value_type;
creator(counters* state)
: state_(state) { }
template<class U>
creator(const creator<U>& other)
: state_(other.state()) { }
T* allocate(std::size_t size) {
void* ptr = ::operator new(sizeof(T) * size);
++state_->allocate;
return static_cast<T*>(ptr);
}
void deallocate(T* ptr, std::size_t) {
::operator delete(ptr);
--state_->allocate;
}
template<class... Args>
void construct(T* ptr, Args&&... args) {
::new(static_cast<void*>(ptr)) T(std::forward<Args>(args)...);
++state_->construct;
}
void destroy(T* ptr) {
ptr->~T();
--state_->construct;
}
counters* state() const {
return state_;
}
private:
counters* state_;
};
template<class T, class U>
inline bool
operator==(const creator<T>& lhs, const creator<U>& rhs)
{
return lhs.state() == rhs.state();
}
template<class T, class U>
inline bool
operator!=(const creator<T>& lhs, const creator<U>& rhs)
{
return !(lhs == rhs);
}
struct deleter {
template<class U>
void operator()(U ptr) const {
delete ptr;
}
};
int main()
{
{
counters state = { };
boost::shared_ptr<int> pointer(new int(), deleter(),
creator<int>(&state));
BOOST_TEST(state.allocate == 1);
BOOST_TEST(state.construct == 0);
pointer.reset();
BOOST_TEST(state.allocate == 0);
}
{
counters state = { };
boost::shared_ptr<int> pointer =
boost::allocate_shared<int>(creator<int>(&state));
BOOST_TEST(state.allocate == 1);
BOOST_TEST(state.construct == 1);
pointer.reset();
BOOST_TEST(state.allocate == 0);
BOOST_TEST(state.construct == 0);
}
{
counters state = { };
boost::shared_ptr<int[]> pointer =
boost::allocate_shared<int[]>(creator<int>(&state), 5);
BOOST_TEST(state.allocate == 1);
BOOST_TEST(state.construct == 5);
pointer.reset();
BOOST_TEST(state.allocate == 0);
BOOST_TEST(state.construct == 0);
}
{
counters state = { };
boost::shared_ptr<int[5]> pointer =
boost::allocate_shared<int[5]>(creator<int>(&state));
BOOST_TEST(state.allocate == 1);
BOOST_TEST(state.construct == 5);
pointer.reset();
BOOST_TEST(state.allocate == 0);
BOOST_TEST(state.construct == 0);
}
return boost::report_errors();
}
#else
int main()
{
return 0;
}
#endif