OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libstdc++-v3/] [include/] [std/] [functional] - Blame information for rev 792

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 742 jeremybenn 
//  -*- C++ -*-
2 
 
3 
// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
4 
// 2011 Free Software Foundation, Inc.
5 
//
6 
// This file is part of the GNU ISO C++ Library.  This library is free
7 
// software; you can redistribute it and/or modify it under the
8 
// terms of the GNU General Public License as published by the
9 
// Free Software Foundation; either version 3, or (at your option)
10 
// any later version.
11 
 
12 
// This library is distributed in the hope that it will be useful,
13 
// but WITHOUT ANY WARRANTY; without even the implied warranty of
14 
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 
// GNU General Public License for more details.
16 
 
17 
// Under Section 7 of GPL version 3, you are granted additional
18 
// permissions described in the GCC Runtime Library Exception, version
19 
// 3.1, as published by the Free Software Foundation.
20 
 
21 
// You should have received a copy of the GNU General Public License and
22 
// a copy of the GCC Runtime Library Exception along with this program;
23 
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
24 
// .
25 
 
26 
/*
27 
 * Copyright (c) 1997
28 
 * Silicon Graphics Computer Systems, Inc.
29 
 *
30 
 * Permission to use, copy, modify, distribute and sell this software
31 
 * and its documentation for any purpose is hereby granted without fee,
32 
 * provided that the above copyright notice appear in all copies and
33 
 * that both that copyright notice and this permission notice appear
34 
 * in supporting documentation.  Silicon Graphics makes no
35 
 * representations about the suitability of this software for any
36 
 * purpose.  It is provided "as is" without express or implied warranty.
37 
 *
38 
 */
39 
 
40 
/** @file include/functional
41 
 *  This is a Standard C++ Library header.
42 
 */
43 
 
44 
#ifndef _GLIBCXX_FUNCTIONAL
45 
#define _GLIBCXX_FUNCTIONAL 1
46 
 
47 
#pragma GCC system_header
48 
 
49 
#include
50 
#include
51 
 
52 
#ifdef __GXX_EXPERIMENTAL_CXX0X__
53 
 
54 
#include
55 
#include
56 
#include
57 
#include
58 
#include
59 
#include
60 
 
61 
namespace std _GLIBCXX_VISIBILITY(default)
62 
{
63 
_GLIBCXX_BEGIN_NAMESPACE_VERSION
64 
 
65 
  template
66 
    class _Mem_fn;
67 
  template
68 
    _Mem_fn<_Tp _Class::*>
69 
    mem_fn(_Tp _Class::*);
70 
 
71 
_GLIBCXX_HAS_NESTED_TYPE(result_type)
72 
 
73 
  /// If we have found a result_type, extract it.
74 
  template
75 
    struct _Maybe_get_result_type
76 
    { };
77 
 
78 
  template
79 
    struct _Maybe_get_result_type
80 
    { typedef typename _Functor::result_type result_type; };
81 
 
82 
  /**
83 
   *  Base class for any function object that has a weak result type, as
84 
   *  defined in 3.3/3 of TR1.
85 
  */
86 
  template
87 
    struct _Weak_result_type_impl
88 
    : _Maybe_get_result_type<__has_result_type<_Functor>::value, _Functor>
89 
    { };
90 
 
91 
  /// Retrieve the result type for a function type.
92 
  template
93 
    struct _Weak_result_type_impl<_Res(_ArgTypes...)>
94 
    { typedef _Res result_type; };
95 
 
96 
  template
97 
    struct _Weak_result_type_impl<_Res(_ArgTypes......)>
98 
    { typedef _Res result_type; };
99 
 
100 
  template
101 
    struct _Weak_result_type_impl<_Res(_ArgTypes...) const>
102 
    { typedef _Res result_type; };
103 
 
104 
  template
105 
    struct _Weak_result_type_impl<_Res(_ArgTypes......) const>
106 
    { typedef _Res result_type; };
107 
 
108 
  template
109 
    struct _Weak_result_type_impl<_Res(_ArgTypes...) volatile>
110 
    { typedef _Res result_type; };
111 
 
112 
  template
113 
    struct _Weak_result_type_impl<_Res(_ArgTypes......) volatile>
114 
    { typedef _Res result_type; };
115 
 
116 
  template
117 
    struct _Weak_result_type_impl<_Res(_ArgTypes...) const volatile>
118 
    { typedef _Res result_type; };
119 
 
120 
  template
121 
    struct _Weak_result_type_impl<_Res(_ArgTypes......) const volatile>
122 
    { typedef _Res result_type; };
123 
 
124 
  /// Retrieve the result type for a function reference.
125 
  template
126 
    struct _Weak_result_type_impl<_Res(&)(_ArgTypes...)>
127 
    { typedef _Res result_type; };
128 
 
129 
  template
130 
    struct _Weak_result_type_impl<_Res(&)(_ArgTypes......)>
131 
    { typedef _Res result_type; };
132 
 
133 
  /// Retrieve the result type for a function pointer.
134 
  template
135 
    struct _Weak_result_type_impl<_Res(*)(_ArgTypes...)>
136 
    { typedef _Res result_type; };
137 
 
138 
  template
139 
    struct _Weak_result_type_impl<_Res(*)(_ArgTypes......)>
140 
    { typedef _Res result_type; };
141 
 
142 
  /// Retrieve result type for a member function pointer.
143 
  template
144 
    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)>
145 
    { typedef _Res result_type; };
146 
 
147 
  template
148 
    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)>
149 
    { typedef _Res result_type; };
150 
 
151 
  /// Retrieve result type for a const member function pointer.
152 
  template
153 
    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) const>
154 
    { typedef _Res result_type; };
155 
 
156 
  template
157 
    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) const>
158 
    { typedef _Res result_type; };
159 
 
160 
  /// Retrieve result type for a volatile member function pointer.
161 
  template
162 
    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) volatile>
163 
    { typedef _Res result_type; };
164 
 
165 
  template
166 
    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) volatile>
167 
    { typedef _Res result_type; };
168 
 
169 
  /// Retrieve result type for a const volatile member function pointer.
170 
  template
171 
    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)
172 
                                  const volatile>
173 
    { typedef _Res result_type; };
174 
 
175 
  template
176 
    struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)
177 
                                  const volatile>
178 
    { typedef _Res result_type; };
179 
 
180 
  /**
181 
   *  Strip top-level cv-qualifiers from the function object and let
182 
   *  _Weak_result_type_impl perform the real work.
183 
  */
184 
  template
185 
    struct _Weak_result_type
186 
    : _Weak_result_type_impl::type>
187 
    { };
188 
 
189 
  /// Determines if the type _Tp derives from unary_function.
190 
  template
191 
    struct _Derives_from_unary_function : __sfinae_types
192 
    {
193 
    private:
194 
      template
195 
        static __one __test(const volatile unary_function<_T1, _Res>*);
196 
 
197 
      // It's tempting to change "..." to const volatile void*, but
198 
      // that fails when _Tp is a function type.
199 
      static __two __test(...);
200 
 
201 
    public:
202 
      static const bool value = sizeof(__test((_Tp*)0)) == 1;
203 
    };
204 
 
205 
  /// Determines if the type _Tp derives from binary_function.
206 
  template
207 
    struct _Derives_from_binary_function : __sfinae_types
208 
    {
209 
    private:
210 
      template
211 
        static __one __test(const volatile binary_function<_T1, _T2, _Res>*);
212 
 
213 
      // It's tempting to change "..." to const volatile void*, but
214 
      // that fails when _Tp is a function type.
215 
      static __two __test(...);
216 
 
217 
    public:
218 
      static const bool value = sizeof(__test((_Tp*)0)) == 1;
219 
    };
220 
 
221 
  /**
222 
   * Invoke a function object, which may be either a member pointer or a
223 
   * function object. The first parameter will tell which.
224 
   */
225 
  template
226 
    inline
227 
    typename enable_if<
228 
             (!is_member_pointer<_Functor>::value
229 
              && !is_function<_Functor>::value
230 
              && !is_function::type>::value),
231 
             typename result_of<_Functor(_Args&&...)>::type
232 
           >::type
233 
    __invoke(_Functor& __f, _Args&&... __args)
234 
    {
235 
      return __f(std::forward<_Args>(__args)...);
236 
    }
237 
 
238 
  template
239 
    inline
240 
    typename enable_if<
241 
             (is_member_pointer<_Functor>::value
242 
              && !is_function<_Functor>::value
243 
              && !is_function::type>::value),
244 
             typename result_of<_Functor(_Args&&...)>::type
245 
           >::type
246 
    __invoke(_Functor& __f, _Args&&... __args)
247 
    {
248 
      return mem_fn(__f)(std::forward<_Args>(__args)...);
249 
    }
250 
 
251 
  // To pick up function references (that will become function pointers)
252 
  template
253 
    inline
254 
    typename enable_if<
255 
             (is_pointer<_Functor>::value
256 
              && is_function::type>::value),
257 
             typename result_of<_Functor(_Args&&...)>::type
258 
           >::type
259 
    __invoke(_Functor __f, _Args&&... __args)
260 
    {
261 
      return __f(std::forward<_Args>(__args)...);
262 
    }
263 
 
264 
  /**
265 
   *  Knowing which of unary_function and binary_function _Tp derives
266 
   *  from, derives from the same and ensures that reference_wrapper
267 
   *  will have a weak result type. See cases below.
268 
   */
269 
  template
270 
    struct _Reference_wrapper_base_impl;
271 
 
272 
  // None of the nested argument types.
273 
  template
274 
    struct _Reference_wrapper_base_impl
275 
    : _Weak_result_type<_Tp>
276 
    { };
277 
 
278 
  // Nested argument_type only.
279 
  template
280 
    struct _Reference_wrapper_base_impl
281 
    : _Weak_result_type<_Tp>
282 
    {
283 
      typedef typename _Tp::argument_type argument_type;
284 
    };
285 
 
286 
  // Nested first_argument_type and second_argument_type only.
287 
  template
288 
    struct _Reference_wrapper_base_impl
289 
    : _Weak_result_type<_Tp>
290 
    {
291 
      typedef typename _Tp::first_argument_type first_argument_type;
292 
      typedef typename _Tp::second_argument_type second_argument_type;
293 
    };
294 
 
295 
  // All the nested argument types.
296 
   template
297 
    struct _Reference_wrapper_base_impl
298 
    : _Weak_result_type<_Tp>
299 
    {
300 
      typedef typename _Tp::argument_type argument_type;
301 
      typedef typename _Tp::first_argument_type first_argument_type;
302 
      typedef typename _Tp::second_argument_type second_argument_type;
303 
    };
304 
 
305 
  _GLIBCXX_HAS_NESTED_TYPE(argument_type)
306 
  _GLIBCXX_HAS_NESTED_TYPE(first_argument_type)
307 
  _GLIBCXX_HAS_NESTED_TYPE(second_argument_type)
308 
 
