--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/genericopenlibs/cppstdlib/stl/test/unit/stack_allocator.h Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,201 @@
+#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