29 Input/output library [input.output]

Effects: Initializes the base class with basic_­streambuf<charT, traits>() ([streambuf.cons]).

Postconditions: is_­open() == false.

Effects: It is implementation-defined whether the sequence pointers in *this (eback(), gptr(), egptr(), pbase(), pptr(), epptr()) obtain the values which rhs had.

Whether they do or not, *this and rhs reference separate buffers (if any at all) after the construction.

Additionally *this references the file which rhs did before the construction, and rhs references no file after the construction.

The openmode, locale and any other state of rhs is also copied.

Postconditions: Let rhs_­p refer to the state of rhs just prior to this construction and let rhs_­a refer to the state of rhs just after this construction.

Effects: Calls close().

If an exception occurs during the destruction of the object, including the call to close(), the exception is caught but not rethrown (see [res.on.exception.handling]).

Effects: Calls close() then move assigns from rhs.

After the move assignment *this has the observable state it would have had if it had been move constructed from rhs (see [filebuf.cons]).

Returns: *this.

Effects: Exchanges the state of *this and rhs.

Effects: Equivalent to: x.swap(y).

Returns: true if a previous call to open succeeded (returned a non-null value) and there has been no intervening call to close.

Preconditions: s points to a NTCTS ([defns.ntcts]).

Effects: If is_­open() != false, returns a null pointer.

Otherwise, initializes the filebuf as required.

It then opens the file to which s resolves, if possible, as if by a call to fopen with the second argument determined from mode & ~ios_­base​::​ate as indicated in Table 126.

If mode is not some combination of flags shown in the table then the open fails.

If the open operation succeeds and ios_­base​::​ate is set in mode, positions the file to the end (as if by calling fseek(file, 0, SEEK_­END), where file is the pointer returned by calling fopen).323

If the repositioning operation fails, calls close() and returns a null pointer to indicate failure.

Returns: this if successful, a null pointer otherwise.

Returns: open(s.c_­str(), mode);

Effects: If is_­open() == false, returns a null pointer.

If a put area exists, calls overflow(traits​::​​eof()) to flush characters.

If the last virtual member function called on *this (between underflow, overflow, seekoff, and seekpos) was overflow then calls a_­codecvt.unshift (possibly several times) to determine a termination sequence, inserts those characters and calls overflow(traits​::​​eof()) again.

Finally, regardless of whether any of the preceding calls fails or throws an exception, the function closes the file (as if by calling fclose(file)).

If any of the calls made by the function, including fclose, fails, close fails by returning a null pointer.

If one of these calls throws an exception, the exception is caught and rethrown after closing the file.

Returns: this on success, a null pointer otherwise.

Postconditions: is_­open() == false.

Effects: Behaves the same as basic_­streambuf​::​showmanyc() ([streambuf.virtuals]).

Remarks: An implementation might well provide an overriding definition for this function signature if it can determine that more characters can be read from the input sequence.

Effects: Behaves according to the description of basic_­streambuf<charT, traits>​::​underflow(), with the specialization that a sequence of characters is read from the input sequence as if by reading from the associated file into an internal buffer (extern_­buf) and then as if by doing:

char   extern_buf[XSIZE];
char*  extern_end;
charT  intern_buf[ISIZE];
charT* intern_end;
codecvt_base::result r =
  a_codecvt.in(state, extern_buf, extern_buf+XSIZE, extern_end,
               intern_buf, intern_buf+ISIZE, intern_end);

This shall be done in such a way that the class can recover the position (fpos_­t) corresponding to each character between intern_­buf and intern_­end.

If the value of r indicates that a_­codecvt.in() ran out of space in intern_­buf, retry with a larger intern_­buf.

Effects: Behaves according to the description of basic_­streambuf<charT, traits>​::​uflow(), with the specialization that a sequence of characters is read from the input with the same method as used by underflow.

Effects: Puts back the character designated by c to the input sequence, if possible, in one of three ways:

• (5.1)
  If traits​::​eq_­int_­type(c, traits​::​eof()) returns false and if the function makes a putback position available and if traits​::​eq(to_­char_­type(c), gptr()[-1]) returns true, decrements the next pointer for the input sequence, gptr().
  Returns: c.
• (5.2)
  If traits​::​eq_­int_­type(c, traits​::​eof()) returns false and if the function makes a putback position available and if the function is permitted to assign to the putback position, decrements the next pointer for the input sequence, and stores c there.
  Returns: c.