309 
  /**
310 
   *  Derives from unary_function or binary_function when it
311 
   *  can. Specializations handle all of the easy cases. The primary
312 
   *  template determines what to do with a class type, which may
313 
   *  derive from both unary_function and binary_function.
314 
  */
315 
  template
316 
    struct _Reference_wrapper_base
317 
    : _Reference_wrapper_base_impl<
318 
      __has_argument_type<_Tp>::value,
319 
      __has_first_argument_type<_Tp>::value
320 
      && __has_second_argument_type<_Tp>::value,
321 
      _Tp>
322 
    { };
323 
 
324 
  // - a function type (unary)
325 
  template
326 
    struct _Reference_wrapper_base<_Res(_T1)>
327 
    : unary_function<_T1, _Res>
328 
    { };
329 
 
330 
  template
331 
    struct _Reference_wrapper_base<_Res(_T1) const>
332 
    : unary_function<_T1, _Res>
333 
    { };
334 
 
335 
  template
336 
    struct _Reference_wrapper_base<_Res(_T1) volatile>
337 
    : unary_function<_T1, _Res>
338 
    { };
339 
 
340 
  template
341 
    struct _Reference_wrapper_base<_Res(_T1) const volatile>
342 
    : unary_function<_T1, _Res>
343 
    { };
344 
 
345 
  // - a function type (binary)
346 
  template
347 
    struct _Reference_wrapper_base<_Res(_T1, _T2)>
348 
    : binary_function<_T1, _T2, _Res>
349 
    { };
350 
 
351 
  template
352 
    struct _Reference_wrapper_base<_Res(_T1, _T2) const>
353 
    : binary_function<_T1, _T2, _Res>
354 
    { };
355 
 
356 
  template
357 
    struct _Reference_wrapper_base<_Res(_T1, _T2) volatile>
358 
    : binary_function<_T1, _T2, _Res>
359 
    { };
360 
 
361 
  template
362 
    struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile>
363 
    : binary_function<_T1, _T2, _Res>
364 
    { };
365 
 
366 
  // - a function pointer type (unary)
367 
  template
368 
    struct _Reference_wrapper_base<_Res(*)(_T1)>
369 
    : unary_function<_T1, _Res>
370 
    { };
371 
 
372 
  // - a function pointer type (binary)
373 
  template
374 
    struct _Reference_wrapper_base<_Res(*)(_T1, _T2)>
375 
    : binary_function<_T1, _T2, _Res>
376 
    { };
377 
 
378 
  // - a pointer to member function type (unary, no qualifiers)
379 
  template
380 
    struct _Reference_wrapper_base<_Res (_T1::*)()>
381 
    : unary_function<_T1*, _Res>
382 
    { };
383 
 
384 
  // - a pointer to member function type (binary, no qualifiers)
385 
  template
386 
    struct _Reference_wrapper_base<_Res (_T1::*)(_T2)>
387 
    : binary_function<_T1*, _T2, _Res>
388 
    { };
389 
 
390 
  // - a pointer to member function type (unary, const)
391 
  template
392 
    struct _Reference_wrapper_base<_Res (_T1::*)() const>
393 
    : unary_function
394 
    { };
395 
 
396 
  // - a pointer to member function type (binary, const)
397 
  template
398 
    struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const>
399 
    : binary_function
400 
    { };
401 
 
402 
  // - a pointer to member function type (unary, volatile)
403 
  template
404 
    struct _Reference_wrapper_base<_Res (_T1::*)() volatile>
405 
    : unary_function
406 
    { };
407 
 
408 
  // - a pointer to member function type (binary, volatile)
409 
  template
410 
    struct _Reference_wrapper_base<_Res (_T1::*)(_T2) volatile>
411 
    : binary_function
412 
    { };
413 
 
414 
  // - a pointer to member function type (unary, const volatile)
415 
  template
416 
    struct _Reference_wrapper_base<_Res (_T1::*)() const volatile>
417 
    : unary_function
418 
    { };
419 
 
420 
  // - a pointer to member function type (binary, const volatile)
421 
  template
422 
    struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const volatile>
423 
    : binary_function
424 
    { };
425 
 
426 
  /**
427 
   *  @brief Primary class template for reference_wrapper.
428 
   *  @ingroup functors
429 
   *  @{
430 
   */
431 
  template
432 
    class reference_wrapper
433 
    : public _Reference_wrapper_base::type>
434 
    {
435 
      _Tp* _M_data;
436 
 
437 
    public:
438 
      typedef _Tp type;
439 
 
440 
      reference_wrapper(_Tp& __indata) noexcept
441 
      : _M_data(std::__addressof(__indata))
442 
      { }
443 
 
444 
      reference_wrapper(_Tp&&) = delete;
445 
 
446 
      reference_wrapper(const reference_wrapper<_Tp>& __inref) noexcept
447 
      : _M_data(__inref._M_data)
448 
      { }
449 
 
450 
      reference_wrapper&
451 
      operator=(const reference_wrapper<_Tp>& __inref) noexcept
452 
      {
453 
        _M_data = __inref._M_data;
454 
        return *this;
455 
      }
456 
 
457 
      operator _Tp&() const noexcept
458 
      { return this->get(); }
459 
 
460 
      _Tp&
461 
      get() const noexcept
462 
      { return *_M_data; }
463 
 
464 
      template
465 
        typename result_of<_Tp&(_Args&&...)>::type
466 
        operator()(_Args&&... __args) const
467 
        {
468 
          return __invoke(get(), std::forward<_Args>(__args)...);
469 
        }
470 
    };
471 
 
472 
 
473 
  /// Denotes a reference should be taken to a variable.
474 
  template
475 
    inline reference_wrapper<_Tp>
476 
    ref(_Tp& __t) noexcept
477 
    { return reference_wrapper<_Tp>(__t); }
478 
 
479 
  /// Denotes a const reference should be taken to a variable.
480 
  template
481 
    inline reference_wrapper
482 
    cref(const _Tp& __t) noexcept
483 
    { return reference_wrapper(__t); }
484 
 
485 
  template
486 
    void ref(const _Tp&&) = delete;
487 
 
488 
  template
489 
    void cref(const _Tp&&) = delete;
490 
 
491 
  /// Partial specialization.
492 
  template
493 
    inline reference_wrapper<_Tp>
494 
    ref(reference_wrapper<_Tp> __t) noexcept
495 
    { return ref(__t.get()); }
496 
 
497 
  /// Partial specialization.
498 
  template
499 
    inline reference_wrapper
500 
    cref(reference_wrapper<_Tp> __t) noexcept
501 
    { return cref(__t.get()); }
502 
 
503 
  // @} group functors
504 
 
505 
  /**
506 
   * Derives from @c unary_function or @c binary_function, or perhaps
507 
   * nothing, depending on the number of arguments provided. The
508 
   * primary template is the basis case, which derives nothing.
509 
   */
510 
  template
511 
    struct _Maybe_unary_or_binary_function { };
512 
 
513 
  /// Derives from @c unary_function, as appropriate.
514 
  template
515 
    struct _Maybe_unary_or_binary_function<_Res, _T1>
516 
    : std::unary_function<_T1, _Res> { };
517 
 
518 
  /// Derives from @c binary_function, as appropriate.
519 
  template
520 
    struct _Maybe_unary_or_binary_function<_Res, _T1, _T2>
521 
    : std::binary_function<_T1, _T2, _Res> { };
522 
 
523 
  /// Implementation of @c mem_fn for member function pointers.
524 
  template
525 
    class _Mem_fn<_Res (_Class::*)(_ArgTypes...)>
526 
    : public _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>
527 
    {
528 
      typedef _Res (_Class::*_Functor)(_ArgTypes...);
529 
 
530 
      template
531 
        _Res
532 
        _M_call(_Tp& __object, const volatile _Class *,
533 
                _ArgTypes... __args) const
534 
        { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); }
535 
 
536 
      template
537 
        _Res
538 
        _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
539 
        { return ((*__ptr).*__pmf)(std::forward<_ArgTypes>(__args)...); }
540 
 
541 
    public:
542 
      typedef _Res result_type;
543 
 
544 
      explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
545 
 
546 
      // Handle objects
547 
      _Res
548 
      operator()(_Class& __object, _ArgTypes... __args) const
549 
      { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); }
550 
 
551 
      // Handle pointers
552 
      _Res
553 
      operator()(_Class* __object, _ArgTypes... __args) const
554 
      { return (__object->*__pmf)(std::forward<_ArgTypes>(__args)...); }
555 
 
556 
      // Handle smart pointers, references and pointers to derived
557 
      template
558 
        _Res
559 
        operator()(_Tp& __object, _ArgTypes... __args) const
560 
        {
561 
          return _M_call(__object, &__object,
562 
              std::forward<_ArgTypes>(__args)...);
563 
        }
564 
 
565 
    private:
566 
      _Functor __pmf;
567 
    };
568 
 
569 
  /// Implementation of @c mem_fn for const member function pointers.
570 
  template
571 
    class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const>
572 
    : public _Maybe_unary_or_binary_function<_Res, const _Class*,
573 
                                             _ArgTypes...>
574 
    {
575 
      typedef _Res (_Class::*_Functor)(_ArgTypes...) const;
576 
 
577 
      template
578 
        _Res
579 
        _M_call(_Tp& __object, const volatile _Class *,
580 
                _ArgTypes... __args) const
581 
        { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); }
582 
 
583 
      template
584 
        _Res
585 
        _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
586 
        { return ((*__ptr).*__pmf)(std::forward<_ArgTypes>(__args)...); }
587 
 
588 
    public:
589 
      typedef _Res result_type;
590 
 
591 
      explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
592 
 
593 
      // Handle objects
594 
      _Res
595 
      operator()(const _Class& __object, _ArgTypes... __args) const
596 
      { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); }
597 
 
598 
      // Handle pointers
599 
      _Res
600 
      operator()(const _Class* __object, _ArgTypes... __args) const
601 
      { return (__object->*__pmf)(std::forward<_ArgTypes>(__args)...); }
602 
 
603 
      // Handle smart pointers, references and pointers to derived
604 
      template
605 
        _Res operator()(_Tp& __object, _ArgTypes... __args) const
606 
        {
607 
          return _M_call(__object, &__object,
608 
              std::forward<_ArgTypes>(__args)...);
609 
        }
610 
 
611 
    private:
612 
      _Functor __pmf;
613 
    };
614 
 
615 
  /// Implementation of @c mem_fn for volatile member function pointers.
616 
  template
617 
    class _Mem_fn<_Res (_Class::*)(_ArgTypes...) volatile>
618 
    : public _Maybe_unary_or_binary_function<_Res, volatile _Class*,
619 
                                             _ArgTypes...>
620 
    {
621 
      typedef _Res (_Class::*_Functor)(_ArgTypes...) volatile;
622 
 
623 
      template
624 
        _Res
625 
        _M_call(_Tp& __object, const volatile _Class *,
626 
                _ArgTypes... __args) const
627 
        { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); }
628 
 
629 
      template
630 
        _Res
631 
        _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
632 
        { return ((*__ptr).*__pmf)(std::forward<_ArgTypes>(__args)...); }
633 
 
634 
    public:
635 
      typedef _Res result_type;
636 
 
637 
      explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
638 
 
639 
      // Handle objects
640 
      _Res
641 
      operator()(volatile _Class& __object, _ArgTypes... __args) const
642 
      { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); }
643 
 
644 
      // Handle pointers
645 
      _Res
646 
      operator()(volatile _Class* __object, _ArgTypes... __args) const
647 
      { return (__object->*__pmf)(std::forward<_ArgTypes>(__args)...); }
648 
 
649 
      // Handle smart pointers, references and pointers to derived
650 
      template
651 
        _Res
652 
        operator()(_Tp& __object, _ArgTypes... __args) const
653 
        {
654 
          return _M_call(__object, &__object,
655 
              std::forward<_ArgTypes>(__args)...);
656 
        }
657 
 
658 
    private:
659 
      _Functor __pmf;
660 
    };
661 
 
662 
  /// Implementation of @c mem_fn for const volatile member function pointers.
663 
  template
664 
    class _Mem_fn<_Res (_Class::*)(_ArgTypes...) const volatile>
665 
    : public _Maybe_unary_or_binary_function<_Res, const volatile _Class*,
666 
                                             _ArgTypes...>
667 
    {
668 
      typedef _Res (_Class::*_Functor)(_ArgTypes...) const volatile;
669 
 
670 
      template
671 
        _Res
672 
        _M_call(_Tp& __object, const volatile _Class *,
673 
                _ArgTypes... __args) const
674 
        { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); }
675 
 
676 
      template
677 
        _Res
678 
        _M_call(_Tp& __ptr, const volatile void *, _ArgTypes... __args) const
679 
        { return ((*__ptr).*__pmf)(std::forward<_ArgTypes>(__args)...); }
680 
 
681 
    public:
682 
      typedef _Res result_type;
683 
 
684 
      explicit _Mem_fn(_Functor __pmf) : __pmf(__pmf) { }
685 
 
686 
      // Handle objects
687 
      _Res
688 
      operator()(const volatile _Class& __object, _ArgTypes... __args) const
689 
      { return (__object.*__pmf)(std::forward<_ArgTypes>(__args)...); }
690 
 
691 
      // Handle pointers
692 
      _Res
693 
      operator()(const volatile _Class* __object, _ArgTypes... __args) const
694 
      { return (__object->*__pmf)(std::forward<_ArgTypes>(__args)...); }
695 
 
696 
      // Handle smart pointers, references and pointers to derived
697 
      template
698 
        _Res operator()(_Tp& __object, _ArgTypes... __args) const
699 
        {
700 
          return _M_call(__object, &__object,
701 
              std::forward<_ArgTypes>(__args)...);
702 
        }
703 
 
704 
    private:
705 
      _Functor __pmf;
706 
    };
707 
 
708 
 
709 
  template
710 
    struct _Mem_fn_const_or_non
711 
    {
712 
      typedef const _Tp& type;
713 
    };
714 
 
715 
  template
716 
    struct _Mem_fn_const_or_non<_Tp, false>
717 
    {
718 
      typedef _Tp& type;
719 
    };
720 
 
721 
  template
722 
    class _Mem_fn<_Res _Class::*>
723 
    {
724 
      // This bit of genius is due to Peter Dimov, improved slightly by
725 
      // Douglas Gregor.
726 
      template
727 
        _Res&
728 
        _M_call(_Tp& __object, _Class *) const
729 
        { return __object.*__pm; }
730 
 
731 
      template
732 
        _Res&
733 
        _M_call(_Tp& __object, _Up * const *) const
734 
        { return (*__object).*__pm; }
735 
 
736 
      template
737 
        const _Res&
738 
        _M_call(_Tp& __object, const _Up * const *) const
739 
        { return (*__object).*__pm; }
740 
 
741 
      template
742 
        const _Res&
743 
        _M_call(_Tp& __object, const _Class *) const
744 
        { return __object.*__pm; }
745 
 
746 
      template
747 
        const _Res&
748 
        _M_call(_Tp& __ptr, const volatile void*) const
749 
        { return (*__ptr).*__pm; }
750 
 
751 
      template static _Tp& __get_ref();
752 
 
753 
      template
754 
        static __sfinae_types::__one __check_const(_Tp&, _Class*);
755 
      template
756 
        static __sfinae_types::__one __check_const(_Tp&, _Up * const *);
757 
      template
758 
        static __sfinae_types::__two __check_const(_Tp&, const _Up * const *);
759 
      template
760 
        static __sfinae_types::__two __check_const(_Tp&, const _Class*);
761 
      template
762 
        static __sfinae_types::__two __check_const(_Tp&, const volatile void*);
763 
 
764 
    public:
765 
      template
766 
        struct _Result_type
767 
        : _Mem_fn_const_or_non<_Res,
768 
          (sizeof(__sfinae_types::__two)
769 
           == sizeof(__check_const<_Tp>(__get_ref<_Tp>(), (_Tp*)0)))>
770 
        { };
771 
 
772 
      template
773 
        struct result;
774 
 
775 
      template
776 
        struct result<_CVMem(_Tp)>
777 
        : public _Result_type<_Tp> { };
778 
 
779 
      template
780 
        struct result<_CVMem(_Tp&)>
781 
        : public _Result_type<_Tp> { };
782 
 
783 
      explicit
784 
      _Mem_fn(_Res _Class::*__pm) : __pm(__pm) { }
785 
 
786 
      // Handle objects
787 
      _Res&
788 
      operator()(_Class& __object) const
789 
      { return __object.*__pm; }
790 
 
791 
      const _Res&
792 
      operator()(const _Class& __object) const
793 
      { return __object.*__pm; }
794 
 
795 
      // Handle pointers
796 
      _Res&
797 
      operator()(_Class* __object) const
798 
      { return __object->*__pm; }
799 
 
800 
      const _Res&
801 
      operator()(const _Class* __object) const
802 
      { return __object->*__pm; }
803 
 
804 
      // Handle smart pointers and derived
805 
      template
806 
        typename _Result_type<_Tp>::type
807 
        operator()(_Tp& __unknown) const
808 
        { return _M_call(__unknown, &__unknown); }
809 
 
810 
    private:
811 
      _Res _Class::*__pm;
812 
    };
813 
 
814 
  /**
815 
   *  @brief Returns a function object that forwards to the member
816 
   *  pointer @a pm.
817 
   *  @ingroup functors
818 
   */
819 
  template
820 
    inline _Mem_fn<_Tp _Class::*>
821 
    mem_fn(_Tp _Class::* __pm)
822 
    {
823 
      return _Mem_fn<_Tp _Class::*>(__pm);
824 
    }
825 
 
826 
  /**
827 
   *  @brief Determines if the given type _Tp is a function object
828 
   *  should be treated as a subexpression when evaluating calls to
829 
   *  function objects returned by bind(). [TR1 3.6.1]
830 
   *  @ingroup binders
831 
   */
832 
  template
833 
    struct is_bind_expression
834 
    : public false_type { };
835 
 
836 
  /**
837 
   *  @brief Determines if the given type _Tp is a placeholder in a
838 
   *  bind() expression and, if so, which placeholder it is. [TR1 3.6.2]
839 
   *  @ingroup binders
840 
   */
841 
  template
842 
    struct is_placeholder
843 
    : public integral_constant
844 
    { };
845 
 
846 
  /** @brief The type of placeholder objects defined by libstdc++.
847 
   *  @ingroup binders
848 
   */
849 
  template struct _Placeholder { };
850 
 
851 
  _GLIBCXX_END_NAMESPACE_VERSION
852 
 
853 
  /** @namespace std::placeholders
854 
   *  @brief ISO C++11 entities sub-namespace for functional.
855 
   *  @ingroup binders
856 
   */
857 
  namespace placeholders
858 
  {
859 
  _GLIBCXX_BEGIN_NAMESPACE_VERSION
860 
  /* Define a large number of placeholders. There is no way to
861 
   * simplify this with variadic templates, because we're introducing
862 
   * unique names for each.
863 
   */
864 
    extern const _Placeholder<1> _1;
865 
    extern const _Placeholder<2> _2;
866 
    extern const _Placeholder<3> _3;
867 
    extern const _Placeholder<4> _4;
868 
    extern const _Placeholder<5> _5;
869 
    extern const _Placeholder<6> _6;
870 
    extern const _Placeholder<7> _7;
871 
    extern const _Placeholder<8> _8;
872 
    extern const _Placeholder<9> _9;
873 
    extern const _Placeholder<10> _10;
874 
    extern const _Placeholder<11> _11;
875 
    extern const _Placeholder<12> _12;
876 
    extern const _Placeholder<13> _13;
877 
    extern const _Placeholder<14> _14;
878 
    extern const _Placeholder<15> _15;
879 
    extern const _Placeholder<16> _16;
880 
    extern const _Placeholder<17> _17;
881 
    extern const _Placeholder<18> _18;
882 
    extern const _Placeholder<19> _19;
883 
    extern const _Placeholder<20> _20;
884 
    extern const _Placeholder<21> _21;
885 
    extern const _Placeholder<22> _22;
886 
    extern const _Placeholder<23> _23;
887 
    extern const _Placeholder<24> _24;
888 
    extern const _Placeholder<25> _25;
889 
    extern const _Placeholder<26> _26;
890 
    extern const _Placeholder<27> _27;
891 
    extern const _Placeholder<28> _28;
892 
    extern const _Placeholder<29> _29;
893 
  _GLIBCXX_END_NAMESPACE_VERSION
894 
  }
895 
 
896 
  _GLIBCXX_BEGIN_NAMESPACE_VERSION
897 
 
898 
  /**
899 
   *  Partial specialization of is_placeholder that provides the placeholder
900 
   *  number for the placeholder objects defined by libstdc++.
901 
   *  @ingroup binders
902 
   */
903 
  template
904 
    struct is_placeholder<_Placeholder<_Num> >
905 
    : public integral_constant
906 
    { };
907 
 
908 
  template
909 
    struct is_placeholder >
910 
    : public integral_constant
911 
    { };
912 
 
913 
  /**
914 
   * Used by _Safe_tuple_element to indicate that there is no tuple
915 
   * element at this position.
916 
   */
917 
  struct _No_tuple_element;
918 
 
919 
  /**
920 
   * Implementation helper for _Safe_tuple_element. This primary
921 
   * template handles the case where it is safe to use @c
922 
   * tuple_element.
923 
   */
924 
  template
925 
    struct _Safe_tuple_element_impl
926 
    : tuple_element<__i, _Tuple> { };
927 
 
928 
  /**
929 
   * Implementation helper for _Safe_tuple_element. This partial
930 
   * specialization handles the case where it is not safe to use @c
931 
   * tuple_element. We just return @c _No_tuple_element.
932 
   */
933 
  template
934 
    struct _Safe_tuple_element_impl<__i, _Tuple, false>
