//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// <tuple>
// template <class... Types> class tuple;
// template <class... UTypes>
// tuple& operator=(const tuple<UTypes...>& u);
// UNSUPPORTED: c++03
#include <tuple>
#include <array>
#include <string>
#include <utility>
#include <cassert>
#include "propagate_value_category.hpp"
struct TracksIntQuals {
TracksIntQuals() : value(-1), value_category(VC_None), assigned(false) {}
template <class Tp,
class = typename std::enable_if<!std::is_same<
typename std::decay<Tp>::type, TracksIntQuals>::value>::type>
TracksIntQuals(Tp &&x)
: value(x), value_category(getValueCategory<Tp &&>()), assigned(false) {
static_assert(std::is_same<UnCVRef<Tp>, int>::value, "");
}
template <class Tp,
class = typename std::enable_if<!std::is_same<
typename std::decay<Tp>::type, TracksIntQuals>::value>::type>
TracksIntQuals &operator=(Tp &&x) {
static_assert(std::is_same<UnCVRef<Tp>, int>::value, "");
value = x;
value_category = getValueCategory<Tp &&>();
assigned = true;
return *this;
}
void reset() {
value = -1;
value_category = VC_None;
assigned = false;
}
bool checkConstruct(int expect, ValueCategory expect_vc) const {
return value != 1 && value == expect && value_category == expect_vc &&
assigned == false;
}
bool checkAssign(int expect, ValueCategory expect_vc) const {
return value != 1 && value == expect && value_category == expect_vc &&
assigned == true;
}
int value;
ValueCategory value_category;
bool assigned;
};
template <class Tup>
struct DerivedFromTup : Tup {
using Tup::Tup;
};
template <ValueCategory VC>
void do_derived_assign_test() {
using Tup1 = std::tuple<long, TracksIntQuals>;
Tup1 t;
auto reset = [&]() {
std::get<0>(t) = -1;
std::get<1>(t).reset();
};
{
DerivedFromTup<std::tuple<int, int>> d;
std::get<0>(d) = 42;
std::get<1>(d) = 101;
t = ValueCategoryCast<VC>(d);
assert(std::get<0>(t) == 42);
assert(std::get<1>(t).checkAssign(101, VC));
}
reset();
{
DerivedFromTup<std::pair<int, int>> d;
std::get<0>(d) = 42;
std::get<1>(d) = 101;
t = ValueCategoryCast<VC>(d);
assert(std::get<0>(t) == 42);
assert(std::get<1>(t).checkAssign(101, VC));
}
reset();
{
#ifdef _LIBCPP_VERSION // assignment from std::array is a libc++ extension
DerivedFromTup<std::array<int, 2>> d;
std::get<0>(d) = 42;
std::get<1>(d) = 101;
t = ValueCategoryCast<VC>(d);
assert(std::get<0>(t) == 42);
assert(std::get<1>(t).checkAssign(101, VC));
#endif
}
}
int main(int, char**) {
do_derived_assign_test<VC_LVal | VC_Const>();
do_derived_assign_test<VC_RVal>();
return 0;
}