/*

  * Portions Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

  *

  * Copyright (c) 1996,1997

  * Silicon Graphics Computer Systems, Inc.

  *

  * Copyright (c) 1997

  * Moscow Center for SPARC Technology

  *

  * Copyright (c) 1999

  * Boris Fomitchev

  *

  * This material is provided "as is", with absolutely no warranty expressed

  * or implied. Any use is at your own risk.

  *

  * Permission to use or copy this software for any purpose is hereby granted

  * without fee, provided the above notices are retained on all copies.

  * Permission to modify the code and to distribute modified code is granted,

  * provided the above notices are retained, and a notice that the code was

  * modified is included with the above copyright notice.

  *

  */

 /* NOTE: This is an internal header file, included by other STL headers.

  *   You should not attempt to use it directly.

  */

 #ifndef _STLP_INTERNAL_ALLOC_H

 #define _STLP_INTERNAL_ALLOC_H

 #ifndef _STLP_INTERNAL_CSTDDEF

 #  include <stl/_cstddef.h>

 #endif

 #if !defined (_STLP_DEBUG_H) && (defined(_STLP_DEBUG) || defined(_STLP_ASSERTIONS) || defined(_STLP_DEBUG_ALLOC))

 #  include <stl/debug/_debug.h>

 #endif

 #ifndef _STLP_INTERNAL_CSTDLIB

 #  include <stl/_cstdlib.h>

 #endif

 #ifndef _STLP_INTERNAL_CSTRING

 #  include <stl/_cstring.h>

 #endif

 #ifndef _STLP_INTERNAL_ALGOBASE_H

 #  include <stl/_algobase.h>

 #endif

 #ifndef __THROW_BAD_ALLOC

 #  if !defined(_STLP_USE_EXCEPTIONS)

 #    ifndef _STLP_INTERNAL_CSTDIO

 #      include <stl/_cstdio.h>

 #    endif

 #    define __THROW_BAD_ALLOC puts("out of memory\n"); exit(1)

 #  else

 #    define __THROW_BAD_ALLOC throw _STLP_STD::bad_alloc()

 #  endif

 #endif

 #ifndef _STLP_INTERNAL_NEW_HEADER

 #  include <stl/_new.h>

 #endif

 #ifndef _STLP_INTERNAL_CONSTRUCT_H

 #  include <stl/_construct.h>

 #endif

 #if !defined (__ALLOC)

 #  define __ALLOC __sgi_alloc

 #endif

 _STLP_BEGIN_NAMESPACE

 #if defined (_STLP_USE_RAW_SGI_ALLOCATORS)

 template <class _Tp, class _Alloc> struct __allocator;

 #endif

 // Malloc-based allocator.  Typically slower than default alloc below.

 // Typically thread-safe and more storage efficient.

 #if !defined (_STLP_USE_NO_IOSTREAMS)

 typedef void (* __oom_handler_type)();

 #endif

 class _STLP_CLASS_DECLSPEC __malloc_alloc {

 public:

   // this one is needed for proper simple_alloc wrapping

   typedef char value_type;

 #if defined (_STLP_MEMBER_TEMPLATE_CLASSES) && defined (_STLP_USE_RAW_SGI_ALLOCATORS)

   template <class _Tp1> struct rebind {

     typedef __allocator<_Tp1, __malloc_alloc> other;

   };

 #endif

   static void* _STLP_CALL allocate(size_t& __n)

 #if !defined (_STLP_USE_NO_IOSTREAMS)

   ;

 #else

   {

     void *__result = malloc(__n);

 #  if defined (_STLP_MALLOC_USABLE_SIZE)

     if (__result != 0) {

       __n = _STLP_MALLOC_USABLE_SIZE(__result);

     }

 #  endif

     if (__result == 0) {

       __THROW_BAD_ALLOC;

     }

     return __result;

   }

 #endif

   static void _STLP_CALL deallocate(void* __p, size_t /* __n */) { free((char*)__p); }

 #if !defined (_STLP_USE_NO_IOSTREAMS)

   static __oom_handler_type _STLP_CALL set_malloc_handler(__oom_handler_type __f);

 #endif

 };

 // New-based allocator.  Typically slower than default alloc below.

 // Typically thread-safe and more storage efficient.

 class _STLP_CLASS_DECLSPEC __new_alloc {

 public:

   // this one is needed for proper simple_alloc wrapping

   typedef char value_type;

 #if defined (_STLP_MEMBER_TEMPLATE_CLASSES) && defined (_STLP_USE_RAW_SGI_ALLOCATORS)

   template <class _Tp1> struct rebind {

     typedef __allocator<_Tp1, __new_alloc > other;

   };

 #endif

   static void* _STLP_CALL allocate(size_t __n) { return __stl_new(__n); }

   static void _STLP_CALL deallocate(void* __p, size_t) { __stl_delete(__p); }

 };

 // Allocator adaptor to check size arguments for debugging.

 // Reports errors using assert.  Checking can be disabled with

 // NDEBUG, but it's far better to just use the underlying allocator

 // instead when no checking is desired.

 // There is some evidence that this can confuse Purify.

 // This adaptor can only be applied to raw allocators

 template <class _Alloc>

 class __debug_alloc : public _Alloc {

 public:

   typedef _Alloc __allocator_type;

   typedef typename _Alloc::value_type value_type;

 private:

   struct __alloc_header {

     size_t __magic: 16;

     size_t __type_size:16;

     _STLP_UINT32_T _M_size;

   }; // that is 8 bytes for sure

   // Sunpro CC has bug on enums, so extra_before/after set explicitly

   enum { __pad = 8, __magic = 0xdeba, __deleted_magic = 0xdebd,

          __shred_byte = _STLP_SHRED_BYTE };

   enum { __extra_before = 16, __extra_after = 8 };

   // Size of space used to store size.  Note

   // that this must be large enough to preserve

   // alignment.

   static size_t _STLP_CALL __extra_before_chunk() {

     return (long)__extra_before / sizeof(value_type) +

       (size_t)((long)__extra_before % sizeof(value_type) > 0);

   }

   static size_t _STLP_CALL __extra_after_chunk() {

     return (long)__extra_after / sizeof(value_type) +

       (size_t)((long)__extra_after % sizeof(value_type) > 0);

   }

 public:

 #if defined (_STLP_MEMBER_TEMPLATE_CLASSES) && defined (_STLP_USE_RAW_SGI_ALLOCATORS)

   template <class _Tp1> struct rebind {

     typedef __allocator< _Tp1, __debug_alloc<_Alloc> > other;

   };

 #endif

   __debug_alloc() {}

   ~__debug_alloc() {}

   static void* _STLP_CALL allocate(size_t);

   static void _STLP_CALL deallocate(void *, size_t);

 };

 #  if defined (__OS400__) || defined (_WIN64)

 enum {_ALIGN = 16, _ALIGN_SHIFT = 4, _MAX_BYTES = 256};

 #  else

 enum {_ALIGN = 8, _ALIGN_SHIFT = 3, _MAX_BYTES = 128};

 #  endif /* __OS400__ */

 #if !defined (_STLP_USE_NO_IOSTREAMS)

 // Default node allocator.

 // With a reasonable compiler, this should be roughly as fast as the

 // original STL class-specific allocators, but with less fragmentation.

 class _STLP_CLASS_DECLSPEC __node_alloc {

   _STLP_DECLSPEC static void * _STLP_CALL _M_allocate(size_t& __n);

   /* __p may not be 0 */

   _STLP_DECLSPEC static void _STLP_CALL _M_deallocate(void *__p, size_t __n);

 public:

   // this one is needed for proper simple_alloc wrapping

   typedef char value_type;

 #  if defined (_STLP_MEMBER_TEMPLATE_CLASSES) && defined (_STLP_USE_RAW_SGI_ALLOCATORS)

   template <class _Tp1> struct rebind {

     typedef __allocator<_Tp1, __node_alloc> other;

   };

 #  endif

   /* __n must be > 0      */

   static void* _STLP_CALL allocate(size_t& __n)

   { return (__n > (size_t)_MAX_BYTES) ? __stl_new(__n) : _M_allocate(__n); }

   /* __p may not be 0 */

   static void _STLP_CALL deallocate(void *__p, size_t __n)

   { if (__n > (size_t)_MAX_BYTES) __stl_delete(__p); else _M_deallocate(__p, __n); }

 };

 #  if defined (_STLP_USE_TEMPLATE_EXPORT)

 _STLP_EXPORT_TEMPLATE_CLASS __debug_alloc<__node_alloc>;

 #  endif

 #endif /* _STLP_USE_NO_IOSTREAMS */

 #if defined (_STLP_USE_TEMPLATE_EXPORT)

 _STLP_EXPORT_TEMPLATE_CLASS __debug_alloc<__new_alloc>;

 _STLP_EXPORT_TEMPLATE_CLASS __debug_alloc<__malloc_alloc>;

 #endif

 /* macro to convert the allocator for initialization

  * not using MEMBER_TEMPLATE_CLASSES as it should work given template constructor  */

 #if defined (_STLP_MEMBER_TEMPLATES) || ! defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)

 /* if _STLP_NO_TEMPLATE_CONVERSIONS is set, the member template constructor is

  * not used implicitly to convert allocator parameter, so let us do it explicitly */

 #  if defined (_STLP_MEMBER_TEMPLATE_CLASSES) && defined (_STLP_NO_TEMPLATE_CONVERSIONS)

 #    define _STLP_CONVERT_ALLOCATOR(__a, _Tp) __stl_alloc_create(__a,(_Tp*)0)

 #  else

 #    define _STLP_CONVERT_ALLOCATOR(__a, _Tp) __a

 #  endif

 /* else convert, but only if partial specialization works, since else

  * Container::allocator_type won't be different */

 #else

 #  define _STLP_CONVERT_ALLOCATOR(__a, _Tp) __stl_alloc_create(__a,(_Tp*)0)

 #endif /* _STLP_MEMBER_TEMPLATES || !_STLP_CLASS_PARTIAL_SPECIALIZATION */

 // Another allocator adaptor: _Alloc_traits.  This serves two

 // purposes.  First, make it possible to write containers that can use

 // either SGI-style allocators or standard-conforming allocator.

 // The fully general version.

 template <class _Tp, class _Allocator>

 struct _Alloc_traits {

   typedef _Allocator _Orig;

 #if !defined (_STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE)

   typedef typename _Allocator::_STLP_TEMPLATE rebind<_Tp> _Rebind_type;

   typedef typename _Rebind_type::other  allocator_type;

   static allocator_type create_allocator(const _Orig& __a)

   { return allocator_type(_STLP_CONVERT_ALLOCATOR(__a, _Tp)); }

 #else

   // this is not actually true, used only to pass this type through

   // to dynamic overload selection in _STLP_alloc_proxy methods

   typedef _Allocator allocator_type;

 #endif /* !_STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE */

 };

 #if defined (_STLP_USE_PERTHREAD_ALLOC)

 _STLP_END_NAMESPACE

 // include additional header here

 #  include <stl/_pthread_alloc.h>

 _STLP_BEGIN_NAMESPACE

 #  if defined (_STLP_DEBUG_ALLOC)

 typedef __debug_alloc<__pthread_alloc> __sgi_alloc;

 #  else

 typedef __pthread_alloc __sgi_alloc;

 #  endif /* _STLP_DEBUG_ALLOC */

 typedef __pthread_alloc __single_client_alloc;

 typedef __pthread_alloc __multithreaded_alloc;

 #else /* _STLP_USE_PERTHREAD_ALLOC */

 #  if defined (_STLP_USE_NEWALLOC)

 #    if defined (_STLP_DEBUG_ALLOC)

 typedef __debug_alloc<__new_alloc> __sgi_alloc;

 #    else

 typedef __new_alloc __sgi_alloc;

 #    endif /* _STLP_DEBUG_ALLOC */

 typedef __new_alloc __single_client_alloc;

 typedef __new_alloc __multithreaded_alloc;

 #  elif defined (_STLP_USE_MALLOC)

 #    if defined (_STLP_DEBUG_ALLOC)

 typedef __debug_alloc<__malloc_alloc> __sgi_alloc;

 #    else

 typedef __malloc_alloc __sgi_alloc;

 #    endif /* _STLP_DEBUG_ALLOC */

 typedef __malloc_alloc __single_client_alloc;

 typedef __malloc_alloc __multithreaded_alloc;

 #  else

 #    if defined (_STLP_DEBUG_ALLOC)

 typedef __debug_alloc<__node_alloc> __sgi_alloc;

 #    else

 typedef __node_alloc __sgi_alloc;

 #    endif

 typedef __node_alloc __single_client_alloc;

 typedef __node_alloc __multithreaded_alloc;

 #  endif /* _STLP_USE_NEWALLOC */

 #endif /* _STLP_USE_PERTHREAD_ALLOC */

 // This implements allocators as specified in the C++ standard.

 //

 // Note that standard-conforming allocators use many language features

 // that are not yet widely implemented.  In particular, they rely on

 // member templates, partial specialization, partial ordering of function

 // templates, the typename keyword, and the use of the template keyword

 // to refer to a template member of a dependent type.

 /*

 template <class _Tp>

 struct _AllocatorAux {

   typedef _Tp*       pointer;

   typedef const _Tp* const_pointer;

   typedef _Tp&       reference;

   typedef const _Tp& const_reference;

   pointer address(reference __x) const {return &__x;}

   const_pointer address(const_reference __x) const { return &__x; }

 };

 template <class _Tp>

 struct _AllocatorAux<const _Tp> {

   typedef _Tp*       pointer;

   typedef const _Tp* const_pointer;

   typedef _Tp&       reference;

   typedef const _Tp& const_reference;

   const_pointer address(const_reference __x) const { return &__x; }

 };

 */

 template <class _Tp>

 class allocator //: public _AllocatorAux<_Tp>

 /* A small helper struct to recognize STLport allocator implementation

  * from any user specialization one.

  */

                 : public __stlport_class<allocator<_Tp> > {

 public:

   typedef _Tp        value_type;

   typedef _Tp*       pointer;

   typedef const _Tp* const_pointer;

   typedef _Tp&       reference;

   typedef const _Tp& const_reference;

   typedef size_t     size_type;

   typedef ptrdiff_t  difference_type;

 #if defined (_STLP_MEMBER_TEMPLATE_CLASSES)

   template <class _Tp1> struct rebind {

     typedef allocator<_Tp1> other;

   };

 #endif

   allocator() _STLP_NOTHROW {}

 #if defined (_STLP_MEMBER_TEMPLATES)

   template <class _Tp1> allocator(const allocator<_Tp1>&) _STLP_NOTHROW {}

 #endif

   allocator(const allocator<_Tp>&) _STLP_NOTHROW {}

   allocator(__move_source<allocator<_Tp> > /*src*/) _STLP_NOTHROW {} 

   ~allocator() _STLP_NOTHROW {}

   pointer address(reference __x) const {return &__x;}

   const_pointer address(const_reference __x) const { return &__x; }

   // __n is permitted to be 0.  The C++ standard says nothing about what the return value is when __n == 0.

   _Tp* allocate(size_type __n, const void* = 0) {

     if (__n > max_size()) {

       __THROW_BAD_ALLOC;

     }

     if (__n != 0) {

       size_type __buf_size = __n * sizeof(value_type);

       _Tp* __ret = __REINTERPRET_CAST(_Tp*, __sgi_alloc::allocate(__buf_size));

 #if defined (_STLP_DEBUG_UNINITIALIZED) && !defined (_STLP_DEBUG_ALLOC)

       if (__ret != 0) {

         memset((char*)__ret, _STLP_SHRED_BYTE, __buf_size);

       }

 #endif

       return __ret;

     }

     else

       return 0;

   }

   // __p is permitted to be a null pointer, only if n==0.

   void deallocate(pointer __p, size_type __n) {

     _STLP_ASSERT( (__p == 0) == (__n == 0) )

     if (__p != 0) {

 #if defined (_STLP_DEBUG_UNINITIALIZED) && !defined (_STLP_DEBUG_ALLOC)

       memset((char*)__p, _STLP_SHRED_BYTE, __n * sizeof(value_type));

 #endif

       __sgi_alloc::deallocate((void*)__p, __n * sizeof(value_type));

     }

   }

   // backwards compatibility

   void deallocate(pointer __p) const {  if (__p != 0) __sgi_alloc::deallocate((void*)__p, sizeof(value_type)); }

   size_type max_size() const _STLP_NOTHROW  { return size_t(-1) / sizeof(value_type); }

   void construct(pointer __p, const_reference __val) { _STLP_STD::_Copy_Construct(__p, __val); }

   void destroy(pointer __p) { _STLP_STD::_Destroy(__p); }

 #if defined(__MRC__)||(defined(__SC__) && !defined(__DMC__))

   template <class _T2> bool operator==(const allocator<_T2>&) const _STLP_NOTHROW { return true; }

   template <class _T2> bool operator!=(const allocator<_T2>&) const _STLP_NOTHROW { return false; }

 #endif

 #if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)

   //This is just to make swap workaround for compiler without template function partial

   //happy.

   void swap(allocator<_Tp>&) {}

 #endif

 #if defined (_STLP_NO_EXTENSIONS)

   /* STLport extension giving rounded size of an allocated memory buffer

    * This method do not have to be part of a user defined allocator implementation

    * and won't even be called if such a function was granted.

    */

 protected:

 #endif

   _Tp* allocate(size_type __n, size_type& __allocated_n) {

     if (__n > max_size()) {

       __THROW_BAD_ALLOC;

     }

     if (__n != 0) {

       size_type __buf_size = __n * sizeof(value_type);

       _Tp* __ret = __REINTERPRET_CAST(_Tp*, __sgi_alloc::allocate(__buf_size));

 #if defined (_STLP_DEBUG_UNINITIALIZED) && !defined (_STLP_DEBUG_ALLOC)

       if (__ret != 0) {

         memset((char*)__ret, _STLP_SHRED_BYTE, __buf_size);

       }

 #endif

       __allocated_n = __buf_size / sizeof(value_type);

       return __ret;

     }

     else

       return 0;

   }

 };

 _STLP_TEMPLATE_NULL

 class _STLP_CLASS_DECLSPEC allocator<void> {

 public:

   typedef size_t      size_type;

   typedef ptrdiff_t   difference_type;

   typedef void*       pointer;

   typedef const void* const_pointer;

 #if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)

   typedef void        value_type;

 #endif

 #if defined (_STLP_MEMBER_TEMPLATE_CLASSES)

   template <class _Tp1> struct rebind {

     typedef allocator<_Tp1> other;

   };

 #endif

 #if defined(__MRC__)||(defined(__SC__)&&!defined(__DMC__))  //*ty 03/24/2001 - MPW compilers get confused on these operator definitions

   template <class _T2> bool operator==(const allocator<_T2>&) const _STLP_NOTHROW { return true; }

   template <class _T2> bool operator!=(const allocator<_T2>&) const _STLP_NOTHROW { return false; }

 #endif

 };

 #if !(defined(__MRC__)||(defined(__SC__)&&!defined(__DMC__)))  //*ty 03/24/2001 - MPW compilers get confused on these operator definitions

 template <class _T1, class _T2> inline bool  _STLP_CALL operator==(const allocator<_T1>&, const allocator<_T2>&) _STLP_NOTHROW { return true; }

 template <class _T1, class _T2> inline bool  _STLP_CALL operator!=(const allocator<_T1>&, const allocator<_T2>&) _STLP_NOTHROW { return false; }

 #endif

 #if defined (_STLP_USE_TEMPLATE_EXPORT)

 _STLP_EXPORT_TEMPLATE_CLASS allocator<char>;

 #  if defined (_STLP_HAS_WCHAR_T)

 _STLP_EXPORT_TEMPLATE_CLASS allocator<wchar_t>;

 #  endif

 #  if defined (_STLP_USE_PTR_SPECIALIZATIONS)

 _STLP_EXPORT_TEMPLATE_CLASS allocator<void*>;

 #  endif

 #endif

 _STLP_MOVE_TO_PRIV_NAMESPACE

 template <class _Tp>

 struct __alloc_type_traits {

 #if !defined (__BORLANDC__)

   typedef typename _IsSTLportClass<allocator<_Tp> >::_Ret _STLportAlloc;

 #else

   enum { _Is = _IsSTLportClass<allocator<_Tp> >::_Is };

   typedef typename __bool2type<_Is>::_Ret _STLportAlloc;

 #endif

   //The default allocator implementation which is recognize thanks to the

   //__stlport_class inheritance is a stateless object so:

   typedef _STLportAlloc has_trivial_default_constructor;

   typedef _STLportAlloc has_trivial_copy_constructor;

   typedef _STLportAlloc has_trivial_assignment_operator;

   typedef _STLportAlloc has_trivial_destructor;

   typedef _STLportAlloc is_POD_type;

 };

 _STLP_MOVE_TO_STD_NAMESPACE

 #if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)

 template <class _Tp>

 struct __type_traits<allocator<_Tp> > : _STLP_PRIV __alloc_type_traits<_Tp> {};

 #else

 _STLP_TEMPLATE_NULL

 struct __type_traits<allocator<char> > : _STLP_PRIV __alloc_type_traits<char> {};

 #  if defined (_STLP_HAS_WCHAR_T)

 _STLP_TEMPLATE_NULL

 struct __type_traits<allocator<wchar_t> > : _STLP_PRIV __alloc_type_traits<wchar_t> {};

 #  endif

 #  if defined (_STLP_USE_PTR_SPECIALIZATIONS)

 _STLP_TEMPLATE_NULL

 struct __type_traits<allocator<void*> > : _STLP_PRIV __alloc_type_traits<void*> {};

 #  endif

 #endif

 #if !defined (_STLP_FORCE_ALLOCATORS)

 #  define _STLP_FORCE_ALLOCATORS(a,y)

 #endif

 #if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION) && !defined (_STLP_MEMBER_TEMPLATE_CLASSES)

 // The version for the default allocator, for rare occasion when we have partial spec w/o member template classes

 template <class _Tp, class _Tp1>

 struct _Alloc_traits<_Tp, allocator<_Tp1> > {

   typedef allocator<_Tp1> _Orig;

   typedef allocator<_Tp> allocator_type;

   static allocator_type create_allocator(const allocator<_Tp1 >& __a)

   { return allocator_type(_STLP_CONVERT_ALLOCATOR(__a, _Tp)); }

 };

 #endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */

 #if !defined (_STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE) && defined (_STLP_MEMBER_TEMPLATES)

 template <class _Tp, class _Alloc>

 inline _STLP_TYPENAME_ON_RETURN_TYPE _Alloc_traits<_Tp, _Alloc>::allocator_type  _STLP_CALL

 __stl_alloc_create(const _Alloc& __a, const _Tp*) {

   typedef typename _Alloc::_STLP_TEMPLATE rebind<_Tp>::other _Rebound_type;

   return _Rebound_type(__a);

 }

 #else

 // If custom allocators are being used without member template classes support :

 // user (on purpose) is forced to define rebind/get operations !!!

 template <class _Tp1, class _Tp2>

 inline allocator<_Tp2>& _STLP_CALL

 __stl_alloc_rebind(allocator<_Tp1>& __a, const _Tp2*) {  return (allocator<_Tp2>&)(__a); }

 template <class _Tp1, class _Tp2>

 inline allocator<_Tp2> _STLP_CALL

 __stl_alloc_create(const allocator<_Tp1>&, const _Tp2*) { return allocator<_Tp2>(); }

 #endif /* _STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE */

 #if defined (_STLP_USE_RAW_SGI_ALLOCATORS)

 // move obsolete stuff out of the way

 #  include <stl/_alloc_old.h>

 #endif

 _STLP_MOVE_TO_PRIV_NAMESPACE

 // inheritance is being used for EBO optimization

 template <class _Value, class _Tp, class _MaybeReboundAlloc>

 class _STLP_alloc_proxy : public _MaybeReboundAlloc {

 private:

   typedef _MaybeReboundAlloc _Base;

   typedef typename _Base::size_type size_type;

   typedef _STLP_alloc_proxy<_Value, _Tp, _MaybeReboundAlloc> _Self;

 public:

   _Value _M_data;

   _STLP_alloc_proxy (const _MaybeReboundAlloc& __a, _Value __p) :

     _MaybeReboundAlloc(__a), _M_data(__p) {}

   _STLP_alloc_proxy (__move_source<_Self> src) :

     _MaybeReboundAlloc(_STLP_PRIV _AsMoveSource<_Base>(src.get())),

     _M_data(_STLP_PRIV _AsMoveSource<_Value>(src.get()._M_data)) {}

 private:

   /* Following are helper methods to detect stateless allocators and avoid

    * swap in this case. For some compilers (VC6) it is a workaround for a

    * compiler bug in the Empty Base class Optimization feature, for others

    * it is a small optimization or nothing if no EBO. */

   void _M_swap_alloc(_Self&, const __true_type& /*_IsStateless*/)

   {}

   void _M_swap_alloc(_Self& __x, const __false_type& /*_IsStateless*/) {

     _MaybeReboundAlloc &__base_this = *this;

     _MaybeReboundAlloc &__base_x = __x;

     _STLP_STD::swap(__base_this, __base_x);

   }

 public:

   void _M_swap_alloc(_Self& __x) {

 #if !defined (__BORLANDC__)

     typedef typename _IsStateless<_MaybeReboundAlloc>::_Ret _StatelessAlloc;

 #else

     typedef typename __bool2type<_IsStateless<_MaybeReboundAlloc>::_Is>::_Ret _StatelessAlloc;

 #endif

     _M_swap_alloc(__x, _StatelessAlloc());

   }

   /* We need to define the following swap implementation for allocator with state

    * as those allocators might have implement a special swap function to correctly

    * move datas from an instance to the oher, _STLP_alloc_proxy should not break

    * this mecanism. */

   void swap(_Self& __x) {

     _M_swap_alloc(__x);

     _STLP_STD::swap(_M_data, __x._M_data);

   }

   _Tp* allocate(size_type __n, size_type& __allocated_n) {

 #if !defined (__BORLANDC__)

     typedef typename _IsSTLportClass<_MaybeReboundAlloc>::_Ret _STLportAlloc;

 #else

     typedef typename __bool2type<_IsSTLportClass<_MaybeReboundAlloc>::_Is>::_Ret _STLportAlloc;

 #endif

     return allocate(__n, __allocated_n, _STLportAlloc());

   }

   // Unified interface to perform allocate()/deallocate() with limited

   // language support

 #if defined (_STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE)

   // else it is rebound already, and allocate() member is accessible

   _Tp* allocate(size_type __n)

   { return __stl_alloc_rebind(__STATIC_CAST(_Base&, *this), __STATIC_CAST(_Tp*, 0)).allocate(__n, 0); }

   void deallocate(_Tp* __p, size_type __n)

   { __stl_alloc_rebind(__STATIC_CAST(_Base&, *this), __STATIC_CAST(_Tp*, 0)).deallocate(__p, __n); }

 private:

   _Tp* allocate(size_type __n, size_type& __allocated_n, const __true_type& /*STLport allocator*/)

   { return __stl_alloc_rebind(__STATIC_CAST(_Base&, *this), __STATIC_CAST(_Tp*, 0)).allocate(__n, __allocated_n); }

 #else

   //Expose Standard allocate overload (using expression do not work for some compilers (Borland))

   _Tp* allocate(size_type __n)

   { return _Base::allocate(__n); }

 private:

   _Tp* allocate(size_type __n, size_type& __allocated_n, const __true_type& /*STLport allocator*/)

   { return _Base::allocate(__n, __allocated_n); }

 #endif

   _Tp* allocate(size_type __n, size_type& __allocated_n, const __false_type& /*STLport allocator*/)

   { __allocated_n = __n; return allocate(__n); }

 };

 #if defined (_STLP_USE_TEMPLATE_EXPORT)

 _STLP_EXPORT_TEMPLATE_CLASS _STLP_alloc_proxy<char*, char, allocator<char> >;

 #  if defined (_STLP_HAS_WCHAR_T)

 _STLP_EXPORT_TEMPLATE_CLASS _STLP_alloc_proxy<wchar_t*, wchar_t, allocator<wchar_t> >;

 #  endif

 #  if defined (_STLP_USE_PTR_SPECIALIZATIONS)

 _STLP_EXPORT_TEMPLATE_CLASS _STLP_alloc_proxy<void**, void*, allocator<void*> >;

 #  endif

 #endif

 _STLP_MOVE_TO_STD_NAMESPACE

 _STLP_END_NAMESPACE

 #if defined (_STLP_EXPOSE_GLOBALS_IMPLEMENTATION) && !defined (_STLP_LINK_TIME_INSTANTIATION)

 #  include <stl/_alloc.c>

 #endif

 #endif /* _STLP_INTERNAL_ALLOC_H */

 // Local Variables:

 // mode:C++

 // End: