00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00034 #ifndef _ARRAY_ALLOCATOR_H
00035 #define _ARRAY_ALLOCATOR_H 1
00036
00037 #include <cstddef>
00038 #include <new>
00039 #include <bits/functexcept.h>
00040 #include <tr1/array>
00041
00042 namespace __gnu_cxx
00043 {
00045 template<typename _Tp>
00046 class array_allocator_base
00047 {
00048 public:
00049 typedef size_t size_type;
00050 typedef ptrdiff_t difference_type;
00051 typedef _Tp* pointer;
00052 typedef const _Tp* const_pointer;
00053 typedef _Tp& reference;
00054 typedef const _Tp& const_reference;
00055 typedef _Tp value_type;
00056
00057 pointer
00058 address(reference __x) const { return &__x; }
00059
00060 const_pointer
00061 address(const_reference __x) const { return &__x; }
00062
00063 void
00064 deallocate(pointer, size_type)
00065 {
00066
00067 }
00068
00069 size_type
00070 max_size() const throw()
00071 { return size_t(-1) / sizeof(_Tp); }
00072
00073
00074
00075 void
00076 construct(pointer __p, const _Tp& __val)
00077 { ::new(__p) value_type(__val); }
00078
00079 void
00080 destroy(pointer __p) { __p->~_Tp(); }
00081 };
00082
00087 template<typename _Tp, typename _Array = std::tr1::array<_Tp, 1> >
00088 class array_allocator : public array_allocator_base<_Tp>
00089 {
00090 public:
00091 typedef size_t size_type;
00092 typedef ptrdiff_t difference_type;
00093 typedef _Tp* pointer;
00094 typedef const _Tp* const_pointer;
00095 typedef _Tp& reference;
00096 typedef const _Tp& const_reference;
00097 typedef _Tp value_type;
00098
00099 typedef _Array array_type;
00100
00101 array_type* _M_array;
00102
00103 template<typename _Tp1, typename _Array1 = _Array>
00104 struct rebind
00105 { typedef array_allocator<_Tp1, _Array1> other; };
00106
00107 array_allocator(array_type* __array = NULL) throw()
00108 : _M_array(__array)
00109 { }
00110
00111 array_allocator(const array_allocator& __o) throw()
00112 : _M_array(__o._M_array) { }
00113
00114 template<typename _Tp1, typename _Array1>
00115 array_allocator(const array_allocator<_Tp1, _Array1>&) throw()
00116 : _M_array(NULL) { }
00117
00118 ~array_allocator() throw() { }
00119
00120 pointer
00121 allocate(size_type __n, const void* = 0)
00122 {
00123 static size_type __array_used;
00124 if (_M_array == 0 || __array_used + __n > _M_array->size())
00125 std::__throw_bad_alloc();
00126 pointer __ret = _M_array->begin() + __array_used;
00127 __array_used += __n;
00128 return __ret;
00129 }
00130 };
00131
00132 template<typename _Tp, typename _Array>
00133 inline bool
00134 operator==(const array_allocator<_Tp, _Array>&,
00135 const array_allocator<_Tp, _Array>&)
00136 { return true; }
00137
00138 template<typename _Tp, typename _Array>
00139 inline bool
00140 operator!=(const array_allocator<_Tp, _Array>&,
00141 const array_allocator<_Tp, _Array>&)
00142 { return false; }
00143 }
00144
00145 #endif