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

Refactoring in detail array_deleter before adding support for special-casing trivially default-constructible construction and trivially destroyable destruction.

Browse Source 
[SVN r81748]
This commit is contained in:
Glen Fernandes
2012-12-07 01:53:35 +00:00
parent 6c2ed927e4
commit 1209531fe0
4 changed files with 145 additions and 140 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -13,7 +13,6 @@
#include <boost/smart_ptr/detail/allocate_array_helper.hpp> #include <boost/smart_ptr/detail/allocate_array_helper.hpp>
#include <boost/smart_ptr/detail/array_deleter.hpp> #include <boost/smart_ptr/detail/array_deleter.hpp>
#include <boost/smart_ptr/detail/array_traits.hpp> #include <boost/smart_ptr/detail/array_traits.hpp>
#include <boost/smart_ptr/detail/sp_forward.hpp>
#include <boost/smart_ptr/detail/sp_if_array.hpp> #include <boost/smart_ptr/detail/sp_if_array.hpp>
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
#include <initializer_list> #include <initializer_list>

174
include/boost/smart_ptr/detail/array_deleter.hpp
View File

@ -9,8 +9,8 @@
#ifndef BOOST_SMART_PTR_DETAIL_ARRAY_DELETER_HPP #ifndef BOOST_SMART_PTR_DETAIL_ARRAY_DELETER_HPP
#define BOOST_SMART_PTR_DETAIL_ARRAY_DELETER_HPP #define BOOST_SMART_PTR_DETAIL_ARRAY_DELETER_HPP
#include <boost/config.hpp> #include <boost/smart_ptr/detail/array_utility.hpp>
#include <cstddef> #include <boost/smart_ptr/detail/sp_forward.hpp>
namespace boost { namespace boost {
namespace detail { namespace detail {
@ -24,97 +24,46 @@ namespace boost {
object(0) { object(0) {
} }
~array_deleter() { ~array_deleter() {
destroy(size); if (object) {
array_destroy(object, size);
}
} }
void construct(T* memory) { void construct(T* memory) {
std::size_t i = 0; array_construct(memory, size);
try { object = memory;
for (object = memory; i < size; i++) {
void* p1 = memory + i;
::new(p1) T();
}
} catch (...) {
destroy(i);
throw;
}
} }
#if defined(BOOST_HAS_RVALUE_REFS) #if defined(BOOST_HAS_RVALUE_REFS)
void construct(T* memory, T&& value) { void construct(T* memory, T&& value) {
std::size_t i = 0; array_construct(memory, size, value);
try { object = memory;
for (object = memory; i < size; i++) {
void* p1 = memory + i;
::new(p1) T(value);
}
} catch (...) {
destroy(i);
throw;
}
} }
#if defined(BOOST_HAS_VARIADIC_TMPL) #if defined(BOOST_HAS_VARIADIC_TMPL)
template<typename... Args> template<typename... Args>
void construct(T* memory, Args&&... args) { void construct(T* memory, Args&&... args) {
std::size_t i = 0; array_construct(memory, size, args...);
try { object = memory;
for (object = memory; i < size; i++) {
void* p1 = memory + i;
::new(p1) T(args...);
}
} catch (...) {
destroy(i);
throw;
}
} }
#endif #endif
#endif #endif
void construct_list(T* memory, const T* list) { void construct_list(T* memory, const T* list) {
std::size_t i = 0; array_construct_list(memory, size, list);
try { object = memory;
for (object = memory; i < size; i++) {
void* p1 = memory + i;
::new(p1) T(list[i]);
}
} catch (...) {
destroy(i);
throw;
}
} }
void construct_list(T* memory, const T* list, std::size_t n) { void construct_list(T* memory, const T* list, std::size_t n) {
std::size_t i = 0; array_construct_list(memory, size, list, n);
try { object = memory;
for (object = memory; i < size; i++) {
void* p1 = memory + i;
::new(p1) T(list[i % n]);
}
} catch (...) {
destroy(i);
throw;
}
} }
void construct_noinit(T* memory) { void construct_noinit(T* memory) {
std::size_t i = 0; array_construct_noinit(memory, size);
try { object = memory;
for (object = memory; i < size; i++) {
void* p1 = memory + i;
::new(p1) T;
}
} catch (...) {
destroy(i);
throw;
}
} }
void operator()(const void*) { void operator()(const void*) {
destroy(size);
}
private:
void destroy(std::size_t n) {
if (object) { if (object) {
for (std::size_t i = n; i > 0; ) { array_destroy(object, size);
object[--i].~T();
}
object = 0; object = 0;
} }
} }
private:
std::size_t size; std::size_t size;
T* object; T* object;
}; };
@ -125,97 +74,46 @@ namespace boost {
: object(0) { : object(0) {
} }
~array_deleter() { ~array_deleter() {
destroy(N); if (object) {
array_destroy(object, N);
}
} }
void construct(T* memory) { void construct(T* memory) {
std::size_t i = 0; array_construct(memory, N);
try { object = memory;
for (object = memory; i < N; i++) {
void* p1 = memory + i;
::new(p1) T();
}
} catch (...) {
destroy(i);
throw;
}
} }
#if defined(BOOST_HAS_RVALUE_REFS) #if defined(BOOST_HAS_RVALUE_REFS)
void construct(T* memory, T&& value) { void construct(T* memory, T&& value) {
std::size_t i = 0; array_construct(memory, N, value);
try { object = memory;
for (object = memory; i < N; i++) {
void* p1 = memory + i;
::new(p1) T(value);
}
} catch (...) {
destroy(i);
throw;
}
} }
#if defined(BOOST_HAS_VARIADIC_TMPL) #if defined(BOOST_HAS_VARIADIC_TMPL)
template<typename... Args> template<typename... Args>
void construct(T* memory, Args&&... args) { void construct(T* memory, Args&&... args) {
std::size_t i = 0; array_construct(memory, N, args...);
try { object = memory;
for (object = memory; i < N; i++) {
void* p1 = memory + i;
::new(p1) T(args...);
}
} catch (...) {
destroy(i);
throw;
}
} }
#endif #endif
#endif #endif
void construct_list(T* memory, const T* list) { void construct_list(T* memory, const T* list) {
std::size_t i = 0; array_construct_list(memory, N, list);
try { object = memory;
for (object = memory; i < N; i++) {
void* p1 = memory + i;
::new(p1) T(list[i]);
}
} catch (...) {
destroy(i);
throw;
}
} }
void construct_list(T* memory, const T* list, std::size_t n) { void construct_list(T* memory, const T* list, std::size_t n) {
std::size_t i = 0; array_construct_list(memory, N, list, n);
try { object = memory;
for (object = memory; i < N; i++) {
void* p1 = memory + i;
::new(p1) T(list[i % n]);
}
} catch (...) {
destroy(i);
throw;
}
} }
void construct_noinit(T* memory) { void construct_noinit(T* memory) {
std::size_t i = 0; array_construct_noinit(memory, N);
try { object = memory;
for (object = memory; i < N; i++) {
void* p1 = memory + i;
::new(p1) T;
}
} catch (...) {
destroy(i);
throw;
}
} }
void operator()(const void*) { void operator()(const void*) {
destroy(N);
}
private:
void destroy(std::size_t n) {
if (object) { if (object) {
for (std::size_t i = n; i > 0; ) { array_destroy(object, N);
object[--i].~T();
}
object = 0; object = 0;
} }
} }
private:
T* object; T* object;
}; };
} }

