#ifndef STLPORT_UNIT_TEST_STACK_ALLOCATOR_H

#define STLPORT_UNIT_TEST_STACK_ALLOCATOR_H

#include <algorithm>

#if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)

//For bad_alloc:

#  include <new>

#endif

#if !defined (STLPORT) || defined (_STLP_USE_NAMESPACES)

#  define __STD std::

#else

#  define __STD

#endif

struct State {

  char *m_beg, *m_end, *m_cur;

  bool m_isOk, m_swaped;

  int m_nbAlloc;

  //The following members are shared among all StackAllocator instance created from

  //a reference StackAllocator instance:

  char **m_sharedCur;

  bool *m_sharedOk;

  int *m_sharedNbAlloc;

#if defined (__DMC__)

  State(){}

#endif

  State(char *beg, char *end)

    : m_beg(beg), m_end(end), m_cur(m_beg), m_isOk(true), m_swaped(false), m_nbAlloc(0),

      m_sharedCur(&m_cur), m_sharedOk(&m_isOk), m_sharedNbAlloc(&m_nbAlloc) {}

  State(const State& other)

  : m_beg(other.m_beg), m_end(other.m_end), m_cur(0),

    m_isOk(true), m_swaped(other.m_swaped), m_nbAlloc(0),

    m_sharedCur(other.m_sharedCur), m_sharedOk(other.m_sharedOk),

    m_sharedNbAlloc(other.m_sharedNbAlloc) {}

};

/* This allocator is not thread safe:

 */

template <class _Tp>

struct StackAllocator

#if (defined (__BORLANDC__) || defined (__DMC__)) && \

    defined (STLPORT) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)

  //Special Borland workaround that have problem with function

  //overloading when one of the overloaded version is a template

  //one. This is the case for the std::swap function.

  : public __STD __stlport_class<StackAllocator<_Tp> >

#endif

{

  typedef _Tp        value_type;

  typedef value_type *       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 (__DMC__)

  StackAllocator(){}

#endif

  StackAllocator(char *beg, char *end)

    : m_state(beg, end) {}

  const State& getState() const { return m_state; }

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

  template <class _OtherTp>

  StackAllocator(StackAllocator<_OtherTp> const& other)

    : m_state(other.getState()) {}

#else

  StackAllocator(const State& state)

    : m_state(state) {}

#endif

#if !defined (STLPORT) || defined (_STLP_MEMBER_TEMPLATE_CLASSES)

  template <class _Other>

  struct rebind {

    typedef StackAllocator<_Other> other;

  };

#endif

  _Tp* allocate(size_type n, void* = 0) {

    if (n == 0)

      return 0;

    ++(*m_state.m_sharedNbAlloc);

    if (*m_state.m_sharedCur + (n * sizeof(_Tp)) < m_state.m_end) {

      char *ret = *m_state.m_sharedCur;

      *m_state.m_sharedCur += n * sizeof(_Tp);

      return reinterpret_cast<_Tp*>(ret);

    }

#if !defined (STLPORT) || defined (_STLP_USE_EXCEPTIONS)

    throw __STD bad_alloc();

#  if defined (__DMC__)

    return 0;

#  endif

#else

    return 0;

#endif

  }

#if (defined (__BORLANDC__) || defined (__DMC__)) && \

    defined (STLPORT) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)

  //Necessary extension to make StackAllocator a real STLport allocator

  //implementation:

  _Tp* allocate(size_type n, size_type &new_n) {

    new_n = n;

    return allocate(n);

  }

#endif

  void deallocate(pointer p, size_type n) {

    if (p == 0)

      return;

    --(*m_state.m_sharedNbAlloc);

    if ((char*)p == (*m_state.m_sharedCur - n * sizeof(_Tp))) {

      *m_state.m_sharedCur -= n * sizeof(_Tp);

    }

    if ((char*)p < m_state.m_beg || (char*)p >= m_state.m_end) {

      //An object has been returned to the bad allocator instance:

      *m_state.m_sharedOk = false;

    }

  }

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

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

  size_type max_size() const { return m_state.m_end - *m_state.m_sharedCur; }

  void construct(pointer __p, const_reference __val) { new(__p) _Tp(__val);  }

  void destroy(pointer __p) { __p->~_Tp(); }

  bool ok() const { return m_state.m_isOk && (m_state.m_nbAlloc == 0); }

  void reset () {

    m_state.m_cur = m_state.m_beg;

    m_state.m_isOk = true;

    m_state.m_swaped = false;

  }

  bool swaped() const { return m_state.m_swaped; }

  void swap(StackAllocator &other) {

    __STD swap(m_state, other.m_state);

    m_state.m_swaped = true;

    other.m_state.m_swaped = true;

  }

  //2 StackAllocator instance are identical if they are built on top

  //of the same buffer.

  bool operator == (StackAllocator const& other) const

  { return m_state.m_beg == other.m_state.m_beg; }

  bool operator != (StackAllocator const& other) const

  { return !(*this == other); }

private:

  State m_state;

};

#if !defined (STLPORT) || defined (_STLP_USE_NAMESPACES)

namespace std {

#endif

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

template <class _Tp1, class _Tp2>

inline StackAllocator<_Tp2>&

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

template <class _Tp1, class _Tp2>

inline StackAllocator<_Tp2>

__stl_alloc_create(const StackAllocator<_Tp1>& __a, const _Tp2*) { return StackAllocator<_Tp2>(__a.getState()); }

#  endif

#  if !defined (STLPORT) || defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)

  template <class _Tp>

  inline void swap(StackAllocator<_Tp>& __a, StackAllocator<_Tp>& __b)

  { __a.swap(__b); }

#  else

//TheFollowing overloads depends on instanciation, if new unit tests are written

//with new StackAllocator instanciations associated swap overload should also be

//written

inline void swap(StackAllocator<int>& __a, StackAllocator<int>& __b)

{ __a.swap(__b); }

inline void swap(StackAllocator<char>& __a, StackAllocator<char>& __b)

{ __a.swap(__b); }

inline void swap(StackAllocator<pair<const int, int> >& __a,

                 StackAllocator<pair<const int, int> >& __b)

{ __a.swap(__b); }

#  endif

#if !defined (STLPORT) || defined (_STLP_USE_NAMESPACES)

}

#endif

#undef __STD

#endif //STLPORT_UNIT_TEST_STACK_ALLOCATOR_H