libstdc++-v3/include/bits/refwrap.h

   1 // Implementation of std::reference_wrapper -*- C++ -*-
   2
   3 // Copyright (C) 2004-2016 Free Software Foundation, Inc.
   4 //
   5 // This file is part of the GNU ISO C++ Library.  This library is free
   6 // software; you can redistribute it and/or modify it under the
   7 // terms of the GNU General Public License as published by the
   8 // Free Software Foundation; either version 3, or (at your option)
   9 // any later version.
  10
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // Under Section 7 of GPL version 3, you are granted additional
  17 // permissions described in the GCC Runtime Library Exception, version
  18 // 3.1, as published by the Free Software Foundation.
  19
  20 // You should have received a copy of the GNU General Public License and
  21 // a copy of the GCC Runtime Library Exception along with this program;
  22 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23 // <http://www.gnu.org/licenses/>.
  24
  25 /** @file include/bits/bind.h
  26  *  This is an internal header file, included by other library headers.
  27  *  Do not attempt to use it directly. @headername{functional}
  28  */
  29
  30 #ifndef _GLIBCXX_REFWRAP_H
  31 #define _GLIBCXX_REFWRAP_H 1
  32
  33 #pragma GCC system_header
  34
  35 #if __cplusplus < 201103L
  36 # include <bits/c++0x_warning.h>
  37 #else
  38
  39 #include <bits/move.h>
  40 #include <bits/invoke.h>
  41 #include <bits/stl_function.h> // for unary_function and binary_function
  42
  43 namespace std _GLIBCXX_VISIBILITY(default)
  44 {
  45 _GLIBCXX_BEGIN_NAMESPACE_VERSION
  46
  47   /// If we have found a result_type, extract it.
  48   template<typename _Functor, typename = __void_t<>>
  49     struct _Maybe_get_result_type
  50     { };
  51
  52   template<typename _Functor>
  53     struct _Maybe_get_result_type<_Functor,
  54                                   __void_t<typename _Functor::result_type>>
  55     { typedef typename _Functor::result_type result_type; };
  56
  57   /**
  58    *  Base class for any function object that has a weak result type, as
  59    *  defined in 20.8.2 [func.require] of C++11.
  60   */
  61   template<typename _Functor>
  62     struct _Weak_result_type_impl
  63     : _Maybe_get_result_type<_Functor>
  64     { };
  65
  66   /// Retrieve the result type for a function type.
  67   template<typename _Res, typename... _ArgTypes>
  68     struct _Weak_result_type_impl<_Res(_ArgTypes...)>
  69     { typedef _Res result_type; };
  70
  71   template<typename _Res, typename... _ArgTypes>
  72     struct _Weak_result_type_impl<_Res(_ArgTypes......)>
  73     { typedef _Res result_type; };
  74
  75   template<typename _Res, typename... _ArgTypes>
  76     struct _Weak_result_type_impl<_Res(_ArgTypes...) const>
  77     { typedef _Res result_type; };
  78
  79   template<typename _Res, typename... _ArgTypes>
  80     struct _Weak_result_type_impl<_Res(_ArgTypes......) const>
  81     { typedef _Res result_type; };
  82
  83   template<typename _Res, typename... _ArgTypes>
  84     struct _Weak_result_type_impl<_Res(_ArgTypes...) volatile>
  85     { typedef _Res result_type; };
  86
  87   template<typename _Res, typename... _ArgTypes>
  88     struct _Weak_result_type_impl<_Res(_ArgTypes......) volatile>
  89     { typedef _Res result_type; };
  90
  91   template<typename _Res, typename... _ArgTypes>
  92     struct _Weak_result_type_impl<_Res(_ArgTypes...) const volatile>
  93     { typedef _Res result_type; };
  94
  95   template<typename _Res, typename... _ArgTypes>
  96     struct _Weak_result_type_impl<_Res(_ArgTypes......) const volatile>
  97     { typedef _Res result_type; };
  98
  99   /// Retrieve the result type for a function reference.
 100   template<typename _Res, typename... _ArgTypes>
 101     struct _Weak_result_type_impl<_Res(&)(_ArgTypes...)>
 102     { typedef _Res result_type; };
 103
 104   template<typename _Res, typename... _ArgTypes>
 105     struct _Weak_result_type_impl<_Res(&)(_ArgTypes......)>
 106     { typedef _Res result_type; };
 107
 108   /// Retrieve the result type for a function pointer.
 109   template<typename _Res, typename... _ArgTypes>
 110     struct _Weak_result_type_impl<_Res(*)(_ArgTypes...)>
 111     { typedef _Res result_type; };
 112
 113   template<typename _Res, typename... _ArgTypes>
 114     struct _Weak_result_type_impl<_Res(*)(_ArgTypes......)>
 115     { typedef _Res result_type; };
 116
 117   /// Retrieve result type for a member function pointer.
 118   template<typename _Res, typename _Class, typename... _ArgTypes>
 119     struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)>
 120     { typedef _Res result_type; };
 121
 122   template<typename _Res, typename _Class, typename... _ArgTypes>
 123     struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)>
 124     { typedef _Res result_type; };
 125
 126   /// Retrieve result type for a const member function pointer.
 127   template<typename _Res, typename _Class, typename... _ArgTypes>
 128     struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) const>
 129     { typedef _Res result_type; };
 130
 131   template<typename _Res, typename _Class, typename... _ArgTypes>
 132     struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) const>
 133     { typedef _Res result_type; };
 134
 135   /// Retrieve result type for a volatile member function pointer.
 136   template<typename _Res, typename _Class, typename... _ArgTypes>
 137     struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...) volatile>
 138     { typedef _Res result_type; };
 139
 140   template<typename _Res, typename _Class, typename... _ArgTypes>
 141     struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......) volatile>
 142     { typedef _Res result_type; };
 143
 144   /// Retrieve result type for a const volatile member function pointer.
 145   template<typename _Res, typename _Class, typename... _ArgTypes>
 146     struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes...)
 147                                   const volatile>
 148     { typedef _Res result_type; };
 149
 150   template<typename _Res, typename _Class, typename... _ArgTypes>
 151     struct _Weak_result_type_impl<_Res (_Class::*)(_ArgTypes......)
 152                                   const volatile>
 153     { typedef _Res result_type; };
 154
 155   /**
 156    *  Strip top-level cv-qualifiers from the function object and let
 157    *  _Weak_result_type_impl perform the real work.
 158   */
 159   template<typename _Functor>
 160     struct _Weak_result_type
 161     : _Weak_result_type_impl<typename remove_cv<_Functor>::type>
 162     { };
 163
 164   // Detect nested argument_type.
 165   template<typename _Tp, typename = __void_t<>>
 166     struct _Refwrap_base_arg1
 167     { };
 168
 169   // Nested argument_type.
 170   template<typename _Tp>
 171     struct _Refwrap_base_arg1<_Tp,
 172                               __void_t<typename _Tp::argument_type>>
 173     {
 174       typedef typename _Tp::argument_type argument_type;
 175     };
 176
 177   // Detect nested first_argument_type and second_argument_type.
 178   template<typename _Tp, typename = __void_t<>>
 179     struct _Refwrap_base_arg2
 180     { };
 181
 182   // Nested first_argument_type and second_argument_type.
 183   template<typename _Tp>
 184     struct _Refwrap_base_arg2<_Tp,
 185                               __void_t<typename _Tp::first_argument_type,
 186                                        typename _Tp::second_argument_type>>
 187     {
 188       typedef typename _Tp::first_argument_type first_argument_type;
 189       typedef typename _Tp::second_argument_type second_argument_type;
 190     };
 191
 192   /**
 193    *  Derives from unary_function or binary_function when it
 194    *  can. Specializations handle all of the easy cases. The primary
 195    *  template determines what to do with a class type, which may
 196    *  derive from both unary_function and binary_function.
 197   */
 198   template<typename _Tp>
 199     struct _Reference_wrapper_base
 200     : _Weak_result_type<_Tp>, _Refwrap_base_arg1<_Tp>, _Refwrap_base_arg2<_Tp>
 201     { };
 202
 203   // - a function type (unary)
 204   template<typename _Res, typename _T1>
 205     struct _Reference_wrapper_base<_Res(_T1)>
 206     : unary_function<_T1, _Res>
 207     { };
 208
 209   template<typename _Res, typename _T1>
 210     struct _Reference_wrapper_base<_Res(_T1) const>
 211     : unary_function<_T1, _Res>
 212     { };
 213
 214   template<typename _Res, typename _T1>
 215     struct _Reference_wrapper_base<_Res(_T1) volatile>
 216     : unary_function<_T1, _Res>
 217     { };
 218
 219   template<typename _Res, typename _T1>
 220     struct _Reference_wrapper_base<_Res(_T1) const volatile>
 221     : unary_function<_T1, _Res>
 222     { };
 223
 224   // - a function type (binary)
 225   template<typename _Res, typename _T1, typename _T2>
 226     struct _Reference_wrapper_base<_Res(_T1, _T2)>
 227     : binary_function<_T1, _T2, _Res>
 228     { };
 229
 230   template<typename _Res, typename _T1, typename _T2>
 231     struct _Reference_wrapper_base<_Res(_T1, _T2) const>
 232     : binary_function<_T1, _T2, _Res>
 233     { };
 234
 235   template<typename _Res, typename _T1, typename _T2>
 236     struct _Reference_wrapper_base<_Res(_T1, _T2) volatile>
 237     : binary_function<_T1, _T2, _Res>
 238     { };
 239
 240   template<typename _Res, typename _T1, typename _T2>
 241     struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile>
 242     : binary_function<_T1, _T2, _Res>
 243     { };
 244
 245   // - a function pointer type (unary)
 246   template<typename _Res, typename _T1>
 247     struct _Reference_wrapper_base<_Res(*)(_T1)>
 248     : unary_function<_T1, _Res>
 249     { };
 250
 251   // - a function pointer type (binary)
 252   template<typename _Res, typename _T1, typename _T2>
 253     struct _Reference_wrapper_base<_Res(*)(_T1, _T2)>
 254     : binary_function<_T1, _T2, _Res>
 255     { };
 256
 257   // - a pointer to member function type (unary, no qualifiers)
 258   template<typename _Res, typename _T1>
 259     struct _Reference_wrapper_base<_Res (_T1::*)()>
 260     : unary_function<_T1*, _Res>
 261     { };
 262
 263   // - a pointer to member function type (binary, no qualifiers)
 264   template<typename _Res, typename _T1, typename _T2>
 265     struct _Reference_wrapper_base<_Res (_T1::*)(_T2)>
 266     : binary_function<_T1*, _T2, _Res>
 267     { };
 268
 269   // - a pointer to member function type (unary, const)
 270   template<typename _Res, typename _T1>
 271     struct _Reference_wrapper_base<_Res (_T1::*)() const>
 272     : unary_function<const _T1*, _Res>
 273     { };
 274
 275   // - a pointer to member function type (binary, const)
 276   template<typename _Res, typename _T1, typename _T2>
 277     struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const>
 278     : binary_function<const _T1*, _T2, _Res>
 279     { };
 280
 281   // - a pointer to member function type (unary, volatile)
 282   template<typename _Res, typename _T1>
 283     struct _Reference_wrapper_base<_Res (_T1::*)() volatile>
 284     : unary_function<volatile _T1*, _Res>
 285     { };
 286
 287   // - a pointer to member function type (binary, volatile)
 288   template<typename _Res, typename _T1, typename _T2>
 289     struct _Reference_wrapper_base<_Res (_T1::*)(_T2) volatile>
 290     : binary_function<volatile _T1*, _T2, _Res>
 291     { };
 292
 293   // - a pointer to member function type (unary, const volatile)
 294   template<typename _Res, typename _T1>
 295     struct _Reference_wrapper_base<_Res (_T1::*)() const volatile>
 296     : unary_function<const volatile _T1*, _Res>
 297     { };
 298
 299   // - a pointer to member function type (binary, const volatile)
 300   template<typename _Res, typename _T1, typename _T2>
 301     struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const volatile>
 302     : binary_function<const volatile _T1*, _T2, _Res>
 303     { };
 304
 305   /**
 306    *  @brief Primary class template for reference_wrapper.
 307    *  @ingroup functors
 308    *  @{
 309    */
 310   template<typename _Tp>
 311     class reference_wrapper
 312     : public _Reference_wrapper_base<typename remove_cv<_Tp>::type>
 313     {
 314       _Tp* _M_data;
 315
 316     public:
 317       typedef _Tp type;
 318
 319       reference_wrapper(_Tp& __indata) noexcept
 320       : _M_data(std::__addressof(__indata))
 321       { }
 322
 323       reference_wrapper(_Tp&&) = delete;
 324
 325       reference_wrapper(const reference_wrapper&) = default;
 326
 327       reference_wrapper&
 328       operator=(const reference_wrapper&) = default;
 329
 330       operator _Tp&() const noexcept
 331       { return this->get(); }
 332
 333       _Tp&
 334       get() const noexcept
 335       { return *_M_data; }
 336
 337       template<typename... _Args>
 338         typename result_of<_Tp&(_Args&&...)>::type
 339         operator()(_Args&&... __args) const
 340         {
 341           return std::__invoke(get(), std::forward<_Args>(__args)...);
 342         }
 343     };
 344
 345
 346   /// Denotes a reference should be taken to a variable.
 347   template<typename _Tp>
 348     inline reference_wrapper<_Tp>
 349     ref(_Tp& __t) noexcept
 350     { return reference_wrapper<_Tp>(__t); }
 351
 352   /// Denotes a const reference should be taken to a variable.
 353   template<typename _Tp>
 354     inline reference_wrapper<const _Tp>
 355     cref(const _Tp& __t) noexcept
 356     { return reference_wrapper<const _Tp>(__t); }
 357
 358   template<typename _Tp>
 359     void ref(const _Tp&&) = delete;
 360
 361   template<typename _Tp>
 362     void cref(const _Tp&&) = delete;
 363
 364   /// Partial specialization.
 365   template<typename _Tp>
 366     inline reference_wrapper<_Tp>
 367     ref(reference_wrapper<_Tp> __t) noexcept
 368     { return ref(__t.get()); }
 369
 370   /// Partial specialization.
 371   template<typename _Tp>
 372     inline reference_wrapper<const _Tp>
 373     cref(reference_wrapper<_Tp> __t) noexcept
 374     { return cref(__t.get()); }
 375
 376   // @} group functors
 377
 378 _GLIBCXX_END_NAMESPACE_VERSION
 379 } // namespace std
 380
 381 #endif // C++11
 382
 383 #endif // _GLIBCXX_REFWRAP_H