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

   1 // Pointer Traits -*- C++ -*-
   2
   3 // Copyright (C) 2011-2015 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 bits/ptr_traits.h
  26  *  This is an internal header file, included by other library headers.
  27  *  Do not attempt to use it directly. @headername{memory}
  28  */
  29
  30 #ifndef _PTR_TRAITS_H
  31 #define _PTR_TRAITS_H 1
  32
  33 #if __cplusplus >= 201103L
  34
  35 #include <bits/move.h>
  36
  37 namespace std _GLIBCXX_VISIBILITY(default)
  38 {
  39 _GLIBCXX_BEGIN_NAMESPACE_VERSION
  40
  41   class __undefined;
  42
  43   // Given Template<T, ...> return T, otherwise invalid.
  44   template<typename _Tp>
  45     struct __get_first_arg
  46     { using type = __undefined; };
  47
  48   template<template<typename, typename...> class _Template, typename _Tp,
  49            typename... _Types>
  50     struct __get_first_arg<_Template<_Tp, _Types...>>
  51     { using type = _Tp; };
  52
  53   template<typename _Tp>
  54     using __get_first_arg_t = typename __get_first_arg<_Tp>::type;
  55
  56   // Given Template<T, ...> and U return Template<U, ...>, otherwise invalid.
  57   template<typename _Tp, typename _Up>
  58     struct __replace_first_arg
  59     { using type = __undefined; };
  60
  61   template<template<typename, typename...> class _Template, typename _Up,
  62            typename _Tp, typename... _Types>
  63     struct __replace_first_arg<_Template<_Tp, _Types...>, _Up>
  64     { using type = _Template<_Up, _Types...>; };
  65
  66   template<typename _Tp, typename _Up>
  67     using __replace_first_arg_t = typename __replace_first_arg<_Tp, _Up>::type;
  68
  69   template<typename _Tp>
  70     using __make_not_void
  71       = typename conditional<is_void<_Tp>::value, __undefined, _Tp>::type;
  72
  73   /**
  74    * @brief  Uniform interface to all pointer-like types
  75    * @ingroup pointer_abstractions
  76   */
  77   template<typename _Ptr>
  78     struct pointer_traits
  79     {
  80     private:
  81       template<typename _Tp>
  82         using __element_type = typename _Tp::element_type;
  83
  84       template<typename _Tp>
  85         using __difference_type = typename _Tp::difference_type;
  86
  87       template<typename _Tp, typename _Up>
  88         using __rebind = typename _Tp::template rebind<_Up>;
  89
  90     public:
  91       /// The pointer type.
  92       using pointer = _Ptr;
  93
  94       /// The type pointed to.
  95       using element_type
  96         = __detected_or_t_<__get_first_arg_t, __element_type, _Ptr>;
  97
  98       /// The type used to represent the difference between two pointers.
  99       using difference_type
 100         = __detected_or_t<ptrdiff_t, __difference_type, _Ptr>;
 101
 102       /// A pointer to a different type.
 103       template<typename _Up>
 104         using rebind
 105           = __detected_or_t_<__replace_first_arg_t, __rebind, _Ptr, _Up>;
 106
 107       static _Ptr
 108       pointer_to(__make_not_void<element_type>& __e)
 109       { return _Ptr::pointer_to(__e); }
 110
 111       static_assert(!is_same<element_type, __undefined>::value,
 112           "pointer type defines element_type or is like SomePointer<T, Args>");
 113       static_assert(!is_same<rebind<element_type>, __undefined>::value,
 114           "pointer type defines rebind<U> or is like SomePointer<T, Args>");
 115     };
 116
 117   /**
 118    * @brief  Partial specialization for built-in pointers.
 119    * @ingroup pointer_abstractions
 120   */
 121   template<typename _Tp>
 122     struct pointer_traits<_Tp*>
 123     {
 124       /// The pointer type
 125       typedef _Tp* pointer;
 126       /// The type pointed to
 127       typedef _Tp  element_type;
 128       /// Type used to represent the difference between two pointers
 129       typedef ptrdiff_t difference_type;
 130
 131       template<typename _Up>
 132         using rebind = _Up*;
 133
 134       /**
 135        *  @brief  Obtain a pointer to an object
 136        *  @param  __r  A reference to an object of type @c element_type
 137        *  @return @c addressof(__r)
 138       */
 139       static pointer
 140       pointer_to(__make_not_void<element_type>& __r) noexcept
 141       { return std::addressof(__r); }
 142     };
 143
 144   /// Convenience alias for rebinding pointers.
 145   template<typename _Ptr, typename _Tp>
 146     using __ptr_rebind = typename pointer_traits<_Ptr>::template rebind<_Tp>;
 147
 148 _GLIBCXX_END_NAMESPACE_VERSION
 149 } // namespace std
 150
 151 #endif
 152
 153 #endif