/*

 *

 * 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 {

  static void * _STLP_CALL _M_allocate(size_t& __n);

  /* __p may not be 0 */

  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)) {}

  /* 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 _M_swap_alloc(_Self& __x) {

    _MaybeReboundAlloc &__base_this = *this;

    _MaybeReboundAlloc &__base_x = __x;

    _STLP_STD::swap(__base_this, __base_x);

  }

  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: