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
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060 #ifndef __SGI_STL_INTERNAL_TEMPBUF_H
00061 #define __SGI_STL_INTERNAL_TEMPBUF_H
00062
00063 namespace std
00064 {
00065
00066 template <class _Tp>
00067 pair<_Tp*, ptrdiff_t>
00068 __get_temporary_buffer(ptrdiff_t __len, _Tp*)
00069 {
00070 if (__len > ptrdiff_t(INT_MAX / sizeof(_Tp)))
00071 __len = INT_MAX / sizeof(_Tp);
00072
00073 while (__len > 0) {
00074 _Tp* __tmp = (_Tp*) malloc((size_t)__len * sizeof(_Tp));
00075 if (__tmp != 0)
00076 return pair<_Tp*, ptrdiff_t>(__tmp, __len);
00077 __len /= 2;
00078 }
00079
00080 return pair<_Tp*, ptrdiff_t>((_Tp*)0, 0);
00081 }
00082
00083 template <class _Tp>
00084 inline pair<_Tp*, ptrdiff_t> get_temporary_buffer(ptrdiff_t __len) {
00085 return __get_temporary_buffer(__len, (_Tp*) 0);
00086 }
00087
00088
00089
00090
00091
00092
00093 template <class _Tp>
00094 inline pair<_Tp*, ptrdiff_t> get_temporary_buffer(ptrdiff_t __len, _Tp*) {
00095 return __get_temporary_buffer(__len, (_Tp*) 0);
00096 }
00097
00098 template <class _Tp>
00099 void return_temporary_buffer(_Tp* __p) {
00100 free(__p);
00101 }
00102
00103 template <class _ForwardIterator, class _Tp>
00104 class _Temporary_buffer {
00105 private:
00106 ptrdiff_t _M_original_len;
00107 ptrdiff_t _M_len;
00108 _Tp* _M_buffer;
00109
00110 void _M_allocate_buffer() {
00111 _M_original_len = _M_len;
00112 _M_buffer = 0;
00113
00114 if (_M_len > (ptrdiff_t)(INT_MAX / sizeof(_Tp)))
00115 _M_len = INT_MAX / sizeof(_Tp);
00116
00117 while (_M_len > 0) {
00118 _M_buffer = (_Tp*) malloc(_M_len * sizeof(_Tp));
00119 if (_M_buffer)
00120 break;
00121 _M_len /= 2;
00122 }
00123 }
00124
00125 void _M_initialize_buffer(const _Tp&, __true_type) {}
00126 void _M_initialize_buffer(const _Tp& val, __false_type) {
00127 uninitialized_fill_n(_M_buffer, _M_len, val);
00128 }
00129
00130 public:
00131 ptrdiff_t size() const { return _M_len; }
00132 ptrdiff_t requested_size() const { return _M_original_len; }
00133 _Tp* begin() { return _M_buffer; }
00134 _Tp* end() { return _M_buffer + _M_len; }
00135
00136 _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last) {
00137
00138 typedef typename __type_traits<_Tp>::has_trivial_default_constructor
00139 _Trivial;
00140
00141 __STL_TRY {
00142 _M_len = 0;
00143 distance(__first, __last, _M_len);
00144 _M_allocate_buffer();
00145 if (_M_len > 0)
00146 _M_initialize_buffer(*__first, _Trivial());
00147 }
00148 __STL_UNWIND(free(_M_buffer); _M_buffer = 0; _M_len = 0);
00149 }
00150
00151 ~_Temporary_buffer() {
00152 destroy(_M_buffer, _M_buffer + _M_len);
00153 free(_M_buffer);
00154 }
00155
00156 private:
00157
00158 _Temporary_buffer(const _Temporary_buffer&) {}
00159 void operator=(const _Temporary_buffer&) {}
00160 };
00161
00162
00163
00164 template <class _ForwardIterator,
00165 class _Tp
00166 = typename iterator_traits<_ForwardIterator>::value_type
00167 >
00168 struct temporary_buffer : public _Temporary_buffer<_ForwardIterator, _Tp>
00169 {
00170 temporary_buffer(_ForwardIterator __first, _ForwardIterator __last)
00171 : _Temporary_buffer<_ForwardIterator, _Tp>(__first, __last) {}
00172 ~temporary_buffer() {}
00173 };
00174
00175 }
00176
00177 #endif
00178
00179
00180
00181