OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

[multiple changes] 

2009-11-30  Paolo Carlini  <paolo.carlini@oracle.com>

	* include/tr1_impl/functional: Remove file, copy its contents,
	trivially adjusted...
	* include/std/functional: ... here, and...
	* include/tr1_impl/functional: ... here.
	* include/Makefile.am: Adjust.
	* include/Makefile.in: Regenerate.

2009-11-30  Jonathan Wakely  <jwakely.gcc@gmail.com>

        * include/tr1_impl/functional (function): Add rvalue support and
        tweak doxygen markup.
        * testsuite/20_util/function/assign/move.cc: New.
        * testsuite/20_util/function/cons/move.cc: New.
        * testsuite/20_util/function/invoke/move_only.cc: New.
        * testsuite/20_util/function/cmp/cmp_neg.cc: New.
        * testsuite/20_util/function/1.cc: Copy from testsuite/tr1/.
        * testsuite/20_util/function/2.cc: Likewise.
        * testsuite/20_util/function/3.cc: Likewise.
        * testsuite/20_util/function/4.cc: Likewise.
        * testsuite/20_util/function/5.cc: Likewise.
        * testsuite/20_util/function/6.cc: Likewise.
        * testsuite/20_util/function/7.cc: Likewise.
        * testsuite/20_util/function/8.cc: Likewise.
        * testsuite/20_util/function/9.cc: Likewise.

From-SVN: r154759
This commit is contained in:
Paolo Carlini 2009-11-30 09:34:04 +00:00
parent 5da0f2d96b
commit 7aec2c6343
19 changed files with 5264 additions and 2177 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
libstdc++-v3/ChangeLog
View File

@ -1,3 +1,30 @@
2009-11-30 Paolo Carlini <paolo.carlini@oracle.com>
* include/tr1_impl/functional: Remove file, copy its contents,
trivially adjusted...
* include/std/functional: ... here, and...
* include/tr1_impl/functional: ... here.
* include/Makefile.am: Adjust.
* include/Makefile.in: Regenerate.
2009-11-30 Jonathan Wakely <jwakely.gcc@gmail.com>
* include/tr1_impl/functional (function): Add rvalue support and
tweak doxygen markup.
* testsuite/20_util/function/assign/move.cc: New.
* testsuite/20_util/function/cons/move.cc: New.
* testsuite/20_util/function/invoke/move_only.cc: New.
* testsuite/20_util/function/cmp/cmp_neg.cc: New.
* testsuite/20_util/function/1.cc: Copy from testsuite/tr1/.
* testsuite/20_util/function/2.cc: Likewise.
* testsuite/20_util/function/3.cc: Likewise.
* testsuite/20_util/function/4.cc: Likewise.
* testsuite/20_util/function/5.cc: Likewise.
* testsuite/20_util/function/6.cc: Likewise.
* testsuite/20_util/function/7.cc: Likewise.
* testsuite/20_util/function/8.cc: Likewise.
* testsuite/20_util/function/9.cc: Likewise.
2009-11-29 Jonathan Wakely <jwakely.gcc@gmail.com>
* doc/doxygen/user.cfg.in: Add __GXX_RTTI to PREDEFINED macros.

1
libstdc++-v3/include/Makefile.am
View File

@ -609,7 +609,6 @@ tr1_impl_headers = \
${tr1_impl_srcdir}/cstdlib \
${tr1_impl_srcdir}/cwchar \
${tr1_impl_srcdir}/cwctype \
${tr1_impl_srcdir}/functional \
${tr1_impl_srcdir}/hashtable \
${tr1_impl_srcdir}/hashtable_policy.h \
${tr1_impl_srcdir}/regex \

1
libstdc++-v3/include/Makefile.in
View File

@ -849,7 +849,6 @@ tr1_impl_headers = \
${tr1_impl_srcdir}/cstdlib \
${tr1_impl_srcdir}/cwchar \
${tr1_impl_srcdir}/cwctype \
${tr1_impl_srcdir}/functional \
${tr1_impl_srcdir}/hashtable \
${tr1_impl_srcdir}/hashtable_policy.h \
${tr1_impl_srcdir}/regex \

2161
libstdc++-v3/include/std/functional
View File

File diff suppressed because it is too large Load Diff

