replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Make pair/tuples assignment operators SFINAE properly. 

llvm-svn: 276548
This commit is contained in:
Eric Fiselier 2016-07-24 05:51:11 +00:00
parent 2e99ae4f97
commit 904a5d7007
6 changed files with 312 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
libcxx/include/tuple
View File

@ -647,6 +647,9 @@ public:
_LIBCPP_CONSTEXPR tuple()
_NOEXCEPT_(__all<is_nothrow_default_constructible<_Tp>::value...>::value) {}
tuple(tuple const&) = default;
tuple(tuple&&) = default;
template <class _AllocArgT, class _Alloc, bool _Dummy = true, class = typename enable_if<
__lazy_and<
is_same<allocator_arg_t, _AllocArgT>,
@ -885,6 +888,25 @@ public:
tuple(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
: base_(allocator_arg_t(), __a, _VSTD::forward<_Tuple>(__t)) {}
using _CanCopyAssign = __all<is_copy_assignable<_Tp>::value...>;
using _CanMoveAssign = __all<is_move_assignable<_Tp>::value...>;
_LIBCPP_INLINE_VISIBILITY
tuple& operator=(typename conditional<_CanCopyAssign::value, tuple, __nat>::type const& __t)
_NOEXCEPT_((__all<is_nothrow_copy_assignable<_Tp>::value...>::value))
{
base_.operator=(__t.base_);
return *this;
}
_LIBCPP_INLINE_VISIBILITY
tuple& operator=(typename conditional<_CanMoveAssign::value, tuple, __nat>::type&& __t)
_NOEXCEPT_((__all<is_nothrow_move_assignable<_Tp>::value...>::value))
{
base_.operator=(static_cast<base&&>(__t.base_));
return *this;
}
template <class _Tuple,
class = typename enable_if
<

21
libcxx/include/utility
View File

@ -348,8 +348,15 @@ struct _LIBCPP_TYPE_VIS_ONLY pair
// Use the implicitly declared copy constructor in C++03
#endif
typedef typename remove_reference<_T1>::type _T1Unref;
typedef typename remove_reference<_T2>::type _T2Unref;
typedef integral_constant<bool,
is_copy_assignable<_T1>::value
&& is_copy_assignable<_T2>::value> _CanCopyAssign;
_LIBCPP_INLINE_VISIBILITY
pair& operator=(const pair& __p)
pair& operator=(typename conditional<_CanCopyAssign::value, pair, __nat>::type const& __p)
_NOEXCEPT_(is_nothrow_copy_assignable<first_type>::value &&
is_nothrow_copy_assignable<second_type>::value)
{
@ -377,10 +384,15 @@ struct _LIBCPP_TYPE_VIS_ONLY pair
: first(_VSTD::forward<_U1>(__p.first)),
second(_VSTD::forward<_U2>(__p.second)) {}
typedef integral_constant<bool,
is_move_assignable<_T1>::value
&& is_move_assignable<_T2>::value> _CanMoveAssign;
_LIBCPP_INLINE_VISIBILITY
pair&
operator=(pair&& __p) _NOEXCEPT_(is_nothrow_move_assignable<first_type>::value &&
is_nothrow_move_assignable<second_type>::value)
operator=(typename conditional<_CanMoveAssign::value, pair, __nat>::type&& __p)
_NOEXCEPT_(is_nothrow_move_assignable<first_type>::value &&
is_nothrow_move_assignable<second_type>::value)
{
first = _VSTD::forward<first_type>(__p.first);
second = _VSTD::forward<second_type>(__p.second);
@ -388,7 +400,6 @@ struct _LIBCPP_TYPE_VIS_ONLY pair
}
#ifndef _LIBCPP_HAS_NO_VARIADICS
template<class _Tuple,
class = typename enable_if<__tuple_convertible<_Tuple, pair>::value>::type>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
@ -411,7 +422,7 @@ struct _LIBCPP_TYPE_VIS_ONLY pair
{}
template <class _Tuple,
class = typename enable_if<__tuple_assignable<_Tuple, pair>::value>::type>
class = typename enable_if<!is_same<typename decay<_Tuple>::type, pair>::value && __tuple_assignable<_Tuple, pair>::value>::type>
_LIBCPP_INLINE_VISIBILITY
pair&
operator=(_Tuple&& __p)

49
libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/copy.pass.cpp
View File

@ -19,6 +19,22 @@
#include <string>
#include <cassert>
#include "test_macros.h"
struct NonAssignable {
NonAssignable& operator=(NonAssignable const&) = delete;
NonAssignable& operator=(NonAssignable&&) = delete;
};
struct CopyAssignable {
CopyAssignable& operator=(CopyAssignable const&) = default;
CopyAssignable& operator=(CopyAssignable &&) = delete;
};
static_assert(std::is_copy_assignable<CopyAssignable>::value, "");
struct MoveAssignable {
MoveAssignable& operator=(MoveAssignable const&) = delete;
MoveAssignable& operator=(MoveAssignable&&) = default;
};
int main()
{
{
@ -51,4 +67,37 @@ int main()
assert(std::get<1>(t) == 'a');
assert(std::get<2>(t) == "some text");
}
{
// test reference assignment.
using T = std::tuple<int&, int&&>;
int x = 42;
int y = 100;
int x2 = -1;
int y2 = 500;
T t(x, std::move(y));
T t2(x2, std::move(y2));
t = t2;
assert(std::get<0>(t) == x2);
assert(&std::get<0>(t) == &x);
assert(std::get<1>(t) == y2);
assert(&std::get<1>(t) == &y);
}
{
// test that the implicitly generated copy assignment operator
// is properly deleted
using T = std::tuple<std::unique_ptr<int>>;
static_assert(!std::is_copy_assignable<T>::value, "");
}
{
using T = std::tuple<int, NonAssignable>;
static_assert(!std::is_copy_assignable<T>::value, "");
}
{
using T = std::tuple<int, CopyAssignable>;
static_assert(std::is_copy_assignable<T>::value, "");
}
{
using T = std::tuple<int, MoveAssignable>;
static_assert(!std::is_copy_assignable<T>::value, "");
}
}

69
libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/move.pass.cpp
View File

@ -21,6 +21,33 @@
#include "MoveOnly.h"
struct NonAssignable {
NonAssignable& operator=(NonAssignable const&) = delete;
NonAssignable& operator=(NonAssignable&&) = delete;
};
struct CopyAssignable {
CopyAssignable& operator=(CopyAssignable const&) = default;
CopyAssignable& operator=(CopyAssignable&&) = delete;
};
static_assert(std::is_copy_assignable<CopyAssignable>::value, "");
struct MoveAssignable {
MoveAssignable& operator=(MoveAssignable const&) = delete;
MoveAssignable& operator=(MoveAssignable&&) = default;
};
struct CountAssign {
static int copied;
static int moved;
static void reset() { copied = moved = 0; }
CountAssign() = default;
CountAssign& operator=(CountAssign const&) { ++copied; return *this; }
CountAssign& operator=(CountAssign&&) { ++moved; return *this; }
};
int CountAssign::copied = 0;
int CountAssign::moved = 0;
int main()
{
{
@ -53,4 +80,46 @@ int main()
assert(std::get<1>(t) == 1);
assert(std::get<2>(t) == 2);
}
{
// test reference assignment.
using T = std::tuple<int&, int&&>;
int x = 42;
int y = 100;
int x2 = -1;
int y2 = 500;
T t(x, std::move(y));
T t2(x2, std::move(y2));
t = std::move(t2);
assert(std::get<0>(t) == x2);
assert(&std::get<0>(t) == &x);
assert(std::get<1>(t) == y2);
assert(&std::get<1>(t) == &y);
}
{
// test that the implicitly generated move assignment operator
// is properly deleted
using T = std::tuple<std::unique_ptr<int>>;
static_assert(std::is_move_assignable<T>::value, "");
static_assert(!std::is_copy_assignable<T>::value, "");
}
{
using T = std::tuple<int, NonAssignable>;
static_assert(!std::is_move_assignable<T>::value, "");
}
{
using T = std::tuple<int, MoveAssignable>;
static_assert(std::is_move_assignable<T>::value, "");
}
{
// The move should decay to a copy.
CountAssign::reset();
using T = std::tuple<CountAssign, CopyAssignable>;
static_assert(std::is_move_assignable<T>::value, "");
T t1;
T t2;
t1 = std::move(t2);
assert(CountAssign::copied == 1);
assert(CountAssign::moved == 0);
}
}

90
libcxx/test/std/utilities/utility/pairs/pairs.pair/assign_pair.pass.cpp Normal file
View File

@ -0,0 +1,90 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <utility>
// template <class T1, class T2> struct pair
// pair& operator=(pair const& p);
#include <utility>
#include <memory>
#include <cassert>
struct NonAssignable {
NonAssignable& operator=(NonAssignable const&) = delete;
NonAssignable& operator=(NonAssignable&&) = delete;
};
struct CopyAssignable {
CopyAssignable() = default;
CopyAssignable(CopyAssignable const&) = default;
CopyAssignable& operator=(CopyAssignable const&) = default;
CopyAssignable& operator=(CopyAssignable&&) = delete;
};
struct MoveAssignable {
MoveAssignable() = default;
MoveAssignable& operator=(MoveAssignable const&) = delete;
MoveAssignable& operator=(MoveAssignable&&) = default;
};
struct CountAssign {
static int copied;
static int moved;
static void reset() { copied = moved = 0; }
CountAssign() = default;
CountAssign& operator=(CountAssign const&) { ++copied; return *this; }
CountAssign& operator=(CountAssign&&) { ++moved; return *this; }
};
int CountAssign::copied = 0;
int CountAssign::moved = 0;
int main()
{
{
typedef std::pair<CopyAssignable, short> P;
const P p1(CopyAssignable(), 4);
P p2;
p2 = p1;
assert(p2.second == 4);
}
{
using P = std::pair<int&, int&&>;
int x = 42;
int y = 101;
int x2 = -1;
int y2 = 300;
P p1(x, std::move(y));
P p2(x2, std::move(y2));
p1 = p2;
assert(p1.first == x2);
assert(p1.second == y2);
}
{
using P = std::pair<int, NonAssignable>;
static_assert(!std::is_copy_assignable<P>::value, "");
}
{
CountAssign::reset();
using P = std::pair<CountAssign, CopyAssignable>;
static_assert(std::is_copy_assignable<P>::value, "");
P p;
P p2;
p = p2;
assert(CountAssign::copied == 1);
assert(CountAssign::moved == 0);
}
{
using P = std::pair<int, MoveAssignable>;
static_assert(!std::is_copy_assignable<P>::value, "");
}
}

68
libcxx/test/std/utilities/utility/pairs/pairs.pair/assign_rv_pair.pass.cpp
View File

@ -7,6 +7,8 @@
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <utility>
// template <class T1, class T2> struct pair
@ -17,9 +19,35 @@
#include <memory>
#include <cassert>
struct NonAssignable {
NonAssignable& operator=(NonAssignable const&) = delete;
NonAssignable& operator=(NonAssignable&&) = delete;
};
struct CopyAssignable {
CopyAssignable() = default;
CopyAssignable& operator=(CopyAssignable const&) = default;
CopyAssignable& operator=(CopyAssignable&&) = delete;
};
struct MoveAssignable {
MoveAssignable() = default;
MoveAssignable& operator=(MoveAssignable const&) = delete;
MoveAssignable& operator=(MoveAssignable&&) = default;
};
struct CountAssign {
static int copied;
static int moved;
static void reset() { copied = moved = 0; }
CountAssign() = default;
CountAssign& operator=(CountAssign const&) { ++copied; return *this; }
CountAssign& operator=(CountAssign&&) { ++moved; return *this; }
};
int CountAssign::copied = 0;
int CountAssign::moved = 0;
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
{
typedef std::pair<std::unique_ptr<int>, short> P;
P p1(std::unique_ptr<int>(new int(3)), 4);
@ -28,5 +56,41 @@ int main()
assert(*p2.first == 3);
assert(p2.second == 4);
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
{
using P = std::pair<int&, int&&>;
int x = 42;
int y = 101;
int x2 = -1;
int y2 = 300;
P p1(x, std::move(y));
P p2(x2, std::move(y2));
p1 = std::move(p2);
assert(p1.first == x2);
assert(p1.second == y2);
}
{
using P = std::pair<int, NonAssignable>;
static_assert(!std::is_move_assignable<P>::value, "");
}
{
// The move decays to the copy constructor
CountAssign::reset();
using P = std::pair<CountAssign, CopyAssignable>;
static_assert(std::is_move_assignable<P>::value, "");
P p;
P p2;
p = std::move(p2);
assert(CountAssign::moved == 0);
assert(CountAssign::copied == 1);
}
{
CountAssign::reset();
using P = std::pair<CountAssign, MoveAssignable>;
static_assert(std::is_move_assignable<P>::value, "");
P p;
P p2;
p = std::move(p2);
assert(CountAssign::moved == 1);
assert(CountAssign::copied == 0);
}
}