• (5.3)
  If traits​::​eq_­int_­type(c, traits​::​eof()) returns true, and if either the input sequence has a putback position available or the function makes a putback position available, decrements the next pointer for the input sequence, gptr().
  Returns: traits​::​not_­eof(c).

Returns: As specified above, or traits​::​eof() to indicate failure.

Remarks: If is_­open() == false, the function always fails.

The function does not put back a character directly to the input sequence.

If the function can succeed in more than one of these ways, it is unspecified which way is chosen.

The function can alter the number of putback positions available as a result of any call.

Effects: Behaves according to the description of basic_­streambuf<charT, traits>​::​overflow(c), except that the behavior of “consuming characters” is performed by first converting as if by:

charT* b = pbase();
charT* p = pptr();
charT* end;
char   xbuf[XSIZE];
char*  xbuf_end;
codecvt_base::result r =
  a_codecvt.out(state, b, p, end, xbuf, xbuf+XSIZE, xbuf_end);

and then

• (10.1)
  If r == codecvt_­base​::​error then fail.
• (10.2)
  If r == codecvt_­base​::​noconv then output characters from b up to (and not including) p.
• (10.3)
  If r == codecvt_­base​::​partial then output to the file characters from xbuf up to xbuf_­end, and repeat using characters from end to p. If output fails, fail (without repeating).
