Line data Source code
1 : // ----------------------------------------------------------------------------
2 : // alt_sstream_impl.hpp : alternative stringstream, templates implementation
3 : // ----------------------------------------------------------------------------
4 :
5 : // Copyright Samuel Krempp 2003. Use, modification, and distribution are
6 : // subject to the Boost Software License, Version 1.0. (See accompanying
7 : // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
8 :
9 : // See http://www.boost.org/libs/format for library home page
10 :
11 : // ----------------------------------------------------------------------------
12 :
13 : #ifndef BOOST_SK_ALT_SSTREAM_IMPL_HPP
14 : #define BOOST_SK_ALT_SSTREAM_IMPL_HPP
15 :
16 : namespace boost {
17 : namespace io {
18 : // --- Implementation ------------------------------------------------------//
19 :
20 : template<class Ch, class Tr, class Alloc>
21 0 : void basic_altstringbuf<Ch, Tr, Alloc>::
22 : clear_buffer () {
23 0 : const Ch * p = pptr();
24 0 : const Ch * b = pbase();
25 0 : if(p != NULL && p != b) {
26 0 : seekpos(0, ::std::ios_base::out);
27 : }
28 0 : p = gptr();
29 0 : b = eback();
30 0 : if(p != NULL && p != b) {
31 0 : seekpos(0, ::std::ios_base::in);
32 : }
33 0 : }
34 :
35 : template<class Ch, class Tr, class Alloc>
36 : void basic_altstringbuf<Ch, Tr, Alloc>::
37 : str (const string_type& s) {
38 : size_type sz=s.size();
39 : if(sz != 0 && mode_ & (::std::ios_base::in | ::std::ios_base::out) ) {
40 : #ifdef _RWSTD_NO_CLASS_PARTIAL_SPEC
41 : void *vd_ptr = alloc_.allocate(sz, is_allocated_? eback() : 0);
42 : Ch *new_ptr = static_cast<Ch *>(vd_ptr);
43 : #else
44 : Ch *new_ptr = alloc_.allocate(sz, is_allocated_? eback() : 0);
45 : #endif
46 : // if this didnt throw, we're safe, update the buffer
47 : dealloc();
48 : sz = s.copy(new_ptr, sz);
49 : putend_ = new_ptr + sz;
50 : if(mode_ & ::std::ios_base::in)
51 : streambuf_t::setg(new_ptr, new_ptr, new_ptr + sz);
52 : if(mode_ & ::std::ios_base::out) {
53 : streambuf_t::setp(new_ptr, new_ptr + sz);
54 : if(mode_ & (::std::ios_base::app | ::std::ios_base::ate))
55 : streambuf_t::pbump(static_cast<int>(sz));
56 : if(gptr() == NULL)
57 : streambuf_t::setg(new_ptr, NULL, new_ptr);
58 : }
59 : is_allocated_ = true;
60 : }
61 : else
62 : dealloc();
63 : }
64 : template<class Ch, class Tr, class Alloc>
65 : Ch* basic_altstringbuf<Ch, Tr, Alloc>::
66 : begin () const {
67 : if(mode_ & ::std::ios_base::out && pptr() != NULL)
68 : return pbase();
69 : else if(mode_ & ::std::ios_base::in && gptr() != NULL)
70 : return eback();
71 : return NULL;
72 : }
73 :
74 : template<class Ch, class Tr, class Alloc>
75 : typename std::basic_string<Ch,Tr,Alloc>::size_type
76 : basic_altstringbuf<Ch, Tr, Alloc>::
77 : size () const {
78 : if(mode_ & ::std::ios_base::out && pptr())
79 : return static_cast<size_type>(pend() - pbase());
80 : else if(mode_ & ::std::ios_base::in && gptr())
81 : return static_cast<size_type>(egptr() - eback());
82 : else
83 : return 0;
84 : }
85 :
86 : template<class Ch, class Tr, class Alloc>
87 : typename std::basic_string<Ch,Tr,Alloc>::size_type
88 : basic_altstringbuf<Ch, Tr, Alloc>::
89 : cur_size () const {
90 : if(mode_ & ::std::ios_base::out && pptr())
91 : return static_cast<streamsize>( pptr() - pbase());
92 : else if(mode_ & ::std::ios_base::in && gptr())
93 : return static_cast<streamsize>( gptr() - eback());
94 : else
95 : return 0;
96 : }
97 :
98 : template<class Ch, class Tr, class Alloc>
99 : typename basic_altstringbuf<Ch, Tr, Alloc>::pos_type
100 0 : basic_altstringbuf<Ch, Tr, Alloc>::
101 : seekoff (off_type off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which) {
102 0 : if(pptr() != NULL && putend_ < pptr())
103 0 : putend_ = pptr();
104 0 : if(which & ::std::ios_base::in && gptr() != NULL) {
105 : // get area
106 0 : if(way == ::std::ios_base::end)
107 0 : off += static_cast<off_type>(putend_ - gptr());
108 0 : else if(way == ::std::ios_base::beg)
109 0 : off += static_cast<off_type>(eback() - gptr());
110 0 : else if(way != ::std::ios_base::cur || (which & ::std::ios_base::out) )
111 : // (altering in&out is only supported if way is beg or end, not cur)
112 0 : return pos_type(off_type(-1));
113 0 : if(eback() <= off+gptr() && off+gptr() <= putend_ ) {
114 : // set gptr
115 0 : streambuf_t::gbump(static_cast<int>(off));
116 0 : if(which & ::std::ios_base::out && pptr() != NULL)
117 : // update pptr to match gptr
118 0 : streambuf_t::pbump(static_cast<int>(gptr()-pptr()));
119 : }
120 : else
121 : off = off_type(-1);
122 : }
123 0 : else if(which & ::std::ios_base::out && pptr() != NULL) {
124 : // put area
125 0 : if(way == ::std::ios_base::end)
126 0 : off += static_cast<off_type>(putend_ - pptr());
127 0 : else if(way == ::std::ios_base::beg)
128 0 : off += static_cast<off_type>(pbase() - pptr());
129 : else if(way != ::std::ios_base::beg)
130 0 : return pos_type(off_type(-1));
131 0 : if(pbase() <= off+pptr() && off+pptr() <= putend_)
132 : // set pptr
133 0 : streambuf_t::pbump(static_cast<int>(off));
134 : else
135 : off = off_type(-1);
136 : }
137 : else // neither in nor out
138 : off = off_type(-1);
139 0 : return (pos_type(off));
140 : }
141 : //- end seekoff(..)
142 :
143 :
144 : template<class Ch, class Tr, class Alloc>
145 : typename basic_altstringbuf<Ch, Tr, Alloc>::pos_type
146 0 : basic_altstringbuf<Ch, Tr, Alloc>::
147 : seekpos (pos_type pos, ::std::ios_base::openmode which) {
148 0 : off_type off = off_type(pos); // operation guaranteed by fpos.operations table 127
149 0 : if(pptr() != NULL && putend_ < pptr())
150 0 : putend_ = pptr();
151 0 : if(off != off_type(-1)) {
152 0 : if(which & ::std::ios_base::in && gptr() != NULL) {
153 : // get area
154 0 : if(0 <= off && off <= putend_ - eback()) {
155 0 : streambuf_t::gbump(static_cast<int>(eback() - gptr() + off));
156 0 : if(which & ::std::ios_base::out && pptr() != NULL) {
157 : // update pptr to match gptr
158 0 : streambuf_t::pbump(static_cast<int>(gptr()-pptr()));
159 : }
160 : }
161 : else
162 : off = off_type(-1);
163 : }
164 0 : else if(which & ::std::ios_base::out && pptr() != NULL) {
165 : // put area
166 0 : if(0 <= off && off <= putend_ - eback())
167 0 : streambuf_t::pbump(static_cast<int>(eback() - pptr() + off));
168 : else
169 : off = off_type(-1);
170 : }
171 : else // neither in nor out
172 : off = off_type(-1);
173 0 : return (pos_type(off));
174 : }
175 : else {
176 0 : BOOST_ASSERT(0); // fpos.operations allows undefined-behaviour here
177 : return pos_type(off_type(-1));
178 : }
179 : }
180 : // -end seekpos(..)
181 :
182 :
183 : template<class Ch, class Tr, class Alloc>
184 : typename basic_altstringbuf<Ch, Tr, Alloc>::int_type
185 0 : basic_altstringbuf<Ch, Tr, Alloc>::
186 : underflow () {
187 0 : if(gptr() == NULL) // no get area -> nothing to get.
188 : return (compat_traits_type::eof());
189 0 : else if(gptr() < egptr()) // ok, in buffer
190 0 : return (compat_traits_type::to_int_type(*gptr()));
191 0 : else if(mode_ & ::std::ios_base::in && pptr() != NULL
192 0 : && (gptr() < pptr() || gptr() < putend_) )
193 : { // expand get area
194 0 : if(putend_ < pptr())
195 0 : putend_ = pptr(); // remember pptr reached this far
196 0 : streambuf_t::setg(eback(), gptr(), putend_);
197 0 : return (compat_traits_type::to_int_type(*gptr()));
198 : }
199 : else // couldnt get anything. EOF.
200 : return (compat_traits_type::eof());
201 : }
202 : // -end underflow(..)
203 :
204 :
205 : template<class Ch, class Tr, class Alloc>
206 : typename basic_altstringbuf<Ch, Tr, Alloc>::int_type
207 0 : basic_altstringbuf<Ch, Tr, Alloc>::
208 : pbackfail (int_type meta) {
209 0 : if(gptr() != NULL && (eback() < gptr())
210 0 : && (mode_ & (::std::ios_base::out)
211 0 : || compat_traits_type::eq_int_type(compat_traits_type::eof(), meta)
212 0 : || compat_traits_type::eq(compat_traits_type::to_char_type(meta), gptr()[-1]) ) ) {
213 0 : streambuf_t::gbump(-1); // back one character
214 0 : if(!compat_traits_type::eq_int_type(compat_traits_type::eof(), meta))
215 : // put-back meta into get area
216 0 : *gptr() = compat_traits_type::to_char_type(meta);
217 0 : return (compat_traits_type::not_eof(meta));
218 : }
219 : else
220 : return (compat_traits_type::eof()); // failed putback
221 : }
222 : // -end pbackfail(..)
223 :
224 :
225 : template<class Ch, class Tr, class Alloc>
226 : typename basic_altstringbuf<Ch, Tr, Alloc>::int_type
227 0 : basic_altstringbuf<Ch, Tr, Alloc>::
228 : overflow (int_type meta) {
229 : #ifdef BOOST_MSVC
230 : #pragma warning(push)
231 : #pragma warning(disable:4996)
232 : #endif
233 0 : if(compat_traits_type::eq_int_type(compat_traits_type::eof(), meta))
234 : return compat_traits_type::not_eof(meta); // nothing to do
235 0 : else if(pptr() != NULL && pptr() < epptr()) {
236 0 : streambuf_t::sputc(compat_traits_type::to_char_type(meta));
237 0 : return meta;
238 : }
239 0 : else if(! (mode_ & ::std::ios_base::out))
240 : // no write position, and cant make one
241 : return compat_traits_type::eof();
242 : else { // make a write position available
243 0 : std::size_t prev_size = pptr() == NULL ? 0 : epptr() - eback();
244 0 : std::size_t new_size = prev_size;
245 : // exponential growth : size *= 1.5
246 0 : std::size_t add_size = new_size / 2;
247 0 : if(add_size < alloc_min)
248 : add_size = alloc_min;
249 0 : Ch * newptr = NULL, *oldptr = eback();
250 :
251 : // make sure adding add_size wont overflow size_t
252 0 : while (0 < add_size && ((std::numeric_limits<std::size_t>::max)()
253 0 : - add_size < new_size) )
254 0 : add_size /= 2;
255 0 : if(0 < add_size) {
256 0 : new_size += add_size;
257 : #ifdef _RWSTD_NO_CLASS_PARTIAL_SPEC
258 : void *vdptr = alloc_.allocate(new_size, is_allocated_? oldptr : 0);
259 : newptr = static_cast<Ch *>(vdptr);
260 : #else
261 0 : newptr = alloc_.allocate(new_size, is_allocated_? oldptr : 0);
262 : #endif
263 : }
264 :
265 0 : if(0 < prev_size)
266 0 : compat_traits_type::copy(newptr, oldptr, prev_size);
267 0 : if(is_allocated_)
268 0 : alloc_.deallocate(oldptr, prev_size);
269 0 : is_allocated_=true;
270 :
271 0 : if(prev_size == 0) { // first allocation
272 0 : putend_ = newptr;
273 0 : streambuf_t::setp(newptr, newptr + new_size);
274 0 : if(mode_ & ::std::ios_base::in)
275 0 : streambuf_t::setg(newptr, newptr, newptr + 1);
276 : else
277 0 : streambuf_t::setg(newptr, 0, newptr);
278 : }
279 : else { // update pointers
280 0 : putend_ = putend_ - oldptr + newptr;
281 0 : int pptr_count = static_cast<int>(pptr()-pbase());
282 0 : int gptr_count = static_cast<int>(gptr()-eback());
283 0 : streambuf_t::setp(pbase() - oldptr + newptr, newptr + new_size);
284 0 : streambuf_t::pbump(pptr_count);
285 0 : if(mode_ & ::std::ios_base::in)
286 0 : streambuf_t::setg(newptr, newptr + gptr_count, pptr() + 1);
287 : else
288 0 : streambuf_t::setg(newptr, 0, newptr);
289 : }
290 0 : streambuf_t::sputc(compat_traits_type::to_char_type(meta));
291 0 : return meta;
292 : }
293 : #ifdef BOOST_MSVC
294 : #pragma warning(pop)
295 : #endif
296 : }
297 : // -end overflow(..)
298 :
299 : template<class Ch, class Tr, class Alloc>
300 0 : void basic_altstringbuf<Ch, Tr, Alloc>:: dealloc() {
301 0 : if(is_allocated_)
302 0 : alloc_.deallocate(eback(), (pptr() != NULL ? epptr() : egptr()) - eback());
303 0 : is_allocated_ = false;
304 0 : streambuf_t::setg(0, 0, 0);
305 0 : streambuf_t::setp(0, 0);
306 0 : putend_ = NULL;
307 : }
308 :
309 : }// N.S. io
310 : } // N.S. boost
311 :
312 : #endif // include guard
313 :
|