935 
    {
936 
      typedef _No_tuple_element type;
937 
    };
938 
 
939 
  /**
940 
   * Like tuple_element, but returns @c _No_tuple_element when
941 
   * tuple_element would return an error.
942 
   */
943 
 template
944 
   struct _Safe_tuple_element
945 
   : _Safe_tuple_element_impl<__i, _Tuple,
946 
                              (__i < tuple_size<_Tuple>::value)>
947 
   { };
948 
 
949 
  /**
950 
   *  Maps an argument to bind() into an actual argument to the bound
951 
   *  function object [TR1 3.6.3/5]. Only the first parameter should
952 
   *  be specified: the rest are used to determine among the various
953 
   *  implementations. Note that, although this class is a function
954 
   *  object, it isn't entirely normal because it takes only two
955 
   *  parameters regardless of the number of parameters passed to the
956 
   *  bind expression. The first parameter is the bound argument and
957 
   *  the second parameter is a tuple containing references to the
958 
   *  rest of the arguments.
959 
   */
960 
  template
961 
           bool _IsBindExp = is_bind_expression<_Arg>::value,
962 
           bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)>
963 
    class _Mu;
964 
 
965 
  /**
966 
   *  If the argument is reference_wrapper<_Tp>, returns the
967 
   *  underlying reference. [TR1 3.6.3/5 bullet 1]
968 
   */
969 
  template
970 
    class _Mu, false, false>
971 
    {
972 
    public:
973 
      typedef _Tp& result_type;
974 
 
975 
      /* Note: This won't actually work for const volatile
976 
       * reference_wrappers, because reference_wrapper::get() is const
977 
       * but not volatile-qualified. This might be a defect in the TR.
978 
       */
979 
      template
980 
        result_type
981 
        operator()(_CVRef& __arg, _Tuple&) const volatile
982 
        { return __arg.get(); }
983 
    };
984 
 
985 
  /**
986 
   *  If the argument is a bind expression, we invoke the underlying
987 
   *  function object with the same cv-qualifiers as we are given and
988 
   *  pass along all of our arguments (unwrapped). [TR1 3.6.3/5 bullet 2]
989 
   */
990 
  template
991 
    class _Mu<_Arg, true, false>
992 
    {
993 
    public:
994 
      template
995 
        auto
996 
        operator()(_CVArg& __arg,
997 
                   tuple<_Args...>& __tuple) const volatile
998 
        -> decltype(__arg(declval<_Args>()...))
999 
        {
1000 
          // Construct an index tuple and forward to __call
1001 
          typedef typename _Build_index_tuple::__type
1002 
            _Indexes;
1003 
          return this->__call(__arg, __tuple, _Indexes());
1004 
        }
1005 
 
1006 
    private:
1007 
      // Invokes the underlying function object __arg by unpacking all
1008 
      // of the arguments in the tuple.
1009 
      template
1010 
        auto
1011 
        __call(_CVArg& __arg, tuple<_Args...>& __tuple,
1012 
               const _Index_tuple<_Indexes...>&) const volatile
1013 
        -> decltype(__arg(declval<_Args>()...))
1014 
        {
1015 
          return __arg(std::forward<_Args>(get<_Indexes>(__tuple))...);
1016 
        }
1017 
    };
1018 
 
1019 
  /**
1020 
   *  If the argument is a placeholder for the Nth argument, returns
1021 
   *  a reference to the Nth argument to the bind function object.
1022 
   *  [TR1 3.6.3/5 bullet 3]
1023 
   */
1024 
  template
1025 
    class _Mu<_Arg, false, true>
1026 
    {
1027 
    public:
1028 
      template class result;
1029 
 
1030 
      template
1031 
        class result<_CVMu(_CVArg, _Tuple)>
1032 
        {
1033 
          // Add a reference, if it hasn't already been done for us.
1034 
          // This allows us to be a little bit sloppy in constructing
1035 
          // the tuple that we pass to result_of<...>.
1036 
          typedef typename _Safe_tuple_element<(is_placeholder<_Arg>::value
1037 
                                                - 1), _Tuple>::type
1038 
            __base_type;
1039 
 
1040 
        public:
1041 
          typedef typename add_rvalue_reference<__base_type>::type type;
1042 
        };
1043 
 
1044 
      template
1045 
        typename result<_Mu(_Arg, _Tuple)>::type
1046 
        operator()(const volatile _Arg&, _Tuple& __tuple) const volatile
1047 
        {
1048 
          return std::forward::type>(
1049 
              ::std::get<(is_placeholder<_Arg>::value - 1)>(__tuple));
1050 
        }
1051 
    };
1052 
 
1053 
  /**
1054 
   *  If the argument is just a value, returns a reference to that
1055 
   *  value. The cv-qualifiers on the reference are the same as the
1056 
   *  cv-qualifiers on the _Mu object. [TR1 3.6.3/5 bullet 4]
1057 
   */
1058 
  template
1059 
    class _Mu<_Arg, false, false>
1060 
    {
1061 
    public:
1062 
      template struct result;
1063 
 
1064 
      template
1065 
        struct result<_CVMu(_CVArg, _Tuple)>
1066 
        {
1067 
          typedef typename add_lvalue_reference<_CVArg>::type type;
1068 
        };
1069 
 
1070 
      // Pick up the cv-qualifiers of the argument
1071 
      template
1072 
        _CVArg&&
1073 
        operator()(_CVArg&& __arg, _Tuple&) const volatile
1074 
        { return std::forward<_CVArg>(__arg); }
1075 
    };
1076 
 
1077 
  /**
1078 
   *  Maps member pointers into instances of _Mem_fn but leaves all
1079 
   *  other function objects untouched. Used by tr1::bind(). The
1080 
   *  primary template handles the non--member-pointer case.
1081 
   */
1082 
  template
1083 
    struct _Maybe_wrap_member_pointer
1084 
    {
1085 
      typedef _Tp type;
1086 
 
1087 
      static const _Tp&
1088 
      __do_wrap(const _Tp& __x)
1089 
      { return __x; }
1090 
 
1091 
      static _Tp&&
1092 
      __do_wrap(_Tp&& __x)
1093 
      { return static_cast<_Tp&&>(__x); }
1094 
    };
1095 
 
1096 
  /**
1097 
   *  Maps member pointers into instances of _Mem_fn but leaves all
1098 
   *  other function objects untouched. Used by tr1::bind(). This
1099 
   *  partial specialization handles the member pointer case.
1100 
   */
1101 
  template
1102 
    struct _Maybe_wrap_member_pointer<_Tp _Class::*>
1103 
    {
1104 
      typedef _Mem_fn<_Tp _Class::*> type;
1105 
 
1106 
      static type
1107 
      __do_wrap(_Tp _Class::* __pm)
1108 
      { return type(__pm); }
1109 
    };
1110 
 
1111 
  // Specialization needed to prevent "forming reference to void" errors when
1112 
  // bind() is called, because argument deduction instantiates
1113 
  // _Maybe_wrap_member_pointer outside the immediate context where
1114 
  // SFINAE applies.
1115 
  template<>
1116 
    struct _Maybe_wrap_member_pointer
1117 
    {
1118 
      typedef void type;
1119 
    };
1120 
 
1121 
  // std::get for volatile-qualified tuples
1122 
  template
1123 
    inline auto
1124 
    __volget(volatile tuple<_Tp...>& __tuple)
1125 
    -> typename tuple_element<_Ind, tuple<_Tp...>>::type volatile&
1126 
    { return std::get<_Ind>(const_cast&>(__tuple)); }
1127 
 
1128 
  // std::get for const-volatile-qualified tuples
1129 
  template
1130 
    inline auto
1131 
    __volget(const volatile tuple<_Tp...>& __tuple)
1132 
    -> typename tuple_element<_Ind, tuple<_Tp...>>::type const volatile&
1133 
    { return std::get<_Ind>(const_cast&>(__tuple)); }
1134 
 
1135 
  /// Type of the function object returned from bind().
1136 
  template
1137 
    struct _Bind;
1138 
 
1139 
   template
1140 
    class _Bind<_Functor(_Bound_args...)>
1141 
    : public _Weak_result_type<_Functor>
1142 
    {
1143 
      typedef _Bind __self_type;
1144 
      typedef typename _Build_index_tuple::__type
1145 
        _Bound_indexes;
1146 
 
1147 
      _Functor _M_f;
1148 
      tuple<_Bound_args...> _M_bound_args;
1149 
 
1150 
      // Call unqualified
1151 
      template
1152 
        _Result
1153 
        __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>)
1154 
        {
1155 
          return _M_f(_Mu<_Bound_args>()
1156 
                      (get<_Indexes>(_M_bound_args), __args)...);
1157 
        }
1158 
 
1159 
      // Call as const
1160 
      template
1161 
        _Result
1162 
        __call_c(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>) const
1163 
        {
1164 
          return _M_f(_Mu<_Bound_args>()
1165 
                      (get<_Indexes>(_M_bound_args), __args)...);
1166 
        }
1167 
 
1168 
      // Call as volatile
1169 
      template
1170 
        _Result
1171 
        __call_v(tuple<_Args...>&& __args,
1172 
                 _Index_tuple<_Indexes...>) volatile
1173 
        {
1174 
          return _M_f(_Mu<_Bound_args>()
1175 
                      (__volget<_Indexes>(_M_bound_args), __args)...);
1176 
        }
1177 
 
1178 
      // Call as const volatile
1179 
      template
1180 
        _Result
1181 
        __call_c_v(tuple<_Args...>&& __args,
1182 
                   _Index_tuple<_Indexes...>) const volatile
1183 
        {
1184 
          return _M_f(_Mu<_Bound_args>()
1185 
                      (__volget<_Indexes>(_M_bound_args), __args)...);
1186 
        }
1187 
 
1188 
     public:
1189 
      template
1190 
        explicit _Bind(const _Functor& __f, _Args&&... __args)
1191 
        : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
1192 
        { }
1193 
 
1194 
      template
1195 
        explicit _Bind(_Functor&& __f, _Args&&... __args)
1196 
        : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
1197 
        { }
1198 
 
1199 
      _Bind(const _Bind&) = default;
1200 
 
1201 
      _Bind(_Bind&& __b)
1202 
      : _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args))
1203 
      { }
1204 
 
1205 
      // Call unqualified
1206 
      template
1207 
        = decltype( std::declval<_Functor>()(
1208 
              _Mu<_Bound_args>()( std::declval<_Bound_args&>(),
1209 
                                  std::declval&>() )... ) )>
1210 
        _Result
1211 
        operator()(_Args&&... __args)
1212 
        {
1213 
          return this->__call<_Result>(
1214 
              std::forward_as_tuple(std::forward<_Args>(__args)...),
1215 
              _Bound_indexes());
1216 
        }
1217 
 
1218 
      // Call as const
1219 
      template
1220 
        = decltype( std::declval= 0),
1221 
                       typename add_const<_Functor>::type>::type>()(
1222 
              _Mu<_Bound_args>()( std::declval(),
1223 
                                  std::declval&>() )... ) )>