2112
libstdc++-v3/include/tr1/functional
View File

File diff suppressed because it is too large Load Diff

2137
libstdc++-v3/include/tr1_impl/functional
View File

File diff suppressed because it is too large Load Diff

94
libstdc++-v3/testsuite/20_util/function/1.cc Normal file
View File

@ -0,0 +1,94 @@
// { dg-options "-std=gnu++0x" }
// 2005-01-15 Douglas Gregor <dgregor@cs.indiana.edu>
//
// Copyright (C) 2005, 2009 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/>.
// 20.7.15 polymorphic function object wrapper
#include <functional>
#include <testsuite_hooks.h>
using namespace __gnu_test;
bool test __attribute__((unused)) = true;
// Operations on empty function<> objects
void test01()
{
using std::function;
using std::bad_function_call;
// Default-construction
function<int(float)> f1;
VERIFY( ((bool)f1 == false) );
VERIFY( !f1 );
VERIFY( f1 == 0 );
VERIFY( 0 == f1 );
VERIFY( !(f1 != 0) );
VERIFY( !(0 != f1) );
// Copy-construction
function<int(float)> f2(f1);
VERIFY( !f2 );
// Construct with NULL pointer
function<int(float)> f3(0);
VERIFY( !f3 );
// Assignment
f1 = f2;
VERIFY( !f1);
// Assignment to NULL pointer
f1 = 0;
VERIFY( !f1 );
// Swap
swap(f1, f2);
VERIFY( !f1 );
VERIFY( !f2 );
// Invocation should throw bad_function_call
bool thrown = false;
try
{
f1(3.14159f);
VERIFY( false );
}
catch (bad_function_call)
{
thrown = true;
}
VERIFY( thrown );
// target_type returns typeid(void)
VERIFY( f1.target_type() == typeid(void) );
// target() always returns a NULL pointer
VERIFY( f1.target<int (*)(float)>() == 0);
// Check const version
const function<int(float)>& f1c = f1;
VERIFY( f1c.target<int (*)(float)>() == 0 );
VERIFY( !f1c );
}
int main()
{
test01();
return 0;
}

78
libstdc++-v3/testsuite/20_util/function/2.cc Normal file
View File

@ -0,0 +1,78 @@
// { dg-options "-std=gnu++0x" }
// 2005-01-15 Douglas Gregor <dgregor@cs.indiana.edu>
//
// Copyright (C) 2005, 2009 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/>.
// 20.7.15 polymorphic function object wrapper
#include <functional>
#include <testsuite_hooks.h>
#include <testsuite_tr1.h>
using namespace __gnu_test;
bool test __attribute__((unused)) = true;
// Put function pointers into function<> wrappers
void test02()
{
using std::function;
function<int(float)> f1(truncate_float);
VERIFY( f1 );
VERIFY( !!f1 );
VERIFY( !(f1 == 0) );
VERIFY( !(0 == f1) );
VERIFY( f1 != 0 );
VERIFY( 0 != f1 );
// Copy-construction
function<int(float)> f2(f1);
VERIFY( f2 );
// Invocation
VERIFY( f1(3.1f) == 3 );
VERIFY( f2(3.1f) == 3 );
// Assignment to zero
f1 = 0;
VERIFY( !f1 );
// Swap
f1.swap(f2);
VERIFY( f1 );
VERIFY( !f2 );
VERIFY( f1(3.1f) == 3 );
// Assignment from a function pointer
f2 = truncate_float;
VERIFY( f2(3.1f) == 3 );
// target_type and target() functions
const function<int(float)>& f1c = f1;
VERIFY( typeid(int(*)(float)) == f1.target_type() );
VERIFY( f2.target<int(*)(float)>() != 0 );
VERIFY( *f2.target<int(*)(float)>() == &truncate_float );
VERIFY( f1c.target<int(*)(float)>() != 0 );
VERIFY( *f1c.target<int(*)(float)>() == &truncate_float );
}
int main()
{
test02();
return 0;
}

78
libstdc++-v3/testsuite/20_util/function/3.cc Normal file
View File

