LineageOS/android_external_libcxx
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[libcxx] Add std::any

Browse Source 
Summary:
This patch adds std::any by moving/adapting <experimental/any>.

This patch also implements the std::any parts of p0032r3 (http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0032r3.pdf)
and LWG 2509 (http://cplusplus.github.io/LWG/lwg-defects.html#2509).

I plan to push it in a day or two if there are no comments.


Reviewers: mclow.lists, EricWF

Subscribers: cfe-commits

Differential Revision: https://reviews.llvm.org/D22733

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@278310 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Eric Fiselier
2016-08-11 03:13:11 +00:00
parent 2d08bc9a9f
commit e739d54f86
44 changed files with 3844 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files

215
test/support/any_helpers.h
View File

@@ -9,12 +9,14 @@
#ifndef ANY_HELPERS_H
#define ANY_HELPERS_H
#include <experimental/any>
#include <typeinfo>
#include <type_traits>
#include <cassert>
namespace std { namespace experimental {} }
#include "test_macros.h"
#include "type_id.h"
#if !defined(TEST_HAS_NO_RTTI)
#define RTTI_ASSERT(X) assert(X)
@@ -32,42 +34,55 @@ template <class _Tp>
>
{};
template <class T>
bool containsType(std::any const& a) {
#if !defined(TEST_HAS_NO_RTTI)
return a.type() == typeid(T);
#else
return a.has_value() && std::any_cast<T>(&a) != nullptr;
#endif
}
// Return 'true' if 'Type' will be considered a small type by 'any'
template <class Type>
bool isSmallType() {
#if defined(_LIBCPP_VERSION)
return std::experimental::__any_imp::_IsSmallObject<Type>::value;
#else
return IsSmallObject<Type>::value;
#endif
}
// Assert that an object is empty. If the object used to contain an object
// of type 'LastType' check that it can no longer be accessed.
template <class LastType = int>
void assertEmpty(std::experimental::any const& a) {
assert(a.empty());
void assertEmpty(std::any const& a) {
using namespace std;
assert(!a.has_value());
RTTI_ASSERT(a.type() == typeid(void));
assert(std::experimental::any_cast<LastType const>(&a) == nullptr);
assert(any_cast<LastType const>(&a) == nullptr);
}
// Assert that an 'any' object stores the specified 'Type' and 'value'.
template <class Type>
void assertContains(std::experimental::any const& a, int value = 1) {
assert(!a.empty());
RTTI_ASSERT(a.type() == typeid(Type));
assert(std::experimental::any_cast<Type const &>(a).value == value);
void assertContains(std::any const& a, int value = 1) {
assert(a.has_value());
assert(containsType<Type>(a));
assert(std::any_cast<Type const &>(a).value == value);
}
template <>
void assertContains<int>(std::any const& a, int value) {
assert(a.has_value());
assert(containsType<int>(a));
assert(std::any_cast<int const &>(a) == value);
}
// Modify the value of a "test type" stored within an any to the specified
// 'value'.
template <class Type>
void modifyValue(std::experimental::any& a, int value) {
assert(!a.empty());
RTTI_ASSERT(a.type() == typeid(Type));
std::experimental::any_cast<Type&>(a).value = value;
void modifyValue(std::any& a, int value) {
using namespace std;
using namespace std::experimental;
assert(a.has_value());
assert(containsType<Type>(a));
any_cast<Type&>(a).value = value;
}
// A test type that will trigger the small object optimization within 'any'.
@@ -89,25 +104,31 @@ struct small_type
int value;
explicit small_type(int val) : value(val) {
explicit small_type(int val = 0) : value(val) {
++count;
}
explicit small_type(int, int val, int) : value(val) {
++count;
}
small_type(std::initializer_list<int> il) : value(*il.begin()) {
++count;
}
small_type(small_type const & other) throw() {
small_type(small_type const & other) noexcept {
value = other.value;
++count;
++copied;
++const_copied;
}
small_type(small_type& other) throw() {
small_type(small_type& other) noexcept {
value = other.value;
++count;
++copied;
++non_const_copied;
}
small_type(small_type && other) throw() {
small_type(small_type && other) noexcept {
value = other.value;
other.value = 0;
++count;
@@ -163,11 +184,17 @@ struct large_type
int value;
large_type(int val) : value(val) {
large_type(int val = 0) : value(val) {
++count;
data[0] = 0;
}
large_type(int, int val, int) : value(val) {
++count;
data[0] = 0;
}
large_type(std::initializer_list<int> il) : value(*il.begin()) {
++count;
}
large_type(large_type const & other) {
value = other.value;
++count;
@@ -219,6 +246,67 @@ typedef large_type<> large;
typedef large_type<1> large1;
typedef large_type<2> large2;
struct deleted_move
{
static int count;
static int copied;
static int moved;
static int const_copied;
static int non_const_copied;
static void reset() {
deleted_move::copied = 0;
deleted_move::moved = 0;
deleted_move::const_copied = 0;
deleted_move::non_const_copied = 0;
}
int value;
explicit deleted_move(int val = 0) : value(val) {
++count;
}
explicit deleted_move(int, int val, int) : value(val) {
++count;
}
deleted_move(std::initializer_list<int> il) : value(*il.begin()) {
++count;
}
deleted_move(deleted_move const & other) noexcept {
value = other.value;
++count;
++copied;
++const_copied;
}
deleted_move(deleted_move& other) noexcept {
value = other.value;
++count;
++copied;
++non_const_copied;
}
deleted_move(deleted_move && other) = delete;
~deleted_move() {
value = -1;
--count;
}
private:
deleted_move& operator=(deleted_move const&) = delete;
deleted_move& operator=(deleted_move&&) = delete;
};
int deleted_move::count = 0;
int deleted_move::copied = 0;
int deleted_move::moved = 0;
int deleted_move::const_copied = 0;
int deleted_move::non_const_copied = 0;
// The exception type thrown by 'small_throws_on_copy', 'large_throws_on_copy'
// and 'throws_on_move'.
struct my_any_exception {};
@@ -236,19 +324,24 @@ void throwMyAnyExpression() {
struct small_throws_on_copy
{
static int count;
static int copied;
static int moved;
static void reset() { count = copied = moved = 0; }
int value;
explicit small_throws_on_copy(int val = 0) : value(val) {
++count;
}
explicit small_throws_on_copy(int, int val, int) : value(val) {
++count;
}
small_throws_on_copy(small_throws_on_copy const &) {
throwMyAnyExpression();
}
small_throws_on_copy(small_throws_on_copy && other) throw() {
value = other.value;
++count;
++count; ++moved;
}
~small_throws_on_copy() {
@@ -260,26 +353,35 @@ private:
};
int small_throws_on_copy::count = 0;
int small_throws_on_copy::copied = 0;
int small_throws_on_copy::moved = 0;
// A test type that will NOT trigger the small object optimization within 'any'.
// this type throws if it is copied.
struct large_throws_on_copy
{
static int count;
static int copied;
static int moved;
static void reset() { count = copied = moved = 0; }
int value = 0;
explicit large_throws_on_copy(int val = 0) : value(val) {
data[0] = 0;
++count;
}
explicit large_throws_on_copy(int, int val, int) : value(val) {
data[0] = 0;
++count;
}
large_throws_on_copy(large_throws_on_copy const &) {
throwMyAnyExpression();
}
large_throws_on_copy(large_throws_on_copy && other) throw() {
value = other.value;
++count;
++count; ++moved;
}
~large_throws_on_copy() {
@@ -293,19 +395,24 @@ private:
};
int large_throws_on_copy::count = 0;
int large_throws_on_copy::copied = 0;
int large_throws_on_copy::moved = 0;
// A test type that throws when it is moved. This object will NOT trigger
// the small object optimization in 'any'.
struct throws_on_move
{
static int count;
static int copied;
static int moved;
static void reset() { count = copied = moved = 0; }
int value;
explicit throws_on_move(int val = 0) : value(val) { ++count; }
explicit throws_on_move(int, int val, int) : value(val) { ++count; }
throws_on_move(throws_on_move const & other) {
value = other.value;
++count;
++count; ++copied;
}
throws_on_move(throws_on_move &&) {
@@ -321,6 +428,56 @@ private:
};
int throws_on_move::count = 0;
int throws_on_move::copied = 0;
int throws_on_move::moved = 0;
struct small_tracked_t {
small_tracked_t()
: arg_types(&makeArgumentID<>()) {}
small_tracked_t(small_tracked_t const&) noexcept
: arg_types(&makeArgumentID<small_tracked_t const&>()) {}
small_tracked_t(small_tracked_t &&) noexcept
: arg_types(&makeArgumentID<small_tracked_t &&>()) {}
template <class ...Args>
explicit small_tracked_t(Args&&...)
: arg_types(&makeArgumentID<Args...>()) {}
template <class ...Args>
explicit small_tracked_t(std::initializer_list<int>, Args&&...)
: arg_types(&makeArgumentID<std::initializer_list<int>, Args...>()) {}
TypeID const* arg_types;
};
static_assert(IsSmallObject<small_tracked_t>::value, "must be small");
struct large_tracked_t {
large_tracked_t()
: arg_types(&makeArgumentID<>()) { dummy[0] = 42; }
large_tracked_t(large_tracked_t const&) noexcept
: arg_types(&makeArgumentID<large_tracked_t const&>()) {}
large_tracked_t(large_tracked_t &&) noexcept
: arg_types(&makeArgumentID<large_tracked_t &&>()) {}
template <class ...Args>
explicit large_tracked_t(Args&&...)
: arg_types(&makeArgumentID<Args...>()) {}
template <class ...Args>
explicit large_tracked_t(std::initializer_list<int>, Args&&...)
: arg_types(&makeArgumentID<std::initializer_list<int>, Args...>()) {}
TypeID const* arg_types;
int dummy[10];
};
static_assert(!IsSmallObject<large_tracked_t>::value, "must be small");
template <class Type, class ...Args>
void assertArgsMatch(std::any const& a) {
using namespace std;
using namespace std::experimental;
assert(a.has_value());
assert(containsType<Type>(a));
assert(any_cast<Type const &>(a).arg_types == &makeArgumentID<Args...>());
};
#endif