1224 
        _Result
1225 
        operator()(_Args&&... __args) const
1226 
        {
1227 
          return this->__call_c<_Result>(
1228 
              std::forward_as_tuple(std::forward<_Args>(__args)...),
1229 
              _Bound_indexes());
1230 
        }
1231 
 
1232 
      // Call as volatile
1233 
      template
1234 
        = decltype( std::declval= 0),
1235 
                       typename add_volatile<_Functor>::type>::type>()(
1236 
              _Mu<_Bound_args>()( std::declval(),
1237 
                                  std::declval&>() )... ) )>
1238 
        _Result
1239 
        operator()(_Args&&... __args) volatile
1240 
        {
1241 
          return this->__call_v<_Result>(
1242 
              std::forward_as_tuple(std::forward<_Args>(__args)...),
1243 
              _Bound_indexes());
1244 
        }
1245 
 
1246 
      // Call as const volatile
1247 
      template
1248 
        = decltype( std::declval= 0),
1249 
                       typename add_cv<_Functor>::type>::type>()(
1250 
              _Mu<_Bound_args>()( std::declval(),
1251 
                                  std::declval&>() )... ) )>
1252 
        _Result
1253 
        operator()(_Args&&... __args) const volatile
1254 
        {
1255 
          return this->__call_c_v<_Result>(
1256 
              std::forward_as_tuple(std::forward<_Args>(__args)...),
1257 
              _Bound_indexes());
1258 
        }
1259 
    };
1260 
 
1261 
  /// Type of the function object returned from bind().
1262 
  template
1263 
    struct _Bind_result;
1264 
 
1265 
  template
1266 
    class _Bind_result<_Result, _Functor(_Bound_args...)>
1267 
    {
1268 
      typedef _Bind_result __self_type;
1269 
      typedef typename _Build_index_tuple::__type
1270 
        _Bound_indexes;
1271 
 
1272 
      _Functor _M_f;
1273 
      tuple<_Bound_args...> _M_bound_args;
1274 
 
1275 
      // sfinae types
1276 
      template
1277 
        struct __enable_if_void : enable_if::value, int> { };
1278 
      template
1279 
        struct __disable_if_void : enable_if::value, int> { };
1280 
 
1281 
      // Call unqualified
1282 
      template
1283 
        _Result
1284 
        __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
1285 
            typename __disable_if_void<_Res>::type = 0)
1286 
        {
1287 
          return _M_f(_Mu<_Bound_args>()
1288 
                      (get<_Indexes>(_M_bound_args), __args)...);
1289 
        }
1290 
 
1291 
      // Call unqualified, return void
1292 
      template
1293 
        void
1294 
        __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
1295 
            typename __enable_if_void<_Res>::type = 0)
1296 
        {
1297 
          _M_f(_Mu<_Bound_args>()
1298 
               (get<_Indexes>(_M_bound_args), __args)...);
1299 
        }
1300 
 
1301 
      // Call as const
1302 
      template
1303 
        _Result
1304 
        __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
1305 
            typename __disable_if_void<_Res>::type = 0) const
1306 
        {
1307 
          return _M_f(_Mu<_Bound_args>()
1308 
                      (get<_Indexes>(_M_bound_args), __args)...);
1309 
        }
1310 
 
1311 
      // Call as const, return void
1312 
      template
1313 
        void
1314 
        __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
1315 
            typename __enable_if_void<_Res>::type = 0) const
1316 
        {
1317 
          _M_f(_Mu<_Bound_args>()
1318 
               (get<_Indexes>(_M_bound_args),  __args)...);
1319 
        }
1320 
 
1321 
      // Call as volatile
1322 
      template
1323 
        _Result
1324 
        __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
1325 
            typename __disable_if_void<_Res>::type = 0) volatile
1326 
        {
1327 
          return _M_f(_Mu<_Bound_args>()
1328 
                      (__volget<_Indexes>(_M_bound_args), __args)...);
1329 
        }
1330 
 
1331 
      // Call as volatile, return void
1332 
      template
1333 
        void
1334 
        __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
1335 
            typename __enable_if_void<_Res>::type = 0) volatile
1336 
        {
1337 
          _M_f(_Mu<_Bound_args>()
1338 
               (__volget<_Indexes>(_M_bound_args), __args)...);
1339 
        }
1340 
 
1341 
      // Call as const volatile
1342 
      template
1343 
        _Result
1344 
        __call(tuple<_Args...>&& __args, _Index_tuple<_Indexes...>,
1345 
            typename __disable_if_void<_Res>::type = 0) const volatile
1346 
        {
1347 
          return _M_f(_Mu<_Bound_args>()
1348 
                      (__volget<_Indexes>(_M_bound_args), __args)...);
1349 
        }
1350 
 
1351 
      // Call as const volatile, return void
1352 
      template
1353 
        void
1354 
        __call(tuple<_Args...>&& __args,
1355 
               _Index_tuple<_Indexes...>,
1356 
            typename __enable_if_void<_Res>::type = 0) const volatile
1357 
        {
1358 
          _M_f(_Mu<_Bound_args>()
1359 
               (__volget<_Indexes>(_M_bound_args), __args)...);
1360 
        }
1361 
 
1362 
    public:
1363 
      typedef _Result result_type;
1364 
 
1365 
      template
1366 
        explicit _Bind_result(const _Functor& __f, _Args&&... __args)
1367 
        : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
1368 
        { }
1369 
 
1370 
      template
1371 
        explicit _Bind_result(_Functor&& __f, _Args&&... __args)
1372 
        : _M_f(std::move(__f)), _M_bound_args(std::forward<_Args>(__args)...)
1373 
        { }
1374 
 
1375 
      _Bind_result(const _Bind_result&) = default;
1376 
 
1377 
      _Bind_result(_Bind_result&& __b)
1378 
      : _M_f(std::move(__b._M_f)), _M_bound_args(std::move(__b._M_bound_args))
1379 
      { }
1380 
 
1381 
      // Call unqualified
1382 
      template
1383 
        result_type
1384 
        operator()(_Args&&... __args)
1385 
        {
1386 
          return this->__call<_Result>(
1387 
              std::forward_as_tuple(std::forward<_Args>(__args)...),
1388 
              _Bound_indexes());
1389 
        }
1390 
 
1391 
      // Call as const
1392 
      template
1393 
        result_type
1394 
        operator()(_Args&&... __args) const
1395 
        {
1396 
          return this->__call<_Result>(
1397 
              std::forward_as_tuple(std::forward<_Args>(__args)...),
1398 
              _Bound_indexes());
1399 
        }
1400 
 
1401 
      // Call as volatile
1402 
      template
1403 
        result_type
1404 
        operator()(_Args&&... __args) volatile
1405 
        {
1406 
          return this->__call<_Result>(
1407 
              std::forward_as_tuple(std::forward<_Args>(__args)...),
1408 
              _Bound_indexes());
1409 
        }
1410 
 
1411 
      // Call as const volatile
1412 
      template
1413 
        result_type
1414 
        operator()(_Args&&... __args) const volatile
1415 
        {
1416 
          return this->__call<_Result>(
1417 
              std::forward_as_tuple(std::forward<_Args>(__args)...),
1418 
              _Bound_indexes());
1419 
        }
1420 
    };
1421 
 
1422 
  /**
1423 
   *  @brief Class template _Bind is always a bind expression.
1424 
   *  @ingroup binders
1425 
   */
1426 
  template
1427 
    struct is_bind_expression<_Bind<_Signature> >
1428 
    : public true_type { };
1429 
 
1430 
  /**
1431 
   *  @brief Class template _Bind is always a bind expression.
1432 
   *  @ingroup binders
1433 
   */
1434 
  template
1435 
    struct is_bind_expression >
1436 
    : public true_type { };
1437 
 
1438 
  /**
1439 
   *  @brief Class template _Bind is always a bind expression.
1440 
   *  @ingroup binders
1441 
   */
1442 
  template
1443 
    struct is_bind_expression >
1444 
    : public true_type { };
1445 
 
1446 
  /**
1447 
   *  @brief Class template _Bind is always a bind expression.
1448 
   *  @ingroup binders
1449 
   */
1450 
  template
1451 
    struct is_bind_expression>
1452 
    : public true_type { };
1453 
 
1454 
  /**
1455 
   *  @brief Class template _Bind_result is always a bind expression.
1456 
   *  @ingroup binders
1457 
   */
1458 
  template
1459 
    struct is_bind_expression<_Bind_result<_Result, _Signature>>
1460 
    : public true_type { };
1461 
 
1462 
  /**
1463 
   *  @brief Class template _Bind_result is always a bind expression.
1464 
   *  @ingroup binders
1465 
   */
1466 
  template
1467 
    struct is_bind_expression>
1468 
    : public true_type { };
1469 
 
1470 
  /**
1471 
   *  @brief Class template _Bind_result is always a bind expression.
1472 
   *  @ingroup binders
1473 
   */
1474 
  template
1475 
    struct is_bind_expression>
1476 
    : public true_type { };
1477 
 
1478 
  /**
1479 
   *  @brief Class template _Bind_result is always a bind expression.
1480 
   *  @ingroup binders
1481 
   */
1482 
  template
1483 
    struct is_bind_expression>
1484 
    : public true_type { };
1485 
 
1486 
  // Trait type used to remove std::bind() from overload set via SFINAE
1487 
  // when first argument has integer type, so that std::bind() will
1488 
  // not be a better match than ::bind() from the BSD Sockets API.
1489 
  template
1490 
    class __is_socketlike
1491 
    {
1492 
      typedef typename decay<_Tp>::type _Tp2;
1493 
    public:
1494 
      static const bool value =
1495 
        is_integral<_Tp2>::value || is_enum<_Tp2>::value;
1496 
    };
1497 
 
1498 
  template
1499 
    struct _Bind_helper
1500 
    {
1501 
      typedef _Maybe_wrap_member_pointer::type>
1502 
        __maybe_type;
1503 
      typedef typename __maybe_type::type __func_type;
1504 
      typedef _Bind<__func_type(typename decay<_BoundArgs>::type...)> type;
1505 
    };
1506 
 
1507 
  // Partial specialization for is_socketlike == true, does not define
1508 
  // nested type so std::bind() will not participate in overload resolution
1509 
  // when the first argument might be a socket file descriptor.
1510 
  template
1511 
    struct _Bind_helper
1512 
    { };
1513 
 
1514 
  /**
1515 
   *  @brief Function template for std::bind.
1516 
   *  @ingroup binders
1517 
   */
1518 
  template
1519 
    inline typename
1520 
    _Bind_helper<__is_socketlike<_Func>::value, _Func, _BoundArgs...>::type
1521 
    bind(_Func&& __f, _BoundArgs&&... __args)
1522 
    {
1523 
      typedef _Bind_helper __helper_type;
1524 
      typedef typename __helper_type::__maybe_type __maybe_type;
1525 
      typedef typename __helper_type::type __result_type;
1526 
      return __result_type(__maybe_type::__do_wrap(std::forward<_Func>(__f)),
1527 
                           std::forward<_BoundArgs>(__args)...);
1528 
    }