• (10.4)
  Otherwise output from xbuf to xbuf_­end, and fail if output fails. At this point if b != p and b == end (xbuf isn't large enough) then increase XSIZE and repeat from the beginning.

Returns: traits​::​not_­eof(c) to indicate success, and traits​::​eof() to indicate failure.

If is_­open() == false, the function always fails.

Effects: If setbuf(0, 0) is called on a stream before any I/O has occurred on that stream, the stream becomes unbuffered.

Otherwise the results are implementation-defined.

“Unbuffered” means that pbase() and pptr() always return null and output to the file should appear as soon as possible.

Effects: Let width denote a_­codecvt.encoding().

If is_­open() == false, or off != 0 && width <= 0, then the positioning operation fails.

Otherwise, if way != basic_­ios​::​cur or off != 0, and if the last operation was output, then update the output sequence and write any unshift sequence.

Next, seek to the new position: if width > 0, call fseek(file, width * off, whence), otherwise call fseek(file, 0, whence).

Remarks: “The last operation was output” means either the last virtual operation was overflow or the put buffer is non-empty.

“Write any unshift sequence” means, if width if less than zero then call a_­codecvt.unshift(state, xbuf, xbuf+XSIZE, xbuf_­end) and output the resulting unshift sequence.

The function determines one of three values for the argument whence, of type int, as indicated in Table 127.

Returns: A newly constructed pos_­type object that stores the resultant stream position, if possible.

If the positioning operation fails, or if the object cannot represent the resultant stream position, returns pos_­type(off_­type(-1)).

Alters the file position, if possible, to correspond to the position stored in sp (as described below).

Altering the file position performs as follows:

1. 1.if (om & ios_­base​::​out) != 0, then update the output sequence and write any unshift sequence;
2. 2.set the file position to sp as if by a call to fsetpos;
3. 3.if (om & ios_­base​::​in) != 0, then update the input sequence;

where om is the open mode passed to the last call to open().

The operation fails if is_­open() returns false.

If sp is an invalid stream position, or if the function positions neither sequence, the positioning operation fails.

If sp has not been obtained by a previous successful call to one of the positioning functions (seekoff or seekpos) on the same file the effects are undefined.

Returns: sp on success.

Otherwise returns pos_­type(off_­type(-1)).

Effects: If a put area exists, calls filebuf​::​overflow to write the characters to the file, then flushes the file as if by calling fflush(file).

If a get area exists, the effect is implementation-defined.

Preconditions: If the file is not positioned at its beginning and the encoding of the current locale as determined by a_­codecvt.encoding() is state-dependent ([locale.codecvt.virtuals]) then that facet is the same as the corresponding facet of loc.

Effects: Causes characters inserted or extracted after this call to be converted according to loc until another call of imbue.

Remarks: This may require reconversion of previously converted characters.

This in turn may require the implementation to be able to reconstruct the original contents of the file.

Effects: Initializes the base class with basic_­istream<charT, traits>(addressof(sb)) ([istream.cons]) and sb with basic_­filebuf<charT, traits>() ([filebuf.cons]).

Effects: Initializes the base class with basic_­istream<charT, traits>(addressof(sb)) ([istream.cons]) and sb with basic_­filebuf<charT, traits>() ([filebuf.cons]), then calls rdbuf()->open(s, mode | ios_­base​::​in).

If that function returns a null pointer, calls setstate(failbit).

Effects: Equivalent to: basic_­ifstream(s.c_­str(), mode).

Effects: Move constructs the base class, and the contained basic_­filebuf.

Then calls basic_­istream<charT, traits>​::​set_­rdbuf(​addressof(sb)) to install the contained basic_­filebuf.

Effects: Exchanges the state of *this and rhs by calling basic_­istream<charT, traits>​::​swap(rhs) and sb.swap(rhs.sb).

Effects: Equivalent to: x.swap(y).

Returns: const_­cast<basic_­filebuf<charT, traits>*>(addressof(sb)).

Returns: rdbuf()->is_­open().

Effects: Calls rdbuf()->open(s, mode | ios_­base​::​in).

If that function does not return a null pointer calls clear(), otherwise calls setstate(failbit) (which may throw ios_­base​::​failure) ([iostate.flags]).

Effects: Calls open(s.c_­str(), mode).

Effects: Calls rdbuf()->close() and, if that function returns a null pointer, calls setstate(failbit) (which may throw ios_­base​::​failure) ([iostate.flags]).

Effects: Initializes the base class with basic_­ostream<charT, traits>(addressof(sb)) ([ostream.cons]) and sb with basic_­filebuf<charT, traits>() ([filebuf.cons]).

Effects: Initializes the base class with basic_­ostream<charT, traits>(addressof(sb)) ([ostream.cons]) and sb with basic_­filebuf<charT, traits>() ([filebuf.cons]), then calls rdbuf()->open(s, mode | ios_­base​::​out).

If that function returns a null pointer, calls setstate(​failbit).

Effects: Equivalent to: basic_­ofstream(s.c_­str(), mode).

Effects: Move constructs the base class, and the contained basic_­filebuf.

Then calls basic_­ostream<charT, traits>​::​set_­rdbuf(​addressof(sb)) to install the contained basic_­filebuf.

Effects: Exchanges the state of *this and rhs by calling basic_­ostream<charT, traits>​::​swap(rhs) and sb.swap(rhs.sb).

Effects: Equivalent to: x.swap(y).

Returns: const_­cast<basic_­filebuf<charT, traits>*>(addressof(sb)).

Returns: rdbuf()->is_­open().

Effects: Calls rdbuf()->open(s, mode | ios_­base​::​out).

If that function does not return a null pointer calls clear(), otherwise calls setstate(​failbit) (which may throw ios_­base​::​failure) ([iostate.flags]).

Effects: Calls rdbuf()->close() and, if that function fails (returns a null pointer), calls setstate(​failbit) (which may throw ios_­base​::​failure) ([iostate.flags]).

Effects: Calls open(s.c_­str(), mode).

Effects: Initializes the base class with basic_­iostream<charT, traits>(addressof(sb)) ([iostream.cons]) and sb with basic_­filebuf<charT, traits>().

Effects: Initializes the base class with basic_­iostream<charT, traits>(addressof(sb)) ([iostream.cons]) and sb with basic_­filebuf<charT, traits>().

Then calls rdbuf()->open(s, mode).

If that function returns a null pointer, calls setstate(failbit).

Effects: Equivalent to: basic_­fstream(s.c_­str(), mode).

Effects: Move constructs the base class, and the contained basic_­filebuf.

Then calls basic_­istream<charT, traits>​::​set_­rdbuf(​addressof(sb)) to install the contained basic_­filebuf.

Effects: Exchanges the state of *this and rhs by calling basic_­iostream<charT,traits>​::​swap(rhs) and sb.swap(rhs.sb).

Effects: Equivalent to: x.swap(y).

Returns: const_­cast<basic_­filebuf<charT, traits>*>(addressof(sb)).

Returns: rdbuf()->is_­open().

Effects: Calls rdbuf()->open(s, mode).

If that function does not return a null pointer calls clear(), otherwise calls setstate(failbit) (which may throw ios_­base​::​failure) ([iostate.flags]).

Effects: Calls open(s.c_­str(), mode).

Effects: Calls rdbuf()->close() and, if that function returns a null pointer, calls setstate(failbit) (which may throw ios_­base​::​failure) ([iostate.flags]).