Stream interfaces for input and output.

A stream is an interface that reads or writes to a destination, one character at a time.

Watt ships with implementations of OutputFileStream and InputFileStream appropriate for the current platform.

Use the plain OutputStream and InputStream definition where possible, and then the implementation is not important.

Example

fn outputAnImportantThing(os: OutputStream)
...
outputAnImportantThing(output);
outputAnImportantThing(new OutputFileStream("foo.txt"));

Code Map

//! Stream interfaces for input and output.
module watt.io.streams;

public import watt.io.streams.fd;
public import watt.io.streams.stdc;


//! An implementation of the InputStream for files.
alias InputFileStream = InputFDStream;
//! An implementation of the OutputStream for files.
alias OutputFileStream = OutputFDStream;

//! OutputStreams write data to a destination (file, console, etc) in
//! characters.
class OutputStream
{
public:
	this() { }
	//! Close the stream.
	fn close();
	//! Determine the stream state.
	fn isOpen() bool;
	//! Write a single character out to the sink.
	fn put(c: dchar);
	//! Write a series of characters to the sink.
	fn write(s: scope (const(scope (char)[])) { }
	//! Ensure that all pending writes (from the put and write functions) are
	//! completed.
	fn flush();
	//! Write a series of characters then a newline.
	fn writeln(s: const(char)[]) { }
	fn vwritef(formatString: const(char)[], typeids: TypeInfo[], vl: va_list) { }
	//! Write a formatted string.
	fn writef(formatString: const(char)[]) { }
	fn vwritefln(formatString: const(char)[], typeids: TypeInfo[], vl: va_list) { }
	//! Write a formatted string and then a newline.
	fn writefln(formatString: const(char)[]) { }
}

//! InputStreams read data in characters from a source (file, device,
//! etc).
class InputStream
{
public:
	this() { }
	//! Close this stream.
	fn close();
	//! Determine this stream's state.
	fn isOpen() bool;
	//! Read a single character from the source.
	fn get() dchar;
	//! Read as much data as possible into buffer.
	fn read(buffer: u8[]) u8[];
	//! Is the source out of data?
	fn eof() bool;
	//! Read input until a newline character is encountered.
	fn readln() string { }
}

ofs.put('A');
ofs.flush();  // Unneeded!
ofs.close();