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

   1 // Allocators -*- 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 // <http://www.gnu.org/licenses/>.
  25
  26 /*
  27  * Copyright (c) 1996-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 /** @file bits/allocator.h
  40  *  This is an internal header file, included by other library headers.
  41  *  Do not attempt to use it directly. @headername{memory}
  42  */
  43
  44 #ifndef _ALLOCATOR_H
  45 #define _ALLOCATOR_H 1
  46
  47 // Define the base class to std::allocator.
  48 #include <bits/c++allocator.h>
  49
  50 #ifdef __GXX_EXPERIMENTAL_CXX0X__
  51 #include <type_traits> // For _GLIBCXX_HAS_NESTED_TYPE
  52 #endif
  53
  54 namespace std _GLIBCXX_VISIBILITY(default)
  55 {
  56 _GLIBCXX_BEGIN_NAMESPACE_VERSION
  57
  58   /**
  59    * @defgroup allocators Allocators
  60    * @ingroup memory
  61    *
  62    * Classes encapsulating memory operations.
  63    */
  64
  65   template<typename _Tp>
  66     class allocator;
  67
  68   /// allocator<void> specialization.
  69   template<>
  70     class allocator<void>
  71     {
  72     public:
  73       typedef size_t      size_type;
  74       typedef ptrdiff_t   difference_type;
  75       typedef void*       pointer;
  76       typedef const void* const_pointer;
  77       typedef void        value_type;
  78
  79       template<typename _Tp1>
  80         struct rebind
  81         { typedef allocator<_Tp1> other; };
  82     };
  83
  84   /**
  85    * @brief  The @a standard allocator, as per [20.4].
  86    * @ingroup allocators
  87    *
  88    *  Further details:
  89    *  http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt04ch11.html
  90    */
  91   template<typename _Tp>
  92     class allocator: public __glibcxx_base_allocator<_Tp>
  93     {
  94    public:
  95       typedef size_t     size_type;
  96       typedef ptrdiff_t  difference_type;
  97       typedef _Tp*       pointer;
  98       typedef const _Tp* const_pointer;
  99       typedef _Tp&       reference;
 100       typedef const _Tp& const_reference;
 101       typedef _Tp        value_type;
 102
 103       template<typename _Tp1>
 104         struct rebind
 105         { typedef allocator<_Tp1> other; };
 106
 107       allocator() throw() { }
 108
 109       allocator(const allocator& __a) throw()
 110       : __glibcxx_base_allocator<_Tp>(__a) { }
 111
 112       template<typename _Tp1>
 113         allocator(const allocator<_Tp1>&) throw() { }
 114
 115       ~allocator() throw() { }
 116
 117       // Inherit everything else.
 118     };
 119
 120   template<typename _T1, typename _T2>
 121     inline bool
 122     operator==(const allocator<_T1>&, const allocator<_T2>&)
 123     { return true; }
 124
 125   template<typename _Tp>
 126     inline bool
 127     operator==(const allocator<_Tp>&, const allocator<_Tp>&)
 128     { return true; }
 129
 130   template<typename _T1, typename _T2>
 131     inline bool
 132     operator!=(const allocator<_T1>&, const allocator<_T2>&)
 133     { return false; }
 134
 135   template<typename _Tp>
 136     inline bool
 137     operator!=(const allocator<_Tp>&, const allocator<_Tp>&)
 138     { return false; }
 139
 140   // Inhibit implicit instantiations for required instantiations,
 141   // which are defined via explicit instantiations elsewhere.
 142 #if _GLIBCXX_EXTERN_TEMPLATE
 143   extern template class allocator<char>;
 144   extern template class allocator<wchar_t>;
 145 #endif
 146
 147   // Undefine.
 148 #undef __glibcxx_base_allocator
 149
 150   // To implement Option 3 of DR 431.
 151   template<typename _Alloc, bool = __is_empty(_Alloc)>
 152     struct __alloc_swap
 153     { static void _S_do_it(_Alloc&, _Alloc&) { } };
 154
 155   template<typename _Alloc>
 156     struct __alloc_swap<_Alloc, false>
 157     {
 158       static void
 159       _S_do_it(_Alloc& __one, _Alloc& __two)
 160       {
 161         // Precondition: swappable allocators.
 162         if (__one != __two)
 163           swap(__one, __two);
 164       }
 165     };
 166
 167   // Optimize for stateless allocators.
 168   template<typename _Alloc, bool = __is_empty(_Alloc)>
 169     struct __alloc_neq
 170     {
 171       static bool
 172       _S_do_it(const _Alloc&, const _Alloc&)
 173       { return false; }
 174     };
 175
 176   template<typename _Alloc>
 177     struct __alloc_neq<_Alloc, false>
 178     {
 179       static bool
 180       _S_do_it(const _Alloc& __one, const _Alloc& __two)
 181       { return __one != __two; }
 182     };
 183
 184 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 185   // A very basic implementation for now.  In general we have to wait for
 186   // the availability of the infrastructure described in N2983:  we should
 187   // try when either T has a move constructor which cannot throw or T is
 188   // CopyContructible.
 189   // NB: This code doesn't properly belong here, we should find a more
 190   // suited place common to std::vector and std::deque.
 191   template<typename _Tp,
 192            bool = __has_trivial_copy(typename _Tp::value_type)>
 193     struct __shrink_to_fit
 194     { static void _S_do_it(_Tp&) { } };
 195
 196   template<typename _Tp>
 197     struct __shrink_to_fit<_Tp, true>
 198     {
 199       static void
 200       _S_do_it(_Tp& __v)
 201       {
 202         __try
 203           { _Tp(__v).swap(__v); }
 204         __catch(...) { }
 205       }
 206     };
 207
 208
 209   /// [allocator.tag]
 210   struct allocator_arg_t { };
 211
 212   constexpr allocator_arg_t allocator_arg = allocator_arg_t();
 213
 214 _GLIBCXX_HAS_NESTED_TYPE(allocator_type)
 215
 216   template<typename _Tp, typename _Alloc,
 217            bool = __has_allocator_type<_Tp>::value>
 218     struct __uses_allocator_helper
 219     : public false_type { };
 220
 221   template<typename _Tp, typename _Alloc>
 222     struct __uses_allocator_helper<_Tp, _Alloc, true>
 223     : public integral_constant<bool, is_convertible<_Alloc,
 224                                      typename _Tp::allocator_type>::value>
 225     { };
 226
 227   /// [allocator.uses.trait]
 228   template<typename _Tp, typename _Alloc>
 229     struct uses_allocator
 230     : public integral_constant<bool,
 231                                __uses_allocator_helper<_Tp, _Alloc>::value>
 232     { };
 233
 234 #endif
 235
 236 _GLIBCXX_END_NAMESPACE_VERSION
 237 } // namespace std
 238
 239 #endif