1529 
 
1530 
  template
1531 
    struct _Bindres_helper
1532 
    {
1533 
      typedef _Maybe_wrap_member_pointer::type>
1534 
        __maybe_type;
1535 
      typedef typename __maybe_type::type __functor_type;
1536 
      typedef _Bind_result<_Result,
1537 
                           __functor_type(typename decay<_BoundArgs>::type...)>
1538 
        type;
1539 
    };
1540 
 
1541 
  /**
1542 
   *  @brief Function template for std::bind.
1543 
   *  @ingroup binders
1544 
   */
1545 
  template
1546 
    inline
1547 
    typename _Bindres_helper<_Result, _Func, _BoundArgs...>::type
1548 
    bind(_Func&& __f, _BoundArgs&&... __args)
1549 
    {
1550 
      typedef _Bindres_helper<_Result, _Func, _BoundArgs...> __helper_type;
1551 
      typedef typename __helper_type::__maybe_type __maybe_type;
1552 
      typedef typename __helper_type::type __result_type;
1553 
      return __result_type(__maybe_type::__do_wrap(std::forward<_Func>(__f)),
1554 
                           std::forward<_BoundArgs>(__args)...);
1555 
    }
1556 
 
1557 
  template
1558 
    struct _Bind_simple;
1559 
 
1560 
  template
1561 
    struct _Bind_simple<_Callable(_Args...)>
1562 
    {
1563 
      typedef typename result_of<_Callable(_Args...)>::type result_type;
1564 
 
1565 
      template
1566 
               enable_if< sizeof...(_Args) == sizeof...(_Args2)>::type>
1567 
        explicit
1568 
        _Bind_simple(const _Callable& __callable, _Args2&&... __args)
1569 
        : _M_bound(__callable, std::forward<_Args2>(__args)...)
1570 
        { }
1571 
 
1572 
      template
1573 
               enable_if< sizeof...(_Args) == sizeof...(_Args2)>::type>
1574 
        explicit
1575 
        _Bind_simple(_Callable&& __callable, _Args2&&... __args)
1576 
        : _M_bound(std::move(__callable), std::forward<_Args2>(__args)...)
1577 
        { }
1578 
 
1579 
      _Bind_simple(const _Bind_simple&) = default;
1580 
      _Bind_simple(_Bind_simple&&) = default;
1581 
 
1582 
      result_type
1583 
      operator()()
1584 
      {
1585 
        typedef typename _Build_index_tuple::__type _Indices;
1586 
        return _M_invoke(_Indices());
1587 
      }
1588 
 
1589 
    private:
1590 
 
1591 
      template
1592 
        typename result_of<_Callable(_Args...)>::type
1593 
        _M_invoke(_Index_tuple<_Indices...>)
1594 
        {
1595 
          // std::bind always forwards bound arguments as lvalues,
1596 
          // but this type can call functions which only accept rvalues.
1597 
          return std::forward<_Callable>(std::get<0>(_M_bound))(
1598 
              std::forward<_Args>(std::get<_Indices+1>(_M_bound))...);
1599 
        }
1600 
 
1601 
      std::tuple<_Callable, _Args...> _M_bound;
1602 
    };
1603 
 
1604 
  template
1605 
    struct _Bind_simple_helper
1606 
    {
1607 
      typedef _Maybe_wrap_member_pointer::type>
1608 
        __maybe_type;
1609 
      typedef typename __maybe_type::type __func_type;
1610 
      typedef _Bind_simple<__func_type(typename decay<_BoundArgs>::type...)>
1611 
        __type;
1612 
    };
1613 
 
1614 
  // Simplified version of std::bind for internal use, without support for
1615 
  // unbound arguments, placeholders or nested bind expressions.
1616 
  template
1617 
    typename _Bind_simple_helper<_Callable, _Args...>::__type
1618 
    __bind_simple(_Callable&& __callable, _Args&&... __args)
1619 
    {
1620 
      typedef _Bind_simple_helper<_Callable, _Args...> __helper_type;
1621 
      typedef typename __helper_type::__maybe_type __maybe_type;
1622 
      typedef typename __helper_type::__type __result_type;
1623 
      return __result_type(
1624 
          __maybe_type::__do_wrap( std::forward<_Callable>(__callable)),
1625 
          std::forward<_Args>(__args)...);
1626 
    }
1627 
 
1628 
  /**
1629 
   *  @brief Exception class thrown when class template function's
1630 
   *  operator() is called with an empty target.
1631 
   *  @ingroup exceptions
1632 
   */
1633 
  class bad_function_call : public std::exception
1634 
  {
1635 
  public:
1636 
    virtual ~bad_function_call() noexcept;
1637 
  };
1638 
 
1639 
  /**
1640 
   *  Trait identifying "location-invariant" types, meaning that the
1641 
   *  address of the object (or any of its members) will not escape.
1642 
   *  Also implies a trivial copy constructor and assignment operator.
1643 
   */
1644 
  template
1645 
    struct __is_location_invariant
1646 
    : integral_constant::value
1647 
                               || is_member_pointer<_Tp>::value)>
1648 
    { };
1649 
 
1650 
  class _Undefined_class;
1651 
 
1652 
  union _Nocopy_types
1653 
  {
1654 
    void*       _M_object;
1655 
    const void* _M_const_object;
1656 
    void (*_M_function_pointer)();
1657 
    void (_Undefined_class::*_M_member_pointer)();
1658 
  };
1659 
 
1660 
  union _Any_data
1661 
  {
1662 
    void*       _M_access()       { return &_M_pod_data[0]; }
1663 
    const void* _M_access() const { return &_M_pod_data[0]; }
1664 
 
1665 
    template
1666 
      _Tp&
1667 
      _M_access()
1668 
      { return *static_cast<_Tp*>(_M_access()); }
1669 
 
1670 
    template
1671 
      const _Tp&
1672 
      _M_access() const
1673 
      { return *static_cast(_M_access()); }
1674 
 
1675 
    _Nocopy_types _M_unused;
1676 
    char _M_pod_data[sizeof(_Nocopy_types)];
1677 
  };
1678 
 
1679 
  enum _Manager_operation
1680 
  {
1681 
    __get_type_info,
1682 
    __get_functor_ptr,
1683 
    __clone_functor,
1684 
    __destroy_functor
1685 
  };
1686 
 
1687 
  // Simple type wrapper that helps avoid annoying const problems
1688 
  // when casting between void pointers and pointers-to-pointers.
1689 
  template
1690 
    struct _Simple_type_wrapper
1691 
    {
1692 
      _Simple_type_wrapper(_Tp __value) : __value(__value) { }
1693 
 
1694 
      _Tp __value;
1695 
    };
1696 
 
1697 
  template
1698 
    struct __is_location_invariant<_Simple_type_wrapper<_Tp> >
1699 
    : __is_location_invariant<_Tp>
1700 
    { };
1701 
 
1702 
  // Converts a reference to a function object into a callable
1703 
  // function object.
1704 
  template
1705 
    inline _Functor&
1706 
    __callable_functor(_Functor& __f)
1707 
    { return __f; }
1708 
 
1709 
  template
1710 
    inline _Mem_fn<_Member _Class::*>
1711 
    __callable_functor(_Member _Class::* &__p)
1712 
    { return mem_fn(__p); }
1713 
 
1714 
  template
1715 
    inline _Mem_fn<_Member _Class::*>
1716 
    __callable_functor(_Member _Class::* const &__p)
1717 
    { return mem_fn(__p); }
1718 
 
1719 
  template
1720 
    class function;
1721 
 
1722 
  /// Base class of all polymorphic function object wrappers.
1723 
  class _Function_base
1724 
  {
1725 
  public:
1726 
    static const std::size_t _M_max_size = sizeof(_Nocopy_types);
1727 
    static const std::size_t _M_max_align = __alignof__(_Nocopy_types);
1728 
 
1729 
    template
1730 
      class _Base_manager
1731 
      {
1732 
      protected:
1733 
        static const bool __stored_locally =
1734 
        (__is_location_invariant<_Functor>::value
1735 
         && sizeof(_Functor) <= _M_max_size
1736 
         && __alignof__(_Functor) <= _M_max_align
1737 
         && (_M_max_align % __alignof__(_Functor) == 0));
1738 
 
1739 
        typedef integral_constant _Local_storage;
1740 
 
1741 
        // Retrieve a pointer to the function object
1742 
        static _Functor*
1743 
        _M_get_pointer(const _Any_data& __source)
1744 
        {
1745 
          const _Functor* __ptr =
1746 
            __stored_locally? std::__addressof(__source._M_access<_Functor>())
1747 
            /* have stored a pointer */ : __source._M_access<_Functor*>();
1748 
          return const_cast<_Functor*>(__ptr);
1749 
        }
1750 
 
1751 
        // Clone a location-invariant function object that fits within
1752 
        // an _Any_data structure.
1753 
        static void
1754 
        _M_clone(_Any_data& __dest, const _Any_data& __source, true_type)
1755 
        {
1756 
          new (__dest._M_access()) _Functor(__source._M_access<_Functor>());
1757 
        }
1758 
 
1759 
        // Clone a function object that is not location-invariant or
1760 
        // that cannot fit into an _Any_data structure.
1761 
        static void
1762 
        _M_clone(_Any_data& __dest, const _Any_data& __source, false_type)
1763 
        {
1764 
          __dest._M_access<_Functor*>() =
1765 
            new _Functor(*__source._M_access<_Functor*>());
1766 
        }
1767 
 
1768 
        // Destroying a location-invariant object may still require
1769 
        // destruction.
1770 
        static void
1771 
        _M_destroy(_Any_data& __victim, true_type)
1772 
        {
1773 
          __victim._M_access<_Functor>().~_Functor();
1774 
        }
1775 
 
1776 
        // Destroying an object located on the heap.
1777 
        static void
1778 
        _M_destroy(_Any_data& __victim, false_type)
1779 
        {
1780 
          delete __victim._M_access<_Functor*>();
1781 
        }
1782 
 
1783 
      public:
1784 
        static bool
1785 
        _M_manager(_Any_data& __dest, const _Any_data& __source,
1786 
                   _Manager_operation __op)
1787 
        {
1788 
          switch (__op)
1789 
            {
1790 
#ifdef __GXX_RTTI
1791 
            case __get_type_info:
1792 
              __dest._M_access() = &typeid(_Functor);
1793 
              break;
1794 
#endif
1795 
            case __get_functor_ptr:
1796 
              __dest._M_access<_Functor*>() = _M_get_pointer(__source);
1797 
              break;
1798 
 
1799 
            case __clone_functor:
1800 
              _M_clone(__dest, __source, _Local_storage());
1801 
              break;
1802 
 
1803 
            case __destroy_functor:
1804 
              _M_destroy(__dest, _Local_storage());
1805 
              break;
1806 
            }
1807 
          return false;
1808 
        }
1809 
 
1810 
        static void
1811 
        _M_init_functor(_Any_data& __functor, _Functor&& __f)
1812 
        { _M_init_functor(__functor, std::move(__f), _Local_storage()); }
1813 
 
1814 
        template
1815 
          static bool
1816 
          _M_not_empty_function(const function<_Signature>& __f)
1817 
          { return static_cast(__f); }
1818 
 
1819 
        template
1820 
          static bool
1821 
          _M_not_empty_function(const _Tp*& __fp)
1822 
          { return __fp; }
1823 
 
1824 
        template
1825 
          static bool
1826 
          _M_not_empty_function(_Tp _Class::* const& __mp)
1827 
          { return __mp; }
1828 
 
1829 
        template
1830 
          static bool
1831 
          _M_not_empty_function(const _Tp&)
1832 
          { return true; }
1833 
 
1834 
      private:
1835 
        static void
1836 
        _M_init_functor(_Any_data& __functor, _Functor&& __f, true_type)
1837 
        { new (__functor._M_access()) _Functor(std::move(__f)); }
1838 
 
1839 
        static void
1840 
        _M_init_functor(_Any_data& __functor, _Functor&& __f, false_type)
1841 
        { __functor._M_access<_Functor*>() = new _Functor(std::move(__f)); }
1842 
      };
1843 
 
1844 
    template
1845 
      class _Ref_manager : public _Base_manager<_Functor*>
1846 
      {
1847 
        typedef _Function_base::_Base_manager<_Functor*> _Base;
1848 
 
1849 
    public:
1850 
        static bool
1851 
        _M_manager(_Any_data& __dest, const _Any_data& __source,
1852 
                   _Manager_operation __op)
1853 
        {
1854 
          switch (__op)
1855 
            {
1856 
#ifdef __GXX_RTTI
1857 
            case __get_type_info:
1858 
              __dest._M_access() = &typeid(_Functor);
1859 
              break;
1860 
#endif
1861 
            case __get_functor_ptr:
1862 
              __dest._M_access<_Functor*>() = *_Base::_M_get_pointer(__source);
1863 
              return is_const<_Functor>::value;
1864 
              break;
1865 
 
1866 
            default:
1867 
              _Base::_M_manager(__dest, __source, __op);
1868 
            }
1869 
          return false;
1870 
        }
1871 
 
1872 
        static void
1873 
        _M_init_functor(_Any_data& __functor, reference_wrapper<_Functor> __f)
1874 
        {
1875 
          // TBD: Use address_of function instead.
1876 
          _Base::_M_init_functor(__functor, &__f.get());
1877 
        }
1878 
      };
1879 
 
1880 
    _Function_base() : _M_manager(0) { }
1881 
 
1882 
    ~_Function_base()
1883 
    {
1884 
      if (_M_manager)
1885 
        _M_manager(_M_functor, _M_functor, __destroy_functor);
1886 
    }
1887 
 
1888 
 
1889 
    bool _M_empty() const { return !_M_manager; }
1890 
 
1891 
    typedef bool (*_Manager_type)(_Any_data&, const _Any_data&,
1892 
                                  _Manager_operation);
1893 
 
1894 
    _Any_data     _M_functor;
1895 
    _Manager_type _M_manager;
1896 
  };