@ -0,0 +1,78 @@
// { dg-options "-std=gnu++0x" }
// 2005-01-15 Douglas Gregor <dgregor@cs.indiana.edu>
//
// Copyright (C) 2005, 2009 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/>.
// 20.7.15 polymorphic function object wrapper
#include <functional>
#include <testsuite_hooks.h>
#include <testsuite_tr1.h>
using namespace __gnu_test;
bool test __attribute__((unused)) = true;
// Put nearly-matching function pointers into function<> wrappers
void test03()
{
using std::function;
function<int(float)> f1(truncate_double);
VERIFY( f1 );
VERIFY( !!f1 );
VERIFY( !(f1 == 0) );
VERIFY( !(0 == f1) );
VERIFY( f1 != 0 );
VERIFY( 0 != f1 );
// Copy-construction
function<int(float)> f2(f1);
VERIFY( f2 );
// Invocation
VERIFY( f1(3.1f) == 3 );
VERIFY( f2(3.1f) == 3 );
// Assignment to zero
f1 = 0;
VERIFY( !f1 );
// Swap
f1.swap(f2);
VERIFY( f1 );
VERIFY( !f2 );
VERIFY( f1(3.1f) == 3 );
// Assignment from a function pointer
f2 = truncate_double;
VERIFY( f2(3.1f) == 3 );
// target_type and target() functions
const function<int(float)>& f1c = f1;
VERIFY( typeid(long(*)(double)) == f1.target_type() );
VERIFY( f2.target<long(*)(double)>() != 0 );
VERIFY( *f2.target<long(*)(double)>() == &truncate_double );
VERIFY( f1c.target<long(*)(double)>() != 0 );
VERIFY( *f1c.target<long(*)(double)>() == &truncate_double );
}
int main()
{
test03();
return 0;
}

82
libstdc++-v3/testsuite/20_util/function/4.cc Normal file
View File

@ -0,0 +1,82 @@
// { dg-options "-std=gnu++0x" }
// 2005-01-15 Douglas Gregor <dgregor@cs.indiana.edu>
//
// Copyright (C) 2005, 2009 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/>.
// 20.7.15 polymorphic function object wrapper
#include <functional>
#include <testsuite_hooks.h>
#include <testsuite_tr1.h>
using namespace __gnu_test;
bool test __attribute__((unused)) = true;
// Put function objects into function<> wrappers
void test04()
{
using std::function;
do_truncate_float_t truncate_float;
function<int(float)> f1(truncate_float);
VERIFY( f1 );
VERIFY( !!f1 );
VERIFY( !(f1 == 0) );
VERIFY( !(0 == f1) );
VERIFY( f1 != 0 );
VERIFY( 0 != f1 );
// Copy-construction
function<int(float)> f2(f1);
VERIFY( f2 );
// Invocation
VERIFY( f1(3.1f) == 3 );
VERIFY( f2(3.1f) == 3 );
// Assignment to zero
f1 = 0;
VERIFY( !f1 );
// Swap
f1.swap(f2);
VERIFY( f1 );
VERIFY( !f2 );
VERIFY( f1(3.1f) == 3 );
// Assignment from a function pointer
f2 = do_truncate_float_t();
VERIFY( f2(3.1f) == 3 );
// target_type and target() functions
const function<int(float)>& f1c = f1;
VERIFY( typeid(do_truncate_float_t) == f1.target_type() );
VERIFY( f2.target<do_truncate_float_t>() != 0 );
VERIFY( f1c.target<do_truncate_float_t>() != 0 );
}
int main()
{
test04();
VERIFY( do_truncate_double_t::live_objects == 0 );
VERIFY( do_truncate_float_t::live_objects == 0 );
return 0;
}

107
libstdc++-v3/testsuite/20_util/function/5.cc Normal file
View File

