//===----------------------------------------------------------------------===// // // 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. // //===----------------------------------------------------------------------===// // // template class tuple; // template // tuple(allocator_arg_t, const Alloc& a, UTypes&&...); // UNSUPPORTED: c++98, c++03 #include #include #include "MoveOnly.h" #include "allocators.h" #include "../alloc_first.h" #include "../alloc_last.h" struct NoDefault { NoDefault() = delete; }; // Make sure the _Up... constructor SFINAEs out when the types that // are not explicitly initialized are not all default constructible. // Otherwise, std::is_constructible would return true but instantiating // the constructor would fail. void test_default_constructible_extension_sfinae() { { typedef std::tuple Tuple; static_assert(!std::is_constructible< Tuple, std::allocator_arg_t, A1, MoveOnly >::value, ""); static_assert(std::is_constructible< Tuple, std::allocator_arg_t, A1, MoveOnly, NoDefault >::value, ""); } { typedef std::tuple Tuple; static_assert(!std::is_constructible< Tuple, std::allocator_arg_t, A1, MoveOnly, MoveOnly >::value, ""); static_assert(std::is_constructible< Tuple, std::allocator_arg_t, A1, MoveOnly, MoveOnly, NoDefault >::value, ""); } { // Same idea as above but with a nested tuple typedef std::tuple Tuple; typedef std::tuple NestedTuple; static_assert(!std::is_constructible< NestedTuple, std::allocator_arg_t, A1, MoveOnly, MoveOnly, MoveOnly, MoveOnly >::value, ""); static_assert(std::is_constructible< NestedTuple, std::allocator_arg_t, A1, MoveOnly, Tuple, MoveOnly, MoveOnly >::value, ""); } { typedef std::tuple Tuple; typedef std::tuple NestedTuple; static_assert(std::is_constructible< NestedTuple, std::allocator_arg_t, A1, MoveOnly, MoveOnly, MoveOnly, MoveOnly >::value, ""); static_assert(std::is_constructible< NestedTuple, std::allocator_arg_t, A1, MoveOnly, Tuple, MoveOnly, MoveOnly >::value, ""); } } int main() { { std::tuple t(std::allocator_arg, A1(), MoveOnly(0)); assert(std::get<0>(t) == 0); } { std::tuple t(std::allocator_arg, A1(), MoveOnly(0), MoveOnly(1)); assert(std::get<0>(t) == 0); assert(std::get<1>(t) == 1); } { std::tuple t(std::allocator_arg, A1(), MoveOnly(0), 1, 2); assert(std::get<0>(t) == 0); assert(std::get<1>(t) == 1); assert(std::get<2>(t) == 2); } { alloc_first::allocator_constructed = false; alloc_last::allocator_constructed = false; std::tuple t(std::allocator_arg, A1(5), 1, 2, 3); assert(std::get<0>(t) == 1); assert(alloc_first::allocator_constructed); assert(std::get<1>(t) == alloc_first(2)); assert(alloc_last::allocator_constructed); assert(std::get<2>(t) == alloc_last(3)); } // extensions { std::tuple t(std::allocator_arg, A1(), 0, 1); assert(std::get<0>(t) == 0); assert(std::get<1>(t) == 1); assert(std::get<2>(t) == MoveOnly()); } { std::tuple t(std::allocator_arg, A1(), 0); assert(std::get<0>(t) == 0); assert(std::get<1>(t) == MoveOnly()); assert(std::get<2>(t) == MoveOnly()); } // Check that SFINAE is properly applied with the default reduced arity // constructor extensions. test_default_constructible_extension_sfinae(); }