* include/Makefile.am: Add <bits/refwrap.h> and <bits/std_function.h>.
Order alphabetically.
* include/Makefile.in: Regenerate.
* include/bits/refwrap.h: New header.
(_Maybe_get_result_type,_Weak_result_type_impl, _Weak_result_type)
(_Reference_wrapper_base_impl, _Reference_wrapper_base)
(reference_wrapper, ref, cref): Move here from <functional>.
* include/bits/shared_ptr_base.h: Include <bits/refwrap.h> and
<bits/stl_function.h> instead of <functional>.
* include/bits/std_function.h: New header.
(_Maybe_unary_or_binary_function, bad_function_call)
(__is_location_invariant, _Nocopy_types, _Any_data)
(_Simple_type_wrapper, _Function_base, _Function_handler, function):
Move here from <functional>.
* include/bits/unique_ptr.h: Include <bits/stl_function.h>.
* include/std/functional: Include new headers and move components to
them.
* include/std/future: Include <bits/std_function.h> instead of
<functional>.
* include/std/mutex: Likewise.
* include/std/regex: Likewise.
* src/c++11/compatibility-thread-c++0x.cc: Include <functional>.
* testsuite/20_util/default_delete/48631_neg.cc: Adjust dg-error line.
* testsuite/20_util/default_delete/void_neg.cc: Likewise.
* testsuite/20_util/unique_ptr/assign/48635_neg.cc: Adjust dg-error
lines.
* testsuite/20_util/unique_ptr/cons/cv_qual_neg.cc: Likewise.
* testsuite/30_threads/packaged_task/49668.cc: Include <functional>.
From-SVN: r241410
2016-10-21 Jonathan Wakely <jwakely@redhat.com>
+ * include/Makefile.am: Add <bits/refwrap.h> and <bits/std_function.h>.
+ Order alphabetically.
+ * include/Makefile.in: Regenerate.
+ * include/bits/refwrap.h: New header.
+ (_Maybe_get_result_type,_Weak_result_type_impl, _Weak_result_type)
+ (_Reference_wrapper_base_impl, _Reference_wrapper_base)
+ (reference_wrapper, ref, cref): Move here from <functional>.
+ * include/bits/shared_ptr_base.h: Include <bits/refwrap.h> and
+ <bits/stl_function.h> instead of <functional>.
+ * include/bits/std_function.h: New header.
+ (_Maybe_unary_or_binary_function, bad_function_call)
+ (__is_location_invariant, _Nocopy_types, _Any_data)
+ (_Simple_type_wrapper, _Function_base, _Function_handler, function):
+ Move here from <functional>.
+ * include/bits/unique_ptr.h: Include <bits/stl_function.h>.
+ * include/std/functional: Include new headers and move components to
+ them.
+ * include/std/future: Include <bits/std_function.h> instead of
+ <functional>.
+ * include/std/mutex: Likewise.
+ * include/std/regex: Likewise.
+ * src/c++11/compatibility-thread-c++0x.cc: Include <functional>.
+ * testsuite/20_util/default_delete/48631_neg.cc: Adjust dg-error line.
+ * testsuite/20_util/default_delete/void_neg.cc: Likewise.
+ * testsuite/20_util/unique_ptr/assign/48635_neg.cc: Adjust dg-error
+ lines.
+ * testsuite/20_util/unique_ptr/cons/cv_qual_neg.cc: Likewise.
+ * testsuite/30_threads/packaged_task/49668.cc: Include <functional>.
+
* libsupc++/exception_ptr.h (make_exception_ptr): Qualify new.
* testsuite/18_support/exception_ptr/make_exception_ptr_2.cc: New
test.
* include/std/future: Include <functional>.
* include/std/memory: Do not include <functional>.
* include/std/mutex: [_GLIBCXX_HAVE_TLS]: Likewise.
+ * src/c++11/compatibility-thread-c++0x.cc: Include <functional>.
* testsuite/20_util/shared_ptr/thread/default_weaktoshared.cc: Add
missing includes.
* testsuite/20_util/shared_ptr/thread/mutex_weaktoshared.cc: Likewise.
${bits_srcdir}/random.h \
${bits_srcdir}/random.tcc \
${bits_srcdir}/range_access.h \
+ ${bits_srcdir}/refwrap.h \
${bits_srcdir}/regex.h \
${bits_srcdir}/regex.tcc \
${bits_srcdir}/regex_constants.h \
${bits_srcdir}/regex_compiler.tcc \
${bits_srcdir}/regex_executor.h \
${bits_srcdir}/regex_executor.tcc \
- ${bits_srcdir}/stream_iterator.h \
- ${bits_srcdir}/streambuf_iterator.h \
${bits_srcdir}/shared_ptr.h \
${bits_srcdir}/shared_ptr_atomic.h \
${bits_srcdir}/shared_ptr_base.h \
${bits_srcdir}/slice_array.h \
${bits_srcdir}/sstream.tcc \
${bits_srcdir}/std_abs.h \
+ ${bits_srcdir}/std_function.h \
${bits_srcdir}/std_mutex.h \
${bits_srcdir}/stl_algo.h \
${bits_srcdir}/stl_algobase.h \
${bits_srcdir}/stl_tree.h \
${bits_srcdir}/stl_uninitialized.h \
${bits_srcdir}/stl_vector.h \
+ ${bits_srcdir}/stream_iterator.h \
+ ${bits_srcdir}/streambuf_iterator.h \
${bits_srcdir}/streambuf.tcc \
${bits_srcdir}/stringfwd.h \
${bits_srcdir}/string_view.tcc \
${bits_srcdir}/random.h \
${bits_srcdir}/random.tcc \
${bits_srcdir}/range_access.h \
+ ${bits_srcdir}/refwrap.h \
${bits_srcdir}/regex.h \
${bits_srcdir}/regex.tcc \
${bits_srcdir}/regex_constants.h \
${bits_srcdir}/regex_compiler.tcc \
${bits_srcdir}/regex_executor.h \
${bits_srcdir}/regex_executor.tcc \
- ${bits_srcdir}/stream_iterator.h \
- ${bits_srcdir}/streambuf_iterator.h \
${bits_srcdir}/shared_ptr.h \
${bits_srcdir}/shared_ptr_atomic.h \
${bits_srcdir}/shared_ptr_base.h \
${bits_srcdir}/slice_array.h \
${bits_srcdir}/sstream.tcc \
${bits_srcdir}/std_abs.h \
+ ${bits_srcdir}/std_function.h \
${bits_srcdir}/std_mutex.h \
${bits_srcdir}/stl_algo.h \
${bits_srcdir}/stl_algobase.h \
${bits_srcdir}/stl_tree.h \
${bits_srcdir}/stl_uninitialized.h \
${bits_srcdir}/stl_vector.h \
+ ${bits_srcdir}/stream_iterator.h \
+ ${bits_srcdir}/streambuf_iterator.h \
${bits_srcdir}/streambuf.tcc \
${bits_srcdir}/stringfwd.h \
${bits_srcdir}/string_view.tcc \
--- /dev/null
+// Implementation of std::reference_wrapper -*- C++ -*-
+
+// Copyright (C) 2004-2016 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
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/bits/bind.h
+ * This is an internal header file, included by other library headers.
+ * Do not attempt to use it directly. @headername{functional}
+ */
+
+#ifndef _GLIBCXX_REFWRAP_H
+#define _GLIBCXX_REFWRAP_H 1
+
+#pragma GCC system_header
+
+#if __cplusplus < 201103L
+# include <bits/c++0x_warning.h>
+#else
+
+#include <bits/move.h>
+#include <bits/invoke.h>
+#include <bits/stl_function.h> // for unary_function and binary_function
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ /// If we have found a result_type, extract it.
+ template<typename _Functor, typename = __void_t<>>
+ struct _Maybe_get_result_type
+ { };
+
+ template<typename _Functor>
+ struct _Maybe_get_result_type<_Functor,
+ __void_t<typename _Functor::result_type>>
+ { typedef typename _Functor::result_type result_type; };
+
+ /**
+ * Base class for any function object that has a weak result type, as
+ * defined in 20.8.2 [func.require] of C++11.
+ */
+ template<typename _Functor>
+ struct _Weak_result_type_impl
+ : _Maybe_get_result_type<_Functor>
+ { };
+
+ /// Retrieve the result type for a function type.
+ template<typename _Res, typename... _ArgTypes>
+ struct _Weak_result_type_impl<_Res(_ArgTypes...)>
+ { typedef _Res result_type; };
+
+ template<typename _Res, typename... _ArgTypes>
+ struct _Weak_result_type_impl<_Res(_ArgTypes......)>
+ { typedef _Res result_type; };
+
+ template<typename _Res, typename... _ArgTypes>
+ struct _Weak_result_type_impl<_Res(_ArgTypes...) const>
+ { typedef _Res result_type; };
+
+ template<typename _Res, typename... _ArgTypes>
+ struct _Weak_result_type_impl<_Res(_ArgTypes......) const>
+ { typedef _Res result_type; };
+
+ template<typename _Res, typename... _ArgTypes>
+ struct _Weak_result_type_impl<_Res(_ArgTypes...) volatile>
+ { typedef _Res result_type; };
+
+ template<typename _Res, typename... _ArgTypes>
+ struct _Weak_result_type_impl<_Res(_ArgTypes......) volatile>
+ { typedef _Res result_type; };
+
+ template<typename _Res, typename... _ArgTypes>
+ struct _Weak_result_type_impl<_Res(_ArgTypes...) const volatile>
+ { typedef _Res result_type; };
+
+ template<typename _Res, typename... _ArgTypes>
+ struct _Weak_result_type_impl<_Res(_ArgTypes......) const volatile>
+ { typedef _Res result_type; };
+
+ /// Retrieve the result type for a function reference.
+ template<typename _Res, typename... _ArgTypes>
+ struct _Weak_result_type_impl<_Res(&)(_ArgTypes...)>
+ { typedef _Res result_type; };
+
+ template<typename _Res, typename... _ArgTypes>
+ struct _Weak_result_type_impl<_Res(&)(_ArgTypes......)>
+ { typedef _Res result_type; };
+
+ /// Retrieve the result type for a function pointer.
+ template<typename _Res, typename... _ArgTypes>
+ struct _Weak_result_type_impl<_Res(*)(_ArgTypes...)>
+ { typedef _Res result_type; };
+
+ template<typename _Res, typename... _ArgTypes>
+ struct _Weak_result_type_impl<_Res(*)(_ArgTypes......)>
+ { typedef _Res result_type; };
+
+ /// Retrieve result type for a member function pointer.
+ template<typename _Res, typename _Class, typename... _ArgTypes>
+ struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)>
+ { typedef _Res result_type; };
+
+ template<typename _Res, typename _Class, typename... _ArgTypes>
+ struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)>
+ { typedef _Res result_type; };
+
+ /// Retrieve result type for a const member function pointer.
+ template<typename _Res, typename _Class, typename... _ArgTypes>
+ struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) const>
+ { typedef _Res result_type; };
+
+ template<typename _Res, typename _Class, typename... _ArgTypes>
+ struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) const>
+ { typedef _Res result_type; };
+
+ /// Retrieve result type for a volatile member function pointer.
+ template<typename _Res, typename _Class, typename... _ArgTypes>
+ struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) volatile>
+ { typedef _Res result_type; };
+
+ template<typename _Res, typename _Class, typename... _ArgTypes>
+ struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) volatile>
+ { typedef _Res result_type; };
+
+ /// Retrieve result type for a const volatile member function pointer.
+ template<typename _Res, typename _Class, typename... _ArgTypes>
+ struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)
+ const volatile>
+ { typedef _Res result_type; };
+
+ template<typename _Res, typename _Class, typename... _ArgTypes>
+ struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)
+ const volatile>
+ { typedef _Res result_type; };
+
+ /**
+ * Strip top-level cv-qualifiers from the function object and let
+ * _Weak_result_type_impl perform the real work.
+ */
+ template<typename _Functor>
+ struct _Weak_result_type
+ : _Weak_result_type_impl<typename remove_cv<_Functor>::type>
+ { };
+
+ // Detect nested argument_type.
+ template<typename _Tp, typename = __void_t<>>
+ struct _Refwrap_base_arg1
+ { };
+
+ // Nested argument_type.
+ template<typename _Tp>
+ struct _Refwrap_base_arg1<_Tp,
+ __void_t<typename _Tp::argument_type>>
+ {
+ typedef typename _Tp::argument_type argument_type;
+ };
+
+ // Detect nested first_argument_type and second_argument_type.
+ template<typename _Tp, typename = __void_t<>>
+ struct _Refwrap_base_arg2
+ { };
+
+ // Nested first_argument_type and second_argument_type.
+ template<typename _Tp>
+ struct _Refwrap_base_arg2<_Tp,
+ __void_t<typename _Tp::first_argument_type,
+ typename _Tp::second_argument_type>>
+ {
+ typedef typename _Tp::first_argument_type first_argument_type;
+ typedef typename _Tp::second_argument_type second_argument_type;
+ };
+
+ /**
+ * Derives from unary_function or binary_function when it
+ * can. Specializations handle all of the easy cases. The primary
+ * template determines what to do with a class type, which may
+ * derive from both unary_function and binary_function.
+ */
+ template<typename _Tp>
+ struct _Reference_wrapper_base
+ : _Weak_result_type<_Tp>, _Refwrap_base_arg1<_Tp>, _Refwrap_base_arg2<_Tp>
+ { };
+
+ // - a function type (unary)
+ template<typename _Res, typename _T1>
+ struct _Reference_wrapper_base<_Res(_T1)>
+ : unary_function<_T1, _Res>
+ { };
+
+ template<typename _Res, typename _T1>
+ struct _Reference_wrapper_base<_Res(_T1) const>
+ : unary_function<_T1, _Res>
+ { };
+
+ template<typename _Res, typename _T1>
+ struct _Reference_wrapper_base<_Res(_T1) volatile>
+ : unary_function<_T1, _Res>
+ { };
+
+ template<typename _Res, typename _T1>
+ struct _Reference_wrapper_base<_Res(_T1) const volatile>
+ : unary_function<_T1, _Res>
+ { };
+
+ // - a function type (binary)
+ template<typename _Res, typename _T1, typename _T2>
+ struct _Reference_wrapper_base<_Res(_T1, _T2)>
+ : binary_function<_T1, _T2, _Res>
+ { };
+
+ template<typename _Res, typename _T1, typename _T2>
+ struct _Reference_wrapper_base<_Res(_T1, _T2) const>
+ : binary_function<_T1, _T2, _Res>
+ { };
+
+ template<typename _Res, typename _T1, typename _T2>
+ struct _Reference_wrapper_base<_Res(_T1, _T2) volatile>
+ : binary_function<_T1, _T2, _Res>
+ { };
+
+ template<typename _Res, typename _T1, typename _T2>
+ struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile>
+ : binary_function<_T1, _T2, _Res>
+ { };
+
+ // - a function pointer type (unary)
+ template<typename _Res, typename _T1>
+ struct _Reference_wrapper_base<_Res(*)(_T1)>
+ : unary_function<_T1, _Res>
+ { };
+
+ // - a function pointer type (binary)
+ template<typename _Res, typename _T1, typename _T2>
+ struct _Reference_wrapper_base<_Res(*)(_T1, _T2)>
+ : binary_function<_T1, _T2, _Res>
+ { };
+
+ // - a pointer to member function type (unary, no qualifiers)
+ template<typename _Res, typename _T1>
+ struct _Reference_wrapper_base<_Res (_T1::*)()>
+ : unary_function<_T1*, _Res>
+ { };
+
+ // - a pointer to member function type (binary, no qualifiers)
+ template<typename _Res, typename _T1, typename _T2>
+ struct _Reference_wrapper_base<_Res (_T1::*)(_T2)>
+ : binary_function<_T1*, _T2, _Res>
+ { };
+
+ // - a pointer to member function type (unary, const)
+ template<typename _Res, typename _T1>
+ struct _Reference_wrapper_base<_Res (_T1::*)() const>
+ : unary_function<const _T1*, _Res>
+ { };
+
+ // - a pointer to member function type (binary, const)
+ template<typename _Res, typename _T1, typename _T2>
+ struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const>
+ : binary_function<const _T1*, _T2, _Res>
+ { };
+
+ // - a pointer to member function type (unary, volatile)
+ template<typename _Res, typename _T1>
+ struct _Reference_wrapper_base<_Res (_T1::*)() volatile>
+ : unary_function<volatile _T1*, _Res>
+ { };
+
+ // - a pointer to member function type (binary, volatile)
+ template<typename _Res, typename _T1, typename _T2>
+ struct _Reference_wrapper_base<_Res (_T1::*)(_T2) volatile>
+ : binary_function<volatile _T1*, _T2, _Res>
+ { };
+
+ // - a pointer to member function type (unary, const volatile)
+ template<typename _Res, typename _T1>
+ struct _Reference_wrapper_base<_Res (_T1::*)() const volatile>
+ : unary_function<const volatile _T1*, _Res>
+ { };
+
+ // - a pointer to member function type (binary, const volatile)
+ template<typename _Res, typename _T1, typename _T2>
+ struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const volatile>
+ : binary_function<const volatile _T1*, _T2, _Res>
+ { };
+
+ /**
+ * @brief Primary class template for reference_wrapper.
+ * @ingroup functors
+ * @{
+ */
+ template<typename _Tp>
+ class reference_wrapper
+ : public _Reference_wrapper_base<typename remove_cv<_Tp>::type>
+ {
+ _Tp* _M_data;
+
+ public:
+ typedef _Tp type;
+
+ reference_wrapper(_Tp& __indata) noexcept
+ : _M_data(std::__addressof(__indata))
+ { }
+
+ reference_wrapper(_Tp&&) = delete;
+
+ reference_wrapper(const reference_wrapper&) = default;
+
+ reference_wrapper&
+ operator=(const reference_wrapper&) = default;
+
+ operator _Tp&() const noexcept
+ { return this->get(); }
+
+ _Tp&
+ get() const noexcept
+ { return *_M_data; }
+
+ template<typename... _Args>
+ typename result_of<_Tp&(_Args&&...)>::type
+ operator()(_Args&&... __args) const
+ {
+ return std::__invoke(get(), std::forward<_Args>(__args)...);
+ }
+ };
+
+
+ /// Denotes a reference should be taken to a variable.
+ template<typename _Tp>
+ inline reference_wrapper<_Tp>
+ ref(_Tp& __t) noexcept
+ { return reference_wrapper<_Tp>(__t); }
+
+ /// Denotes a const reference should be taken to a variable.
+ template<typename _Tp>
+ inline reference_wrapper<const _Tp>
+ cref(const _Tp& __t) noexcept
+ { return reference_wrapper<const _Tp>(__t); }
+
+ template<typename _Tp>
+ void ref(const _Tp&&) = delete;
+
+ template<typename _Tp>
+ void cref(const _Tp&&) = delete;
+
+ /// Partial specialization.
+ template<typename _Tp>
+ inline reference_wrapper<_Tp>
+ ref(reference_wrapper<_Tp> __t) noexcept
+ { return ref(__t.get()); }
+
+ /// Partial specialization.
+ template<typename _Tp>
+ inline reference_wrapper<const _Tp>
+ cref(reference_wrapper<_Tp> __t) noexcept
+ { return cref(__t.get()); }
+
+ // @} group functors
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#endif // C++11
+
+#endif // _GLIBCXX_REFWRAP_H
#ifndef _SHARED_PTR_BASE_H
#define _SHARED_PTR_BASE_H 1
-#include <functional>
#if __cpp_rtti
# include <typeinfo>
#endif
#include <bits/allocated_ptr.h>
+#include <bits/refwrap.h>
+#include <bits/stl_function.h>
#include <ext/aligned_buffer.h>
namespace std _GLIBCXX_VISIBILITY(default)
--- /dev/null
+// Implementation of std::function -*- C++ -*-
+
+// Copyright (C) 2004-2016 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
+// <http://www.gnu.org/licenses/>.
+
+/** @file include/bits/function.h
+ * This is an internal header file, included by other library headers.
+ * Do not attempt to use it directly. @headername{functional}
+ */
+
+#ifndef _GLIBCXX_STD_FUNCTION_H
+#define _GLIBCXX_STD_FUNCTION_H 1
+
+#pragma GCC system_header
+
+#if __cplusplus < 201103L
+# include <bits/c++0x_warning.h>
+#else
+
+#if __cpp_rtti
+# include <typeinfo>
+#endif
+#include <bits/stl_function.h>
+#include <bits/invoke.h>
+#include <bits/refwrap.h>
+#include <bits/functexcept.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ /**
+ * Derives from @c unary_function or @c binary_function, or perhaps
+ * nothing, depending on the number of arguments provided. The
+ * primary template is the basis case, which derives nothing.
+ */
+ template<typename _Res, typename... _ArgTypes>
+ struct _Maybe_unary_or_binary_function { };
+
+ /// Derives from @c unary_function, as appropriate.
+ template<typename _Res, typename _T1>
+ struct _Maybe_unary_or_binary_function<_Res, _T1>
+ : std::unary_function<_T1, _Res> { };
+
+ /// Derives from @c binary_function, as appropriate.
+ template<typename _Res, typename _T1, typename _T2>
+ struct _Maybe_unary_or_binary_function<_Res, _T1, _T2>
+ : std::binary_function<_T1, _T2, _Res> { };
+
+
+ /**
+ * @brief Exception class thrown when class template function's
+ * operator() is called with an empty target.
+ * @ingroup exceptions
+ */
+ class bad_function_call : public std::exception
+ {
+ public:
+ virtual ~bad_function_call() noexcept;
+
+ const char* what() const noexcept;
+ };
+
+ /**
+ * Trait identifying "location-invariant" types, meaning that the
+ * address of the object (or any of its members) will not escape.
+ * Trivially copyable types are location-invariant and users can
+ * specialize this trait for other types.
+ */
+ template<typename _Tp>
+ struct __is_location_invariant
+ : is_trivially_copyable<_Tp>::type
+ { };
+
+ class _Undefined_class;
+
+ union _Nocopy_types
+ {
+ void* _M_object;
+ const void* _M_const_object;
+ void (*_M_function_pointer)();
+ void (_Undefined_class::*_M_member_pointer)();
+ };
+
+ union [[gnu::may_alias]] _Any_data
+ {
+ void* _M_access() { return &_M_pod_data[0]; }
+ const void* _M_access() const { return &_M_pod_data[0]; }
+
+ template<typename _Tp>
+ _Tp&
+ _M_access()
+ { return *static_cast<_Tp*>(_M_access()); }
+
+ template<typename _Tp>
+ const _Tp&
+ _M_access() const
+ { return *static_cast<const _Tp*>(_M_access()); }
+
+ _Nocopy_types _M_unused;
+ char _M_pod_data[sizeof(_Nocopy_types)];
+ };
+
+ enum _Manager_operation
+ {
+ __get_type_info,
+ __get_functor_ptr,
+ __clone_functor,
+ __destroy_functor
+ };
+
+ // Simple type wrapper that helps avoid annoying const problems
+ // when casting between void pointers and pointers-to-pointers.
+ template<typename _Tp>
+ struct _Simple_type_wrapper
+ {
+ _Simple_type_wrapper(_Tp __value) : __value(__value) { }
+
+ _Tp __value;
+ };
+
+ template<typename _Tp>
+ struct __is_location_invariant<_Simple_type_wrapper<_Tp> >
+ : __is_location_invariant<_Tp>
+ { };
+
+ template<typename _Signature>
+ class function;
+
+ /// Base class of all polymorphic function object wrappers.
+ class _Function_base
+ {
+ public:
+ static const std::size_t _M_max_size = sizeof(_Nocopy_types);
+ static const std::size_t _M_max_align = __alignof__(_Nocopy_types);
+
+ template<typename _Functor>
+ class _Base_manager
+ {
+ protected:
+ static const bool __stored_locally =
+ (__is_location_invariant<_Functor>::value
+ && sizeof(_Functor) <= _M_max_size
+ && __alignof__(_Functor) <= _M_max_align
+ && (_M_max_align % __alignof__(_Functor) == 0));
+
+ typedef integral_constant<bool, __stored_locally> _Local_storage;
+
+ // Retrieve a pointer to the function object
+ static _Functor*
+ _M_get_pointer(const _Any_data& __source)
+ {
+ const _Functor* __ptr =
+ __stored_locally? std::__addressof(__source._M_access<_Functor>())
+ /* have stored a pointer */ : __source._M_access<_Functor*>();
+ return const_cast<_Functor*>(__ptr);
+ }
+
+ // Clone a location-invariant function object that fits within
+ // an _Any_data structure.
+ static void
+ _M_clone(_Any_data& __dest, const _Any_data& __source, true_type)
+ {
+ ::new (__dest._M_access()) _Functor(__source._M_access<_Functor>());
+ }
+
+ // Clone a function object that is not location-invariant or
+ // that cannot fit into an _Any_data structure.
+ static void
+ _M_clone(_Any_data& __dest, const _Any_data& __source, false_type)
+ {
+ __dest._M_access<_Functor*>() =
+ new _Functor(*__source._M_access<_Functor*>());
+ }
+
+ // Destroying a location-invariant object may still require
+ // destruction.
+ static void
+ _M_destroy(_Any_data& __victim, true_type)
+ {
+ __victim._M_access<_Functor>().~_Functor();
+ }
+
+ // Destroying an object located on the heap.
+ static void
+ _M_destroy(_Any_data& __victim, false_type)
+ {
+ delete __victim._M_access<_Functor*>();
+ }
+
+ public:
+ static bool
+ _M_manager(_Any_data& __dest, const _Any_data& __source,
+ _Manager_operation __op)
+ {
+ switch (__op)
+ {
+#if __cpp_rtti
+ case __get_type_info:
+ __dest._M_access<const type_info*>() = &typeid(_Functor);
+ break;
+#endif
+ case __get_functor_ptr:
+ __dest._M_access<_Functor*>() = _M_get_pointer(__source);
+ break;
+
+ case __clone_functor:
+ _M_clone(__dest, __source, _Local_storage());
+ break;
+
+ case __destroy_functor:
+ _M_destroy(__dest, _Local_storage());
+ break;
+ }
+ return false;
+ }
+
+ static void
+ _M_init_functor(_Any_data& __functor, _Functor&& __f)
+ { _M_init_functor(__functor, std::move(__f), _Local_storage()); }
+
+ template<typename _Signature>
+ static bool
+ _M_not_empty_function(const function<_Signature>& __f)
+ { return static_cast<bool>(__f); }
+
+ template<typename _Tp>
+ static bool
+ _M_not_empty_function(_Tp* __fp)
+ { return __fp != nullptr; }
+
+ template<typename _Class, typename _Tp>
+ static bool
+ _M_not_empty_function(_Tp _Class::* __mp)
+ { return __mp != nullptr; }
+
+ template<typename _Tp>
+ static bool
+ _M_not_empty_function(const _Tp&)
+ { return true; }
+
+ private:
+ static void
+ _M_init_functor(_Any_data& __functor, _Functor&& __f, true_type)
+ { ::new (__functor._M_access()) _Functor(std::move(__f)); }
+
+ static void
+ _M_init_functor(_Any_data& __functor, _Functor&& __f, false_type)
+ { __functor._M_access<_Functor*>() = new _Functor(std::move(__f)); }
+ };
+
+ template<typename _Functor>
+ class _Ref_manager : public _Base_manager<_Functor*>
+ {
+ typedef _Function_base::_Base_manager<_Functor*> _Base;
+
+ public:
+ static bool
+ _M_manager(_Any_data& __dest, const _Any_data& __source,
+ _Manager_operation __op)
+ {
+ switch (__op)
+ {
+#if __cpp_rtti
+ case __get_type_info:
+ __dest._M_access<const type_info*>() = &typeid(_Functor);
+ break;
+#endif
+ case __get_functor_ptr:
+ __dest._M_access<_Functor*>() = *_Base::_M_get_pointer(__source);
+ return is_const<_Functor>::value;
+ break;
+
+ default:
+ _Base::_M_manager(__dest, __source, __op);
+ }
+ return false;
+ }
+
+ static void
+ _M_init_functor(_Any_data& __functor, reference_wrapper<_Functor> __f)
+ {
+ _Base::_M_init_functor(__functor, std::__addressof(__f.get()));
+ }
+ };
+
+ _Function_base() : _M_manager(nullptr) { }
+
+ ~_Function_base()
+ {
+ if (_M_manager)
+ _M_manager(_M_functor, _M_functor, __destroy_functor);
+ }
+
+
+ bool _M_empty() const { return !_M_manager; }
+
+ typedef bool (*_Manager_type)(_Any_data&, const _Any_data&,
+ _Manager_operation);
+
+ _Any_data _M_functor;
+ _Manager_type _M_manager;
+ };
+
+ template<typename _Signature, typename _Functor>
+ class _Function_handler;
+
+ template<typename _Res, typename _Functor, typename... _ArgTypes>
+ class _Function_handler<_Res(_ArgTypes...), _Functor>
+ : public _Function_base::_Base_manager<_Functor>
+ {
+ typedef _Function_base::_Base_manager<_Functor> _Base;
+
+ public:
+ static _Res
+ _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
+ {
+ return (*_Base::_M_get_pointer(__functor))(
+ std::forward<_ArgTypes>(__args)...);
+ }
+ };
+
+ template<typename _Functor, typename... _ArgTypes>
+ class _Function_handler<void(_ArgTypes...), _Functor>
+ : public _Function_base::_Base_manager<_Functor>
+ {
+ typedef _Function_base::_Base_manager<_Functor> _Base;
+
+ public:
+ static void
+ _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
+ {
+ (*_Base::_M_get_pointer(__functor))(
+ std::forward<_ArgTypes>(__args)...);
+ }
+ };
+
+ template<typename _Res, typename _Functor, typename... _ArgTypes>
+ class _Function_handler<_Res(_ArgTypes...), reference_wrapper<_Functor> >
+ : public _Function_base::_Ref_manager<_Functor>
+ {
+ typedef _Function_base::_Ref_manager<_Functor> _Base;
+
+ public:
+ static _Res
+ _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
+ {
+ return std::__invoke(**_Base::_M_get_pointer(__functor),
+ std::forward<_ArgTypes>(__args)...);
+ }
+ };
+
+ template<typename _Functor, typename... _ArgTypes>
+ class _Function_handler<void(_ArgTypes...), reference_wrapper<_Functor> >
+ : public _Function_base::_Ref_manager<_Functor>
+ {
+ typedef _Function_base::_Ref_manager<_Functor> _Base;
+
+ public:
+ static void
+ _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
+ {
+ std::__invoke(**_Base::_M_get_pointer(__functor),
+ std::forward<_ArgTypes>(__args)...);
+ }
+ };
+
+ template<typename _Class, typename _Member, typename _Res,
+ typename... _ArgTypes>
+ class _Function_handler<_Res(_ArgTypes...), _Member _Class::*>
+ : public _Function_handler<void(_ArgTypes...), _Member _Class::*>
+ {
+ typedef _Function_handler<void(_ArgTypes...), _Member _Class::*>
+ _Base;
+
+ public:
+ static _Res
+ _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
+ {
+ return std::__invoke(_Base::_M_get_pointer(__functor)->__value,
+ std::forward<_ArgTypes>(__args)...);
+ }
+ };
+
+ template<typename _Class, typename _Member, typename... _ArgTypes>
+ class _Function_handler<void(_ArgTypes...), _Member _Class::*>
+ : public _Function_base::_Base_manager<
+ _Simple_type_wrapper< _Member _Class::* > >
+ {
+ typedef _Member _Class::* _Functor;
+ typedef _Simple_type_wrapper<_Functor> _Wrapper;
+ typedef _Function_base::_Base_manager<_Wrapper> _Base;
+
+ public:
+ static bool
+ _M_manager(_Any_data& __dest, const _Any_data& __source,
+ _Manager_operation __op)
+ {
+ switch (__op)
+ {
+#if __cpp_rtti
+ case __get_type_info:
+ __dest._M_access<const type_info*>() = &typeid(_Functor);
+ break;
+#endif
+ case __get_functor_ptr:
+ __dest._M_access<_Functor*>() =
+ &_Base::_M_get_pointer(__source)->__value;
+ break;
+
+ default:
+ _Base::_M_manager(__dest, __source, __op);
+ }
+ return false;
+ }
+
+ static void
+ _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
+ {
+ std::__invoke(_Base::_M_get_pointer(__functor)->__value,
+ std::forward<_ArgTypes>(__args)...);
+ }
+ };
+
+ template<typename _From, typename _To>
+ using __check_func_return_type
+ = __or_<is_void<_To>, is_same<_From, _To>, is_convertible<_From, _To>>;
+
+ /**
+ * @brief Primary class template for std::function.
+ * @ingroup functors
+ *
+ * Polymorphic function wrapper.
+ */
+ template<typename _Res, typename... _ArgTypes>
+ class function<_Res(_ArgTypes...)>
+ : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>,
+ private _Function_base
+ {
+ typedef _Res _Signature_type(_ArgTypes...);
+
+ template<typename _Func,
+ typename _Res2 = typename result_of<_Func&(_ArgTypes...)>::type>
+ struct _Callable : __check_func_return_type<_Res2, _Res> { };
+
+ // Used so the return type convertibility checks aren't done when
+ // performing overload resolution for copy construction/assignment.
+ template<typename _Tp>
+ struct _Callable<function, _Tp> : false_type { };
+
+ template<typename _Cond, typename _Tp>
+ using _Requires = typename enable_if<_Cond::value, _Tp>::type;
+
+ public:
+ typedef _Res result_type;
+
+ // [3.7.2.1] construct/copy/destroy
+
+ /**
+ * @brief Default construct creates an empty function call wrapper.
+ * @post @c !(bool)*this
+ */
+ function() noexcept
+ : _Function_base() { }
+
+ /**
+ * @brief Creates an empty function call wrapper.
+ * @post @c !(bool)*this
+ */
+ function(nullptr_t) noexcept
+ : _Function_base() { }
+
+ /**
+ * @brief %Function copy constructor.
+ * @param __x A %function object with identical call signature.
+ * @post @c bool(*this) == bool(__x)
+ *
+ * The newly-created %function contains a copy of the target of @a
+ * __x (if it has one).
+ */
+ function(const function& __x);
+
+ /**
+ * @brief %Function move constructor.
+ * @param __x A %function object rvalue with identical call signature.
+ *
+ * The newly-created %function contains the target of @a __x
+ * (if it has one).
+ */
+ function(function&& __x) : _Function_base()
+ {
+ __x.swap(*this);
+ }
+
+ /**
+ * @brief Builds a %function that targets a copy of the incoming
+ * function object.
+ * @param __f A %function object that is callable with parameters of
+ * type @c T1, @c T2, ..., @c TN and returns a value convertible
+ * to @c Res.
+ *
+ * The newly-created %function object will target a copy of
+ * @a __f. If @a __f is @c reference_wrapper<F>, then this function
+ * object will contain a reference to the function object @c
+ * __f.get(). If @a __f is a NULL function pointer or NULL
+ * pointer-to-member, the newly-created object will be empty.
+ *
+ * If @a __f is a non-NULL function pointer or an object of type @c
+ * reference_wrapper<F>, this function will not throw.
+ */
+ template<typename _Functor,
+ typename = _Requires<__not_<is_same<_Functor, function>>, void>,
+ typename = _Requires<_Callable<_Functor>, void>>
+ function(_Functor);
+
+ /**
+ * @brief %Function assignment operator.
+ * @param __x A %function with identical call signature.
+ * @post @c (bool)*this == (bool)x
+ * @returns @c *this
+ *
+ * The target of @a __x is copied to @c *this. If @a __x has no
+ * target, then @c *this will be empty.
+ *
+ * If @a __x targets a function pointer or a reference to a function
+ * object, then this operation will not throw an %exception.
+ */
+ function&
+ operator=(const function& __x)
+ {
+ function(__x).swap(*this);
+ return *this;
+ }
+
+ /**
+ * @brief %Function move-assignment operator.
+ * @param __x A %function rvalue with identical call signature.
+ * @returns @c *this
+ *
+ * The target of @a __x is moved to @c *this. If @a __x has no
+ * target, then @c *this will be empty.
+ *
+ * If @a __x targets a function pointer or a reference to a function
+ * object, then this operation will not throw an %exception.
+ */
+ function&
+ operator=(function&& __x)
+ {
+ function(std::move(__x)).swap(*this);
+ return *this;
+ }
+
+ /**
+ * @brief %Function assignment to zero.
+ * @post @c !(bool)*this
+ * @returns @c *this
+ *
+ * The target of @c *this is deallocated, leaving it empty.
+ */
+ function&
+ operator=(nullptr_t) noexcept
+ {
+ if (_M_manager)
+ {
+ _M_manager(_M_functor, _M_functor, __destroy_functor);
+ _M_manager = nullptr;
+ _M_invoker = nullptr;
+ }
+ return *this;
+ }
+
+ /**
+ * @brief %Function assignment to a new target.
+ * @param __f A %function object that is callable with parameters of
+ * type @c T1, @c T2, ..., @c TN and returns a value convertible
+ * to @c Res.
+ * @return @c *this
+ *
+ * This %function object wrapper will target a copy of @a
+ * __f. If @a __f is @c reference_wrapper<F>, then this function
+ * object will contain a reference to the function object @c
+ * __f.get(). If @a __f is a NULL function pointer or NULL
+ * pointer-to-member, @c this object will be empty.
+ *
+ * If @a __f is a non-NULL function pointer or an object of type @c
+ * reference_wrapper<F>, this function will not throw.
+ */
+ template<typename _Functor>
+ _Requires<_Callable<typename decay<_Functor>::type>, function&>
+ operator=(_Functor&& __f)
+ {
+ function(std::forward<_Functor>(__f)).swap(*this);
+ return *this;
+ }
+
+ /// @overload
+ template<typename _Functor>
+ function&
+ operator=(reference_wrapper<_Functor> __f) noexcept
+ {
+ function(__f).swap(*this);
+ return *this;
+ }
+
+ // [3.7.2.2] function modifiers
+
+ /**
+ * @brief Swap the targets of two %function objects.
+ * @param __x A %function with identical call signature.
+ *
+ * Swap the targets of @c this function object and @a __f. This
+ * function will not throw an %exception.
+ */
+ void swap(function& __x) noexcept
+ {
+ std::swap(_M_functor, __x._M_functor);
+ std::swap(_M_manager, __x._M_manager);
+ std::swap(_M_invoker, __x._M_invoker);
+ }
+
+ // [3.7.2.3] function capacity
+
+ /**
+ * @brief Determine if the %function wrapper has a target.
+ *
+ * @return @c true when this %function object contains a target,
+ * or @c false when it is empty.
+ *
+ * This function will not throw an %exception.
+ */
+ explicit operator bool() const noexcept
+ { return !_M_empty(); }
+
+ // [3.7.2.4] function invocation
+
+ /**
+ * @brief Invokes the function targeted by @c *this.
+ * @returns the result of the target.
+ * @throws bad_function_call when @c !(bool)*this
+ *
+ * The function call operator invokes the target function object
+ * stored by @c this.
+ */
+ _Res operator()(_ArgTypes... __args) const;
+
+#if __cpp_rtti
+ // [3.7.2.5] function target access
+ /**
+ * @brief Determine the type of the target of this function object
+ * wrapper.
+ *
+ * @returns the type identifier of the target function object, or
+ * @c typeid(void) if @c !(bool)*this.
+ *
+ * This function will not throw an %exception.
+ */
+ const type_info& target_type() const noexcept;
+
+ /**
+ * @brief Access the stored target function object.
+ *
+ * @return Returns a pointer to the stored target function object,
+ * if @c typeid(Functor).equals(target_type()); otherwise, a NULL
+ * pointer.
+ *
+ * This function will not throw an %exception.
+ */
+ template<typename _Functor> _Functor* target() noexcept;
+
+ /// @overload
+ template<typename _Functor> const _Functor* target() const noexcept;
+#endif
+
+ private:
+ using _Invoker_type = _Res (*)(const _Any_data&, _ArgTypes&&...);
+ _Invoker_type _M_invoker;
+ };
+
+ // Out-of-line member definitions.
+ template<typename _Res, typename... _ArgTypes>
+ function<_Res(_ArgTypes...)>::
+ function(const function& __x)
+ : _Function_base()
+ {
+ if (static_cast<bool>(__x))
+ {
+ __x._M_manager(_M_functor, __x._M_functor, __clone_functor);
+ _M_invoker = __x._M_invoker;
+ _M_manager = __x._M_manager;
+ }
+ }
+
+ template<typename _Res, typename... _ArgTypes>
+ template<typename _Functor, typename, typename>
+ function<_Res(_ArgTypes...)>::
+ function(_Functor __f)
+ : _Function_base()
+ {
+ typedef _Function_handler<_Signature_type, _Functor> _My_handler;
+
+ if (_My_handler::_M_not_empty_function(__f))
+ {
+ _My_handler::_M_init_functor(_M_functor, std::move(__f));
+ _M_invoker = &_My_handler::_M_invoke;
+ _M_manager = &_My_handler::_M_manager;
+ }
+ }
+
+ template<typename _Res, typename... _ArgTypes>
+ _Res
+ function<_Res(_ArgTypes...)>::
+ operator()(_ArgTypes... __args) const
+ {
+ if (_M_empty())
+ __throw_bad_function_call();
+ return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...);
+ }
+
+#if __cpp_rtti
+ template<typename _Res, typename... _ArgTypes>
+ const type_info&
+ function<_Res(_ArgTypes...)>::
+ target_type() const noexcept
+ {
+ if (_M_manager)
+ {
+ _Any_data __typeinfo_result;
+ _M_manager(__typeinfo_result, _M_functor, __get_type_info);
+ return *__typeinfo_result._M_access<const type_info*>();
+ }
+ else
+ return typeid(void);
+ }
+
+ template<typename _Res, typename... _ArgTypes>
+ template<typename _Functor>
+ _Functor*
+ function<_Res(_ArgTypes...)>::
+ target() noexcept
+ {
+ if (typeid(_Functor) == target_type() && _M_manager)
+ {
+ _Any_data __ptr;
+ if (_M_manager(__ptr, _M_functor, __get_functor_ptr)
+ && !is_const<_Functor>::value)
+ return 0;
+ else
+ return __ptr._M_access<_Functor*>();
+ }
+ else
+ return 0;
+ }
+
+ template<typename _Res, typename... _ArgTypes>
+ template<typename _Functor>
+ const _Functor*
+ function<_Res(_ArgTypes...)>::
+ target() const noexcept
+ {
+ if (typeid(_Functor) == target_type() && _M_manager)
+ {
+ _Any_data __ptr;
+ _M_manager(__ptr, _M_functor, __get_functor_ptr);
+ return __ptr._M_access<const _Functor*>();
+ }
+ else
+ return 0;
+ }
+#endif
+
+ // [20.7.15.2.6] null pointer comparisons
+
+ /**
+ * @brief Compares a polymorphic function object wrapper against 0
+ * (the NULL pointer).
+ * @returns @c true if the wrapper has no target, @c false otherwise
+ *
+ * This function will not throw an %exception.
+ */
+ template<typename _Res, typename... _Args>
+ inline bool
+ operator==(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
+ { return !static_cast<bool>(__f); }
+
+ /// @overload
+ template<typename _Res, typename... _Args>
+ inline bool
+ operator==(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
+ { return !static_cast<bool>(__f); }
+
+ /**
+ * @brief Compares a polymorphic function object wrapper against 0
+ * (the NULL pointer).
+ * @returns @c false if the wrapper has no target, @c true otherwise
+ *
+ * This function will not throw an %exception.
+ */
+ template<typename _Res, typename... _Args>
+ inline bool
+ operator!=(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
+ { return static_cast<bool>(__f); }
+
+ /// @overload
+ template<typename _Res, typename... _Args>
+ inline bool
+ operator!=(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
+ { return static_cast<bool>(__f); }
+
+
+ // [20.7.15.2.7] specialized algorithms
+
+ /**
+ * @brief Swap the targets of two polymorphic function object wrappers.
+ *
+ * This function will not throw an %exception.
+ */
+ // _GLIBCXX_RESOLVE_LIB_DEFECTS
+ // 2062. Effect contradictions w/o no-throw guarantee of std::function swaps
+ template<typename _Res, typename... _Args>
+ inline void
+ swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y) noexcept
+ { __x.swap(__y); }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
+#endif // C++11
+
+#endif // _GLIBCXX_STD_FUNCTION_H
#include <type_traits>
#include <utility>
#include <tuple>
+#include <bits/stl_function.h>
namespace std _GLIBCXX_VISIBILITY(default)
{
#if __cplusplus >= 201103L
-#include <typeinfo>
#include <new>
#include <tuple>
#include <type_traits>
-#include <bits/functexcept.h>
#include <bits/functional_hash.h>
#include <bits/invoke.h>
-
+#include <bits/std_function.h>
#if __cplusplus > 201402L
-#include <unordered_map>
-#include <vector>
-#include <array>
-#include <utility>
-#include <bits/stl_algo.h>
+# include <unordered_map>
+# include <vector>
+# include <utility>
+# include <bits/stl_algo.h>
#endif
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
- template<typename _MemberPointer>
- class _Mem_fn;
- template<typename _Tp, typename _Class>
- _Mem_fn<_Tp _Class::*>
- mem_fn(_Tp _Class::*) noexcept;
-
- /// If we have found a result_type, extract it.
- template<typename _Functor, typename = __void_t<>>
- struct _Maybe_get_result_type
- { };
-
- template<typename _Functor>
- struct _Maybe_get_result_type<_Functor,
- __void_t<typename _Functor::result_type>>
- { typedef typename _Functor::result_type result_type; };
-
- /**
- * Base class for any function object that has a weak result type, as
- * defined in 20.8.2 [func.require] of C++11.
- */
- template<typename _Functor>
- struct _Weak_result_type_impl
- : _Maybe_get_result_type<_Functor>
- { };
-
- /// Retrieve the result type for a function type.
- template<typename _Res, typename... _ArgTypes>
- struct _Weak_result_type_impl<_Res(_ArgTypes...)>
- { typedef _Res result_type; };
-
- template<typename _Res, typename... _ArgTypes>
- struct _Weak_result_type_impl<_Res(_ArgTypes......)>
- { typedef _Res result_type; };
-
- template<typename _Res, typename... _ArgTypes>
- struct _Weak_result_type_impl<_Res(_ArgTypes...) const>
- { typedef _Res result_type; };
-
- template<typename _Res, typename... _ArgTypes>
- struct _Weak_result_type_impl<_Res(_ArgTypes......) const>
- { typedef _Res result_type; };
-
- template<typename _Res, typename... _ArgTypes>
- struct _Weak_result_type_impl<_Res(_ArgTypes...) volatile>
- { typedef _Res result_type; };
-
- template<typename _Res, typename... _ArgTypes>
- struct _Weak_result_type_impl<_Res(_ArgTypes......) volatile>
- { typedef _Res result_type; };
-
- template<typename _Res, typename... _ArgTypes>
- struct _Weak_result_type_impl<_Res(_ArgTypes...) const volatile>
- { typedef _Res result_type; };
-
- template<typename _Res, typename... _ArgTypes>
- struct _Weak_result_type_impl<_Res(_ArgTypes......) const volatile>
- { typedef _Res result_type; };
-
- /// Retrieve the result type for a function reference.
- template<typename _Res, typename... _ArgTypes>
- struct _Weak_result_type_impl<_Res(&)(_ArgTypes...)>
- { typedef _Res result_type; };
-
- template<typename _Res, typename... _ArgTypes>
- struct _Weak_result_type_impl<_Res(&)(_ArgTypes......)>
- { typedef _Res result_type; };
-
- /// Retrieve the result type for a function pointer.
- template<typename _Res, typename... _ArgTypes>
- struct _Weak_result_type_impl<_Res(*)(_ArgTypes...)>
- { typedef _Res result_type; };
-
- template<typename _Res, typename... _ArgTypes>
- struct _Weak_result_type_impl<_Res(*)(_ArgTypes......)>
- { typedef _Res result_type; };
-
- /// Retrieve result type for a member function pointer.
- template<typename _Res, typename _Class, typename... _ArgTypes>
- struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)>
- { typedef _Res result_type; };
-
- template<typename _Res, typename _Class, typename... _ArgTypes>
- struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)>
- { typedef _Res result_type; };
-
- /// Retrieve result type for a const member function pointer.
- template<typename _Res, typename _Class, typename... _ArgTypes>
- struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) const>
- { typedef _Res result_type; };
-
- template<typename _Res, typename _Class, typename... _ArgTypes>
- struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) const>
- { typedef _Res result_type; };
-
- /// Retrieve result type for a volatile member function pointer.
- template<typename _Res, typename _Class, typename... _ArgTypes>
- struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) volatile>
- { typedef _Res result_type; };
-
- template<typename _Res, typename _Class, typename... _ArgTypes>
- struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) volatile>
- { typedef _Res result_type; };
-
- /// Retrieve result type for a const volatile member function pointer.
- template<typename _Res, typename _Class, typename... _ArgTypes>
- struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)
- const volatile>
- { typedef _Res result_type; };
-
- template<typename _Res, typename _Class, typename... _ArgTypes>
- struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)
- const volatile>
- { typedef _Res result_type; };
-
- /**
- * Strip top-level cv-qualifiers from the function object and let
- * _Weak_result_type_impl perform the real work.
- */
- template<typename _Functor>
- struct _Weak_result_type
- : _Weak_result_type_impl<typename remove_cv<_Functor>::type>
- { };
-
#if __cplusplus > 201402L
# define __cpp_lib_invoke 201411
}
#endif
- // Detect nested argument_type.
- template<typename _Tp, typename = __void_t<>>
- struct _Refwrap_base_arg1
- { };
-
- // Nested argument_type.
- template<typename _Tp>
- struct _Refwrap_base_arg1<_Tp,
- __void_t<typename _Tp::argument_type>>
- {
- typedef typename _Tp::argument_type argument_type;
- };
-
- // Detect nested first_argument_type and second_argument_type.
- template<typename _Tp, typename = __void_t<>>
- struct _Refwrap_base_arg2
- { };
-
- // Nested first_argument_type and second_argument_type.
- template<typename _Tp>
- struct _Refwrap_base_arg2<_Tp,
- __void_t<typename _Tp::first_argument_type,
- typename _Tp::second_argument_type>>
- {
- typedef typename _Tp::first_argument_type first_argument_type;
- typedef typename _Tp::second_argument_type second_argument_type;
- };
-
- /**
- * Derives from unary_function or binary_function when it
- * can. Specializations handle all of the easy cases. The primary
- * template determines what to do with a class type, which may
- * derive from both unary_function and binary_function.
- */
- template<typename _Tp>
- struct _Reference_wrapper_base
- : _Weak_result_type<_Tp>, _Refwrap_base_arg1<_Tp>, _Refwrap_base_arg2<_Tp>
- { };
-
- // - a function type (unary)
- template<typename _Res, typename _T1>
- struct _Reference_wrapper_base<_Res(_T1)>
- : unary_function<_T1, _Res>
- { };
-
- template<typename _Res, typename _T1>
- struct _Reference_wrapper_base<_Res(_T1) const>
- : unary_function<_T1, _Res>
- { };
-
- template<typename _Res, typename _T1>
- struct _Reference_wrapper_base<_Res(_T1) volatile>
- : unary_function<_T1, _Res>
- { };
-
- template<typename _Res, typename _T1>
- struct _Reference_wrapper_base<_Res(_T1) const volatile>
- : unary_function<_T1, _Res>
- { };
-
- // - a function type (binary)
- template<typename _Res, typename _T1, typename _T2>
- struct _Reference_wrapper_base<_Res(_T1, _T2)>
- : binary_function<_T1, _T2, _Res>
- { };
-
- template<typename _Res, typename _T1, typename _T2>
- struct _Reference_wrapper_base<_Res(_T1, _T2) const>
- : binary_function<_T1, _T2, _Res>
- { };
-
- template<typename _Res, typename _T1, typename _T2>
- struct _Reference_wrapper_base<_Res(_T1, _T2) volatile>
- : binary_function<_T1, _T2, _Res>
- { };
-
- template<typename _Res, typename _T1, typename _T2>
- struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile>
- : binary_function<_T1, _T2, _Res>
- { };
-
- // - a function pointer type (unary)
- template<typename _Res, typename _T1>
- struct _Reference_wrapper_base<_Res(*)(_T1)>
- : unary_function<_T1, _Res>
- { };
-
- // - a function pointer type (binary)
- template<typename _Res, typename _T1, typename _T2>
- struct _Reference_wrapper_base<_Res(*)(_T1, _T2)>
- : binary_function<_T1, _T2, _Res>
- { };
-
- // - a pointer to member function type (unary, no qualifiers)
- template<typename _Res, typename _T1>
- struct _Reference_wrapper_base<_Res (_T1::*)()>
- : unary_function<_T1*, _Res>
- { };
-
- // - a pointer to member function type (binary, no qualifiers)
- template<typename _Res, typename _T1, typename _T2>
- struct _Reference_wrapper_base<_Res (_T1::*)(_T2)>
- : binary_function<_T1*, _T2, _Res>
- { };
-
- // - a pointer to member function type (unary, const)
- template<typename _Res, typename _T1>
- struct _Reference_wrapper_base<_Res (_T1::*)() const>
- : unary_function<const _T1*, _Res>
- { };
-
- // - a pointer to member function type (binary, const)
- template<typename _Res, typename _T1, typename _T2>
- struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const>
- : binary_function<const _T1*, _T2, _Res>
- { };
-
- // - a pointer to member function type (unary, volatile)
- template<typename _Res, typename _T1>
- struct _Reference_wrapper_base<_Res (_T1::*)() volatile>
- : unary_function<volatile _T1*, _Res>
- { };
-
- // - a pointer to member function type (binary, volatile)
- template<typename _Res, typename _T1, typename _T2>
- struct _Reference_wrapper_base<_Res (_T1::*)(_T2) volatile>
- : binary_function<volatile _T1*, _T2, _Res>
- { };
-
- // - a pointer to member function type (unary, const volatile)
- template<typename _Res, typename _T1>
- struct _Reference_wrapper_base<_Res (_T1::*)() const volatile>
- : unary_function<const volatile _T1*, _Res>
- { };
-
- // - a pointer to member function type (binary, const volatile)
- template<typename _Res, typename _T1, typename _T2>
- struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const volatile>
- : binary_function<const volatile _T1*, _T2, _Res>
- { };
-
- /**
- * @brief Primary class template for reference_wrapper.
- * @ingroup functors
- * @{
- */
- template<typename _Tp>
- class reference_wrapper
- : public _Reference_wrapper_base<typename remove_cv<_Tp>::type>
- {
- _Tp* _M_data;
-
- public:
- typedef _Tp type;
-
- reference_wrapper(_Tp& __indata) noexcept
- : _M_data(std::__addressof(__indata))
- { }
-
- reference_wrapper(_Tp&&) = delete;
-
- reference_wrapper(const reference_wrapper&) = default;
-
- reference_wrapper&
- operator=(const reference_wrapper&) = default;
-
- operator _Tp&() const noexcept
- { return this->get(); }
-
- _Tp&
- get() const noexcept
- { return *_M_data; }
-
- template<typename... _Args>
- typename result_of<_Tp&(_Args&&...)>::type
- operator()(_Args&&... __args) const
- {
- return std::__invoke(get(), std::forward<_Args>(__args)...);
- }
- };
-
-
- /// Denotes a reference should be taken to a variable.
- template<typename _Tp>
- inline reference_wrapper<_Tp>
- ref(_Tp& __t) noexcept
- { return reference_wrapper<_Tp>(__t); }
-
- /// Denotes a const reference should be taken to a variable.
- template<typename _Tp>
- inline reference_wrapper<const _Tp>
- cref(const _Tp& __t) noexcept
- { return reference_wrapper<const _Tp>(__t); }
-
- template<typename _Tp>
- void ref(const _Tp&&) = delete;
-
- template<typename _Tp>
- void cref(const _Tp&&) = delete;
-
- /// Partial specialization.
- template<typename _Tp>
- inline reference_wrapper<_Tp>
- ref(reference_wrapper<_Tp> __t) noexcept
- { return ref(__t.get()); }
-
- /// Partial specialization.
- template<typename _Tp>
- inline reference_wrapper<const _Tp>
- cref(reference_wrapper<_Tp> __t) noexcept
- { return cref(__t.get()); }
-
- // @} group functors
-
template<typename... _Types>
struct _Pack : integral_constant<size_t, sizeof...(_Types)>
{ };
using _NotSame = __not_<is_same<typename std::decay<_Tp1>::type,
typename std::decay<_Tp2>::type>>;
- /**
- * Derives from @c unary_function or @c binary_function, or perhaps
- * nothing, depending on the number of arguments provided. The
- * primary template is the basis case, which derives nothing.
- */
- template<typename _Res, typename... _ArgTypes>
- struct _Maybe_unary_or_binary_function { };
-
- /// Derives from @c unary_function, as appropriate.
- template<typename _Res, typename _T1>
- struct _Maybe_unary_or_binary_function<_Res, _T1>
- : std::unary_function<_T1, _Res> { };
-
- /// Derives from @c binary_function, as appropriate.
- template<typename _Res, typename _T1, typename _T2>
- struct _Maybe_unary_or_binary_function<_Res, _T1, _T2>
- : std::binary_function<_T1, _T2, _Res> { };
-
template<typename _Signature>
struct _Mem_fn_traits;
{ return std::__invoke(_M_pm, std::forward<_Tp>(__obj)); }
};
+ template<typename _MemberPointer>
+ struct _Mem_fn; // undefined
+
template<typename _Res, typename _Class>
struct _Mem_fn<_Res _Class::*>
: _Mem_fn_base<_Res _Class::*>
std::forward<_BoundArgs>(__args)...);
}
- /**
- * @brief Exception class thrown when class template function's
- * operator() is called with an empty target.
- * @ingroup exceptions
- */
- class bad_function_call : public std::exception
- {
- public:
- virtual ~bad_function_call() noexcept;
-
- const char* what() const noexcept;
- };
-
- /**
- * Trait identifying "location-invariant" types, meaning that the
- * address of the object (or any of its members) will not escape.
- * Trivially copyable types are location-invariant and users can
- * specialize this trait for other types.
- */
- template<typename _Tp>
- struct __is_location_invariant
- : is_trivially_copyable<_Tp>::type
- { };
-
- class _Undefined_class;
-
- union _Nocopy_types
- {
- void* _M_object;
- const void* _M_const_object;
- void (*_M_function_pointer)();
- void (_Undefined_class::*_M_member_pointer)();
- };
-
- union [[gnu::may_alias]] _Any_data
- {
- void* _M_access() { return &_M_pod_data[0]; }
- const void* _M_access() const { return &_M_pod_data[0]; }
-
- template<typename _Tp>
- _Tp&
- _M_access()
- { return *static_cast<_Tp*>(_M_access()); }
-
- template<typename _Tp>
- const _Tp&
- _M_access() const
- { return *static_cast<const _Tp*>(_M_access()); }
-
- _Nocopy_types _M_unused;
- char _M_pod_data[sizeof(_Nocopy_types)];
- };
-
- enum _Manager_operation
- {
- __get_type_info,
- __get_functor_ptr,
- __clone_functor,
- __destroy_functor
- };
-
- // Simple type wrapper that helps avoid annoying const problems
- // when casting between void pointers and pointers-to-pointers.
- template<typename _Tp>
- struct _Simple_type_wrapper
- {
- _Simple_type_wrapper(_Tp __value) : __value(__value) { }
-
- _Tp __value;
- };
-
- template<typename _Tp>
- struct __is_location_invariant<_Simple_type_wrapper<_Tp> >
- : __is_location_invariant<_Tp>
- { };
-
- template<typename _Signature>
- class function;
-
- /// Base class of all polymorphic function object wrappers.
- class _Function_base
- {
- public:
- static const std::size_t _M_max_size = sizeof(_Nocopy_types);
- static const std::size_t _M_max_align = __alignof__(_Nocopy_types);
-
- template<typename _Functor>
- class _Base_manager
- {
- protected:
- static const bool __stored_locally =
- (__is_location_invariant<_Functor>::value
- && sizeof(_Functor) <= _M_max_size
- && __alignof__(_Functor) <= _M_max_align
- && (_M_max_align % __alignof__(_Functor) == 0));
-
- typedef integral_constant<bool, __stored_locally> _Local_storage;
-
- // Retrieve a pointer to the function object
- static _Functor*
- _M_get_pointer(const _Any_data& __source)
- {
- const _Functor* __ptr =
- __stored_locally? std::__addressof(__source._M_access<_Functor>())
- /* have stored a pointer */ : __source._M_access<_Functor*>();
- return const_cast<_Functor*>(__ptr);
- }
-
- // Clone a location-invariant function object that fits within
- // an _Any_data structure.
- static void
- _M_clone(_Any_data& __dest, const _Any_data& __source, true_type)
- {
- ::new (__dest._M_access()) _Functor(__source._M_access<_Functor>());
- }
-
- // Clone a function object that is not location-invariant or
- // that cannot fit into an _Any_data structure.
- static void
- _M_clone(_Any_data& __dest, const _Any_data& __source, false_type)
- {
- __dest._M_access<_Functor*>() =
- new _Functor(*__source._M_access<_Functor*>());
- }
-
- // Destroying a location-invariant object may still require
- // destruction.
- static void
- _M_destroy(_Any_data& __victim, true_type)
- {
- __victim._M_access<_Functor>().~_Functor();
- }
-
- // Destroying an object located on the heap.
- static void
- _M_destroy(_Any_data& __victim, false_type)
- {
- delete __victim._M_access<_Functor*>();
- }
-
- public:
- static bool
- _M_manager(_Any_data& __dest, const _Any_data& __source,
- _Manager_operation __op)
- {
- switch (__op)
- {
-#if __cpp_rtti
- case __get_type_info:
- __dest._M_access<const type_info*>() = &typeid(_Functor);
- break;
-#endif
- case __get_functor_ptr:
- __dest._M_access<_Functor*>() = _M_get_pointer(__source);
- break;
-
- case __clone_functor:
- _M_clone(__dest, __source, _Local_storage());
- break;
-
- case __destroy_functor:
- _M_destroy(__dest, _Local_storage());
- break;
- }
- return false;
- }
-
- static void
- _M_init_functor(_Any_data& __functor, _Functor&& __f)
- { _M_init_functor(__functor, std::move(__f), _Local_storage()); }
-
- template<typename _Signature>
- static bool
- _M_not_empty_function(const function<_Signature>& __f)
- { return static_cast<bool>(__f); }
-
- template<typename _Tp>
- static bool
- _M_not_empty_function(_Tp* __fp)
- { return __fp != nullptr; }
-
- template<typename _Class, typename _Tp>
- static bool
- _M_not_empty_function(_Tp _Class::* __mp)
- { return __mp != nullptr; }
-
- template<typename _Tp>
- static bool
- _M_not_empty_function(const _Tp&)
- { return true; }
-
- private:
- static void
- _M_init_functor(_Any_data& __functor, _Functor&& __f, true_type)
- { ::new (__functor._M_access()) _Functor(std::move(__f)); }
-
- static void
- _M_init_functor(_Any_data& __functor, _Functor&& __f, false_type)
- { __functor._M_access<_Functor*>() = new _Functor(std::move(__f)); }
- };
-
- template<typename _Functor>
- class _Ref_manager : public _Base_manager<_Functor*>
- {
- typedef _Function_base::_Base_manager<_Functor*> _Base;
-
- public:
- static bool
- _M_manager(_Any_data& __dest, const _Any_data& __source,
- _Manager_operation __op)
- {
- switch (__op)
- {
-#if __cpp_rtti
- case __get_type_info:
- __dest._M_access<const type_info*>() = &typeid(_Functor);
- break;
-#endif
- case __get_functor_ptr:
- __dest._M_access<_Functor*>() = *_Base::_M_get_pointer(__source);
- return is_const<_Functor>::value;
- break;
-
- default:
- _Base::_M_manager(__dest, __source, __op);
- }
- return false;
- }
-
- static void
- _M_init_functor(_Any_data& __functor, reference_wrapper<_Functor> __f)
- {
- _Base::_M_init_functor(__functor, std::__addressof(__f.get()));
- }
- };
-
- _Function_base() : _M_manager(nullptr) { }
-
- ~_Function_base()
- {
- if (_M_manager)
- _M_manager(_M_functor, _M_functor, __destroy_functor);
- }
-
-
- bool _M_empty() const { return !_M_manager; }
-
- typedef bool (*_Manager_type)(_Any_data&, const _Any_data&,
- _Manager_operation);
-
- _Any_data _M_functor;
- _Manager_type _M_manager;
- };
-
- template<typename _Signature, typename _Functor>
- class _Function_handler;
-
- template<typename _Res, typename _Functor, typename... _ArgTypes>
- class _Function_handler<_Res(_ArgTypes...), _Functor>
- : public _Function_base::_Base_manager<_Functor>
- {
- typedef _Function_base::_Base_manager<_Functor> _Base;
-
- public:
- static _Res
- _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
- {
- return (*_Base::_M_get_pointer(__functor))(
- std::forward<_ArgTypes>(__args)...);
- }
- };
-
- template<typename _Functor, typename... _ArgTypes>
- class _Function_handler<void(_ArgTypes...), _Functor>
- : public _Function_base::_Base_manager<_Functor>
- {
- typedef _Function_base::_Base_manager<_Functor> _Base;
-
- public:
- static void
- _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
- {
- (*_Base::_M_get_pointer(__functor))(
- std::forward<_ArgTypes>(__args)...);
- }
- };
-
- template<typename _Res, typename _Functor, typename... _ArgTypes>
- class _Function_handler<_Res(_ArgTypes...), reference_wrapper<_Functor> >
- : public _Function_base::_Ref_manager<_Functor>
- {
- typedef _Function_base::_Ref_manager<_Functor> _Base;
-
- public:
- static _Res
- _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
- {
- return std::__invoke(**_Base::_M_get_pointer(__functor),
- std::forward<_ArgTypes>(__args)...);
- }
- };
-
- template<typename _Functor, typename... _ArgTypes>
- class _Function_handler<void(_ArgTypes...), reference_wrapper<_Functor> >
- : public _Function_base::_Ref_manager<_Functor>
- {
- typedef _Function_base::_Ref_manager<_Functor> _Base;
-
- public:
- static void
- _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
- {
- std::__invoke(**_Base::_M_get_pointer(__functor),
- std::forward<_ArgTypes>(__args)...);
- }
- };
-
- template<typename _Class, typename _Member, typename _Res,
- typename... _ArgTypes>
- class _Function_handler<_Res(_ArgTypes...), _Member _Class::*>
- : public _Function_handler<void(_ArgTypes...), _Member _Class::*>
- {
- typedef _Function_handler<void(_ArgTypes...), _Member _Class::*>
- _Base;
-
- public:
- static _Res
- _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
- {
- return std::__invoke(_Base::_M_get_pointer(__functor)->__value,
- std::forward<_ArgTypes>(__args)...);
- }
- };
-
- template<typename _Class, typename _Member, typename... _ArgTypes>
- class _Function_handler<void(_ArgTypes...), _Member _Class::*>
- : public _Function_base::_Base_manager<
- _Simple_type_wrapper< _Member _Class::* > >
- {
- typedef _Member _Class::* _Functor;
- typedef _Simple_type_wrapper<_Functor> _Wrapper;
- typedef _Function_base::_Base_manager<_Wrapper> _Base;
-
- public:
- static bool
- _M_manager(_Any_data& __dest, const _Any_data& __source,
- _Manager_operation __op)
- {
- switch (__op)
- {
-#if __cpp_rtti
- case __get_type_info:
- __dest._M_access<const type_info*>() = &typeid(_Functor);
- break;
-#endif
- case __get_functor_ptr:
- __dest._M_access<_Functor*>() =
- &_Base::_M_get_pointer(__source)->__value;
- break;
-
- default:
- _Base::_M_manager(__dest, __source, __op);
- }
- return false;
- }
-
- static void
- _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
- {
- std::__invoke(_Base::_M_get_pointer(__functor)->__value,
- std::forward<_ArgTypes>(__args)...);
- }
- };
-
- template<typename _From, typename _To>
- using __check_func_return_type
- = __or_<is_void<_To>, is_same<_From, _To>, is_convertible<_From, _To>>;
-
- /**
- * @brief Primary class template for std::function.
- * @ingroup functors
- *
- * Polymorphic function wrapper.
- */
- template<typename _Res, typename... _ArgTypes>
- class function<_Res(_ArgTypes...)>
- : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>,
- private _Function_base
- {
- typedef _Res _Signature_type(_ArgTypes...);
-
- template<typename _Func,
- typename _Res2 = typename result_of<_Func&(_ArgTypes...)>::type>
- struct _Callable : __check_func_return_type<_Res2, _Res> { };
-
- // Used so the return type convertibility checks aren't done when
- // performing overload resolution for copy construction/assignment.
- template<typename _Tp>
- struct _Callable<function, _Tp> : false_type { };
-
- template<typename _Cond, typename _Tp>
- using _Requires = typename enable_if<_Cond::value, _Tp>::type;
-
- public:
- typedef _Res result_type;
-
- // [3.7.2.1] construct/copy/destroy
-
- /**
- * @brief Default construct creates an empty function call wrapper.
- * @post @c !(bool)*this
- */
- function() noexcept
- : _Function_base() { }
-
- /**
- * @brief Creates an empty function call wrapper.
- * @post @c !(bool)*this
- */
- function(nullptr_t) noexcept
- : _Function_base() { }
-
- /**
- * @brief %Function copy constructor.
- * @param __x A %function object with identical call signature.
- * @post @c bool(*this) == bool(__x)
- *
- * The newly-created %function contains a copy of the target of @a
- * __x (if it has one).
- */
- function(const function& __x);
-
- /**
- * @brief %Function move constructor.
- * @param __x A %function object rvalue with identical call signature.
- *
- * The newly-created %function contains the target of @a __x
- * (if it has one).
- */
- function(function&& __x) : _Function_base()
- {
- __x.swap(*this);
- }
-
- /**
- * @brief Builds a %function that targets a copy of the incoming
- * function object.
- * @param __f A %function object that is callable with parameters of
- * type @c T1, @c T2, ..., @c TN and returns a value convertible
- * to @c Res.
- *
- * The newly-created %function object will target a copy of
- * @a __f. If @a __f is @c reference_wrapper<F>, then this function
- * object will contain a reference to the function object @c
- * __f.get(). If @a __f is a NULL function pointer or NULL
- * pointer-to-member, the newly-created object will be empty.
- *
- * If @a __f is a non-NULL function pointer or an object of type @c
- * reference_wrapper<F>, this function will not throw.
- */
- template<typename _Functor,
- typename = _Requires<__not_<is_same<_Functor, function>>, void>,
- typename = _Requires<_Callable<_Functor>, void>>
- function(_Functor);
-
- /**
- * @brief %Function assignment operator.
- * @param __x A %function with identical call signature.
- * @post @c (bool)*this == (bool)x
- * @returns @c *this
- *
- * The target of @a __x is copied to @c *this. If @a __x has no
- * target, then @c *this will be empty.
- *
- * If @a __x targets a function pointer or a reference to a function
- * object, then this operation will not throw an %exception.
- */
- function&
- operator=(const function& __x)
- {
- function(__x).swap(*this);
- return *this;
- }
-
- /**
- * @brief %Function move-assignment operator.
- * @param __x A %function rvalue with identical call signature.
- * @returns @c *this
- *
- * The target of @a __x is moved to @c *this. If @a __x has no
- * target, then @c *this will be empty.
- *
- * If @a __x targets a function pointer or a reference to a function
- * object, then this operation will not throw an %exception.
- */
- function&
- operator=(function&& __x)
- {
- function(std::move(__x)).swap(*this);
- return *this;
- }
-
- /**
- * @brief %Function assignment to zero.
- * @post @c !(bool)*this
- * @returns @c *this
- *
- * The target of @c *this is deallocated, leaving it empty.
- */
- function&
- operator=(nullptr_t) noexcept
- {
- if (_M_manager)
- {
- _M_manager(_M_functor, _M_functor, __destroy_functor);
- _M_manager = nullptr;
- _M_invoker = nullptr;
- }
- return *this;
- }
-
- /**
- * @brief %Function assignment to a new target.
- * @param __f A %function object that is callable with parameters of
- * type @c T1, @c T2, ..., @c TN and returns a value convertible
- * to @c Res.
- * @return @c *this
- *
- * This %function object wrapper will target a copy of @a
- * __f. If @a __f is @c reference_wrapper<F>, then this function
- * object will contain a reference to the function object @c
- * __f.get(). If @a __f is a NULL function pointer or NULL
- * pointer-to-member, @c this object will be empty.
- *
- * If @a __f is a non-NULL function pointer or an object of type @c
- * reference_wrapper<F>, this function will not throw.
- */
- template<typename _Functor>
- _Requires<_Callable<typename decay<_Functor>::type>, function&>
- operator=(_Functor&& __f)
- {
- function(std::forward<_Functor>(__f)).swap(*this);
- return *this;
- }
-
- /// @overload
- template<typename _Functor>
- function&
- operator=(reference_wrapper<_Functor> __f) noexcept
- {
- function(__f).swap(*this);
- return *this;
- }
-
- // [3.7.2.2] function modifiers
-
- /**
- * @brief Swap the targets of two %function objects.
- * @param __x A %function with identical call signature.
- *
- * Swap the targets of @c this function object and @a __f. This
- * function will not throw an %exception.
- */
- void swap(function& __x) noexcept
- {
- std::swap(_M_functor, __x._M_functor);
- std::swap(_M_manager, __x._M_manager);
- std::swap(_M_invoker, __x._M_invoker);
- }
-
- // [3.7.2.3] function capacity
-
- /**
- * @brief Determine if the %function wrapper has a target.
- *
- * @return @c true when this %function object contains a target,
- * or @c false when it is empty.
- *
- * This function will not throw an %exception.
- */
- explicit operator bool() const noexcept
- { return !_M_empty(); }
-
- // [3.7.2.4] function invocation
-
- /**
- * @brief Invokes the function targeted by @c *this.
- * @returns the result of the target.
- * @throws bad_function_call when @c !(bool)*this
- *
- * The function call operator invokes the target function object
- * stored by @c this.
- */
- _Res operator()(_ArgTypes... __args) const;
-
-#if __cpp_rtti
- // [3.7.2.5] function target access
- /**
- * @brief Determine the type of the target of this function object
- * wrapper.
- *
- * @returns the type identifier of the target function object, or
- * @c typeid(void) if @c !(bool)*this.
- *
- * This function will not throw an %exception.
- */
- const type_info& target_type() const noexcept;
-
- /**
- * @brief Access the stored target function object.
- *
- * @return Returns a pointer to the stored target function object,
- * if @c typeid(Functor).equals(target_type()); otherwise, a NULL
- * pointer.
- *
- * This function will not throw an %exception.
- */
- template<typename _Functor> _Functor* target() noexcept;
-
- /// @overload
- template<typename _Functor> const _Functor* target() const noexcept;
-#endif
-
- private:
- using _Invoker_type = _Res (*)(const _Any_data&, _ArgTypes&&...);
- _Invoker_type _M_invoker;
- };
-
- // Out-of-line member definitions.
- template<typename _Res, typename... _ArgTypes>
- function<_Res(_ArgTypes...)>::
- function(const function& __x)
- : _Function_base()
- {
- if (static_cast<bool>(__x))
- {
- __x._M_manager(_M_functor, __x._M_functor, __clone_functor);
- _M_invoker = __x._M_invoker;
- _M_manager = __x._M_manager;
- }
- }
-
- template<typename _Res, typename... _ArgTypes>
- template<typename _Functor, typename, typename>
- function<_Res(_ArgTypes...)>::
- function(_Functor __f)
- : _Function_base()
- {
- typedef _Function_handler<_Signature_type, _Functor> _My_handler;
-
- if (_My_handler::_M_not_empty_function(__f))
- {
- _My_handler::_M_init_functor(_M_functor, std::move(__f));
- _M_invoker = &_My_handler::_M_invoke;
- _M_manager = &_My_handler::_M_manager;
- }
- }
-
- template<typename _Res, typename... _ArgTypes>
- _Res
- function<_Res(_ArgTypes...)>::
- operator()(_ArgTypes... __args) const
- {
- if (_M_empty())
- __throw_bad_function_call();
- return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...);
- }
-
-#if __cpp_rtti
- template<typename _Res, typename... _ArgTypes>
- const type_info&
- function<_Res(_ArgTypes...)>::
- target_type() const noexcept
- {
- if (_M_manager)
- {
- _Any_data __typeinfo_result;
- _M_manager(__typeinfo_result, _M_functor, __get_type_info);
- return *__typeinfo_result._M_access<const type_info*>();
- }
- else
- return typeid(void);
- }
-
- template<typename _Res, typename... _ArgTypes>
- template<typename _Functor>
- _Functor*
- function<_Res(_ArgTypes...)>::
- target() noexcept
- {
- if (typeid(_Functor) == target_type() && _M_manager)
- {
- _Any_data __ptr;
- if (_M_manager(__ptr, _M_functor, __get_functor_ptr)
- && !is_const<_Functor>::value)
- return 0;
- else
- return __ptr._M_access<_Functor*>();
- }
- else
- return 0;
- }
-
- template<typename _Res, typename... _ArgTypes>
- template<typename _Functor>
- const _Functor*
- function<_Res(_ArgTypes...)>::
- target() const noexcept
- {
- if (typeid(_Functor) == target_type() && _M_manager)
- {
- _Any_data __ptr;
- _M_manager(__ptr, _M_functor, __get_functor_ptr);
- return __ptr._M_access<const _Functor*>();
- }
- else
- return 0;
- }
-#endif
-
- // [20.7.15.2.6] null pointer comparisons
-
- /**
- * @brief Compares a polymorphic function object wrapper against 0
- * (the NULL pointer).
- * @returns @c true if the wrapper has no target, @c false otherwise
- *
- * This function will not throw an %exception.
- */
- template<typename _Res, typename... _Args>
- inline bool
- operator==(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
- { return !static_cast<bool>(__f); }
-
- /// @overload
- template<typename _Res, typename... _Args>
- inline bool
- operator==(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
- { return !static_cast<bool>(__f); }
-
- /**
- * @brief Compares a polymorphic function object wrapper against 0
- * (the NULL pointer).
- * @returns @c false if the wrapper has no target, @c true otherwise
- *
- * This function will not throw an %exception.
- */
- template<typename _Res, typename... _Args>
- inline bool
- operator!=(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
- { return static_cast<bool>(__f); }
-
- /// @overload
- template<typename _Res, typename... _Args>
- inline bool
- operator!=(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
- { return static_cast<bool>(__f); }
-
- // [20.7.15.2.7] specialized algorithms
-
- /**
- * @brief Swap the targets of two polymorphic function object wrappers.
- *
- * This function will not throw an %exception.
- */
- // _GLIBCXX_RESOLVE_LIB_DEFECTS
- // 2062. Effect contradictions w/o no-throw guarantee of std::function swaps
- template<typename _Res, typename... _Args>
- inline void
- swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y) noexcept
- { __x.swap(__y); }
-
#if __cplusplus >= 201402L
/// Generalized negator.
template<typename _Fn>
private:
_Fn _M_fn;
};
-#endif // C++14
#if __cplusplus > 201402L
-
#define __cpp_lib_not_fn 201603
-
/// [func.not_fn] Function template not_fn
template<typename _Fn>
inline auto
}
#endif // C++17
+#endif // C++14
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#include <condition_variable>
#include <system_error>
#include <atomic>
-#include <functional>
#include <bits/atomic_futex.h>
#include <bits/functexcept.h>
#include <bits/invoke.h>
#include <bits/unique_ptr.h>
#include <bits/shared_ptr.h>
+#include <bits/std_function.h>
#include <bits/uses_allocator.h>
#include <bits/allocated_ptr.h>
#include <ext/aligned_buffer.h>
# include <thread>
#endif
#ifndef _GLIBCXX_HAVE_TLS
-# include <functional>
+# include <bits/std_function.h>
#endif
#ifdef _GLIBCXX_USE_C99_STDINT_TR1
#include <algorithm>
#include <bitset>
-#include <functional>
#ifdef _GLIBCXX_DEBUG
# include <iosfwd>
#endif
#include <cstring>
#include <ext/aligned_buffer.h>
+#include <bits/std_function.h>
#include <bits/regex_constants.h>
#include <bits/regex_error.h>
#include <bits/regex_automaton.h>
#include <future>
#include <mutex>
+#include <functional>
#if __cplusplus < 201103L
# error "compatibility-thread-c++0x.cc must be compiled with -std=gnu++0x"
D d;
std::default_delete<B[]> db;
typedef decltype(db(&d)) type; // { dg-error "no match" }
-// { dg-error "no type" "" { target *-*-* } 106 }
+// { dg-error "no type" "" { target *-*-* } 107 }
{
std::default_delete<void> d;
d(nullptr); // { dg-error "here" }
- // { dg-error "incomplete" "" { target *-*-* } 72 }
+ // { dg-error "incomplete" "" { target *-*-* } 73 }
}
std::unique_ptr<int, D&> ud(nullptr, d);
ub = std::move(ud); // { dg-error "no match" }
ub2 = ud; // { dg-error "no match" }
-// { dg-error "no type" "" { target *-*-* } 287 }
+// { dg-error "no type" "" { target *-*-* } 288 }
std::unique_ptr<int[], B&> uba(nullptr, b);
std::unique_ptr<int[], D&> uda(nullptr, d);
uba = std::move(uda); // { dg-error "no match" }
-// { dg-error "no type" "" { target *-*-* } 538 }
+// { dg-error "no type" "" { target *-*-* } 539 }
}
std::unique_ptr<const A[]> cA3(p); // { dg-error "no matching function" }
std::unique_ptr<volatile A[]> vA3(p); // { dg-error "no matching function" }
std::unique_ptr<const volatile A[]> cvA3(p); // { dg-error "no matching function" }
- // { dg-error "no type" "" { target *-*-* } 446 }
+ // { dg-error "no type" "" { target *-*-* } 447 }
}
template<typename T>
#include <future>
+#include <functional>
#include <testsuite_hooks.h>
struct moveable
projects / gcc.git / commitdiff