@ -0,0 +1,107 @@
// { dg-options "-std=gnu++0x" }
// 2005-01-15 Douglas Gregor <dgregor@cs.indiana.edu>
//
// Copyright (C) 2005, 2009 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/>.
// 20.7.15 polymorphic function object wrapper
#include <functional>
#include <testsuite_hooks.h>
#include <testsuite_tr1.h>
using namespace __gnu_test;
bool test __attribute__((unused)) = true;
// Put member pointers into function<> wrappers
void test05()
{
using std::function;
X x;
x.bar = 17;
function<int(X&)> frm(&X::bar);
VERIFY( frm );
VERIFY( frm(x) == 17 );
VERIFY( typeid(int X::*) == frm.target_type() );
VERIFY( *frm.target<int X::*>() == &X::bar );
function<int(X&)> fr(&X::foo);
VERIFY( fr );
VERIFY( fr(x) == 1 );
VERIFY( typeid(int (X::*)()) == fr.target_type() );
VERIFY( *fr.target<int (X::*)()>() == &X::foo );
function<int(const X&)> frc(&X::foo_c);
VERIFY( frc );
VERIFY( frc(x) == 2 );
VERIFY( typeid(int (X::*)() const) == frc.target_type() );
VERIFY( *frc.target<int (X::*)() const >() == &X::foo_c );
function<int(volatile X&)> frv(&X::foo_v);
VERIFY( frv );
VERIFY( frv(x) == 3 );
VERIFY( typeid(int (X::*)() volatile) == frv.target_type() );
VERIFY( *frv.target<int (X::*)() volatile >() == &X::foo_v );
VERIFY( frv.target<int (X::*)() const volatile>() == 0 );
function<int(const volatile X&)> frcv(&X::foo_cv);
VERIFY( frcv );
VERIFY( frcv(x) == 4 );
VERIFY( typeid(int (X::*)() const volatile) == frcv.target_type() );
VERIFY( *frcv.target<int (X::*)() const volatile >() == &X::foo_cv );
VERIFY( frcv.target<int (X::*)() const>() == 0 );
function<int(X*)> grm(&X::bar);
VERIFY( grm );
VERIFY( grm(&x) == 17 );
VERIFY( typeid(int X::*) == grm.target_type() );
VERIFY( *grm.target<int X::*>() == &X::bar );
function<int(X*)> gr(&X::foo);
VERIFY( gr );
VERIFY( gr(&x) == 1 );
VERIFY( typeid(int (X::*)()) == gr.target_type() );
VERIFY( *gr.target<int (X::*)()>() == &X::foo );
function<int(const X*)> grc(&X::foo_c);
VERIFY( grc );
VERIFY( grc(&x) == 2 );
VERIFY( typeid(int (X::*)() const) == grc.target_type() );
VERIFY( *grc.target<int (X::*)() const >() == &X::foo_c );
function<int(volatile X*)> grv(&X::foo_v);
VERIFY( grv );
VERIFY( grv(&x) == 3 );
VERIFY( typeid(int (X::*)() volatile) == grv.target_type() );
VERIFY( *grv.target<int (X::*)() volatile >() == &X::foo_v );
VERIFY( grv.target<int (X::*)() const volatile>() == 0 );
function<int(const volatile X*)> grcv(&X::foo_cv);
VERIFY( grcv );
VERIFY( grcv(&x) == 4 );
VERIFY( typeid(int (X::*)() const volatile) == grcv.target_type() );
VERIFY( *grcv.target<int (X::*)() const volatile >() == &X::foo_cv );
VERIFY( grcv.target<int (X::*)() const>() == 0 );
}
int main()
{
test05();
return 0;
}

82
libstdc++-v3/testsuite/20_util/function/6.cc Normal file
View File

@ -0,0 +1,82 @@
// { dg-options "-std=gnu++0x" }
// 2005-01-15 Douglas Gregor <dgregor@cs.indiana.edu>
//
// Copyright (C) 2005, 2009 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/>.
// 20.7.15 polymorphic function object wrapper
#include <functional>
#include <testsuite_hooks.h>
using namespace __gnu_test;
bool test __attribute__((unused)) = true;
struct secret {};
struct noncopyable_function_object_type
{
noncopyable_function_object_type(secret) {}
int operator()() const { return 42; }
int operator()() { return 17; }
private:
noncopyable_function_object_type();
noncopyable_function_object_type(const noncopyable_function_object_type&);
void operator=(const noncopyable_function_object_type&);
};
// Put reference_wrappers into function<> wrappers
void test06()
{
using std::function;
using std::ref;
using std::cref;
secret password;
noncopyable_function_object_type x(password);
function<int()> f(ref(x));
VERIFY( f );
VERIFY( f() == 17 );
VERIFY( f.target_type() == typeid(noncopyable_function_object_type) );
VERIFY( f.target<noncopyable_function_object_type>() == &x );
function<int()> g = f;
VERIFY( g );
VERIFY( g() == 17 );
VERIFY( g.target_type() == typeid(noncopyable_function_object_type) );
VERIFY( g.target<noncopyable_function_object_type>() == &x );
function<int()> h = cref(x);
VERIFY( h );
VERIFY( h() == 42 );
VERIFY( h.target_type() == typeid(noncopyable_function_object_type) );
VERIFY( h.target<const noncopyable_function_object_type>() == &x );
VERIFY( h.target<const noncopyable_function_object_type>() == &x );
const function<int()>& hc = h;
VERIFY( h.target<noncopyable_function_object_type>() == 0 );
VERIFY( hc.target<noncopyable_function_object_type>() == &x );
}
int main()
{
test06();
return 0;
}

