1/*
2Copyright 2002, 2005 Daryle Walker
3
4Distributed under the Boost Software License, Version 1.0.
5(http://www.boost.org/LICENSE_1_0.txt)
6*/
7#ifndef BOOST_IO_IOS_STATE_HPP
8#define BOOST_IO_IOS_STATE_HPP
9
10#include <boost/config.hpp>
11#include <boost/io_fwd.hpp>
12#include <ios>
13#ifndef BOOST_NO_STD_LOCALE
14#include <locale>
15#endif
16#include <ostream>
17#include <streambuf>
18#include <string>
19
20namespace boost {
21namespace io {
22
23class ios_flags_saver {
24public:
25 typedef std::ios_base state_type;
26 typedef std::ios_base::fmtflags aspect_type;
27
28 explicit ios_flags_saver(state_type& s)
29 : s_save_(s)
30 , a_save_(s.flags()) { }
31
32 ios_flags_saver(state_type& s, aspect_type a)
33 : s_save_(s)
34 , a_save_(s.flags(fmtfl: a)) { }
35
36 ~ios_flags_saver() {
37 this->restore();
38 }
39
40 void restore() {
41 s_save_.flags(fmtfl: a_save_);
42 }
43
44private:
45 ios_flags_saver(const ios_flags_saver&);
46 ios_flags_saver& operator=(const ios_flags_saver&);
47
48 state_type& s_save_;
49 aspect_type a_save_;
50};
51
52class ios_precision_saver {
53public:
54 typedef std::ios_base state_type;
55 typedef std::streamsize aspect_type;
56
57 explicit ios_precision_saver(state_type& s)
58 : s_save_(s)
59 , a_save_(s.precision()) { }
60
61 ios_precision_saver(state_type& s, aspect_type a)
62 : s_save_(s)
63 , a_save_(s.precision(prec: a)) { }
64
65 ~ios_precision_saver() {
66 this->restore();
67 }
68
69 void restore() {
70 s_save_.precision(prec: a_save_);
71 }
72
73private:
74 ios_precision_saver(const ios_precision_saver&);
75 ios_precision_saver& operator=(const ios_precision_saver&);
76
77 state_type& s_save_;
78 aspect_type a_save_;
79};
80
81class ios_width_saver {
82public:
83 typedef std::ios_base state_type;
84 typedef std::streamsize aspect_type;
85
86 explicit ios_width_saver(state_type& s)
87 : s_save_(s)
88 , a_save_(s.width()) { }
89
90 ios_width_saver(state_type& s, aspect_type a)
91 : s_save_(s)
92 , a_save_(s.width(wide: a)) { }
93
94 ~ios_width_saver() {
95 this->restore();
96 }
97
98 void restore() {
99 s_save_.width(wide: a_save_);
100 }
101
102private:
103 ios_width_saver(const ios_width_saver&);
104 ios_width_saver& operator=(const ios_width_saver&);
105
106 state_type& s_save_;
107 aspect_type a_save_;
108};
109
110template<class Ch, class Tr>
111class basic_ios_iostate_saver {
112public:
113 typedef std::basic_ios<Ch, Tr> state_type;
114 typedef std::ios_base::iostate aspect_type;
115
116 explicit basic_ios_iostate_saver(state_type& s)
117 : s_save_(s)
118 , a_save_(s.rdstate()) { }
119
120 basic_ios_iostate_saver(state_type& s, aspect_type a)
121 : s_save_(s)
122 , a_save_(s.rdstate()) {
123 s.clear(a);
124 }
125
126 ~basic_ios_iostate_saver() {
127 this->restore();
128 }
129
130 void restore() {
131 s_save_.clear(a_save_);
132 }
133
134private:
135 basic_ios_iostate_saver(const basic_ios_iostate_saver&);
136 basic_ios_iostate_saver& operator=(const basic_ios_iostate_saver&);
137
138 state_type& s_save_;
139 aspect_type a_save_;
140};
141
142template<class Ch, class Tr>
143class basic_ios_exception_saver {
144public:
145 typedef std::basic_ios<Ch, Tr> state_type;
146 typedef std::ios_base::iostate aspect_type;
147
148 explicit basic_ios_exception_saver(state_type& s)
149 : s_save_(s)
150 , a_save_(s.exceptions()) { }
151
152 basic_ios_exception_saver(state_type& s, aspect_type a)
153 : s_save_(s)
154 , a_save_(s.exceptions()) {
155 s.exceptions(a);
156 }
157
158 ~basic_ios_exception_saver() {
159 this->restore();
160 }
161
162 void restore() {
163 s_save_.exceptions(a_save_);
164 }
165
166private:
167 basic_ios_exception_saver(const basic_ios_exception_saver&);
168 basic_ios_exception_saver& operator=(const basic_ios_exception_saver&);
169
170 state_type& s_save_;
171 aspect_type a_save_;
172};
173
174template<class Ch, class Tr>
175class basic_ios_tie_saver {
176public:
177 typedef std::basic_ios<Ch, Tr> state_type;
178 typedef std::basic_ostream<Ch, Tr>* aspect_type;
179
180 explicit basic_ios_tie_saver(state_type& s)
181 : s_save_(s)
182 , a_save_(s.tie()) { }
183
184 basic_ios_tie_saver(state_type& s, aspect_type a)
185 : s_save_(s)
186 , a_save_(s.tie(a)) { }
187
188 ~basic_ios_tie_saver() {
189 this->restore();
190 }
191
192 void restore() {
193 s_save_.tie(a_save_);
194 }
195
196private:
197 basic_ios_tie_saver(const basic_ios_tie_saver&);
198 basic_ios_tie_saver& operator=(const basic_ios_tie_saver&);
199
200 state_type& s_save_;
201 aspect_type a_save_;
202};
203
204template<class Ch, class Tr>
205class basic_ios_rdbuf_saver {
206public:
207 typedef std::basic_ios<Ch, Tr> state_type;
208 typedef std::basic_streambuf<Ch, Tr>* aspect_type;
209
210 explicit basic_ios_rdbuf_saver(state_type& s)
211 : s_save_(s)
212 , a_save_(s.rdbuf()) { }
213
214 basic_ios_rdbuf_saver(state_type& s, aspect_type a)
215 : s_save_(s)
216 , a_save_(s.rdbuf(a)) { }
217
218 ~basic_ios_rdbuf_saver() {
219 this->restore();
220 }
221
222 void restore() {
223 s_save_.rdbuf(a_save_);
224 }
225
226private:
227 basic_ios_rdbuf_saver(const basic_ios_rdbuf_saver&);
228 basic_ios_rdbuf_saver& operator=(const basic_ios_rdbuf_saver&);
229
230 state_type& s_save_;
231 aspect_type a_save_;
232};
233
234template<class Ch, class Tr>
235class basic_ios_fill_saver {
236public:
237 typedef std::basic_ios<Ch, Tr> state_type;
238 typedef typename state_type::char_type aspect_type;
239
240 explicit basic_ios_fill_saver(state_type& s)
241 : s_save_(s)
242 , a_save_(s.fill()) { }
243
244 basic_ios_fill_saver(state_type& s, aspect_type a)
245 : s_save_(s)
246 , a_save_(s.fill(a)) { }
247
248 ~basic_ios_fill_saver() {
249 this->restore();
250 }
251
252 void restore() {
253 s_save_.fill(a_save_);
254 }
255
256private:
257 basic_ios_fill_saver(const basic_ios_fill_saver&);
258 basic_ios_fill_saver& operator=(const basic_ios_fill_saver&);
259
260 state_type& s_save_;
261 aspect_type a_save_;
262};
263
264#ifndef BOOST_NO_STD_LOCALE
265template<class Ch, class Tr>
266class basic_ios_locale_saver {
267public:
268 typedef std::basic_ios<Ch, Tr> state_type;
269 typedef std::locale aspect_type;
270
271 explicit basic_ios_locale_saver(state_type& s)
272 : s_save_(s)
273 , a_save_(s.getloc()) { }
274
275 basic_ios_locale_saver(state_type& s, const aspect_type& a)
276 : s_save_(s)
277 , a_save_(s.imbue(a)) { }
278
279 ~basic_ios_locale_saver() {
280 this->restore();
281 }
282
283 void restore() {
284 s_save_.imbue(a_save_);
285 }
286
287private:
288 basic_ios_locale_saver(const basic_ios_locale_saver&);
289 basic_ios_locale_saver& operator=(const basic_ios_locale_saver&);
290
291 state_type& s_save_;
292 aspect_type a_save_;
293};
294#endif
295
296class ios_iword_saver {
297public:
298 typedef std::ios_base state_type;
299 typedef int index_type;
300 typedef long aspect_type;
301
302 explicit ios_iword_saver(state_type& s, index_type i)
303 : s_save_(s)
304 , a_save_(s.iword(ix: i))
305 , i_save_(i) { }
306
307 ios_iword_saver(state_type& s, index_type i, aspect_type a)
308 : s_save_(s)
309 , a_save_(s.iword(ix: i))
310 , i_save_(i) {
311 s.iword(ix: i) = a;
312 }
313
314 ~ios_iword_saver() {
315 this->restore();
316 }
317
318 void restore() {
319 s_save_.iword(ix: i_save_) = a_save_;
320 }
321
322private:
323 ios_iword_saver(const ios_iword_saver&);
324 ios_iword_saver& operator=(const ios_iword_saver&);
325
326 state_type& s_save_;
327 aspect_type a_save_;
328 index_type i_save_;
329};
330
331class ios_pword_saver {
332public:
333 typedef std::ios_base state_type;
334 typedef int index_type;
335 typedef void* aspect_type;
336
337 explicit ios_pword_saver(state_type& s, index_type i)
338 : s_save_(s)
339 , a_save_(s.pword(ix: i))
340 , i_save_(i) { }
341
342 ios_pword_saver(state_type& s, index_type i, aspect_type a)
343 : s_save_(s)
344 , a_save_(s.pword(ix: i))
345 , i_save_(i) {
346 s.pword(ix: i) = a;
347 }
348
349 ~ios_pword_saver() {
350 this->restore();
351 }
352
353 void restore() {
354 s_save_.pword(ix: i_save_) = a_save_;
355 }
356
357private:
358 ios_pword_saver(const ios_pword_saver&);
359 ios_pword_saver operator=(const ios_pword_saver&);
360
361 state_type& s_save_;
362 aspect_type a_save_;
363 index_type i_save_;
364};
365
366class ios_base_all_saver {
367public:
368 typedef std::ios_base state_type;
369
370 explicit ios_base_all_saver(state_type& s)
371 : s_save_(s)
372 , a1_save_(s.flags())
373 , a2_save_(s.precision())
374 , a3_save_(s.width()) { }
375
376 ~ios_base_all_saver() {
377 this->restore();
378 }
379
380 void restore() {
381 s_save_.width(wide: a3_save_);
382 s_save_.precision(prec: a2_save_);
383 s_save_.flags(fmtfl: a1_save_);
384 }
385
386private:
387 ios_base_all_saver(const ios_base_all_saver&);
388 ios_base_all_saver& operator=(const ios_base_all_saver&);
389
390 state_type& s_save_;
391 state_type::fmtflags a1_save_;
392 std::streamsize a2_save_;
393 std::streamsize a3_save_;
394};
395
396template<class Ch, class Tr>
397class basic_ios_all_saver {
398public:
399 typedef std::basic_ios<Ch, Tr> state_type;
400
401 explicit basic_ios_all_saver(state_type& s)
402 : s_save_(s)
403 , a1_save_(s.flags())
404 , a2_save_(s.precision())
405 , a3_save_(s.width())
406 , a4_save_(s.rdstate())
407 , a5_save_(s.exceptions())
408 , a6_save_(s.tie())
409 , a7_save_(s.rdbuf())
410 , a8_save_(s.fill())
411#ifndef BOOST_NO_STD_LOCALE
412 , a9_save_(s.getloc())
413#endif
414 { }
415
416 ~basic_ios_all_saver() {
417 this->restore();
418 }
419
420 void restore() {
421#ifndef BOOST_NO_STD_LOCALE
422 s_save_.imbue(a9_save_);
423#endif
424 s_save_.fill(a8_save_);
425 s_save_.rdbuf(a7_save_);
426 s_save_.tie(a6_save_);
427 s_save_.exceptions(a5_save_);
428 s_save_.clear(a4_save_);
429 s_save_.width(a3_save_);
430 s_save_.precision(a2_save_);
431 s_save_.flags(a1_save_);
432 }
433
434private:
435 basic_ios_all_saver(const basic_ios_all_saver&);
436 basic_ios_all_saver& operator=(const basic_ios_all_saver&);
437
438 state_type& s_save_;
439 typename state_type::fmtflags a1_save_;
440 std::streamsize a2_save_;
441 std::streamsize a3_save_;
442 typename state_type::iostate a4_save_;
443 typename state_type::iostate a5_save_;
444 std::basic_ostream<Ch, Tr>* a6_save_;
445 std::basic_streambuf<Ch, Tr>* a7_save_;
446 typename state_type::char_type a8_save_;
447#ifndef BOOST_NO_STD_LOCALE
448 std::locale a9_save_;
449#endif
450};
451
452class ios_all_word_saver {
453public:
454 typedef std::ios_base state_type;
455 typedef int index_type;
456
457 ios_all_word_saver(state_type& s, index_type i)
458 : s_save_(s)
459 , i_save_(i)
460 , a1_save_(s.iword(ix: i))
461 , a2_save_(s.pword(ix: i)) { }
462
463 ~ios_all_word_saver() {
464 this->restore();
465 }
466
467 void restore() {
468 s_save_.pword(ix: i_save_) = a2_save_;
469 s_save_.iword(ix: i_save_) = a1_save_;
470 }
471
472private:
473 ios_all_word_saver(const ios_all_word_saver&);
474 ios_all_word_saver& operator=(const ios_all_word_saver&);
475
476 state_type& s_save_;
477 index_type i_save_;
478 long a1_save_;
479 void* a2_save_;
480};
481
482} /* io */
483} /* boost */
484
485#endif
486

source code of include/boost/io/ios_state.hpp