From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 1720) id C41543856267; Wed, 15 Jun 2022 18:23:31 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org C41543856267 MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Content-Type: text/plain; charset="utf-8" From: =?utf-8?b?RnJhbuCkpeCkiG9pcyBEdW1vbnQ=?= To: gcc-cvs@gcc.gnu.org, libstdc++-cvs@gcc.gnu.org Subject: [gcc r13-1114] libstdc++: [_Hashtable] Insert range of types convertible to value_type PR 105717 X-Act-Checkin: gcc X-Git-Author: =?utf-8?q?Fran=C3=A7ois_Dumont?= X-Git-Refname: refs/heads/master X-Git-Oldrev: 636b01ab4910da0b96d844301fea1a2b56c5344d X-Git-Newrev: dc9b92facf87a6f2d8b0e5d5fc404f30c3b15a74 Message-Id: <20220615182331.C41543856267@sourceware.org> Date: Wed, 15 Jun 2022 18:23:31 +0000 (GMT) X-BeenThere: libstdc++-cvs@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Libstdc++-cvs mailing list List-Unsubscribe: , List-Archive: List-Help: List-Subscribe: , X-List-Received-Date: Wed, 15 Jun 2022 18:23:31 -0000 https://gcc.gnu.org/g:dc9b92facf87a6f2d8b0e5d5fc404f30c3b15a74 commit r13-1114-gdc9b92facf87a6f2d8b0e5d5fc404f30c3b15a74 Author: François Dumont Date: Tue Feb 15 09:47:52 2022 +0100 libstdc++: [_Hashtable] Insert range of types convertible to value_type PR 105717 Fix insertion of range of instances convertible to value_type. libstdc++-v3/ChangeLog: PR libstdc++/105717 * include/bits/hashtable_policy.h (_ConvertToValueType): New. * include/bits/hashtable.h (_Hashtable<>::_M_insert_unique_aux): New. (_Hashtable<>::_M_insert(_Arg&&, const _NodeGenerator&, true_type)): Use latters. (_Hashtable<>::_M_insert(_Arg&&, const _NodeGenerator&, false_type)): Likewise. (_Hashtable(_InputIterator, _InputIterator, size_type, const _Hash&, const _Equal&, const allocator_type&, true_type)): Use this.insert range. (_Hashtable(_InputIterator, _InputIterator, size_type, const _Hash&, const _Equal&, const allocator_type&, false_type)): Use _M_insert. * testsuite/23_containers/unordered_map/cons/56112.cc: Check how many times conversion is done. * testsuite/23_containers/unordered_map/insert/105717.cc: New test. * testsuite/23_containers/unordered_set/insert/105717.cc: New test. Diff: --- libstdc++-v3/include/bits/hashtable.h | 30 ++++++--- libstdc++-v3/include/bits/hashtable_policy.h | 34 ++++++++++ .../23_containers/unordered_map/cons/56112.cc | 33 ++++++++-- .../23_containers/unordered_map/insert/105717.cc | 73 ++++++++++++++++++++++ .../23_containers/unordered_set/insert/105717.cc | 73 ++++++++++++++++++++++ 5 files changed, 227 insertions(+), 16 deletions(-) diff --git a/libstdc++-v3/include/bits/hashtable.h b/libstdc++-v3/include/bits/hashtable.h index 29ec1192f32..1b21b795f89 100644 --- a/libstdc++-v3/include/bits/hashtable.h +++ b/libstdc++-v3/include/bits/hashtable.h @@ -899,21 +899,33 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template std::pair - _M_insert(_Arg&& __arg, const _NodeGenerator& __node_gen, - true_type /* __uks */) + _M_insert_unique_aux(_Arg&& __arg, const _NodeGenerator& __node_gen) { return _M_insert_unique( _S_forward_key(_ExtractKey{}(std::forward<_Arg>(__arg))), std::forward<_Arg>(__arg), __node_gen); } + template + std::pair + _M_insert(_Arg&& __arg, const _NodeGenerator& __node_gen, + true_type /* __uks */) + { + using __to_value + = __detail::_ConvertToValueType<_ExtractKey, value_type>; + return _M_insert_unique_aux( + __to_value{}(std::forward<_Arg>(__arg)), __node_gen); + } + template iterator _M_insert(_Arg&& __arg, const _NodeGenerator& __node_gen, false_type __uks) { - return _M_insert(cend(), std::forward<_Arg>(__arg), __node_gen, - __uks); + using __to_value + = __detail::_ConvertToValueType<_ExtractKey, value_type>; + return _M_insert(cend(), + __to_value{}(std::forward<_Arg>(__arg)), __node_gen, __uks); } // Insert with hint, not used when keys are unique. @@ -1185,10 +1197,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION const _Hash& __h, const _Equal& __eq, const allocator_type& __a, true_type /* __uks */) : _Hashtable(__bkt_count_hint, __h, __eq, __a) - { - for (; __f != __l; ++__f) - this->insert(*__f); - } + { this->insert(__f, __l); } templateinsert(*__f); + _M_insert(*__f, __node_gen, __uks); } template(__x).first; } }; + template + struct _ConvertToValueType; + + template + struct _ConvertToValueType<_Identity, _Value> + { + template + constexpr _Kt&& + operator()(_Kt&& __k) const noexcept + { return std::forward<_Kt>(__k); } + }; + + template + struct _ConvertToValueType<_Select1st, _Value> + { + constexpr _Value&& + operator()(_Value&& __x) const noexcept + { return std::move(__x); } + + constexpr const _Value& + operator()(const _Value& __x) const noexcept + { return __x; } + + template + constexpr std::pair<_Kt, _Val>&& + operator()(std::pair<_Kt, _Val>&& __x) const noexcept + { return std::move(__x); } + + template + constexpr const std::pair<_Kt, _Val>& + operator()(const std::pair<_Kt, _Val>& __x) const noexcept + { return __x; } + }; + template struct _NodeBuilder; diff --git a/libstdc++-v3/testsuite/23_containers/unordered_map/cons/56112.cc b/libstdc++-v3/testsuite/23_containers/unordered_map/cons/56112.cc index c4cdeee234c..b0eda30b4cb 100644 --- a/libstdc++-v3/testsuite/23_containers/unordered_map/cons/56112.cc +++ b/libstdc++-v3/testsuite/23_containers/unordered_map/cons/56112.cc @@ -20,30 +20,51 @@ #include #include +#include + struct Key { explicit Key(const int* p) : value(p) { } ~Key() { value = nullptr; } - bool operator==(const Key& k) const { return *value == *k.value; } + bool operator==(const Key& k) const + { return *value == *k.value; } const int* value; }; struct hash { - std::size_t operator()(const Key& k) const noexcept { return *k.value; } + std::size_t operator()(const Key& k) const noexcept + { return *k.value; } }; struct S { + static int _count; + int value; - operator std::pair() const { return {Key(&value), value}; } + operator std::pair() const + { + ++_count; + return { Key(&value), value }; + } }; -int main() +int S::_count = 0; + +void test01() { S s[1] = { {2} }; - std::unordered_map m(s, s+1); - std::unordered_multimap mm(s, s+1); + std::unordered_map m(s, s + 1); + VERIFY( S::_count == 1 ); + + std::unordered_multimap mm(s, s + 1); + VERIFY( S::_count == 2 ); +} + +int main() +{ + test01(); + return 0; } diff --git a/libstdc++-v3/testsuite/23_containers/unordered_map/insert/105717.cc b/libstdc++-v3/testsuite/23_containers/unordered_map/insert/105717.cc new file mode 100644 index 00000000000..202baa9818b --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/unordered_map/insert/105717.cc @@ -0,0 +1,73 @@ +// { dg-do run { target c++11 } } + +// Copyright (C) 2022 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// . + +#include +#include + +#include + +struct Key +{ + explicit Key(const int* p) : value(p) { } + ~Key() { value = nullptr; } + + bool operator==(const Key& k) const + { return *value == *k.value; } + + const int* value; +}; + +struct hash +{ + std::size_t operator()(const Key& k) const noexcept + { return *k.value; } +}; + +struct S +{ + static int _count; + + int value; + operator std::pair() const + { + ++_count; + return { Key(&value), value }; + } +}; + +int S::_count = 0; + +void test01() +{ + S s[1] = { {2} }; + std::unordered_map m; + std::unordered_multimap mm; + + m.insert(s, s + 1); + VERIFY( S::_count == 1 ); + + mm.insert(s, s + 1); + VERIFY( S::_count == 2 ); +} + +int main() +{ + test01(); + return 0; +} diff --git a/libstdc++-v3/testsuite/23_containers/unordered_set/insert/105717.cc b/libstdc++-v3/testsuite/23_containers/unordered_set/insert/105717.cc new file mode 100644 index 00000000000..ab229c5baa1 --- /dev/null +++ b/libstdc++-v3/testsuite/23_containers/unordered_set/insert/105717.cc @@ -0,0 +1,73 @@ +// { dg-do run { target c++11 } } + +// Copyright (C) 2022 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// . + +#include +#include + +#include + +struct Key +{ + explicit Key(const int* p) : value(p) { } + ~Key() { value = nullptr; } + + bool operator==(const Key& k) const + { return *value == *k.value; } + + const int* value; +}; + +struct hash +{ + std::size_t operator()(const Key& k) const noexcept + { return *k.value; } +}; + +struct S +{ + static int _count; + + int value; + operator Key() const + { + ++_count; + return Key(&value); + } +}; + +int S::_count = 0; + +void test01() +{ + S a[1] = { {2} }; + std::unordered_set s; + std::unordered_multiset ms; + + s.insert(a, a + 1); + VERIFY( S::_count == 1 ); + + ms.insert(a, a + 1); + VERIFY( S::_count == 2 ); +} + +int main() +{ + test01(); + return 0; +}