82
libstdc++-v3/testsuite/20_util/function/7.cc Normal file
View File

@ -0,0 +1,82 @@
// { dg-options "-std=gnu++0x" }
// 2005-01-15 Douglas Gregor <dgregor@cs.indiana.edu>
//
// Copyright (C) 2005, 2009 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/>.
// 20.7.15 polymorphic function object wrapper
#include <functional>
#include <testsuite_hooks.h>
#include <testsuite_tr1.h>
using namespace __gnu_test;
bool test __attribute__((unused)) = true;
// Put reference_wrappers to function pointers into function<> wrappers
void test07()
{
using std::function;
using std::ref;
using std::cref;
int (*fptr)(float) = truncate_float;
function<int(float)> f1(ref(fptr));
VERIFY( f1 );
VERIFY( !!f1 );
VERIFY( !(f1 == 0) );
VERIFY( !(0 == f1) );
VERIFY( f1 != 0 );
VERIFY( 0 != f1 );
// Invocation
VERIFY( f1(3.1f) == 3 );
// target_type and target() functions
const function<int(float)>& f1c = f1;
VERIFY( typeid(int(*)(float)) == f1.target_type() );
VERIFY( f1.target<int(*)(float)>() != 0 );
VERIFY( f1.target<int(*)(float)>() == &fptr );
VERIFY( f1c.target<int(*)(float)>() != 0 );
VERIFY( f1c.target<int(*)(float)>() == &fptr );
function<int(float)> f2(cref(fptr));
VERIFY( f2 );
VERIFY( !!f2 );
VERIFY( !(f2 == 0) );
VERIFY( !(0 == f2) );
VERIFY( f2 != 0 );
VERIFY( 0 != f2 );
// Invocation
VERIFY( f2(3.1f) == 3 );
// target_type and target() functions
const function<int(float)>& f2c = f2;
VERIFY( typeid(int(*)(float)) == f2.target_type() );
VERIFY( f2.target<int(*)(float)>() == 0 );
VERIFY( f2.target<int(* const)(float)>() == &fptr );
VERIFY( f2c.target<int(*)(float)>() != 0 );
VERIFY( f2c.target<int(*)(float)>() == &fptr );
}
int main()
{
test07();
return 0;
}

148
libstdc++-v3/testsuite/20_util/function/8.cc Normal file
View File