109
include/boost/smart_ptr/detail/array_utility.hpp Normal file
View File

@ -0,0 +1,109 @@
/*
* Copyright (c) 2012 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>
namespace boost {
namespace detail {
template<typename T>
inline void array_destroy(T* memory, std::size_t size) {
for (std::size_t i = size; i > 0; ) {
memory[--i].~T();
}
}
template<typename T>
inline void array_construct(T* memory, std::size_t size) {
std::size_t i = 0;
try {
for (; i < size; i++) {
void* p1 = memory + i;
::new(p1) T();
}
} catch (...) {
array_destroy(memory, i);
throw;
}
}
#if defined(BOOST_HAS_RVALUE_REFS)
template<typename T>
inline void array_construct(T* memory, std::size_t size, T value) {
std::size_t i = 0;
try {
for (; i < size; i++) {
void* p1 = memory + i;
::new(p1) T(value);
}
} catch (...) {
array_destroy(memory, i);
throw;
}
}
#if defined(BOOST_HAS_VARIADIC_TMPL)
template<typename T, typename... Args>
inline void array_construct(T* memory, std::size_t size, Args... args) {
std::size_t i = 0;
try {
for (; i < size; i++) {
void* p1 = memory + i;
::new(p1) T(args...);
}
} catch (...) {
array_destroy(memory, i);
throw;
}
}
#endif
#endif
template<typename T>
inline void array_construct_list(T* memory, std::size_t size, const T* list) {
std::size_t i = 0;
try {
for (; i < size; i++) {
void* p1 = memory + i;
::new(p1) T(list[i]);
}
} catch (...) {
array_destroy(memory, i);
throw;
}
}
template<typename T>
inline void array_construct_list(T* memory, std::size_t size, const T* list, std::size_t n) {
std::size_t i = 0;
try {
for (; i < size; i++) {
void* p1 = memory + i;
::new(p1) T(list[i % n]);
}
} catch (...) {
array_destroy(memory, i);
throw;
}
}
template<typename T>
inline void array_construct_noinit(T* memory, std::size_t size) {
std::size_t i = 0;
try {
for (; i < size; i++) {
void* p1 = memory + i;
::new(p1) T;
}
} catch (...) {
array_destroy(memory, i);
throw;
}
}
}
}
#endif

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

@ -13,7 +13,6 @@
#include <boost/smart_ptr/detail/array_deleter.hpp> #include <boost/smart_ptr/detail/array_deleter.hpp>
#include <boost/smart_ptr/detail/array_traits.hpp> #include <boost/smart_ptr/detail/array_traits.hpp>
#include <boost/smart_ptr/detail/make_array_helper.hpp> #include <boost/smart_ptr/detail/make_array_helper.hpp>
#include <boost/smart_ptr/detail/sp_forward.hpp>
#include <boost/smart_ptr/detail/sp_if_array.hpp> #include <boost/smart_ptr/detail/sp_if_array.hpp>
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
#include <initializer_list> #include <initializer_list>