1897 
 
1898 
  template
1899 
    class _Function_handler;
1900 
 
1901 
  template
1902 
    class _Function_handler<_Res(_ArgTypes...), _Functor>
1903 
    : public _Function_base::_Base_manager<_Functor>
1904 
    {
1905 
      typedef _Function_base::_Base_manager<_Functor> _Base;
1906 
 
1907 
    public:
1908 
      static _Res
1909 
      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
1910 
      {
1911 
        return (*_Base::_M_get_pointer(__functor))(
1912 
            std::forward<_ArgTypes>(__args)...);
1913 
      }
1914 
    };
1915 
 
1916 
  template
1917 
    class _Function_handler
1918 
    : public _Function_base::_Base_manager<_Functor>
1919 
    {
1920 
      typedef _Function_base::_Base_manager<_Functor> _Base;
1921 
 
1922 
     public:
1923 
      static void
1924 
      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
1925 
      {
1926 
        (*_Base::_M_get_pointer(__functor))(
1927 
            std::forward<_ArgTypes>(__args)...);
1928 
      }
1929 
    };
1930 
 
1931 
  template
1932 
    class _Function_handler<_Res(_ArgTypes...), reference_wrapper<_Functor> >
1933 
    : public _Function_base::_Ref_manager<_Functor>
1934 
    {
1935 
      typedef _Function_base::_Ref_manager<_Functor> _Base;
1936 
 
1937 
     public:
1938 
      static _Res
1939 
      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
1940 
      {
1941 
        return __callable_functor(**_Base::_M_get_pointer(__functor))(
1942 
              std::forward<_ArgTypes>(__args)...);
1943 
      }
1944 
    };
1945 
 
1946 
  template
1947 
    class _Function_handler >
1948 
    : public _Function_base::_Ref_manager<_Functor>
1949 
    {
1950 
      typedef _Function_base::_Ref_manager<_Functor> _Base;
1951 
 
1952 
     public:
1953 
      static void
1954 
      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
1955 
      {
1956 
        __callable_functor(**_Base::_M_get_pointer(__functor))(
1957 
            std::forward<_ArgTypes>(__args)...);
1958 
      }
1959 
    };
1960 
 
1961 
  template
1962 
           typename... _ArgTypes>
1963 
    class _Function_handler<_Res(_ArgTypes...), _Member _Class::*>
1964 
    : public _Function_handler
1965 
    {
1966 
      typedef _Function_handler
1967 
        _Base;
1968 
 
1969 
     public:
1970 
      static _Res
1971 
      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
1972 
      {
1973 
        return mem_fn(_Base::_M_get_pointer(__functor)->__value)(
1974 
            std::forward<_ArgTypes>(__args)...);
1975 
      }
1976 
    };
1977 
 
1978 
  template
1979 
    class _Function_handler
1980 
    : public _Function_base::_Base_manager<
1981 
                 _Simple_type_wrapper< _Member _Class::* > >
1982 
    {
1983 
      typedef _Member _Class::* _Functor;
1984 
      typedef _Simple_type_wrapper<_Functor> _Wrapper;
1985 
      typedef _Function_base::_Base_manager<_Wrapper> _Base;
1986 
 
1987 
     public:
1988 
      static bool
1989 
      _M_manager(_Any_data& __dest, const _Any_data& __source,
1990 
                 _Manager_operation __op)
1991 
      {
1992 
        switch (__op)
1993 
          {
1994 
#ifdef __GXX_RTTI
1995 
          case __get_type_info:
1996 
            __dest._M_access() = &typeid(_Functor);
1997 
            break;
1998 
#endif
1999 
          case __get_functor_ptr:
2000 
            __dest._M_access<_Functor*>() =
2001 
              &_Base::_M_get_pointer(__source)->__value;
2002 
            break;
2003 
 
2004 
          default:
2005 
            _Base::_M_manager(__dest, __source, __op);
2006 
          }
2007 
        return false;
2008 
      }
2009 
 
2010 
      static void
2011 
      _M_invoke(const _Any_data& __functor, _ArgTypes... __args)
2012 
      {
2013 
        mem_fn(_Base::_M_get_pointer(__functor)->__value)(
2014 
            std::forward<_ArgTypes>(__args)...);
2015 
      }
2016 
    };
2017 
 
2018 
  /**
2019 
   *  @brief Primary class template for std::function.
2020 
   *  @ingroup functors
2021 
   *
2022 
   *  Polymorphic function wrapper.
2023 
   */
2024 
  template
2025 
    class function<_Res(_ArgTypes...)>
2026 
    : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>,
2027 
      private _Function_base
