feedc0de/boost_move
1
0
Fork 0
forked from boostorg/move
Code Pull Requests Activity

Simplified and improved unique_ptr implementation:

Browse Source 
- No array specialization to avoid code duplication
- Constructible and assignable from literal zero
This commit is contained in:
Ion Gaztañaga
2014-08-27 23:21:36 +02:00
parent 6b2982a385
commit 364ee17476
7 changed files with 571 additions and 695 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
doc/Jamfile.v2
View File

@@ -24,7 +24,12 @@ doxygen autodoc
<doxygen:param>"PREDEFINED=\"BOOST_MOVE_DOXYGEN_INVOKED\" \\
\"BOOST_MOVE_SEEDOC(T)=see_documentation\" \\
\"BOOST_RV_REF(T)=T&&\" \\
\"BOOST_RV_REF_BEG=\" \\
\"BOOST_RV_REF_END=&&\" \\
\"BOOST_FWD_REF(T)=T&&\" \\
\"BOOST_MOVE_DOC0PTR(T)=std::nullptr_t\" \\
\"BOOST_MOVE_DOC1ST(T1, T2)=T1\" \\
\"BOOST_MOVE_DOCIGN(T1) \"\\
"
;

84
include/boost/move/detail/meta_utils.hpp
View File

@@ -313,6 +313,15 @@ struct add_lvalue_reference<const volatile void>
typedef const volatile void type;
};
template<class T>
struct add_const_lvalue_reference
{
typedef typename remove_reference<T>::type t_unreferenced;
typedef typename add_const<t_unreferenced>::type t_unreferenced_const;
typedef typename add_lvalue_reference
<t_unreferenced_const>::type type;
};
//////////////////////////////////////
// is_same
@@ -483,7 +492,8 @@ struct pointer_type_imp<T, D, false>
template <class T, class D>
struct pointer_type
{
typedef typename pointer_type_imp<T, typename remove_reference<D>::type>::type type;
typedef typename pointer_type_imp
<typename remove_extent<T>::type, typename remove_reference<D>::type>::type type;
};
//////////////////////////////////////
@@ -517,7 +527,7 @@ class is_convertible
#endif
//////////////////////////////////////
// is_unary_or_binary_function
// is_unary_function
//////////////////////////////////////
#if defined(BOOST_MSVC) || defined(__BORLANDC_)
#define BOOST_MOVE_TT_DECL __cdecl
@@ -530,120 +540,86 @@ class is_convertible
#endif
template <typename T>
struct is_unary_or_binary_function_impl
struct is_unary_function_impl
{ static const bool value = false; };
// avoid duplicate definitions of is_unary_or_binary_function_impl
// avoid duplicate definitions of is_unary_function_impl
#ifndef BOOST_MOVE_TT_TEST_MSC_FUNC_SIGS
template <typename R>
struct is_unary_or_binary_function_impl<R (*)()>
struct is_unary_function_impl<R (*)()>
{ static const bool value = true; };
template <typename R>
struct is_unary_or_binary_function_impl<R (*)(...)>
struct is_unary_function_impl<R (*)(...)>
{ static const bool value = true; };
#else // BOOST_MOVE_TT_TEST_MSC_FUNC_SIGS
template <typename R>
struct is_unary_or_binary_function_impl<R (__stdcall*)()>
struct is_unary_function_impl<R (__stdcall*)()>
{ static const bool value = true; };
#ifndef _MANAGED
template <typename R>
struct is_unary_or_binary_function_impl<R (__fastcall*)()>
struct is_unary_function_impl<R (__fastcall*)()>
{ static const bool value = true; };
#endif
template <typename R>
struct is_unary_or_binary_function_impl<R (__cdecl*)()>
struct is_unary_function_impl<R (__cdecl*)()>
{ static const bool value = true; };
template <typename R>
struct is_unary_or_binary_function_impl<R (__cdecl*)(...)>
struct is_unary_function_impl<R (__cdecl*)(...)>
{ static const bool value = true; };
#endif
// avoid duplicate definitions of is_unary_or_binary_function_impl
// avoid duplicate definitions of is_unary_function_impl
#ifndef BOOST_MOVE_TT_TEST_MSC_FUNC_SIGS
template <typename R, class T0>
struct is_unary_or_binary_function_impl<R (*)(T0)>
struct is_unary_function_impl<R (*)(T0)>
{ static const bool value = true; };
template <typename R, class T0>
struct is_unary_or_binary_function_impl<R (*)(T0...)>
struct is_unary_function_impl<R (*)(T0...)>
{ static const bool value = true; };
#else // BOOST_MOVE_TT_TEST_MSC_FUNC_SIGS
template <typename R, class T0>
struct is_unary_or_binary_function_impl<R (__stdcall*)(T0)>
struct is_unary_function_impl<R (__stdcall*)(T0)>
{ static const bool value = true; };
#ifndef _MANAGED
template <typename R, class T0>
struct is_unary_or_binary_function_impl<R (__fastcall*)(T0)>
struct is_unary_function_impl<R (__fastcall*)(T0)>
{ static const bool value = true; };
#endif
template <typename R, class T0>
struct is_unary_or_binary_function_impl<R (__cdecl*)(T0)>
struct is_unary_function_impl<R (__cdecl*)(T0)>
{ static const bool value = true; };
template <typename R, class T0>
struct is_unary_or_binary_function_impl<R (__cdecl*)(T0...)>
struct is_unary_function_impl<R (__cdecl*)(T0...)>
{ static const bool value = true; };
#endif
// avoid duplicate definitions of is_unary_or_binary_function_impl
#ifndef BOOST_MOVE_TT_TEST_MSC_FUNC_SIGS
template <typename R, class T0, class T1>
struct is_unary_or_binary_function_impl<R (*)(T0, T1)>
{ static const bool value = true; };
template <typename R, class T0, class T1>
struct is_unary_or_binary_function_impl<R (*)(T0, T1...)>
{ static const bool value = true; };
#else // BOOST_MOVE_TT_TEST_MSC_FUNC_SIGS
template <typename R, class T0, class T1>
struct is_unary_or_binary_function_impl<R (__stdcall*)(T0, T1)>
{ static const bool value = true; };
#ifndef _MANAGED
template <typename R, class T0, class T1>
struct is_unary_or_binary_function_impl<R (__fastcall*)(T0, T1)>
{ static const bool value = true; };
#endif
template <typename R, class T0, class T1>
struct is_unary_or_binary_function_impl<R (__cdecl*)(T0, T1)>
{ static const bool value = true; };
template <typename R, class T0, class T1>
struct is_unary_or_binary_function_impl<R (__cdecl*)(T0, T1...)>
{ static const bool value = true; };
#endif
template <typename T>
struct is_unary_or_binary_function_impl<T&>
struct is_unary_function_impl<T&>
{ static const bool value = false; };
template<typename T>
struct is_unary_or_binary_function
{ static const bool value = is_unary_or_binary_function_impl<T>::value; };
struct is_unary_function
{ static const bool value = is_unary_function_impl<T>::value; };
} //namespace move_detail {
} //namespace boost {

