include/c++/stl/stl/_alloc_old.h

   1 template<class _Tp, class _Alloc>
   2 class __simple_alloc {
   3   typedef _Alloc __alloc_type;
   4 public:
   5   typedef typename _Alloc::value_type __alloc_value_type;
   6   typedef _Tp value_type;
   7   static size_t  _STLP_CALL __chunk(size_t __n) {
   8     return (sizeof(__alloc_value_type)==sizeof(value_type)) ? __n :
   9       ((__n*sizeof(value_type)+sizeof(__alloc_value_type)-1)/sizeof(__alloc_value_type));
  10   }
  11   static _Tp*  _STLP_CALL allocate(size_t __n) { return 0 == __n ? 0 : (_Tp*) __alloc_type::allocate(__chunk(__n)); }
  12   static void  _STLP_CALL deallocate(_Tp * __p, size_t __n) {
  13     __alloc_type::deallocate((__alloc_value_type*)__p, __chunk(__n)); }
  14 };
  15
  16 // Allocator adaptor to turn an SGI-style allocator (e.g. alloc, malloc_alloc)
  17 // into a standard-conforming allocator.   Note that this adaptor does
  18 // *not* assume that all objects of the underlying alloc class are
  19 // identical, nor does it assume that all of the underlying alloc's
  20 // member functions are static member functions.  Note, also, that
  21 // __allocator<_Tp, alloc> is essentially the same thing as allocator<_Tp>.
  22
  23 template <class _Tp, class _Alloc>
  24 struct __allocator : public _Alloc {
  25   typedef _Alloc __underlying_alloc;
  26
  27   typedef size_t    size_type;
  28   typedef ptrdiff_t difference_type;
  29   typedef _Tp*       pointer;
  30   typedef const _Tp* const_pointer;
  31   typedef _Tp&       reference;
  32   typedef const _Tp& const_reference;
  33   typedef _Tp        value_type;
  34
  35 # if defined (_STLP_MEMBER_TEMPLATE_CLASSES)
  36   template <class _Tp1> struct rebind {
  37     typedef __allocator<_Tp1, _Alloc> other;
  38   };
  39 # endif
  40   __allocator() _STLP_NOTHROW {}
  41   __allocator(const _Alloc& ) _STLP_NOTHROW {}
  42   __allocator(const __allocator<_Tp, _Alloc>& __a) _STLP_NOTHROW
  43     : _Alloc(__a) {}
  44 # if defined (_STLP_MEMBER_TEMPLATES) && defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
  45   template <class _Tp1>
  46   __allocator(const __allocator<_Tp1, _Alloc>& __a) _STLP_NOTHROW
  47     : _Alloc(__a) {}
  48 # endif
  49 # ifdef _STLP_TRIVIAL_DESTRUCTOR_BUG
  50   ~__allocator() _STLP_NOTHROW {}
  51 # endif
  52   pointer address(reference __x) const { return &__x; }
  53
  54 # if !defined (__WATCOM_CPLUSPLUS__)
  55   const_pointer address(const_reference __x) const { return &__x; }
  56 # endif
  57
  58   // __n is permitted to be 0.
  59   _Tp* allocate(size_type __n, const void* = 0) {
  60     if (__n > max_size())
  61       __THROW_BAD_ALLOC;
  62     return __n != 0
  63         ? __STATIC_CAST(_Tp*,__underlying_alloc::allocate(__n * sizeof(_Tp)))
  64         : 0;
  65   }
  66
  67   // __p is not permitted to be a null pointer.
  68   void deallocate(pointer __p, size_type __n)
  69     { if (__p) __underlying_alloc::deallocate(__p, __n * sizeof(_Tp)); }
  70
  71   size_type max_size() const _STLP_NOTHROW
  72     { return size_t(-1) / sizeof(_Tp); }
  73
  74   void construct(pointer __p, const_reference __val) { _STLP_STD::_Copy_Construct(__p, __val); }
  75   void destroy(pointer __p) { _STLP_STD::_Destroy(__p); }
  76
  77   const __underlying_alloc& __get_underlying_alloc() const { return *this; }
  78 };
  79
  80 #ifdef _STLP_CLASS_PARTIAL_SPECIALIZATION
  81 template <class _Alloc>
  82 class __allocator<void, _Alloc> {
  83   typedef size_t      size_type;
  84   typedef ptrdiff_t   difference_type;
  85   typedef void*       pointer;
  86   typedef const void* const_pointer;
  87   typedef void        value_type;
  88 #ifdef _STLP_MEMBER_TEMPLATE_CLASSES
  89   template <class _Tp1> struct rebind {
  90     typedef __allocator<_Tp1, _Alloc> other;
  91   };
  92 #endif
  93 };
  94 #endif
  95
  96 template <class _Tp, class _Alloc>
  97 inline bool  _STLP_CALL operator==(const __allocator<_Tp, _Alloc>& __a1,
  98                                    const __allocator<_Tp, _Alloc>& __a2)
  99 {
 100   return __a1.__get_underlying_alloc() == __a2.__get_underlying_alloc();
 101 }
 102
 103 #ifdef _STLP_USE_SEPARATE_RELOPS_NAMESPACE
 104 template <class _Tp, class _Alloc>
 105 inline bool  _STLP_CALL operator!=(const __allocator<_Tp, _Alloc>& __a1,
 106                                    const __allocator<_Tp, _Alloc>& __a2)
 107 {
 108   return __a1.__get_underlying_alloc() != __a2.__get_underlying_alloc();
 109 }
 110 #endif /* _STLP_FUNCTION_TMPL_PARTIAL_ORDER */
 111
 112
 113 // Comparison operators for all of the predifined SGI-style allocators.
 114 // This ensures that __allocator<malloc_alloc> (for example) will
 115 // work correctly.
 116
 117 #ifndef _STLP_NON_TYPE_TMPL_PARAM_BUG
 118 inline bool  _STLP_CALL operator==(const __malloc_alloc&, const __malloc_alloc&)
 119 { return true; }
 120
 121 #  ifdef _STLP_FUNCTION_TMPL_PARTIAL_ORDER
 122 inline bool  _STLP_CALL operator!=(const __malloc_alloc&, const __malloc_alloc&)
 123 { return false; }
 124 #  endif
 125
 126 inline bool _STLP_CALL operator==(const __new_alloc&, const __new_alloc&) { return true; }
 127
 128 #  ifdef _STLP_USE_SEPARATE_RELOPS_NAMESPACE
 129 inline bool _STLP_CALL operator!=(const __new_alloc&, const __new_alloc&) { return false; }
 130 #  endif
 131
 132 #  if !defined (_STLP_USE_NO_IOSTREAMS)
 133 inline bool  _STLP_CALL operator==(const __node_alloc&,
 134                                    const __node_alloc&)
 135 { return true; }
 136
 137 #    if defined( _STLP_FUNCTION_TMPL_PARTIAL_ORDER )
 138
 139 inline bool  _STLP_CALL operator!=(const __node_alloc&,
 140                                    const __node_alloc&)
 141 { return false; }
 142 #    endif
 143 #  endif
 144
 145 #endif /* _STLP_NON_TYPE_TMPL_PARAM_BUG */
 146
 147 template <class _Alloc>
 148 inline bool  _STLP_CALL operator==(const __debug_alloc<_Alloc>&, const __debug_alloc<_Alloc>&) {  return true; }
 149 # ifdef _STLP_USE_SEPARATE_RELOPS_NAMESPACE
 150 template <class _Alloc>
 151 inline bool  _STLP_CALL operator!=(const __debug_alloc<_Alloc>&, const __debug_alloc<_Alloc>&) {  return false; }
 152 # endif
 153
 154 #if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
 155
 156 // Versions for the predefined SGI-style allocators.
 157 template <class _Tp>
 158 struct _Alloc_traits<_Tp, __malloc_alloc> {
 159   typedef __allocator<_Tp, __malloc_alloc> allocator_type;
 160 };
 161
 162 #  if !defined (_STLP_USE_NO_IOSTREAMS)
 163 template <class _Tp>
 164 struct _Alloc_traits<_Tp, __node_alloc> {
 165   typedef __allocator<_Tp, __node_alloc> allocator_type;
 166 };
 167 #  endif
 168
 169 template <class _Tp, class _Alloc>
 170 struct _Alloc_traits<_Tp, __debug_alloc<_Alloc> > {
 171   typedef __allocator<_Tp, __debug_alloc<_Alloc> > allocator_type;
 172 };
 173
 174 // Versions for the __allocator adaptor used with the predefined
 175 // SGI-style allocators.
 176
 177 template <class _Tp, class _Tp1, class _Alloc>
 178 struct _Alloc_traits<_Tp, __allocator<_Tp1, _Alloc > > {
 179   typedef __allocator<_Tp, _Alloc > allocator_type;
 180 };
 181
 182 #endif
 183
 184 #if defined (_STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE)
 185
 186 // Versions for the predefined SGI-style allocators.
 187
 188
 189 #  if defined (_STLP_NON_TYPE_TMPL_PARAM_BUG)
 190
 191 typedef __malloc_alloc __malloc_alloc_dfl;
 192
 193 template <class _Tp>
 194 inline __allocator<_Tp, __malloc_alloc_dfl >& _STLP_CALL
 195 __stl_alloc_rebind(__malloc_alloc_dfl& __a, const _Tp*) {
 196   return (__allocator<_Tp, __malloc_alloc_dfl >&)__a;
 197 }
 198
 199 #    if !defined (_STLP_USE_NO_IOSTREAMS)
 200 template <class _Tp>
 201 inline __allocator<_Tp, __node_alloc>& _STLP_CALL
 202 __stl_alloc_rebind(__node_alloc& __a, const _Tp*) {
 203   return (__allocator<_Tp, __node_alloc>&)__a;
 204 }
 205 #    endif
 206
 207 template <class _Tp>
 208 inline __allocator<_Tp, __malloc_alloc_dfl > _STLP_CALL
 209 __stl_alloc_create(const __malloc_alloc_dfl&, const _Tp*) {
 210   return __allocator<_Tp, __malloc_alloc_dfl > ();
 211 }
 212
 213 #    if !defined (_STLP_USE_NO_IOSTREAMS)
 214 template <class _Tp>
 215 inline __allocator<_Tp, __node_alloc> _STLP_CALL
 216 __stl_alloc_create(const __node_alloc&, const _Tp*) {
 217   return __allocator<_Tp, __node_alloc>();
 218 }
 219
 220 #    endif
 221
 222 #  else
 223
 224 template <class _Tp>
 225 inline __allocator<_Tp, __malloc_alloc>& _STLP_CALL
 226 __stl_alloc_rebind(__malloc_alloc& __a, const _Tp*) {
 227   return (__allocator<_Tp, __malloc_alloc>&)__a;
 228 }
 229
 230 #    if !defined (_STLP_USE_NO_IOSTREAMS)
 231 template <class _Tp>
 232 inline __allocator<_Tp, __node_alloc>& _STLP_CALL
 233 __stl_alloc_rebind(__node_alloc& __a, const _Tp*) {
 234   return (__allocator<_Tp, __node_alloc>&)__a;
 235 }
 236 #    endif
 237
 238 template <class _Tp>
 239 inline __allocator<_Tp, __malloc_alloc> _STLP_CALL
 240 __stl_alloc_create(const __malloc_alloc&, const _Tp*) {
 241   return __allocator<_Tp, __malloc_alloc>();
 242 }
 243
 244 #    if !defined (_STLP_USE_NO_IOSTREAMS)
 245 template <class _Tp>
 246 inline __allocator<_Tp, __node_alloc> _STLP_CALL
 247 __stl_alloc_create(const __node_alloc&, const _Tp*) {
 248   return __allocator<_Tp, __node_alloc>();
 249 }
 250 #    endif
 251
 252 #  endif
 253
 254 template <class _Tp, class _Alloc>
 255 inline __allocator<_Tp, __debug_alloc<_Alloc> > _STLP_CALL
 256 __stl_alloc_create(const __debug_alloc<_Alloc>&, const _Tp*) {
 257   return __allocator<_Tp, __debug_alloc<_Alloc> >();
 258 }
 259 template <class _Tp, class _Alloc>
 260 inline __allocator<_Tp, __debug_alloc<_Alloc> >& _STLP_CALL
 261 __stl_alloc_rebind(__debug_alloc<_Alloc>& __a, const _Tp*) {
 262   return (__allocator<_Tp, __debug_alloc<_Alloc> >&)__a;
 263 }
 264
 265 template <class _Tp>
 266 inline __allocator<_Tp, __new_alloc > _STLP_CALL
 267 __stl_alloc_create(const __new_alloc&, const _Tp*) {
 268   return __allocator<_Tp, __new_alloc >();
 269 }
 270 template <class _Tp>
 271 inline __allocator<_Tp, __new_alloc >&  _STLP_CALL
 272 __stl_alloc_rebind(__new_alloc& __a, const _Tp*) {
 273   return (__allocator<_Tp, __new_alloc >&)__a;
 274 }
 275
 276 template <class _Tp1, class _Alloc, class _Tp2>
 277 inline __allocator<_Tp2, _Alloc>& _STLP_CALL
 278 __stl_alloc_rebind(__allocator<_Tp1, _Alloc>& __a, const _Tp2*) {
 279   return (__allocator<_Tp2, _Alloc>&)__a;
 280 }
 281
 282 template <class _Tp1, class _Alloc, class _Tp2>
 283 inline __allocator<_Tp2, _Alloc> _STLP_CALL
 284 __stl_alloc_create(const __allocator<_Tp1, _Alloc>&, const _Tp2*) {
 285   return __allocator<_Tp2, _Alloc>();
 286 }
 287 #endif