From patchwork Wed Sep 22 12:05:56 2010 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Paolo Carlini X-Patchwork-Id: 65420 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) by ozlabs.org (Postfix) with SMTP id 2FA43B70D5 for ; Wed, 22 Sep 2010 22:06:16 +1000 (EST) Received: (qmail 10814 invoked by alias); 22 Sep 2010 12:06:14 -0000 Received: (qmail 10792 invoked by uid 22791); 22 Sep 2010 12:06:10 -0000 X-SWARE-Spam-Status: No, hits=-1.7 required=5.0 tests=AWL, BAYES_00, RCVD_IN_DNSWL_NONE X-Spam-Check-By: sourceware.org Received: from vsmtp3.tin.it (HELO vsmtp3.tin.it) (212.216.176.223) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Wed, 22 Sep 2010 12:06:00 +0000 Received: from [192.168.0.4] (79.43.235.198) by vsmtp3.tin.it (8.5.113) id 4BCE36060B834C96; Wed, 22 Sep 2010 14:05:57 +0200 Message-ID: <4C99F124.6070900@oracle.com> Date: Wed, 22 Sep 2010 14:05:56 +0200 From: Paolo Carlini User-Agent: Mozilla/5.0 (X11; U; Linux x86_64; en-US; rv:1.9.1.11) Gecko/20100714 SUSE/3.0.6 Thunderbird/3.0.6 MIME-Version: 1.0 To: "gcc-patches@gcc.gnu.org" CC: libstdc++ Subject: [v3] Add X-IsSubscribed: yes Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Hi, rather straightforward, now that we have sorted out the issue with _Hash_bytes to libsupc++. Tested x86_64-linux multilib, committed to mainline. Paolo. /////////////////////////// 2010-09-22 Paolo Carlini * include/std/typeindex: New. * include/Makefile.am: Add. * include/Makefile.in: Regenerate. * include/precompiled/stdc++.h: Add. * testsuite/20_util/typeindex/comparison_operators.cc: New. * testsuite/20_util/typeindex/hash.cc: Likewise. * testsuite/20_util/typeindex/hash_code.cc: Likewise. * testsuite/20_util/typeindex/name.cc: Likewise. * testsuite/18_support/type_info/hash_code.cc: Tweak. Index: include/std/typeindex =================================================================== --- include/std/typeindex (revision 0) +++ include/std/typeindex (revision 0) @@ -0,0 +1,105 @@ +// C++0x typeindex -*- C++ -*- + +// Copyright (C) 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. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// . + +/** @file include/typeindex + * This is a Standard C++ Library header. + */ + +#ifndef _GLIBCXX_TYPEINDEX +#define _GLIBCXX_TYPEINDEX 1 + +#pragma GCC system_header + +#ifndef __GXX_EXPERIMENTAL_CXX0X__ +# include +#else + +#include +#include +#include // For unary_function + +namespace std +{ + /** + @brief The class type_index provides a simple wrapper for type_info + which can be used as an index type in associative containers (23.6) + and in unordered associative containers (23.7). + */ + struct type_index + { + type_index(const type_info& __rhs) + : _M_target(&__rhs) { } + + bool + operator==(const type_index& __rhs) const + { return *_M_target == *__rhs._M_target; } + + bool + operator!=(const type_index& __rhs) const + { return *_M_target != *__rhs._M_target; } + + bool + operator<(const type_index& __rhs) const + { return _M_target->before(*__rhs._M_target); } + + bool + operator<=(const type_index& __rhs) const + { return !__rhs._M_target->before(*_M_target); } + + bool + operator>(const type_index& __rhs) const + { return __rhs._M_target->before(*_M_target); } + + bool + operator>=(const type_index& __rhs) const + { return !_M_target->before(*__rhs._M_target); } + + size_t + hash_code() const + { return _M_target->hash_code(); } + + const char* + name() const + { return _M_target->name(); } + + private: + const type_info* _M_target; + }; + + template struct hash; + + /// std::hash specialization for type_index. + template<> + struct hash + : public std::unary_function + { + size_t + operator()(const type_index& __ti) const + { return __ti.hash_code(); } + }; +} + +#endif // __GXX_EXPERIMENTAL_CXX0X__ + +#endif // _GLIBCXX_TYPEINDEX Index: include/precompiled/stdc++.h =================================================================== --- include/precompiled/stdc++.h (revision 164509) +++ include/precompiled/stdc++.h (working copy) @@ -1,6 +1,6 @@ // C++ includes used for precompiling -*- C++ -*- -// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 +// Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 // Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free @@ -109,6 +109,7 @@ #include #include #include +#include #include #include #include Index: include/Makefile.am =================================================================== --- include/Makefile.am (revision 164509) +++ include/Makefile.am (working copy) @@ -66,6 +66,7 @@ ${std_srcdir}/system_error \ ${std_srcdir}/thread \ ${std_srcdir}/tuple \ + ${std_srcdir}/typeindex \ ${std_srcdir}/type_traits \ ${std_srcdir}/unordered_map \ ${std_srcdir}/unordered_set \ Index: testsuite/18_support/type_info/hash_code.cc =================================================================== --- testsuite/18_support/type_info/hash_code.cc (revision 164510) +++ testsuite/18_support/type_info/hash_code.cc (working copy) @@ -22,37 +22,54 @@ #include #include -class Abraca { }; -Abraca a1, a2_; -const Abraca a2 = a2_; - -class Dabra { }; -Dabra d1; - void test01() { bool test __attribute__((unused)) = true; + using namespace std; - VERIFY( typeid(int) != typeid(double) ); - VERIFY( typeid(int).hash_code() != typeid(double).hash_code() ); + class Abraca { }; + Abraca a1, a2_; - VERIFY( typeid(a1) == typeid(a2) ); - VERIFY( typeid(a1).hash_code() == typeid(a2).hash_code() ); + typedef const Abraca cAbraca; + cAbraca a2 = a2_; - VERIFY( typeid(Abraca) == typeid(const Abraca) ); - VERIFY( typeid(Abraca).hash_code() == typeid(const Abraca).hash_code() ); + class Dabra { }; + Dabra d1; - VERIFY( typeid(Abraca) == typeid(a2) ); - VERIFY( typeid(Abraca).hash_code() == typeid(a2).hash_code() ); + const type_info& to01 = typeid(int); + const type_info& to02 = typeid(double); + VERIFY( to01 != to02 ); + VERIFY( to01.hash_code() != to02.hash_code() ); - VERIFY( typeid(Abraca) == typeid(const Abraca&) ); - VERIFY( typeid(Abraca).hash_code() == typeid(const Abraca&).hash_code() ); + const type_info& to03 = typeid(a1); + const type_info& to04 = typeid(a2); + VERIFY( to03 == to04 ); + VERIFY( to03.hash_code() == to04.hash_code() ); - VERIFY( typeid(Abraca) != typeid(Dabra) ); - VERIFY( typeid(Abraca).hash_code() != typeid(Dabra).hash_code() ); + const type_info& to05 = typeid(Abraca); + const type_info& to06 = typeid(cAbraca); + VERIFY( to05 == to06 ); + VERIFY( to05.hash_code() == to06.hash_code() ); - VERIFY( typeid(a1) != typeid(d1) ); - VERIFY( typeid(a1).hash_code() != typeid(d1).hash_code() ); + const type_info& to07 = typeid(Abraca); + const type_info& to08 = typeid(a2); + VERIFY( to07 == to08 ); + VERIFY( to07.hash_code() == to08.hash_code() ); + + const type_info& to09 = typeid(Abraca); + const type_info& to10 = typeid(const Abraca&); + VERIFY( to09 == to10 ); + VERIFY( to09.hash_code() == to10.hash_code() ); + + const type_info& to11 = typeid(Abraca); + const type_info& to12 = typeid(Dabra); + VERIFY( to11 != to12 ); + VERIFY( to11.hash_code() != to12.hash_code() ); + + const type_info& to13 = typeid(a1); + const type_info& to14 = typeid(d1); + VERIFY( to13 != to14 ); + VERIFY( to13.hash_code() != to14.hash_code() ); } int main() Index: testsuite/20_util/typeindex/hash_code.cc =================================================================== --- testsuite/20_util/typeindex/hash_code.cc (revision 0) +++ testsuite/20_util/typeindex/hash_code.cc (revision 0) @@ -0,0 +1,67 @@ +// { dg-options "-std=gnu++0x" } + +// 2010-09-22 Paolo Carlini +// +// Copyright (C) 2010 Free Software Foundation +// +// 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 + +void test01() +{ + bool test __attribute__((unused)) = true; + using namespace std; + + class Abraca { }; + Abraca a1, a2_; + const Abraca a2 = a2_; + + const type_info& to1 = typeid(int); + const type_index ti1(to1); + VERIFY( ti1.hash_code() == to1.hash_code() ); + + const type_info& to2 = typeid(double); + const type_index ti2(to2); + VERIFY( ti2.hash_code() == to2.hash_code() ); + + const type_info& to3 = typeid(Abraca); + const type_index ti3(to3); + VERIFY( ti3.hash_code() == to3.hash_code() ); + + const type_info& to4 = typeid(const Abraca); + const type_index ti4(to4); + VERIFY( ti4.hash_code() == to4.hash_code() ); + + const type_info& to5 = typeid(const Abraca&); + const type_index ti5(to5); + VERIFY( ti5.hash_code() == to5.hash_code() ); + + const type_info& to6 = typeid(a1); + const type_index ti6(to6); + VERIFY( ti6.hash_code() == to6.hash_code() ); + + const type_info& to7 = typeid(a2); + const type_index ti7(to7); + VERIFY( ti7.hash_code() == to7.hash_code() ); +} + +int main() +{ + test01(); + return 0; +} Index: testsuite/20_util/typeindex/name.cc =================================================================== --- testsuite/20_util/typeindex/name.cc (revision 0) +++ testsuite/20_util/typeindex/name.cc (revision 0) @@ -0,0 +1,67 @@ +// { dg-options "-std=gnu++0x" } + +// 2010-09-22 Paolo Carlini +// +// Copyright (C) 2010 Free Software Foundation +// +// 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 + +void test01() +{ + bool test __attribute__((unused)) = true; + using namespace std; + + class Abraca { }; + Abraca a1, a2_; + const Abraca a2 = a2_; + + const type_info& to1 = typeid(int); + const type_index ti1(to1); + VERIFY( ti1.name() == to1.name() ); + + const type_info& to2 = typeid(double); + const type_index ti2(to2); + VERIFY( ti2.name() == to2.name() ); + + const type_info& to3 = typeid(Abraca); + const type_index ti3(to3); + VERIFY( ti3.name() == to3.name() ); + + const type_info& to4 = typeid(const Abraca); + const type_index ti4(to4); + VERIFY( ti4.name() == to4.name() ); + + const type_info& to5 = typeid(const Abraca&); + const type_index ti5(to5); + VERIFY( ti5.name() == to5.name() ); + + const type_info& to6 = typeid(a1); + const type_index ti6(to6); + VERIFY( ti6.name() == to6.name() ); + + const type_info& to7 = typeid(a2); + const type_index ti7(to7); + VERIFY( ti7.name() == to7.name() ); +} + +int main() +{ + test01(); + return 0; +} Index: testsuite/20_util/typeindex/hash.cc =================================================================== --- testsuite/20_util/typeindex/hash.cc (revision 0) +++ testsuite/20_util/typeindex/hash.cc (revision 0) @@ -0,0 +1,60 @@ +// { dg-options "-std=gnu++0x" } + +// 2010-09-22 Paolo Carlini +// +// Copyright (C) 2010 Free Software Foundation +// +// 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 + +void test01() +{ + bool test __attribute__((unused)) = true; + using namespace std; + + class Abraca { }; + Abraca a1, a2_; + const Abraca a2 = a2_; + + const type_index ti1(typeid(int)); + VERIFY( hash()(ti1) == ti1.hash_code() ); + + const type_index ti2(typeid(double)); + VERIFY( hash()(ti2) == ti2.hash_code() ); + + const type_index ti3(typeid(Abraca)); + VERIFY( hash()(ti3) == ti3.hash_code() ); + + const type_index ti4(typeid(const Abraca)); + VERIFY( hash()(ti4) == ti4.hash_code() ); + + const type_index ti5(typeid(const Abraca&)); + VERIFY( hash()(ti5) == ti5.hash_code() ); + + const type_index ti6(typeid(a1)); + VERIFY( hash()(ti6) == ti6.hash_code() ); + + const type_index ti7(typeid(a2)); + VERIFY( hash()(ti7) == ti7.hash_code() ); +} + +int main() +{ + test01(); + return 0; +} Index: testsuite/20_util/typeindex/comparison_operators.cc =================================================================== --- testsuite/20_util/typeindex/comparison_operators.cc (revision 0) +++ testsuite/20_util/typeindex/comparison_operators.cc (revision 0) @@ -0,0 +1,88 @@ +// { dg-options "-std=gnu++0x" } + +// 2010-09-22 Paolo Carlini +// +// Copyright (C) 2010 Free Software Foundation +// +// 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 + +#define TEST3(TI1, TI2, TO1, TO2) \ + VERIFY( (TI1 == TI2) == (TO1 == TO2) ); \ + VERIFY( (TI1 != TI2) == (TO1 != TO2) ); \ + VERIFY( (TI1 < TI2) == (TO1.before(TO2)) ); \ + VERIFY( (TI1 <= TI2) == (!TO2.before(TO1)) ); \ + VERIFY( (TI1 > TI2) == (TO2.before(TO1)) ); \ + VERIFY( (TI1 >= TI2) == (!TO1.before(TO2)) ); + +#define TEST2(TI, TO) \ + TEST3(TI, ti1, TO, to1) \ + TEST3(TI, ti2, TO, to2) \ + TEST3(TI, ti3, TO, to3) \ + TEST3(TI, ti4, TO, to4) \ + TEST3(TI, ti5, TO, to5) \ + TEST3(TI, ti6, TO, to6) \ + TEST3(TI, ti7, TO, to7) + +#define TEST \ + TEST2(ti1, to1) \ + TEST2(ti2, to2) \ + TEST2(ti3, to3) \ + TEST2(ti4, to4) \ + TEST2(ti5, to5) \ + TEST2(ti6, to6) \ + TEST2(ti7, to7) + +void test01() +{ + bool test __attribute__((unused)) = true; + using namespace std; + + class Abraca { }; + Abraca a1, a2_; + const Abraca a2 = a2_; + + const type_info& to1 = typeid(int); + const type_index ti1(to1); + + const type_info& to2 = typeid(double); + const type_index ti2(to2); + + const type_info& to3 = typeid(Abraca); + const type_index ti3(to3); + + const type_info& to4 = typeid(const Abraca); + const type_index ti4(to4); + + const type_info& to5 = typeid(const Abraca&); + const type_index ti5(to5); + + const type_info& to6 = typeid(a1); + const type_index ti6(to6); + + const type_info& to7 = typeid(a2); + const type_index ti7(to7); + + TEST +} + +int main() +{ + test01(); + return 0; +}