Line data Source code
1 : // Iostreams base classes -*- C++ -*-
2 :
3 : // Copyright (C) 1997-2019 Free Software Foundation, Inc.
4 : //
5 : // This file is part of the GNU ISO C++ Library. This library is free
6 : // software; you can redistribute it and/or modify it under the
7 : // terms of the GNU General Public License as published by the
8 : // Free Software Foundation; either version 3, or (at your option)
9 : // any later version.
10 :
11 : // This library is distributed in the hope that it will be useful,
12 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : // GNU General Public License for more details.
15 :
16 : // Under Section 7 of GPL version 3, you are granted additional
17 : // permissions described in the GCC Runtime Library Exception, version
18 : // 3.1, as published by the Free Software Foundation.
19 :
20 : // You should have received a copy of the GNU General Public License and
21 : // a copy of the GCC Runtime Library Exception along with this program;
22 : // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 : // <http://www.gnu.org/licenses/>.
24 :
25 : /** @file bits/basic_ios.h
26 : * This is an internal header file, included by other library headers.
27 : * Do not attempt to use it directly. @headername{ios}
28 : */
29 :
30 : #ifndef _BASIC_IOS_H
31 : #define _BASIC_IOS_H 1
32 :
33 : #pragma GCC system_header
34 :
35 : #include <bits/localefwd.h>
36 : #include <bits/locale_classes.h>
37 : #include <bits/locale_facets.h>
38 : #include <bits/streambuf_iterator.h>
39 : #include <bits/move.h>
40 :
41 : namespace std _GLIBCXX_VISIBILITY(default)
42 : {
43 : _GLIBCXX_BEGIN_NAMESPACE_VERSION
44 :
45 : template<typename _Facet>
46 : inline const _Facet&
47 0 : __check_facet(const _Facet* __f)
48 : {
49 0 : if (!__f)
50 0 : __throw_bad_cast();
51 : return *__f;
52 : }
53 :
54 : /**
55 : * @brief Template class basic_ios, virtual base class for all
56 : * stream classes.
57 : * @ingroup io
58 : *
59 : * @tparam _CharT Type of character stream.
60 : * @tparam _Traits Traits for character type, defaults to
61 : * char_traits<_CharT>.
62 : *
63 : * Most of the member functions called dispatched on stream objects
64 : * (e.g., @c std::cout.foo(bar);) are consolidated in this class.
65 : */
66 : template<typename _CharT, typename _Traits>
67 : class basic_ios : public ios_base
68 : {
69 : public:
70 : ///@{
71 : /**
72 : * These are standard types. They permit a standardized way of
73 : * referring to names of (or names dependent on) the template
74 : * parameters, which are specific to the implementation.
75 : */
76 : typedef _CharT char_type;
77 : typedef typename _Traits::int_type int_type;
78 : typedef typename _Traits::pos_type pos_type;
79 : typedef typename _Traits::off_type off_type;
80 : typedef _Traits traits_type;
81 : ///@}
82 :
83 : ///@{
84 : /**
85 : * These are non-standard types.
86 : */
87 : typedef ctype<_CharT> __ctype_type;
88 : typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
89 : __num_put_type;
90 : typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
91 : __num_get_type;
92 : ///@}
93 :
94 : // Data members:
95 : protected:
96 : basic_ostream<_CharT, _Traits>* _M_tie;
97 : mutable char_type _M_fill;
98 : mutable bool _M_fill_init;
99 : basic_streambuf<_CharT, _Traits>* _M_streambuf;
100 :
101 : // Cached use_facet<ctype>, which is based on the current locale info.
102 : const __ctype_type* _M_ctype;
103 : // For ostream.
104 : const __num_put_type* _M_num_put;
105 : // For istream.
106 : const __num_get_type* _M_num_get;
107 :
108 : public:
109 : ///@{
110 : /**
111 : * @brief The quick-and-easy status check.
112 : *
113 : * This allows you to write constructs such as
114 : * <code>if (!a_stream) ...</code> and <code>while (a_stream) ...</code>
115 : */
116 : #if __cplusplus >= 201103L
117 8 : explicit operator bool() const
118 8 : { return !this->fail(); }
119 : #else
120 : operator void*() const
121 : { return this->fail() ? 0 : const_cast<basic_ios*>(this); }
122 : #endif
123 :
124 : bool
125 361 : operator!() const
126 361 : { return this->fail(); }
127 : ///@}
128 :
129 : /**
130 : * @brief Returns the error state of the stream buffer.
131 : * @return A bit pattern (well, isn't everything?)
132 : *
133 : * See std::ios_base::iostate for the possible bit values. Most
134 : * users will call one of the interpreting wrappers, e.g., good().
135 : */
136 : iostate
137 1229 : rdstate() const
138 : { return _M_streambuf_state; }
139 :
140 : /**
141 : * @brief [Re]sets the error state.
142 : * @param __state The new state flag(s) to set.
143 : *
144 : * See std::ios_base::iostate for the possible bit values. Most
145 : * users will not need to pass an argument.
146 : */
147 : void
148 : clear(iostate __state = goodbit);
149 :
150 : /**
151 : * @brief Sets additional flags in the error state.
152 : * @param __state The additional state flag(s) to set.
153 : *
154 : * See std::ios_base::iostate for the possible bit values.
155 : */
156 : void
157 : setstate(iostate __state)
158 : { this->clear(this->rdstate() | __state); }
159 :
160 : // Flip the internal state on for the proper state bits, then
161 : // rethrows the propagated exception if bit also set in
162 : // exceptions().
163 : void
164 : _M_setstate(iostate __state)
165 : {
166 : // 27.6.1.2.1 Common requirements.
167 : // Turn this on without causing an ios::failure to be thrown.
168 : _M_streambuf_state |= __state;
169 : if (this->exceptions() & __state)
170 : __throw_exception_again;
171 : }
172 :
173 : /**
174 : * @brief Fast error checking.
175 : * @return True if no error flags are set.
176 : *
177 : * A wrapper around rdstate.
178 : */
179 : bool
180 70 : good() const
181 35 : { return this->rdstate() == 0; }
182 :
183 : /**
184 : * @brief Fast error checking.
185 : * @return True if the eofbit is set.
186 : *
187 : * Note that other iostate flags may also be set.
188 : */
189 : bool
190 715 : eof() const
191 715 : { return (this->rdstate() & eofbit) != 0; }
192 :
193 : /**
194 : * @brief Fast error checking.
195 : * @return True if either the badbit or the failbit is set.
196 : *
197 : * Checking the badbit in fail() is historical practice.
198 : * Note that other iostate flags may also be set.
199 : */
200 : bool
201 444 : fail() const
202 509 : { return (this->rdstate() & (badbit | failbit)) != 0; }
203 :
204 : /**
205 : * @brief Fast error checking.
206 : * @return True if the badbit is set.
207 : *
208 : * Note that other iostate flags may also be set.
209 : */
210 : bool
211 : bad() const
212 : { return (this->rdstate() & badbit) != 0; }
213 :
214 : /**
215 : * @brief Throwing exceptions on errors.
216 : * @return The current exceptions mask.
217 : *
218 : * This changes nothing in the stream. See the one-argument version
219 : * of exceptions(iostate) for the meaning of the return value.
220 : */
221 : iostate
222 : exceptions() const
223 : { return _M_exception; }
224 :
225 : /**
226 : * @brief Throwing exceptions on errors.
227 : * @param __except The new exceptions mask.
228 : *
229 : * By default, error flags are set silently. You can set an
230 : * exceptions mask for each stream; if a bit in the mask becomes set
231 : * in the error flags, then an exception of type
232 : * std::ios_base::failure is thrown.
233 : *
234 : * If the error flag is already set when the exceptions mask is
235 : * added, the exception is immediately thrown. Try running the
236 : * following under GCC 3.1 or later:
237 : * @code
238 : * #include <iostream>
239 : * #include <fstream>
240 : * #include <exception>
241 : *
242 : * int main()
243 : * {
244 : * std::set_terminate (__gnu_cxx::__verbose_terminate_handler);
245 : *
246 : * std::ifstream f ("/etc/motd");
247 : *
248 : * std::cerr << "Setting badbit\n";
249 : * f.setstate (std::ios_base::badbit);
250 : *
251 : * std::cerr << "Setting exception mask\n";
252 : * f.exceptions (std::ios_base::badbit);
253 : * }
254 : * @endcode
255 : */
256 : void
257 0 : exceptions(iostate __except)
258 : {
259 0 : _M_exception = __except;
260 0 : this->clear(_M_streambuf_state);
261 : }
262 :
263 : // Constructor/destructor:
264 : /**
265 : * @brief Constructor performs initialization.
266 : *
267 : * The parameter is passed by derived streams.
268 : */
269 : explicit
270 : basic_ios(basic_streambuf<_CharT, _Traits>* __sb)
271 : : ios_base(), _M_tie(0), _M_fill(), _M_fill_init(false), _M_streambuf(0),
272 : _M_ctype(0), _M_num_put(0), _M_num_get(0)
273 : { this->init(__sb); }
274 :
275 : /**
276 : * @brief Empty.
277 : *
278 : * The destructor does nothing. More specifically, it does not
279 : * destroy the streambuf held by rdbuf().
280 : */
281 : virtual
282 28851 : ~basic_ios() { }
283 :
284 : // Members:
285 : /**
286 : * @brief Fetches the current @e tied stream.
287 : * @return A pointer to the tied stream, or NULL if the stream is
288 : * not tied.
289 : *
290 : * A stream may be @e tied (or synchronized) to a second output
291 : * stream. When this stream performs any I/O, the tied stream is
292 : * first flushed. For example, @c std::cin is tied to @c std::cout.
293 : */
294 : basic_ostream<_CharT, _Traits>*
295 : tie() const
296 : { return _M_tie; }
297 :
298 : /**
299 : * @brief Ties this stream to an output stream.
300 : * @param __tiestr The output stream.
301 : * @return The previously tied output stream, or NULL if the stream
302 : * was not tied.
303 : *
304 : * This sets up a new tie; see tie() for more.
305 : */
306 : basic_ostream<_CharT, _Traits>*
307 : tie(basic_ostream<_CharT, _Traits>* __tiestr)
308 : {
309 : basic_ostream<_CharT, _Traits>* __old = _M_tie;
310 : _M_tie = __tiestr;
311 : return __old;
312 : }
313 :
314 : /**
315 : * @brief Accessing the underlying buffer.
316 : * @return The current stream buffer.
317 : *
318 : * This does not change the state of the stream.
319 : */
320 : basic_streambuf<_CharT, _Traits>*
321 56992 : rdbuf() const
322 : { return _M_streambuf; }
323 :
324 : /**
325 : * @brief Changing the underlying buffer.
326 : * @param __sb The new stream buffer.
327 : * @return The previous stream buffer.
328 : *
329 : * Associates a new buffer with the current stream, and clears the
330 : * error state.
331 : *
332 : * Due to historical accidents which the LWG refuses to correct, the
333 : * I/O library suffers from a design error: this function is hidden
334 : * in derived classes by overrides of the zero-argument @c rdbuf(),
335 : * which is non-virtual for hysterical raisins. As a result, you
336 : * must use explicit qualifications to access this function via any
337 : * derived class. For example:
338 : *
339 : * @code
340 : * std::fstream foo; // or some other derived type
341 : * std::streambuf* p = .....;
342 : *
343 : * foo.ios::rdbuf(p); // ios == basic_ios<char>
344 : * @endcode
345 : */
346 : basic_streambuf<_CharT, _Traits>*
347 : rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
348 :
349 : /**
350 : * @brief Copies fields of __rhs into this.
351 : * @param __rhs The source values for the copies.
352 : * @return Reference to this object.
353 : *
354 : * All fields of __rhs are copied into this object except that rdbuf()
355 : * and rdstate() remain unchanged. All values in the pword and iword
356 : * arrays are copied. Before copying, each callback is invoked with
357 : * erase_event. After copying, each (new) callback is invoked with
358 : * copyfmt_event. The final step is to copy exceptions().
359 : */
360 : basic_ios&
361 : copyfmt(const basic_ios& __rhs);
362 :
363 : /**
364 : * @brief Retrieves the @a empty character.
365 : * @return The current fill character.
366 : *
367 : * It defaults to a space (' ') in the current locale.
368 : */
369 : char_type
370 : fill() const
371 : {
372 : if (!_M_fill_init)
373 : {
374 : _M_fill = this->widen(' ');
375 : _M_fill_init = true;
376 : }
377 : return _M_fill;
378 : }
379 :
380 : /**
381 : * @brief Sets a new @a empty character.
382 : * @param __ch The new character.
383 : * @return The previous fill character.
384 : *
385 : * The fill character is used to fill out space when P+ characters
386 : * have been requested (e.g., via setw), Q characters are actually
387 : * used, and Q<P. It defaults to a space (' ') in the current locale.
388 : */
389 : char_type
390 816 : fill(char_type __ch)
391 : {
392 816 : char_type __old = this->fill();
393 816 : _M_fill = __ch;
394 0 : return __old;
395 : }
396 :
397 : // Locales:
398 : /**
399 : * @brief Moves to a new locale.
400 : * @param __loc The new locale.
401 : * @return The previous locale.
402 : *
403 : * Calls @c ios_base::imbue(loc), and if a stream buffer is associated
404 : * with this stream, calls that buffer's @c pubimbue(loc).
405 : *
406 : * Additional l10n notes are at
407 : * http://gcc.gnu.org/onlinedocs/libstdc++/manual/localization.html
408 : */
409 : locale
410 : imbue(const locale& __loc);
411 :
412 : /**
413 : * @brief Squeezes characters.
414 : * @param __c The character to narrow.
415 : * @param __dfault The character to narrow.
416 : * @return The narrowed character.
417 : *
418 : * Maps a character of @c char_type to a character of @c char,
419 : * if possible.
420 : *
421 : * Returns the result of
422 : * @code
423 : * std::use_facet<ctype<char_type> >(getloc()).narrow(c,dfault)
424 : * @endcode
425 : *
426 : * Additional l10n notes are at
427 : * http://gcc.gnu.org/onlinedocs/libstdc++/manual/localization.html
428 : */
429 : char
430 : narrow(char_type __c, char __dfault) const
431 : { return __check_facet(_M_ctype).narrow(__c, __dfault); }
432 :
433 : /**
434 : * @brief Widens characters.
435 : * @param __c The character to widen.
436 : * @return The widened character.
437 : *
438 : * Maps a character of @c char to a character of @c char_type.
439 : *
440 : * Returns the result of
441 : * @code
442 : * std::use_facet<ctype<char_type> >(getloc()).widen(c)
443 : * @endcode
444 : *
445 : * Additional l10n notes are at
446 : * http://gcc.gnu.org/onlinedocs/libstdc++/manual/localization.html
447 : */
448 : char_type
449 0 : widen(char __c) const
450 0 : { return __check_facet(_M_ctype).widen(__c); }
451 :
452 : protected:
453 : // 27.4.5.1 basic_ios constructors
454 : /**
455 : * @brief Empty.
456 : *
457 : * The default constructor does nothing and is not normally
458 : * accessible to users.
459 : */
460 356 : basic_ios()
461 : : ios_base(), _M_tie(0), _M_fill(char_type()), _M_fill_init(false),
462 356 : _M_streambuf(0), _M_ctype(0), _M_num_put(0), _M_num_get(0)
463 : { }
464 :
465 : /**
466 : * @brief All setup is performed here.
467 : *
468 : * This is called from the public constructor. It is not virtual and
469 : * cannot be redefined.
470 : */
471 : void
472 : init(basic_streambuf<_CharT, _Traits>* __sb);
473 :
474 : #if __cplusplus >= 201103L
475 : basic_ios(const basic_ios&) = delete;
476 : basic_ios& operator=(const basic_ios&) = delete;
477 :
478 : void
479 : move(basic_ios& __rhs)
480 : {
481 : ios_base::_M_move(__rhs);
482 : _M_cache_locale(_M_ios_locale);
483 : this->tie(__rhs.tie(nullptr));
484 : _M_fill = __rhs._M_fill;
485 : _M_fill_init = __rhs._M_fill_init;
486 : _M_streambuf = nullptr;
487 : }
488 :
489 : void
490 : move(basic_ios&& __rhs)
491 : { this->move(__rhs); }
492 :
493 : void
494 : swap(basic_ios& __rhs) noexcept
495 : {
496 : ios_base::_M_swap(__rhs);
497 : _M_cache_locale(_M_ios_locale);
498 : __rhs._M_cache_locale(__rhs._M_ios_locale);
499 : std::swap(_M_tie, __rhs._M_tie);
500 : std::swap(_M_fill, __rhs._M_fill);
501 : std::swap(_M_fill_init, __rhs._M_fill_init);
502 : }
503 :
504 : void
505 : set_rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
506 : { _M_streambuf = __sb; }
507 : #endif
508 :
509 : void
510 : _M_cache_locale(const locale& __loc);
511 : };
512 :
513 : _GLIBCXX_END_NAMESPACE_VERSION
514 : } // namespace
515 :
516 : #include <bits/basic_ios.tcc>
517 :
518 : #endif /* _BASIC_IOS_H */
|
