Index: libcxx/trunk/include/set =================================================================== --- libcxx/trunk/include/set +++ libcxx/trunk/include/set @@ -446,7 +446,7 @@ typedef key_type value_type; typedef _Compare key_compare; typedef key_compare value_compare; - typedef _Allocator allocator_type; + typedef typename __identity<_Allocator>::type allocator_type; typedef value_type& reference; typedef const value_type& const_reference; @@ -840,6 +840,34 @@ #endif }; +#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES +template::value_type>, + class _Allocator = allocator::value_type>, + class = typename enable_if<__is_allocator<_Allocator>::value, void>::type, + class = typename enable_if::value, void>::type> +set(_InputIterator, _InputIterator, _Compare = _Compare(), _Allocator = _Allocator()) + -> set::value_type, _Compare, _Allocator>; + +template, + class _Allocator = allocator<_Key>, + class = typename enable_if<__is_allocator<_Allocator>::value, void>::type, + class = typename enable_if::value, void>::type> +set(initializer_list<_Key>, _Compare = _Compare(), _Allocator = _Allocator()) + -> set<_Key, _Compare, _Allocator>; + +template::value, void>::type> +set(_InputIterator, _InputIterator, _Allocator) + -> set::value_type, + less::value_type>, _Allocator>; + +template::value, void>::type> +set(initializer_list<_Key>, _Allocator) + -> set<_Key, less<_Key>, _Allocator>; +#endif + #ifndef _LIBCPP_CXX03_LANG template @@ -938,7 +966,7 @@ typedef key_type value_type; typedef _Compare key_compare; typedef key_compare value_compare; - typedef _Allocator allocator_type; + typedef typename __identity<_Allocator>::type allocator_type; typedef value_type& reference; typedef const value_type& const_reference; @@ -1332,6 +1360,34 @@ #endif }; +#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES +template::value_type>, + class _Allocator = allocator::value_type>, + class = typename enable_if<__is_allocator<_Allocator>::value, void>::type, + class = typename enable_if::value, void>::type> +multiset(_InputIterator, _InputIterator, _Compare = _Compare(), _Allocator = _Allocator()) + -> multiset::value_type, _Compare, _Allocator>; + +template, + class _Allocator = allocator<_Key>, + class = typename enable_if<__is_allocator<_Allocator>::value, void>::type, + class = typename enable_if::value, void>::type> +multiset(initializer_list<_Key>, _Compare = _Compare(), _Allocator = _Allocator()) + -> multiset<_Key, _Compare, _Allocator>; + +template::value, void>::type> +multiset(_InputIterator, _InputIterator, _Allocator) + -> multiset::value_type, + less::value_type>, _Allocator>; + +template::value, void>::type> +multiset(initializer_list<_Key>, _Allocator) + -> multiset<_Key, less<_Key>, _Allocator>; +#endif + #ifndef _LIBCPP_CXX03_LANG template Index: libcxx/trunk/test/std/containers/associative/multiset/multiset.cons/deduct.fail.cpp =================================================================== --- libcxx/trunk/test/std/containers/associative/multiset/multiset.cons/deduct.fail.cpp +++ libcxx/trunk/test/std/containers/associative/multiset/multiset.cons/deduct.fail.cpp @@ -0,0 +1,69 @@ +//===----------------------------------------------------------------------===// +// +// 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 +// +//===----------------------------------------------------------------------===// + +// +// UNSUPPORTED: c++98, c++03, c++11, c++14 +// UNSUPPORTED: libcpp-no-deduction-guides + +// template>, +// class Allocator = allocator>> +// multiset(InputIterator, InputIterator, +// Compare = Compare(), Allocator = Allocator()) +// -> multiset, Compare, Allocator>; +// template, +// class Allocator = allocator> +// multiset(initializer_list, Compare = Compare(), Allocator = Allocator()) +// -> multiset; +// template +// multiset(InputIterator, InputIterator, Allocator) +// -> multiset, +// less>, Allocator>; +// template +// multiset(initializer_list, Allocator) +// -> multiset, Allocator>; + +#include +#include +#include + +struct NotAnAllocator { + friend bool operator<(NotAnAllocator, NotAnAllocator) { return false; } +}; + +int main(int, char **) { + { + // cannot deduce Key from nothing + std::multiset s; + // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'multiset'}} + } + { + // cannot deduce Key from just (Compare) + std::multiset s(std::less{}); + // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'multiset'}} + } + { + // cannot deduce Key from just (Compare, Allocator) + std::multiset s(std::less{}, std::allocator{}); + // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'multiset'}} + } + { + // cannot deduce Key from multiset(Allocator) + std::multiset s(std::allocator{}); + // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'multiset'}} + } + { + // since we have parens, not braces, this deliberately does not find the + // initializer_list constructor + NotAnAllocator a; + std::multiset s(a); + // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'multiset'}} + } + + return 0; +} Index: libcxx/trunk/test/std/containers/associative/multiset/multiset.cons/deduct.pass.cpp =================================================================== --- libcxx/trunk/test/std/containers/associative/multiset/multiset.cons/deduct.pass.cpp +++ libcxx/trunk/test/std/containers/associative/multiset/multiset.cons/deduct.pass.cpp @@ -0,0 +1,190 @@ +//===----------------------------------------------------------------------===// +// +// 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 +// +//===----------------------------------------------------------------------===// + +// +// UNSUPPORTED: c++98, c++03, c++11, c++14 +// UNSUPPORTED: libcpp-no-deduction-guides + +// template>, +// class Allocator = allocator>> +// multiset(InputIterator, InputIterator, +// Compare = Compare(), Allocator = Allocator()) +// -> multiset, Compare, Allocator>; +// template, +// class Allocator = allocator> +// multiset(initializer_list, Compare = Compare(), Allocator = Allocator()) +// -> multiset; +// template +// multiset(InputIterator, InputIterator, Allocator) +// -> multiset, +// less>, Allocator>; +// template +// multiset(initializer_list, Allocator) +// -> multiset, Allocator>; + +#include // std::equal +#include +#include // INT_MAX +#include +#include +#include + +#include "test_allocator.h" + +struct NotAnAllocator { + friend bool operator<(NotAnAllocator, NotAnAllocator) { return false; } +}; + +int main(int, char **) { + { + const int arr[] = { 1, 2, 1, INT_MAX, 3 }; + std::multiset s(std::begin(arr), std::end(arr)); + + ASSERT_SAME_TYPE(decltype(s), std::multiset); + const int expected_s[] = { 1, 1, 2, 3, INT_MAX }; + assert(std::equal(s.begin(), s.end(), std::begin(expected_s), + std::end(expected_s))); + } + + { + const int arr[] = { 1, 2, 1, INT_MAX, 3 }; + std::multiset s(std::begin(arr), std::end(arr), std::greater()); + + ASSERT_SAME_TYPE(decltype(s), std::multiset >); + const int expected_s[] = { INT_MAX, 3, 2, 1, 1 }; + assert(std::equal(s.begin(), s.end(), std::begin(expected_s), + std::end(expected_s))); + } + + { + const int arr[] = { 1, 2, 1, INT_MAX, 3 }; + std::multiset s(std::begin(arr), std::end(arr), std::greater(), + test_allocator(0, 42)); + + ASSERT_SAME_TYPE( + decltype(s), + std::multiset, test_allocator >); + const int expected_s[] = { INT_MAX, 3, 2, 1, 1 }; + assert(std::equal(s.begin(), s.end(), std::begin(expected_s), + std::end(expected_s))); + assert(s.get_allocator().get_id() == 42); + } + + { + std::multiset source; + std::multiset s(source); + ASSERT_SAME_TYPE(decltype(s), std::multiset); + assert(s.size() == 0); + } + + { + std::multiset source; + std::multiset s{ source }; // braces instead of parens + ASSERT_SAME_TYPE(decltype(s), std::multiset); + assert(s.size() == 0); + } + + { + std::multiset source; + std::multiset s(source, std::multiset::allocator_type()); + ASSERT_SAME_TYPE(decltype(s), std::multiset); + assert(s.size() == 0); + } + + { + std::multiset s{ 1, 2, 1, INT_MAX, 3 }; + + ASSERT_SAME_TYPE(decltype(s), std::multiset); + const int expected_s[] = { 1, 1, 2, 3, INT_MAX }; + assert(std::equal(s.begin(), s.end(), std::begin(expected_s), + std::end(expected_s))); + } + + { + std::multiset s({ 1, 2, 1, INT_MAX, 3 }, std::greater()); + + ASSERT_SAME_TYPE(decltype(s), std::multiset >); + const int expected_s[] = { INT_MAX, 3, 2, 1, 1 }; + assert(std::equal(s.begin(), s.end(), std::begin(expected_s), + std::end(expected_s))); + } + + { + std::multiset s({ 1, 2, 1, INT_MAX, 3 }, std::greater(), + test_allocator(0, 43)); + + ASSERT_SAME_TYPE( + decltype(s), + std::multiset, test_allocator >); + const int expected_s[] = { INT_MAX, 3, 2, 1, 1 }; + assert(std::equal(s.begin(), s.end(), std::begin(expected_s), + std::end(expected_s))); + assert(s.get_allocator().get_id() == 43); + } + + { + const int arr[] = { 1, 2, 1, INT_MAX, 3 }; + std::multiset s(std::begin(arr), std::end(arr), test_allocator(0, 44)); + + ASSERT_SAME_TYPE(decltype(s), + std::multiset, test_allocator >); + const int expected_s[] = { 1, 1, 2, 3, INT_MAX }; + assert(std::equal(s.begin(), s.end(), std::begin(expected_s), + std::end(expected_s))); + assert(s.get_allocator().get_id() == 44); + } + + { + std::multiset s({ 1, 2, 1, INT_MAX, 3 }, test_allocator(0, 45)); + + ASSERT_SAME_TYPE(decltype(s), + std::multiset, test_allocator >); + const int expected_s[] = { 1, 1, 2, 3, INT_MAX }; + assert(std::equal(s.begin(), s.end(), std::begin(expected_s), + std::end(expected_s))); + assert(s.get_allocator().get_id() == 45); + } + + { + NotAnAllocator a; + std::multiset s{ a }; // multiset(initializer_list) + ASSERT_SAME_TYPE(decltype(s), std::multiset); + assert(s.size() == 1); + } + + { + std::multiset source; + std::multiset s{ source, source }; // multiset(initializer_list>) + ASSERT_SAME_TYPE(decltype(s), std::multiset >); + assert(s.size() == 2); + } + + { + NotAnAllocator a; + std::multiset s{ a, a }; // multiset(initializer_list) + ASSERT_SAME_TYPE(decltype(s), std::multiset); + assert(s.size() == 2); + } + + { + int source[3] = { 3, 4, 5 }; + std::multiset s(source, source + 3); // multiset(InputIterator, InputIterator) + ASSERT_SAME_TYPE(decltype(s), std::multiset); + assert(s.size() == 3); + } + + { + int source[3] = { 3, 4, 5 }; + std::multiset s{ source, source + 3 }; // multiset(initializer_list) + ASSERT_SAME_TYPE(decltype(s), std::multiset); + assert(s.size() == 2); + } + + return 0; +} Index: libcxx/trunk/test/std/containers/associative/set/set.cons/deduct.fail.cpp =================================================================== --- libcxx/trunk/test/std/containers/associative/set/set.cons/deduct.fail.cpp +++ libcxx/trunk/test/std/containers/associative/set/set.cons/deduct.fail.cpp @@ -0,0 +1,69 @@ +//===----------------------------------------------------------------------===// +// +// 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 +// +//===----------------------------------------------------------------------===// + +// +// UNSUPPORTED: c++98, c++03, c++11, c++14 +// UNSUPPORTED: libcpp-no-deduction-guides + +// template>, +// class Allocator = allocator>> +// set(InputIterator, InputIterator, +// Compare = Compare(), Allocator = Allocator()) +// -> set, Compare, Allocator>; +// template, +// class Allocator = allocator> +// set(initializer_list, Compare = Compare(), Allocator = Allocator()) +// -> set; +// template +// set(InputIterator, InputIterator, Allocator) +// -> set, +// less>, Allocator>; +// template +// set(initializer_list, Allocator) +// -> set, Allocator>; + +#include +#include +#include + +struct NotAnAllocator { + friend bool operator<(NotAnAllocator, NotAnAllocator) { return false; } +}; + +int main(int, char **) { + { + // cannot deduce Key from nothing + std::set s; + // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'set'}} + } + { + // cannot deduce Key from just (Compare) + std::set s(std::less{}); + // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'set'}} + } + { + // cannot deduce Key from just (Compare, Allocator) + std::set s(std::less{}, std::allocator{}); + // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'set'}} + } + { + // cannot deduce Key from just (Allocator) + std::set s(std::allocator{}); + // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'set'}} + } + { + // since we have parens, not braces, this deliberately does not find the + // initializer_list constructor + NotAnAllocator a; + std::set s(a); + // expected-error@-1{{no viable constructor or deduction guide for deduction of template arguments of 'set'}} + } + + return 0; +} Index: libcxx/trunk/test/std/containers/associative/set/set.cons/deduct.pass.cpp =================================================================== --- libcxx/trunk/test/std/containers/associative/set/set.cons/deduct.pass.cpp +++ libcxx/trunk/test/std/containers/associative/set/set.cons/deduct.pass.cpp @@ -0,0 +1,188 @@ +//===----------------------------------------------------------------------===// +// +// 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 +// +//===----------------------------------------------------------------------===// + +// +// UNSUPPORTED: c++98, c++03, c++11, c++14 +// UNSUPPORTED: libcpp-no-deduction-guides + +// template>, +// class Allocator = allocator>> +// set(InputIterator, InputIterator, +// Compare = Compare(), Allocator = Allocator()) +// -> set, Compare, Allocator>; +// template, +// class Allocator = allocator> +// set(initializer_list, Compare = Compare(), Allocator = Allocator()) +// -> set; +// template +// set(InputIterator, InputIterator, Allocator) +// -> set, +// less>, Allocator>; +// template +// set(initializer_list, Allocator) +// -> set, Allocator>; + +#include // std::equal +#include +#include // INT_MAX +#include +#include +#include + +#include "test_allocator.h" + +struct NotAnAllocator { + friend bool operator<(NotAnAllocator, NotAnAllocator) { return false; } +}; + +int main(int, char **) { + { + const int arr[] = { 1, 2, 1, INT_MAX, 3 }; + std::set s(std::begin(arr), std::end(arr)); + + ASSERT_SAME_TYPE(decltype(s), std::set); + const int expected_s[] = { 1, 2, 3, INT_MAX }; + assert(std::equal(s.begin(), s.end(), std::begin(expected_s), + std::end(expected_s))); + } + + { + const int arr[] = { 1, 2, 1, INT_MAX, 3 }; + std::set s(std::begin(arr), std::end(arr), std::greater()); + + ASSERT_SAME_TYPE(decltype(s), std::set >); + const int expected_s[] = { INT_MAX, 3, 2, 1 }; + assert(std::equal(s.begin(), s.end(), std::begin(expected_s), + std::end(expected_s))); + } + + { + const int arr[] = { 1, 2, 1, INT_MAX, 3 }; + std::set s(std::begin(arr), std::end(arr), std::greater(), + test_allocator(0, 42)); + + ASSERT_SAME_TYPE(decltype(s), + std::set, test_allocator >); + const int expected_s[] = { INT_MAX, 3, 2, 1 }; + assert(std::equal(s.begin(), s.end(), std::begin(expected_s), + std::end(expected_s))); + assert(s.get_allocator().get_id() == 42); + } + + { + std::set source; + std::set s(source); + ASSERT_SAME_TYPE(decltype(s), std::set); + assert(s.size() == 0); + } + + { + std::set source; + std::set s{ source }; // braces instead of parens + ASSERT_SAME_TYPE(decltype(s), std::set); + assert(s.size() == 0); + } + + { + std::set source; + std::set s(source, std::set::allocator_type()); + ASSERT_SAME_TYPE(decltype(s), std::set); + assert(s.size() == 0); + } + + { + std::set s{ 1, 2, 1, INT_MAX, 3 }; + + ASSERT_SAME_TYPE(decltype(s), std::set); + const int expected_s[] = { 1, 2, 3, INT_MAX }; + assert(std::equal(s.begin(), s.end(), std::begin(expected_s), + std::end(expected_s))); + } + + { + std::set s({ 1, 2, 1, INT_MAX, 3 }, std::greater()); + + ASSERT_SAME_TYPE(decltype(s), std::set >); + const int expected_s[] = { INT_MAX, 3, 2, 1 }; + assert(std::equal(s.begin(), s.end(), std::begin(expected_s), + std::end(expected_s))); + } + + { + std::set s({ 1, 2, 1, INT_MAX, 3 }, std::greater(), + test_allocator(0, 43)); + + ASSERT_SAME_TYPE(decltype(s), + std::set, test_allocator >); + const int expected_s[] = { INT_MAX, 3, 2, 1 }; + assert(std::equal(s.begin(), s.end(), std::begin(expected_s), + std::end(expected_s))); + assert(s.get_allocator().get_id() == 43); + } + + { + const int arr[] = { 1, 2, 1, INT_MAX, 3 }; + std::set s(std::begin(arr), std::end(arr), test_allocator(0, 44)); + + ASSERT_SAME_TYPE(decltype(s), + std::set, test_allocator >); + const int expected_s[] = { 1, 2, 3, INT_MAX }; + assert(std::equal(s.begin(), s.end(), std::begin(expected_s), + std::end(expected_s))); + assert(s.get_allocator().get_id() == 44); + } + + { + std::set s({ 1, 2, 1, INT_MAX, 3 }, test_allocator(0, 45)); + + ASSERT_SAME_TYPE(decltype(s), + std::set, test_allocator >); + const int expected_s[] = { 1, 2, 3, INT_MAX }; + assert(std::equal(s.begin(), s.end(), std::begin(expected_s), + std::end(expected_s))); + assert(s.get_allocator().get_id() == 45); + } + + { + NotAnAllocator a; + std::set s{ a }; // set(initializer_list) + ASSERT_SAME_TYPE(decltype(s), std::set); + assert(s.size() == 1); + } + + { + std::set source; + std::set s{ source, source }; // set(initializer_list>) + ASSERT_SAME_TYPE(decltype(s), std::set >); + assert(s.size() == 1); + } + + { + NotAnAllocator a; + std::set s{ a, a }; // set(initializer_list) + ASSERT_SAME_TYPE(decltype(s), std::set); + assert(s.size() == 1); + } + + { + int source[3] = { 3, 4, 5 }; + std::set s(source, source + 3); // set(InputIterator, InputIterator) + ASSERT_SAME_TYPE(decltype(s), std::set); + assert(s.size() == 3); + } + + { + int source[3] = { 3, 4, 5 }; + std::set s{ source, source + 3 }; // set(initializer_list) + ASSERT_SAME_TYPE(decltype(s), std::set); + assert(s.size() == 2); + } + + return 0; +}