fb7342fd6f
2010-10-28 Paolo Carlini <paolo.carlini@oracle.com> PR libstdc++/44436 (partial) * include/bits/hashtable.h (_Hashtable<>::insert(value_type&&), insert(_Pair&&), insert(const_iterator, value_type&&), insert(const_iterator, _Pair&&)): Add. (_M_allocate_node, _M_insert, _M_insert_bucket): Templatize. * include/bits/hashtable_policy.h (__detail::_Select1st): Add; use it throughout. (_Map_base<>::operator[](_Key&&)): Add. * include/bits/unordered_map.h: Use __detail::_Select1st throughout. * include/debug/unordered_map: Update. * include/debug/unordered_set: Likewise. * include/profile/unordered_map: Likewise. * include/profile/unordered_set: Likewise. * testsuite/util/testsuite_rvalref.h (struct hash<rvalstruct>): Add; minor tweaks throughout, use deleted special members. * testsuite/23_containers/unordered_map/insert/map_single_move-1.cc: New. * testsuite/23_containers/unordered_map/insert/map_single_move-2.cc: Likewise. * testsuite/23_containers/unordered_map/insert/array_syntax_move.cc: Likewise. * testsuite/23_containers/unordered_multimap/insert/ multimap_single_move-1.cc: Likewise. * testsuite/23_containers/unordered_multimap/insert/ multimap_single_move-2.cc: Likewise. * testsuite/23_containers/unordered_set/insert/set_single_move.cc: Likewise. * testsuite/23_containers/unordered_multiset/insert/ multiset_single_move.cc: Likewise. * testsuite/23_containers/unordered_map/insert/array_syntax.cc: Minor cosmetic changes. From-SVN: r166030
195 lines
4.3 KiB
C++
195 lines
4.3 KiB
C++
// -*- C++ -*-
|
|
// Testing utilities for the rvalue reference.
|
|
//
|
|
// Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010
|
|
// 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
|
|
// <http://www.gnu.org/licenses/>.
|
|
//
|
|
|
|
#ifndef _GLIBCXX_TESTSUITE_RVALREF_H
|
|
#define _GLIBCXX_TESTSUITE_RVALREF_H 1
|
|
|
|
#include <testsuite_hooks.h>
|
|
|
|
namespace __gnu_test
|
|
{
|
|
|
|
// This class is designed to test libstdc++'s template-based rvalue
|
|
// reference support. It should fail at compile-time if there is an
|
|
// attempt to copy it.
|
|
struct rvalstruct
|
|
{
|
|
int val;
|
|
bool valid;
|
|
|
|
rvalstruct() : val(0), valid(true)
|
|
{ }
|
|
|
|
rvalstruct(int inval) : val(inval), valid(true)
|
|
{ }
|
|
|
|
rvalstruct&
|
|
operator=(int newval)
|
|
{
|
|
val = newval;
|
|
valid = true;
|
|
return *this;
|
|
}
|
|
|
|
rvalstruct(const rvalstruct&) = delete;
|
|
|
|
rvalstruct(rvalstruct&& in)
|
|
{
|
|
VERIFY(in.valid == true);
|
|
val = in.val;
|
|
in.valid = false;
|
|
valid = true;
|
|
}
|
|
|
|
rvalstruct&
|
|
operator=(const rvalstruct&) = delete;
|
|
|
|
rvalstruct&
|
|
operator=(rvalstruct&& in)
|
|
{
|
|
VERIFY(in.valid == true);
|
|
val = in.val;
|
|
in.valid = false;
|
|
valid = true;
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
inline bool
|
|
operator==(const rvalstruct& lhs, const rvalstruct& rhs)
|
|
{ return lhs.val == rhs.val; }
|
|
|
|
inline bool
|
|
operator<(const rvalstruct& lhs, const rvalstruct& rhs)
|
|
{ return lhs.val < rhs.val; }
|
|
|
|
void
|
|
swap(rvalstruct& lhs, rvalstruct& rhs)
|
|
{
|
|
VERIFY(lhs.valid && rhs.valid);
|
|
int temp = lhs.val;
|
|
lhs.val = rhs.val;
|
|
rhs.val = temp;
|
|
}
|
|
|
|
// This is a moveable class which copies how many times it is copied.
|
|
// This is mainly of use in the containers, where the an element inserted
|
|
// into a container has to be copied once to get there, but we want to check
|
|
// nothing else is copied.
|
|
struct copycounter
|
|
{
|
|
static int copycount;
|
|
int val;
|
|
bool valid;
|
|
|
|
copycounter() : val(0), valid(true)
|
|
{ }
|
|
|
|
copycounter(int inval) : val(inval), valid(true)
|
|
{ }
|
|
|
|
copycounter(const copycounter& in) : val(in.val), valid(true)
|
|
{
|
|
VERIFY(in.valid == true);
|
|
++copycount;
|
|
}
|
|
|
|
copycounter(copycounter&& in)
|
|
{
|
|
VERIFY(in.valid == true);
|
|
val = in.val;
|
|
in.valid = false;
|
|
valid = true;
|
|
}
|
|
|
|
copycounter&
|
|
operator=(int newval)
|
|
{
|
|
val = newval;
|
|
valid = true;
|
|
return *this;
|
|
}
|
|
|
|
bool
|
|
operator=(const copycounter& in)
|
|
{
|
|
VERIFY(in.valid == true);
|
|
++copycount;
|
|
val = in.val;
|
|
valid = true;
|
|
return true;
|
|
}
|
|
|
|
copycounter&
|
|
operator=(copycounter&& in)
|
|
{
|
|
VERIFY(in.valid == true);
|
|
val = in.val;
|
|
in.valid = false;
|
|
valid = true;
|
|
return *this;
|
|
}
|
|
|
|
~copycounter()
|
|
{ valid = false; }
|
|
};
|
|
|
|
int copycounter::copycount = 0;
|
|
|
|
inline bool
|
|
operator==(const copycounter& lhs, const copycounter& rhs)
|
|
{ return lhs.val == rhs.val; }
|
|
|
|
inline bool
|
|
operator<(const copycounter& lhs, const copycounter& rhs)
|
|
{ return lhs.val < rhs.val; }
|
|
|
|
inline void
|
|
swap(copycounter& lhs, copycounter& rhs)
|
|
{
|
|
VERIFY(lhs.valid && rhs.valid);
|
|
int temp = lhs.val;
|
|
lhs.val = rhs.val;
|
|
rhs.val = temp;
|
|
}
|
|
|
|
} // namespace __gnu_test
|
|
|
|
namespace std
|
|
{
|
|
template<typename _Tp> struct hash;
|
|
|
|
/// std::hash specialization for type_index.
|
|
template<>
|
|
struct hash<__gnu_test::rvalstruct>
|
|
{
|
|
typedef size_t result_type;
|
|
typedef __gnu_test::rvalstruct argument_type;
|
|
|
|
size_t
|
|
operator()(const __gnu_test::rvalstruct& __rvs) const
|
|
{ return __rvs.val; }
|
|
};
|
|
}
|
|
|
|
#endif // _GLIBCXX_TESTSUITE_TR1_H
|