Construct a StreamException with given error message.

Construct a ReadException with given error message.

Construct a WriteException with given error message.

Construct a SeekException with given error message.

Read exactly size bytes into the buffer.

Throws a ReadException if it is not correct.

Read a block of data big enough to fill the given array buffer.

Read a basic type or counted string.

Throw a ReadException if it could not be  read. Outside of byte, ubyte, and char, the format is implementation-specific and should not be used except as opposite actions to write.

Read a line that is terminated with some combination of carriage return and line feed or end-of-file.

The terminators are not included. The wchar version is identical. The optional buffer parameter is filled (reallocating it if necessary) and a slice of the result is returned.

Overload foreach statements to read the stream line by line and call the supplied delegate with each line or with each line with line number.

The string passed in line may be reused between calls to the delegate. Line numbering starts at 1. Breaking out of the foreach will leave the stream position at the beginning of the next line to be read. For example, to echo a file line-by-line with line numbers run:

Stream file = new BufferedFile("sample.txt");
foreach(ulong n, char[] line; file)
{
    writefln("line %d: %s", n, line);
}
file.close();

Read a string of the given length, throwing ReadException if there was a problem.

Read a string of the given length, throwing ReadException if there was a problem.

The file format is implementation-specific and should not be used except as opposite actions to write.

Read and return the next character in the stream.

This is the only method that will handle ungetc properly. getcw's format is implementation-specific. If EOF is reached then  getc returns char.init and getcw returns wchar.init.

Push a character back onto the stream.

They will be returned in first-in last-out order from getc/getcw. Only has effect on further calls to getc() and getcw().

Scan a string from the input using a similar form to C's scanf and std.format.

An argument of type string is interpreted as a format string. All other arguments must be pointer types. If a format string is not present a default will be supplied computed from the base type of the pointer type. An argument of type string* is filled (possibly with appending characters) and a slice of the result is assigned back into the argument. For example the following readf statements are equivalent:

int x;
double y;
string s;
file.readf(&x, " hello ", &y, &s);
file.readf("%d hello %f %s", &x, &y, &s);
file.readf("%d hello %f", &x, &y, "%s", &s);

Retrieve the number of bytes  available for immediate reading.

Return whether the current file position is the same as the end of the file.

This does not require actually reading past the end, as with stdio. For non-seekable streams this might only return true after attempting to read past the end.

Return true if the stream is currently open.

Write exactly size bytes from buffer, or throw a WriteException if that could not be done.

Write as much of the buffer as possible, returning the number of bytes written.

Write a basic type.

Outside of byte, ubyte, and char, the format is implementation-specific and should only be used in conjunction with read. Throw WriteException on error.

Writes a string, together with its length.

The format is implementation-specific and should only be used in conjunction with read. Throw WriteException on error.

Write a line of text, appending the line with an operating-system-specific line ending.

Throws WriteException on error.

Write a line of text, appending the line with an operating-system-specific line ending.

The format is implementation-specific. Throws WriteException on error.

Write a string of text.

Throws WriteException if it could not be fully written.

Write a string of text.

The format is implementation-specific. Throws WriteException if it could not be fully written.

Print a formatted string into the stream using printf-style syntax, returning the number of bytes written.

Print a formatted string into the stream using  writef-style syntax.

Flush pending output if appropriate.

Close the stream, flushing output if appropriate.

Return true if the stream is currently open.

Indicates whether this stream can be read from.

Indicates whether this stream can be written to.

Indicates whether this stream can be seeked within.

Indicates whether this stream is open.

Indicates whether this stream is at eof after the last read attempt.

For a non-seekable stream indicates that the last readLine or readLineW ended on a '\r' character.

Read up to size bytes into the buffer and return the number of bytes actually read. A return value of 0 indicates end-of-file.

Write up to size bytes from buffer in the stream, returning the actual number of bytes that were written.

Copies all data from s into this stream. This may throw ReadException or WriteException on failure. This restores the file position of s so that it is unchanged.

Copy a specified number of bytes from the given stream into this one. This may throw ReadException or WriteException on failure. Unlike the previous form, this doesn't restore the file position of s.

Change the current position of the stream. whence is either SeekPos.Set, in which case the offset is an absolute index from the beginning of the stream, SeekPos.Current, in which case the offset is a delta from the current position, or SeekPos.End, in which case the offset is a delta from the end of the stream (negative or zero offsets only make sense in that case). This returns the new file position.

Aliases for their normal seek counterparts.

Sets file  position. Equivalent to calling seek(pos, SeekPos.Set).

Returns current file  position. Equivalent to seek(0, SeekPos.Current).

Retrieve the  size of the stream in bytes. The stream must be seekable or a SeekException is thrown.

Read the entire stream and return it as a string. If the stream is not seekable the contents from the current position to eof is read and returned.

Get a hash of the stream by reading each byte and using it in a CRC-32 checksum.

Property indicating when this stream closes to close the source stream as well. Defaults to true.

Construct a FilterStream for the given source.

Get the current  source stream.

Set the current  source stream.

Setting the  source stream closes this stream before attaching the new  source. Attaching an open stream reopens this stream and resets the stream state.

Indicates the source stream changed state and that this stream should reset any readable, writeable, seekable, isopen and buffering flags.

Create a buffered stream for the stream source with the buffer size bufferSize.

Construct a StreamFileException with given error message.

Construct an OpenFileException with given error message.

Create the stream with no open file, an open file in read mode, or an open file with explicit file mode. mode, if given, is a combination of FileMode.In (indicating a file that can be read) and FileMode.Out (indicating a file that can be written). Opening a file for reading that doesn't exist will error. Opening a file for writing that doesn't exist will create the file. The FileMode.OutNew mode will open the file for writing and reset the length to zero. The FileMode.Append mode will open the file for writing and move the file position to the end of the file.

Open a file for the stream, in an identical manner to the constructors. If an error occurs an OpenException is thrown.

Create a file for writing.

Close the current file if it is open; otherwise it does nothing.

For a seekable file returns the difference of the size and position and otherwise returns 0.

opens file for reading

opens file in requested mode and buffer size

opens file for reading with requested buffer size

opens existing handle; use with care!

opens file in requested mode

creates file in requested mode

UTF-8

UTF-16 Little Endian

UTF-16 Big Endian

UTF-32 Little Endian

UTF-32 Big Endian

Endianness property of the source stream.

Create the endian stream for the source stream source with endianness end. The default endianness is the native byte order. The Endian type is defined in the std.system module.

Return -1 if no BOM and otherwise read the BOM and return it.

If there is no BOM or if bytes beyond the BOM are read then the bytes read are pushed back onto the ungetc buffer or ungetcw buffer. Pass ungetCharSize == 2 to use ungetcw instead of ungetc when no BOM is present.

Correct the byte order of buffer to match native endianness. size must be even.

Correct the byte order of the given buffer in blocks of the given size and repeated the given number of times. size must be even.

Write the specified BOM b to the source stream.

Create the stream for the the buffer buf. Non-copying.

Get the current memory  data in total.

Create the output buffer and setup for reading, writing, and seeking.

Create the output buffer and setup for reading, writing, and seeking. Load it with specific input data.

Ensure the stream can hold count bytes.

Create stream wrapper for file.

Indicate both the source stream to use for reading from and the low part of the slice.

The high part of the slice is dependent upon the end of the source stream, so that if you write beyond the end it resizes the stream normally.

Indicate the high index as well.

Attempting to read or write past the high index results in the end being clipped off.