4
include/boost/move/detail/workaround.hpp
View File

@@ -20,6 +20,10 @@
//Macros for documentation purposes. For code, expands to the argument
#define BOOST_MOVE_IMPDEF(TYPE) TYPE
#define BOOST_MOVE_SEEDOC(TYPE) TYPE
#define BOOST_MOVE_DOC0PTR(TYPE) TYPE
#define BOOST_MOVE_DOC1ST(TYPE1, TYPE2) TYPE2
#define BOOST_MOVE_I ,
#define BOOST_MOVE_DOCIGN(T1) T1
#include <boost/intrusive/detail/config_end.hpp>

904
include/boost/move/unique_ptr.hpp
View File

File diff suppressed because it is too large Load Diff

144
test/unique_ptr.cpp
View File

@@ -10,8 +10,6 @@
// See http://www.boost.org/libs/move for documentation.
//
//////////////////////////////////////////////////////////////////////////////
#include <boost/move/detail/config_begin.hpp>
#include <boost/move/utility_core.hpp>
#include <boost/move/unique_ptr.hpp>
#include <boost/static_assert.hpp>
@@ -511,17 +509,22 @@ void test()
} //unique_ptr_asgn_move01
////////////////////////////////
// unique_ptr_asgn_null
// unique_ptr_zero
////////////////////////////////
namespace unique_ptr_asgn_null {
namespace unique_ptr_zero {
// test assignment from null
// test initialization/assignment from zero
void test()
{
//Single unique_ptr
reset_counters();
{
bml::unique_ptr<A> s2(0);
BOOST_TEST(A::count == 0);
}
BOOST_TEST(A::count == 0);
{
bml::unique_ptr<A> s2(new A);
BOOST_TEST(A::count == 1);
s2 = 0;
@@ -532,6 +535,11 @@ void test()
//Array unique_ptr
{
bml::unique_ptr<A[]> s2(0);
BOOST_TEST(A::count == 0);
}
BOOST_TEST(A::count == 0);
{
bml::unique_ptr<A[]> s2(new A[2]);
BOOST_TEST(A::count == 2);
s2 = 0;
@@ -541,8 +549,7 @@ void test()
BOOST_TEST(A::count == 0);
}
} //namespace unique_ptr_asgn_null {
} //namespace unique_ptr_zero {
////////////////////////////////
@@ -1476,7 +1483,7 @@ void test()
{
//Single unique_ptr
reset_counters();
{
{ //reset()
bml::unique_ptr<A> p(new A);
BOOST_TEST(A::count == 1);
A* i = p.get();
@@ -1486,7 +1493,7 @@ void test()
BOOST_TEST(p.get() == 0);
}
BOOST_TEST(A::count == 0);
{
{ //reset(p)
bml::unique_ptr<A> p(new A);
BOOST_TEST(A::count == 1);
A* i = p.get();
@@ -1495,9 +1502,19 @@ void test()
BOOST_TEST(A::count == 1);
}
BOOST_TEST(A::count == 0);
{ //reset(0)
bml::unique_ptr<A> p(new A);
BOOST_TEST(A::count == 1);
A* i = p.get();
(void)i;
p.reset(0);
BOOST_TEST(A::count == 0);
BOOST_TEST(p.get() == 0);
}
BOOST_TEST(A::count == 0);
//Array unique_ptr
reset_counters();
{
{ //reset()
bml::unique_ptr<A[]> p(new A[2]);
BOOST_TEST(A::count == 2);
A* i = p.get();
@@ -1507,7 +1524,7 @@ void test()
BOOST_TEST(p.get() == 0);
}
BOOST_TEST(A::count == 0);
{
{ //reset(p)
bml::unique_ptr<A[]> p(new A[2]);
BOOST_TEST(A::count == 2);
A* i = p.get();
@@ -1516,6 +1533,16 @@ void test()
BOOST_TEST(A::count == 3);
}
BOOST_TEST(A::count == 0);
{ //reset(0)
bml::unique_ptr<A[]> p(new A[2]);
BOOST_TEST(A::count == 2);
A* i = p.get();
(void)i;
p.reset(0);
BOOST_TEST(A::count == 0);
BOOST_TEST(p.get() == 0);
}
BOOST_TEST(A::count == 0);
}
} //namespace unique_ptr_modifiers_reset1{
@@ -1820,6 +1847,92 @@ void test()
} //namespace unique_ptr_observers_op_index{
////////////////////////////////
// unique_ptr_nullptr
////////////////////////////////
namespace unique_ptr_nullptr{
void test()
{
#if !defined(BOOST_NO_CXX11_NULLPTR)
//Single unique_ptr
reset_counters();
{
bml::unique_ptr<A> p(new A);
BOOST_TEST(A::count == 1);
A* i = p.get();
(void)i;
p.reset(nullptr);
BOOST_TEST(A::count == 0);
BOOST_TEST(p.get() == 0);
}
BOOST_TEST(A::count == 0);
{
bml::unique_ptr<A> p(new A);
BOOST_TEST(A::count == 1);
A* i = p.get();
(void)i;
p = nullptr;
BOOST_TEST(A::count == 0);
BOOST_TEST(p.get() == 0);
}
BOOST_TEST(A::count == 0);
{
bml::unique_ptr<A> pi(nullptr);
BOOST_TEST(pi.get() == nullptr);
BOOST_TEST(pi.get() == 0);
}
BOOST_TEST(A::count == 0);
{
bml::unique_ptr<A> pi(nullptr, bml::unique_ptr<A>::deleter_type());
BOOST_TEST(pi.get() == nullptr);
BOOST_TEST(pi.get() == 0);
}
BOOST_TEST(A::count == 0);
//Array unique_ptr
reset_counters();
{
bml::unique_ptr<A[]> p(new A[2]);
BOOST_TEST(A::count == 2);
A* i = p.get();
(void)i;
p.reset(nullptr);
BOOST_TEST(A::count == 0);
BOOST_TEST(p.get() == 0);
}
BOOST_TEST(A::count == 0);
{
bml::unique_ptr<A[]> p(new A[2]);
BOOST_TEST(A::count == 2);
A* i = p.get();
(void)i;
p = nullptr;
BOOST_TEST(A::count == 0);
BOOST_TEST(p.get() == 0);
}
BOOST_TEST(A::count == 0);
{
bml::unique_ptr<A[]> pi(nullptr);
BOOST_TEST(pi.get() == nullptr);
BOOST_TEST(pi.get() == 0);
}
BOOST_TEST(A::count == 0);
{
bml::unique_ptr<A[]> pi(nullptr, bml::unique_ptr<A[]>::deleter_type());
BOOST_TEST(pi.get() == nullptr);
BOOST_TEST(pi.get() == 0);
}
BOOST_TEST(A::count == 0);
//Array element
#endif
}
} //namespace unique_ptr_nullptr{
////////////////////////////////
// main
////////////////////////////////
@@ -1833,7 +1946,6 @@ int main()
unique_ptr_asgn_move_convert02::test();
unique_ptr_asgn_move_convert03::test();
unique_ptr_asgn_move01::test();
unique_ptr_asgn_null::test();
//Constructor
unique_ptr_ctor_default01::test();
@@ -1873,8 +1985,13 @@ int main()
unique_ptr_observers_op_arrow::test();
unique_ptr_observers_op_index::test();
//nullptr
unique_ptr_zero::test();
unique_ptr_nullptr::test();
//Test results
return boost::report_errors();
}
//Define the incomplete I type and out of line functions
@@ -1902,6 +2019,3 @@ J<T, D>::~J() {}
void reset_counters()
{ A::count = 0; B::count = 0; I::count = 0; }
#include <boost/move/detail/config_end.hpp>

4
test/unique_ptr_default_deleter.cpp
View File

@@ -10,8 +10,6 @@
// See http://www.boost.org/libs/move for documentation.
//
//////////////////////////////////////////////////////////////////////////////
#include <boost/move/detail/config_begin.hpp>
#include <boost/move/unique_ptr.hpp>
#include <boost/core/lightweight_test.hpp>
@@ -130,5 +128,3 @@ int main()
//Test results
return boost::report_errors();
}
#include <boost/move/detail/config_end.hpp>

121
test/unique_ptr_functions.cpp
View File

@@ -9,7 +9,6 @@
// See http://www.boost.org/libs/move for documentation.
//
//////////////////////////////////////////////////////////////////////////////
#include <boost/move/detail/config_begin.hpp>
#include <boost/move/make_unique.hpp>
#include <boost/core/lightweight_test.hpp>
@@ -135,30 +134,135 @@ void test()
//Equal
BOOST_TEST(rpl == rpl && rpl.get() == rpl.get());
BOOST_TEST(!(rpl == rpg) && !(rpl.get() != rpg.get()));
BOOST_TEST(!(rpl == rpg) && !(rpl.get() == rpg.get()));
//Unequal
BOOST_TEST(rpl != rpg && rpl.get() != rpg.get());
BOOST_TEST(!(rpl != rpl) && !(rpl.get() != rpl.get()));
//Less
BOOST_TEST(rpl < rpg && rpl.get() < rpg.get());
BOOST_TEST(!(rpl < rpg) && !(rpl.get() < rpg.get()));
BOOST_TEST(!(rpg < rpl) && !(rpg.get() < rpl.get()));
//Greater
BOOST_TEST(rpg > rpl && rpg.get() > rpl.get());
BOOST_TEST(!(rpg > rpg) && !(rpg.get() > rpl.get()));
BOOST_TEST(!(rpg > rpg) && !(rpg.get() > rpg.get()));
//Less or equal
BOOST_TEST(rpl <= rpg && rpl.get() <= rpg.get());
BOOST_TEST(rpl <= rpl && rpl.get() <= rpl.get());
BOOST_TEST(!(rpg <= rpl) && !(rpg.get() < rpl.get()));
BOOST_TEST(!(rpg <= rpl) && !(rpg.get() <= rpl.get()));
//Greater or equal
BOOST_TEST(rpg >= rpl && rpg.get() >= rpl.get());
BOOST_TEST(rpg >= rpg && rpg.get() >= rpg.get());
BOOST_TEST(!(rpl >= rpg) && !(rpl.get() < rpg.get()));
BOOST_TEST(!(rpl >= rpg) && !(rpl.get() >= rpg.get()));
}
BOOST_TEST(A::count == 0);
}
} //namespace unique_compare{
////////////////////////////////
// unique_compare_zero
////////////////////////////////
namespace unique_compare_zero{
void test()
{
//Single element deleter
reset_counters();
{
bml::unique_ptr<A> pa(bml::make_unique<A>());
bml::unique_ptr<A> pb;
BOOST_TEST(A::count == 1);
//Equal
BOOST_TEST(!(pa == 0));
BOOST_TEST(!(0 == pa));
BOOST_TEST((pb == 0));
BOOST_TEST((0 == pb));
//Unequal
BOOST_TEST((pa != 0));
BOOST_TEST((0 != pa));
BOOST_TEST(!(pb != 0));
BOOST_TEST(!(0 != pb));
//Less
BOOST_TEST((pa < 0) == (pa.get() < 0));
BOOST_TEST((0 < pa) == (0 < pa.get()));
BOOST_TEST((pb < 0) == (pb.get() < 0));
BOOST_TEST((0 < pb) == (0 < pb.get()));
//Greater
BOOST_TEST((pa > 0) == (pa.get() > 0));
BOOST_TEST((0 > pa) == (0 > pa.get()));
BOOST_TEST((pb > 0) == (pb.get() > 0));
BOOST_TEST((0 > pb) == (0 > pb.get()));
//Less or equal
BOOST_TEST((pa <= 0) == (pa.get() <= 0));
BOOST_TEST((0 <= pa) == (0 <= pa.get()));
BOOST_TEST((pb <= 0) == (pb.get() <= 0));
BOOST_TEST((0 <= pb) == (0 <= pb.get()));
//Greater or equal
BOOST_TEST((pa >= 0) == (pa.get() >= 0));
BOOST_TEST((0 >= pa) == (0 >= pa.get()));
BOOST_TEST((pb >= 0) == (pb.get() >= 0));
BOOST_TEST((0 >= pb) == (0 >= pb.get()));
}
BOOST_TEST(A::count == 0);
}
} //namespace unique_compare_zero{
////////////////////////////////
// unique_compare_nullptr
////////////////////////////////
namespace unique_compare_nullptr{
void test()
{
#if !defined(BOOST_NO_CXX11_NULLPTR)
//Single element deleter
reset_counters();
{
bml::unique_ptr<A> pa(bml::make_unique<A>());
bml::unique_ptr<A> pb;
BOOST_TEST(A::count == 1);
//Equal
BOOST_TEST(!(pa == nullptr));
BOOST_TEST(!(nullptr == pa));
BOOST_TEST((pb == nullptr));
BOOST_TEST((nullptr == pb));
//Unequal
BOOST_TEST((pa != nullptr));
BOOST_TEST((nullptr != pa));
BOOST_TEST(!(pb != nullptr));
BOOST_TEST(!(nullptr != pb));
//Less
BOOST_TEST((pa < nullptr) == (pa.get() < nullptr));
BOOST_TEST((nullptr < pa) == (nullptr < pa.get()));
BOOST_TEST((pb < nullptr) == (pb.get() < nullptr));
BOOST_TEST((nullptr < pb) == (nullptr < pb.get()));
//Greater
BOOST_TEST((pa > nullptr) == (pa.get() > nullptr));
BOOST_TEST((nullptr > pa) == (nullptr > pa.get()));
BOOST_TEST((pb > nullptr) == (pb.get() > nullptr));
BOOST_TEST((nullptr > pb) == (nullptr > pb.get()));
//Less or equal
BOOST_TEST((pa <= nullptr) == (pa.get() <= nullptr));
BOOST_TEST((nullptr <= pa) == (nullptr <= pa.get()));
BOOST_TEST((pb <= nullptr) == (pb.get() <= nullptr));
BOOST_TEST((nullptr <= pb) == (nullptr <= pb.get()));
//Greater or equal
BOOST_TEST((pa >= nullptr) == (pa.get() >= nullptr));
BOOST_TEST((nullptr >= pa) == (nullptr >= pa.get()));
BOOST_TEST((pb >= nullptr) == (pb.get() >= nullptr));
BOOST_TEST((nullptr >= pb) == (nullptr >= pb.get()));
}
BOOST_TEST(A::count == 0);
#endif //#if !defined(BOOST_NO_CXX11_NULLPTR)
}
} //namespace unique_compare_nullptr{
////////////////////////////////
// main
////////////////////////////////
@@ -166,9 +270,10 @@ int main()
{
make_unique_single::test();
make_unique_array::test();
unique_compare::test();
unique_compare_zero::test();
unique_compare_nullptr::test();
//Test results
return boost::report_errors();
}
#include <boost/move/detail/config_end.hpp>