@ -0,0 +1,148 @@
// { dg-options "-std=gnu++0x" }
// 2005-01-15 Douglas Gregor <dgregor@cs.indiana.edu>
//
// Copyright (C) 2005, 2009 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/>.
// 20.7.15 polymorphic function object wrapper
#include <functional>
#include <testsuite_hooks.h>
#include <testsuite_tr1.h>
using namespace __gnu_test;
bool test __attribute__((unused)) = true;
// Put reference_wrappers to member pointers
void test08()
{
using std::function;
using std::ref;
using std::cref;
int X::* X_bar = &X::bar;
int (X::* X_foo)() = &X::foo;
int (X::* X_foo_c)() const = &X::foo_c;
int (X::* X_foo_v)() volatile = &X::foo_v;
int (X::* X_foo_cv)() const volatile = &X::foo_cv;
X x;
x.bar = 17;
function<int(X&)> frm(ref(X_bar));
VERIFY( frm );
VERIFY( frm(x) == 17 );
VERIFY( typeid(int X::*) == frm.target_type() );
VERIFY( frm.target<int X::*>() == &X_bar );
function<int(X&)> fr(ref(X_foo));
VERIFY( fr );
VERIFY( fr(x) == 1 );
VERIFY( typeid(int (X::*)()) == fr.target_type() );
VERIFY( fr.target<int (X::*)()>() == &X_foo );
function<int(const X&)> frc(ref(X_foo_c));
VERIFY( frc );
VERIFY( frc(x) == 2 );
VERIFY( typeid(int (X::*)() const) == frc.target_type() );
VERIFY( frc.target<int (X::*)() const >() == &X_foo_c );
function<int(volatile X&)> frv(ref(X_foo_v));
VERIFY( frv );
VERIFY( frv(x) == 3 );
VERIFY( typeid(int (X::*)() volatile) == frv.target_type() );
VERIFY( *frv.target<int (X::*)() volatile >() == X_foo_v );
VERIFY( frv.target<int (X::*)() const volatile>() == 0 );
function<int(const volatile X&)> frcv(ref(X_foo_cv));
VERIFY( frcv );
VERIFY( frcv(x) == 4 );
VERIFY( typeid(int (X::*)() const volatile) == frcv.target_type() );
VERIFY( *frcv.target<int (X::*)() const volatile >() == X_foo_cv );
VERIFY( frcv.target<int (X::*)() const>() == 0 );
function<int(X*)> grm(ref(X_bar));
VERIFY( grm );
VERIFY( grm(&x) == 17 );
VERIFY( typeid(int X::*) == grm.target_type() );
VERIFY( *grm.target<int X::*>() == X_bar );
function<int(X*)> gr(ref(X_foo));
VERIFY( gr );
VERIFY( gr(&x) == 1 );
VERIFY( typeid(int (X::*)()) == gr.target_type() );
VERIFY( *gr.target<int (X::*)()>() == X_foo );
function<int(const X*)> grc(ref(X_foo_c));
VERIFY( grc );
VERIFY( grc(&x) == 2 );
VERIFY( typeid(int (X::*)() const) == grc.target_type() );
VERIFY( *grc.target<int (X::*)() const >() == X_foo_c );
function<int(volatile X*)> grv(ref(X_foo_v));
VERIFY( grv );
VERIFY( grv(&x) == 3 );
VERIFY( typeid(int (X::*)() volatile) == grv.target_type() );
VERIFY( *grv.target<int (X::*)() volatile >() == X_foo_v );
VERIFY( grv.target<int (X::*)() const volatile>() == 0 );
function<int(const volatile X*)> grcv(ref(X_foo_cv));
VERIFY( grcv );
VERIFY( grcv(&x) == 4 );
VERIFY( typeid(int (X::*)() const volatile) == grcv.target_type() );
VERIFY( *grcv.target<int (X::*)() const volatile >() == X_foo_cv );
VERIFY( grcv.target<int (X::*)() const>() == 0 );
function<int(X&)> hrm(cref(X_bar));
VERIFY( hrm );
VERIFY( hrm(x) == 17 );
VERIFY( typeid(int X::*) == hrm.target_type() );
VERIFY( hrm.target<int X::*>() == 0 );
VERIFY( hrm.target<int X::* const>() == &X_bar );
function<int(X&)> hr(cref(X_foo));
VERIFY( hr );
VERIFY( hr(x) == 1 );
VERIFY( typeid(int (X::*)()) == hr.target_type() );
VERIFY( hr.target<int (X::* const)()>() == &X_foo );
function<int(const X&)> hrc(cref(X_foo_c));
VERIFY( hrc );
VERIFY( hrc(x) == 2 );
VERIFY( typeid(int (X::*)() const) == hrc.target_type() );
VERIFY( hrc.target<int (X::* const)() const >() == &X_foo_c );
function<int(volatile X&)> hrv(cref(X_foo_v));
VERIFY( hrv );
VERIFY( hrv(x) == 3 );
VERIFY( typeid(int (X::*)() volatile) == hrv.target_type() );
VERIFY( hrv.target<int (X::* const)() volatile >() == &X_foo_v );
VERIFY( hrv.target<int (X::* const)() const volatile>() == 0 );
function<int(const volatile X&)> hrcv(cref(X_foo_cv));
VERIFY( hrcv );
VERIFY( hrcv(x) == 4 );
VERIFY( typeid(int (X::*)() const volatile) == hrcv.target_type() );
VERIFY( hrcv.target<int (X::* const)() const volatile >() == &X_foo_cv );
VERIFY( hrcv.target<int (X::* const)() const>() == 0 );
}
int main()
{
test08();
return 0;
}

