--- /dev/null
+template<class _Tp, class _Alloc>
+class __simple_alloc {
+ typedef _Alloc __alloc_type;
+public:
+ typedef typename _Alloc::value_type __alloc_value_type;
+ typedef _Tp value_type;
+ static size_t _STLP_CALL __chunk(size_t __n) {
+ return (sizeof(__alloc_value_type)==sizeof(value_type)) ? __n :
+ ((__n*sizeof(value_type)+sizeof(__alloc_value_type)-1)/sizeof(__alloc_value_type));
+ }
+ static _Tp* _STLP_CALL allocate(size_t __n) { return 0 == __n ? 0 : (_Tp*) __alloc_type::allocate(__chunk(__n)); }
+ static void _STLP_CALL deallocate(_Tp * __p, size_t __n) {
+ __alloc_type::deallocate((__alloc_value_type*)__p, __chunk(__n)); }
+};
+
+// Allocator adaptor to turn an SGI-style allocator (e.g. alloc, malloc_alloc)
+// into a standard-conforming allocator. Note that this adaptor does
+// *not* assume that all objects of the underlying alloc class are
+// identical, nor does it assume that all of the underlying alloc's
+// member functions are static member functions. Note, also, that
+// __allocator<_Tp, alloc> is essentially the same thing as allocator<_Tp>.
+
+template <class _Tp, class _Alloc>
+struct __allocator : public _Alloc {
+ typedef _Alloc __underlying_alloc;
+
+ typedef size_t size_type;
+ typedef ptrdiff_t difference_type;
+ typedef _Tp* pointer;
+ typedef const _Tp* const_pointer;
+ typedef _Tp& reference;
+ typedef const _Tp& const_reference;
+ typedef _Tp value_type;
+
+# if defined (_STLP_MEMBER_TEMPLATE_CLASSES)
+ template <class _Tp1> struct rebind {
+ typedef __allocator<_Tp1, _Alloc> other;
+ };
+# endif
+ __allocator() _STLP_NOTHROW {}
+ __allocator(const _Alloc& ) _STLP_NOTHROW {}
+ __allocator(const __allocator<_Tp, _Alloc>& __a) _STLP_NOTHROW
+ : _Alloc(__a) {}
+# if defined (_STLP_MEMBER_TEMPLATES) && defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
+ template <class _Tp1>
+ __allocator(const __allocator<_Tp1, _Alloc>& __a) _STLP_NOTHROW
+ : _Alloc(__a) {}
+# endif
+# ifdef _STLP_TRIVIAL_DESTRUCTOR_BUG
+ ~__allocator() _STLP_NOTHROW {}
+# endif
+ pointer address(reference __x) const { return &__x; }
+
+# if !defined (__WATCOM_CPLUSPLUS__)
+ const_pointer address(const_reference __x) const { return &__x; }
+# endif
+
+ // __n is permitted to be 0.
+ _Tp* allocate(size_type __n, const void* = 0) {
+ if (__n > max_size())
+ __THROW_BAD_ALLOC;
+ return __n != 0
+ ? __STATIC_CAST(_Tp*,__underlying_alloc::allocate(__n * sizeof(_Tp)))
+ : 0;
+ }
+
+ // __p is not permitted to be a null pointer.
+ void deallocate(pointer __p, size_type __n)
+ { if (__p) __underlying_alloc::deallocate(__p, __n * sizeof(_Tp)); }
+
+ size_type max_size() const _STLP_NOTHROW
+ { return size_t(-1) / sizeof(_Tp); }
+
+ void construct(pointer __p, const_reference __val) { _STLP_STD::_Copy_Construct(__p, __val); }
+ void destroy(pointer __p) { _STLP_STD::_Destroy(__p); }
+
+ const __underlying_alloc& __get_underlying_alloc() const { return *this; }
+};
+
+#ifdef _STLP_CLASS_PARTIAL_SPECIALIZATION
+template <class _Alloc>
+class __allocator<void, _Alloc> {
+ typedef size_t size_type;
+ typedef ptrdiff_t difference_type;
+ typedef void* pointer;
+ typedef const void* const_pointer;
+ typedef void value_type;
+#ifdef _STLP_MEMBER_TEMPLATE_CLASSES
+ template <class _Tp1> struct rebind {
+ typedef __allocator<_Tp1, _Alloc> other;
+ };
+#endif
+};
+#endif
+
+template <class _Tp, class _Alloc>
+inline bool _STLP_CALL operator==(const __allocator<_Tp, _Alloc>& __a1,
+ const __allocator<_Tp, _Alloc>& __a2)
+{
+ return __a1.__get_underlying_alloc() == __a2.__get_underlying_alloc();
+}
+
+#ifdef _STLP_USE_SEPARATE_RELOPS_NAMESPACE
+template <class _Tp, class _Alloc>
+inline bool _STLP_CALL operator!=(const __allocator<_Tp, _Alloc>& __a1,
+ const __allocator<_Tp, _Alloc>& __a2)
+{
+ return __a1.__get_underlying_alloc() != __a2.__get_underlying_alloc();
+}
+#endif /* _STLP_FUNCTION_TMPL_PARTIAL_ORDER */
+
+
+// Comparison operators for all of the predifined SGI-style allocators.
+// This ensures that __allocator<malloc_alloc> (for example) will
+// work correctly.
+
+#ifndef _STLP_NON_TYPE_TMPL_PARAM_BUG
+inline bool _STLP_CALL operator==(const __malloc_alloc&, const __malloc_alloc&)
+{ return true; }
+
+# ifdef _STLP_FUNCTION_TMPL_PARTIAL_ORDER
+inline bool _STLP_CALL operator!=(const __malloc_alloc&, const __malloc_alloc&)
+{ return false; }
+# endif
+
+inline bool _STLP_CALL operator==(const __new_alloc&, const __new_alloc&) { return true; }
+
+# ifdef _STLP_USE_SEPARATE_RELOPS_NAMESPACE
+inline bool _STLP_CALL operator!=(const __new_alloc&, const __new_alloc&) { return false; }
+# endif
+
+# if !defined (_STLP_USE_NO_IOSTREAMS)
+inline bool _STLP_CALL operator==(const __node_alloc&,
+ const __node_alloc&)
+{ return true; }
+
+# if defined( _STLP_FUNCTION_TMPL_PARTIAL_ORDER )
+
+inline bool _STLP_CALL operator!=(const __node_alloc&,
+ const __node_alloc&)
+{ return false; }
+# endif
+# endif
+
+#endif /* _STLP_NON_TYPE_TMPL_PARAM_BUG */
+
+template <class _Alloc>
+inline bool _STLP_CALL operator==(const __debug_alloc<_Alloc>&, const __debug_alloc<_Alloc>&) { return true; }
+# ifdef _STLP_USE_SEPARATE_RELOPS_NAMESPACE
+template <class _Alloc>
+inline bool _STLP_CALL operator!=(const __debug_alloc<_Alloc>&, const __debug_alloc<_Alloc>&) { return false; }
+# endif
+
+#if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
+
+// Versions for the predefined SGI-style allocators.
+template <class _Tp>
+struct _Alloc_traits<_Tp, __malloc_alloc> {
+ typedef __allocator<_Tp, __malloc_alloc> allocator_type;
+};
+
+# if !defined (_STLP_USE_NO_IOSTREAMS)
+template <class _Tp>
+struct _Alloc_traits<_Tp, __node_alloc> {
+ typedef __allocator<_Tp, __node_alloc> allocator_type;
+};
+# endif
+
+template <class _Tp, class _Alloc>
+struct _Alloc_traits<_Tp, __debug_alloc<_Alloc> > {
+ typedef __allocator<_Tp, __debug_alloc<_Alloc> > allocator_type;
+};
+
+// Versions for the __allocator adaptor used with the predefined
+// SGI-style allocators.
+
+template <class _Tp, class _Tp1, class _Alloc>
+struct _Alloc_traits<_Tp, __allocator<_Tp1, _Alloc > > {
+ typedef __allocator<_Tp, _Alloc > allocator_type;
+};
+
+#endif
+
+#if defined (_STLP_DONT_SUPPORT_REBIND_MEMBER_TEMPLATE)
+
+// Versions for the predefined SGI-style allocators.
+
+
+# if defined (_STLP_NON_TYPE_TMPL_PARAM_BUG)
+
+typedef __malloc_alloc __malloc_alloc_dfl;
+
+template <class _Tp>
+inline __allocator<_Tp, __malloc_alloc_dfl >& _STLP_CALL
+__stl_alloc_rebind(__malloc_alloc_dfl& __a, const _Tp*) {
+ return (__allocator<_Tp, __malloc_alloc_dfl >&)__a;
+}
+
+# if !defined (_STLP_USE_NO_IOSTREAMS)
+template <class _Tp>
+inline __allocator<_Tp, __node_alloc>& _STLP_CALL
+__stl_alloc_rebind(__node_alloc& __a, const _Tp*) {
+ return (__allocator<_Tp, __node_alloc>&)__a;
+}
+# endif
+
+template <class _Tp>
+inline __allocator<_Tp, __malloc_alloc_dfl > _STLP_CALL
+__stl_alloc_create(const __malloc_alloc_dfl&, const _Tp*) {
+ return __allocator<_Tp, __malloc_alloc_dfl > ();
+}
+
+# if !defined (_STLP_USE_NO_IOSTREAMS)
+template <class _Tp>
+inline __allocator<_Tp, __node_alloc> _STLP_CALL
+__stl_alloc_create(const __node_alloc&, const _Tp*) {
+ return __allocator<_Tp, __node_alloc>();
+}
+
+# endif
+
+# else
+
+template <class _Tp>
+inline __allocator<_Tp, __malloc_alloc>& _STLP_CALL
+__stl_alloc_rebind(__malloc_alloc& __a, const _Tp*) {
+ return (__allocator<_Tp, __malloc_alloc>&)__a;
+}
+
+# if !defined (_STLP_USE_NO_IOSTREAMS)
+template <class _Tp>
+inline __allocator<_Tp, __node_alloc>& _STLP_CALL
+__stl_alloc_rebind(__node_alloc& __a, const _Tp*) {
+ return (__allocator<_Tp, __node_alloc>&)__a;
+}
+# endif
+
+template <class _Tp>
+inline __allocator<_Tp, __malloc_alloc> _STLP_CALL
+__stl_alloc_create(const __malloc_alloc&, const _Tp*) {
+ return __allocator<_Tp, __malloc_alloc>();
+}
+
+# if !defined (_STLP_USE_NO_IOSTREAMS)
+template <class _Tp>
+inline __allocator<_Tp, __node_alloc> _STLP_CALL
+__stl_alloc_create(const __node_alloc&, const _Tp*) {
+ return __allocator<_Tp, __node_alloc>();
+}
+# endif
+
+# endif
+
+template <class _Tp, class _Alloc>
+inline __allocator<_Tp, __debug_alloc<_Alloc> > _STLP_CALL
+__stl_alloc_create(const __debug_alloc<_Alloc>&, const _Tp*) {
+ return __allocator<_Tp, __debug_alloc<_Alloc> >();
+}
+template <class _Tp, class _Alloc>
+inline __allocator<_Tp, __debug_alloc<_Alloc> >& _STLP_CALL
+__stl_alloc_rebind(__debug_alloc<_Alloc>& __a, const _Tp*) {
+ return (__allocator<_Tp, __debug_alloc<_Alloc> >&)__a;
+}
+
+template <class _Tp>
+inline __allocator<_Tp, __new_alloc > _STLP_CALL
+__stl_alloc_create(const __new_alloc&, const _Tp*) {
+ return __allocator<_Tp, __new_alloc >();
+}
+template <class _Tp>
+inline __allocator<_Tp, __new_alloc >& _STLP_CALL
+__stl_alloc_rebind(__new_alloc& __a, const _Tp*) {
+ return (__allocator<_Tp, __new_alloc >&)__a;
+}
+
+template <class _Tp1, class _Alloc, class _Tp2>
+inline __allocator<_Tp2, _Alloc>& _STLP_CALL
+__stl_alloc_rebind(__allocator<_Tp1, _Alloc>& __a, const _Tp2*) {
+ return (__allocator<_Tp2, _Alloc>&)__a;
+}
+
+template <class _Tp1, class _Alloc, class _Tp2>
+inline __allocator<_Tp2, _Alloc> _STLP_CALL
+__stl_alloc_create(const __allocator<_Tp1, _Alloc>&, const _Tp2*) {
+ return __allocator<_Tp2, _Alloc>();
+}
+#endif
projects / polintos / scott / priv.git / blobdiff