2028 
    {
2029 
      typedef _Res _Signature_type(_ArgTypes...);
2030 
 
2031 
      struct _Useless { };
2032 
 
2033 
    public:
2034 
      typedef _Res result_type;
2035 
 
2036 
      // [3.7.2.1] construct/copy/destroy
2037 
 
2038 
      /**
2039 
       *  @brief Default construct creates an empty function call wrapper.
2040 
       *  @post @c !(bool)*this
2041 
       */
2042 
      function() noexcept
2043 
      : _Function_base() { }
2044 
 
2045 
      /**
2046 
       *  @brief Creates an empty function call wrapper.
2047 
       *  @post @c !(bool)*this
2048 
       */
2049 
      function(nullptr_t) noexcept
2050 
      : _Function_base() { }
2051 
 
2052 
      /**
2053 
       *  @brief %Function copy constructor.
2054 
       *  @param __x A %function object with identical call signature.
2055 
       *  @post @c bool(*this) == bool(__x)
2056 
       *
2057 
       *  The newly-created %function contains a copy of the target of @a
2058 
       *  __x (if it has one).
2059 
       */
2060 
      function(const function& __x);
2061 
 
2062 
      /**
2063 
       *  @brief %Function move constructor.
2064 
       *  @param __x A %function object rvalue with identical call signature.
2065 
       *
2066 
       *  The newly-created %function contains the target of @a __x
2067 
       *  (if it has one).
2068 
       */
2069 
      function(function&& __x) : _Function_base()
2070 
      {
2071 
        __x.swap(*this);
2072 
      }
2073 
 
2074 
      // TODO: needs allocator_arg_t
2075 
 
2076 
      /**
2077 
       *  @brief Builds a %function that targets a copy of the incoming
2078 
       *  function object.
2079 
       *  @param __f A %function object that is callable with parameters of
2080 
       *  type @c T1, @c T2, ..., @c TN and returns a value convertible
2081 
       *  to @c Res.
2082 
       *
2083 
       *  The newly-created %function object will target a copy of
2084 
       *  @a __f. If @a __f is @c reference_wrapper, then this function
2085 
       *  object will contain a reference to the function object @c
2086 
       *  __f.get(). If @a __f is a NULL function pointer or NULL
2087 
       *  pointer-to-member, the newly-created object will be empty.
2088 
       *
2089 
       *  If @a __f is a non-NULL function pointer or an object of type @c
2090 
       *  reference_wrapper, this function will not throw.
2091 
       */
2092 
      template
2093 
        function(_Functor __f,
2094 
                 typename enable_if<
2095 
                           !is_integral<_Functor>::value, _Useless>::type
2096 
                   = _Useless());
2097 
 
2098 
      /**
2099 
       *  @brief %Function assignment operator.
2100 
       *  @param __x A %function with identical call signature.
2101 
       *  @post @c (bool)*this == (bool)x
2102 
       *  @returns @c *this
2103 
       *
2104 
       *  The target of @a __x is copied to @c *this. If @a __x has no
2105 
       *  target, then @c *this will be empty.
2106 
       *
2107 
       *  If @a __x targets a function pointer or a reference to a function
2108 
       *  object, then this operation will not throw an %exception.
2109 
       */
2110 
      function&
2111 
      operator=(const function& __x)
2112 
      {
2113 
        function(__x).swap(*this);
2114 
        return *this;
2115 
      }
2116 
 
2117 
      /**
2118 
       *  @brief %Function move-assignment operator.
2119 
       *  @param __x A %function rvalue with identical call signature.
2120 
       *  @returns @c *this
2121 
       *
2122 
       *  The target of @a __x is moved to @c *this. If @a __x has no
2123 
       *  target, then @c *this will be empty.
2124 
       *
2125 
       *  If @a __x targets a function pointer or a reference to a function
2126 
       *  object, then this operation will not throw an %exception.
2127 
       */
2128 
      function&
2129 
      operator=(function&& __x)
2130 
      {
2131 
        function(std::move(__x)).swap(*this);
2132 
        return *this;
2133 
      }
2134 
 
2135 
      /**
2136 
       *  @brief %Function assignment to zero.
2137 
       *  @post @c !(bool)*this
2138 
       *  @returns @c *this
2139 
       *
2140 
       *  The target of @c *this is deallocated, leaving it empty.
2141 
       */
2142 
      function&
2143 
      operator=(nullptr_t)
2144 
      {
2145 
        if (_M_manager)
2146 
          {
2147 
            _M_manager(_M_functor, _M_functor, __destroy_functor);
2148 
            _M_manager = 0;
2149 
            _M_invoker = 0;
2150 
          }
2151 
        return *this;
2152 
      }
2153 
 
2154 
      /**
2155 
       *  @brief %Function assignment to a new target.
2156 
       *  @param __f A %function object that is callable with parameters of
2157 
       *  type @c T1, @c T2, ..., @c TN and returns a value convertible
2158 
       *  to @c Res.
2159 
       *  @return @c *this
2160 
       *
2161 
       *  This  %function object wrapper will target a copy of @a
2162 
       *  __f. If @a __f is @c reference_wrapper, then this function
2163 
       *  object will contain a reference to the function object @c
2164 
       *  __f.get(). If @a __f is a NULL function pointer or NULL
2165 
       *  pointer-to-member, @c this object will be empty.
2166 
       *
2167 
       *  If @a __f is a non-NULL function pointer or an object of type @c
2168 
       *  reference_wrapper, this function will not throw.
2169 
       */
2170 
      template
2171 
        typename enable_if::value, function&>::type
2172 
        operator=(_Functor&& __f)
2173 
        {
2174 
          function(std::forward<_Functor>(__f)).swap(*this);
2175 
          return *this;
2176 
        }
2177 
 
2178 
      /// @overload
2179 
      template
2180 
        typename enable_if::value, function&>::type
2181 
        operator=(reference_wrapper<_Functor> __f) noexcept
2182 
        {
2183 
          function(__f).swap(*this);
2184 
          return *this;
2185 
        }
2186 
 
2187 
      // [3.7.2.2] function modifiers
2188 
 
2189 
      /**
2190 
       *  @brief Swap the targets of two %function objects.
2191 
       *  @param __x A %function with identical call signature.
2192 
       *
2193 
       *  Swap the targets of @c this function object and @a __f. This
2194 
       *  function will not throw an %exception.
2195 
       */
2196 
      void swap(function& __x)
2197 
      {
2198 
        std::swap(_M_functor, __x._M_functor);
2199 
        std::swap(_M_manager, __x._M_manager);
2200 
        std::swap(_M_invoker, __x._M_invoker);
2201 
      }
2202 
 
2203 
      // TODO: needs allocator_arg_t
2204 
      /*
2205 
      template
2206 
        void
2207 
        assign(_Functor&& __f, const _Alloc& __a)
2208 
        {
2209 
          function(allocator_arg, __a,
2210 
                   std::forward<_Functor>(__f)).swap(*this);
2211 
        }
2212 
      */
2213 
 
2214 
      // [3.7.2.3] function capacity
2215 
 
2216 
      /**
2217 
       *  @brief Determine if the %function wrapper has a target.
2218 
       *
2219 
       *  @return @c true when this %function object contains a target,
2220 
       *  or @c false when it is empty.
2221 
       *
2222 
       *  This function will not throw an %exception.
2223 
       */
2224 
      explicit operator bool() const noexcept
2225 
      { return !_M_empty(); }
2226 
 
2227 
      // [3.7.2.4] function invocation
2228 
 
2229 
      /**
2230 
       *  @brief Invokes the function targeted by @c *this.
2231 
       *  @returns the result of the target.
2232 
       *  @throws bad_function_call when @c !(bool)*this
2233 
       *
2234 
       *  The function call operator invokes the target function object
2235 
       *  stored by @c this.
2236 
       */
2237 
      _Res operator()(_ArgTypes... __args) const;
2238 
 
2239 
#ifdef __GXX_RTTI
2240 
      // [3.7.2.5] function target access
2241 
      /**
2242 
       *  @brief Determine the type of the target of this function object
2243 
       *  wrapper.
2244 
       *
2245 
       *  @returns the type identifier of the target function object, or
2246 
       *  @c typeid(void) if @c !(bool)*this.
2247 
       *
2248 
       *  This function will not throw an %exception.
2249 
       */
2250 
      const type_info& target_type() const noexcept;
2251 
 
2252 
      /**
2253 
       *  @brief Access the stored target function object.
2254 
       *
2255 
       *  @return Returns a pointer to the stored target function object,
2256 
       *  if @c typeid(Functor).equals(target_type()); otherwise, a NULL
2257 
       *  pointer.
2258 
       *
2259 
       * This function will not throw an %exception.
2260 
       */
2261 
      template       _Functor* target() noexcept;
2262 
 
2263 
      /// @overload
2264 
      template const _Functor* target() const noexcept;
2265 
#endif
2266 
 
2267 
    private:
2268 
      typedef _Res (*_Invoker_type)(const _Any_data&, _ArgTypes...);
2269 
      _Invoker_type _M_invoker;
2270 
  };
2271 
 
2272 
  // Out-of-line member definitions.
2273 
  template
2274 
    function<_Res(_ArgTypes...)>::
2275 
    function(const function& __x)
2276 
    : _Function_base()
2277 
    {
2278 
      if (static_cast(__x))
2279 
        {
2280 
          _M_invoker = __x._M_invoker;
2281 
          _M_manager = __x._M_manager;
2282 
          __x._M_manager(_M_functor, __x._M_functor, __clone_functor);
2283 
        }
2284 
    }
2285 
 
2286 
  template
2287 
    template
2288 
      function<_Res(_ArgTypes...)>::
2289 
      function(_Functor __f,
2290 
               typename enable_if<
2291 
                        !is_integral<_Functor>::value, _Useless>::type)
2292 
      : _Function_base()
2293 
      {
2294 
        typedef _Function_handler<_Signature_type, _Functor> _My_handler;
2295 
 
2296 
        if (_My_handler::_M_not_empty_function(__f))
2297 
          {
2298 
            _M_invoker = &_My_handler::_M_invoke;
2299 
            _M_manager = &_My_handler::_M_manager;
2300 
            _My_handler::_M_init_functor(_M_functor, std::move(__f));
2301 
          }
2302 
      }
2303 
 
2304 
  template
2305 
    _Res
2306 
    function<_Res(_ArgTypes...)>::
2307 
    operator()(_ArgTypes... __args) const
2308 
    {
2309 
      if (_M_empty())
2310 
        __throw_bad_function_call();
2311 
      return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...);
2312 
    }
2313 
 
2314 
#ifdef __GXX_RTTI
2315 
  template
2316 
    const type_info&
2317 
    function<_Res(_ArgTypes...)>::
2318 
    target_type() const noexcept
2319 
    {
2320 
      if (_M_manager)
2321 
        {
2322 
          _Any_data __typeinfo_result;
2323 
          _M_manager(__typeinfo_result, _M_functor, __get_type_info);
2324 
          return *__typeinfo_result._M_access();
2325 
        }
2326 
      else
2327 
        return typeid(void);
2328 
    }
2329 
 
2330 
  template
2331 
    template
2332 
      _Functor*
2333 
      function<_Res(_ArgTypes...)>::
2334 
      target() noexcept
2335 
      {
2336 
        if (typeid(_Functor) == target_type() && _M_manager)
2337 
          {
2338 
            _Any_data __ptr;
2339 
            if (_M_manager(__ptr, _M_functor, __get_functor_ptr)
2340 
                && !is_const<_Functor>::value)
2341 
              return 0;
2342 
            else
2343 
              return __ptr._M_access<_Functor*>();
2344 
          }
2345 
        else
2346 
          return 0;
2347 
      }
2348 
 
2349 
  template
2350 
    template
2351 
      const _Functor*
2352 
      function<_Res(_ArgTypes...)>::
2353 
      target() const noexcept
2354 
      {
2355 
        if (typeid(_Functor) == target_type() && _M_manager)
2356 
          {
2357 
            _Any_data __ptr;
2358 
            _M_manager(__ptr, _M_functor, __get_functor_ptr);
2359 
            return __ptr._M_access();
2360 
          }
2361 
        else
2362 
          return 0;
2363 
      }
2364 
#endif
2365 
 
2366 
  // [20.7.15.2.6] null pointer comparisons
2367 
 
2368 
  /**
2369 
   *  @brief Compares a polymorphic function object wrapper against 0
2370 
   *  (the NULL pointer).
2371 
   *  @returns @c true if the wrapper has no target, @c false otherwise
2372 
   *
2373 
   *  This function will not throw an %exception.
2374 
   */
2375 
  template
2376 
    inline bool
2377 
    operator==(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
2378 
    { return !static_cast(__f); }
2379 
 
2380 
  /// @overload
2381 
  template
2382 
    inline bool
2383 
    operator==(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
2384 
    { return !static_cast(__f); }
2385 
 
2386 
  /**
2387 
   *  @brief Compares a polymorphic function object wrapper against 0
2388 
   *  (the NULL pointer).
2389 
   *  @returns @c false if the wrapper has no target, @c true otherwise
2390 
   *
2391 
   *  This function will not throw an %exception.
2392 
   */
2393 
  template
2394 
    inline bool
2395 
    operator!=(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
2396 
    { return static_cast(__f); }
2397 
 
2398 
  /// @overload
2399 
  template
2400 
    inline bool
2401 
    operator!=(nullptr_t, const function<_Res(_Args...)>& __f) noexcept
2402 
    { return static_cast(__f); }
2403 
 
2404 
  // [20.7.15.2.7] specialized algorithms
2405 
 
2406 
  /**
2407 
   *  @brief Swap the targets of two polymorphic function object wrappers.
2408 
   *
2409 
   *  This function will not throw an %exception.
2410 
   */
2411 
  template
2412 
    inline void
2413 
    swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y)
2414 
    { __x.swap(__y); }
2415 
 
2416 
_GLIBCXX_END_NAMESPACE_VERSION
2417 
} // namespace std
2418 
 
2419 
#endif // __GXX_EXPERIMENTAL_CXX0X__
2420 
 
2421 
#endif // _GLIBCXX_FUNCTIONAL

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.