55
libstdc++-v3/testsuite/20_util/function/9.cc Normal file
View File

@ -0,0 +1,55 @@
// { dg-options "-std=gnu++0x" }
// 2005-01-15 Douglas Gregor <dgregor@cs.indiana.edu>
//
// Copyright (C) 2005, 2009 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/>.
// 20.7.15 polymorphic function object wrapper
#include <functional>
#include <testsuite_hooks.h>
#include <testsuite_tr1.h>
using namespace __gnu_test;
bool test __attribute__((unused)) = true;
// Put function objects into a void-returning function<> wrapper
void test09()
{
using std::function;
using std::ref;
using std::cref;
int (X::*X_foo_c)() const = &X::foo_c;
function<void(X&)> f(&X::bar);
f = &X::foo;
f = ref(X_foo_c);
f = cref(X_foo_c);
function<void(float)> g = &truncate_float;
g = do_truncate_float_t();
}
int main()
{
test09();
VERIFY( do_truncate_double_t::live_objects == 0 );
VERIFY( do_truncate_float_t::live_objects == 0 );
return 0;
}

50
libstdc++-v3/testsuite/20_util/function/assign/move.cc Normal file
View File

@ -0,0 +1,50 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2009 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/>.
#include <functional>
#include <testsuite_hooks.h>
int f1() { return 1; }
struct { int operator()() { return 2; } } f2;
void test01()
{
bool test __attribute__((unused)) = true;
typedef std::function<int()> function;
function fo(f1);
function fo1;
fo1 = (std::move(fo));
VERIFY( static_cast<bool>(fo1) );
VERIFY( fo1() == 1 );
fo = function(f2);
function fo2;
fo2 = (std::move(fo));
VERIFY( static_cast<bool>(fo2) );
VERIFY( fo2() == 2 );
}
int main()
{
test01();
return 0;
}

37
libstdc++-v3/testsuite/20_util/function/cmp/cmp_neg.cc Normal file
View File

@ -0,0 +1,37 @@
// { dg-options "-std=gnu++0x" }
// { dg-do compile }
// Copyright (C) 2009 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/>.
#include <functional>
void test01()
{
std::function<void()> f1;
std::function<void()> f2;
f1 == f2; // { dg-error "here" }
f1 != f2; // { dg-error "here" }
// { dg-excess-errors "" }
}
int main()
{
test01();
return 0;
}

48
libstdc++-v3/testsuite/20_util/function/cons/move.cc Normal file
View File

@ -0,0 +1,48 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2009 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/>.
#include <functional>
#include <testsuite_hooks.h>
int f1() { return 1; }
struct { int operator()() { return 2; } } f2;
void test01()
{
bool test __attribute__((unused)) = true;
typedef std::function<int()> function;
function fo(f1);
function fo1(std::move(fo));
VERIFY( static_cast<bool>(fo1) );
VERIFY( fo1() == 1 );
fo = function(f2);
function fo2(std::move(fo));
VERIFY( static_cast<bool>(fo2) );
VERIFY( fo2() == 2 );
}
int main()
{
test01();
return 0;
}

61
libstdc++-v3/testsuite/20_util/function/invoke/move_only.cc Normal file
View File

@ -0,0 +1,61 @@
// { dg-options "-std=gnu++0x" }
// Copyright (C) 2009 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/>.
#include <functional>
struct moveable
{
moveable() = default;
~moveable() = default;
moveable(const moveable& c) = delete;
moveable& operator=(const moveable&) = delete;
moveable(moveable&&) { }
};
void f1(moveable) { }
void f2(moveable&&) { }
struct { void operator()(moveable&&) { } } f3;
void test01()
{
std::function<void (moveable)> fo1a(f1);
fo1a(moveable());
std::function<void (moveable)> fo2a(f2);
fo2a(moveable());
std::function<void (moveable)> fo3a(f3);
fo3a(moveable());
std::function<void (moveable&&)> fo1b(f1);
fo1b(moveable());
std::function<void (moveable&&)> fo2b(f2);
fo2b(moveable());
std::function<void (moveable&&)> fo3b(f3);
fo3b(moveable());
}
int main()
{
test01();
return 0;
}