Asynchronous IO API

std/asyncio/IDuplex.hx

@@ -0,0 +1,12 @@
+package asyncio;
+
+import haxe.NoData;
+import haxe.io.Bytes;
+import haxe.Callback;
+
+/**
+	An interface to read and write bytes.
+	If a class has to implement both `IReadable` and `IWritable` it is strongly
+	recommended to implement `IDuplex` instead.
+**/
+interface IDuplex extends IReadable extends IWritable {}

std/asyncio/IReadable.hx

@@ -0,0 +1,21 @@
+package asyncio;
+
+import haxe.NoData;
+import haxe.io.Bytes;
+import haxe.Callback;
+
+/**
+	An interface to read bytes from a source of bytes.
+**/
+interface IReadable {
+	/**
+		Read up to `length` bytes and write them into `buffer` starting from `offset`
+		position in `buffer`, then invoke `callback` with the amount of bytes read.
+	**/
+	function read(buffer:Bytes, offset:Int, length:Int, callback:Callback<Int>):Void;
+
+	/**
+		Close this stream.
+	**/
+	function close(callback:Callback<NoData>):Void;
+}

std/asyncio/IWritable.hx

@@ -0,0 +1,26 @@
+package asyncio;
+
+import haxe.NoData;
+import haxe.io.Bytes;
+import haxe.Callback;
+
+/**
+	An interface to write bytes into an out-going stream of bytes.
+**/
+interface IWritable {
+	/**
+		Write up to `length` bytes from `buffer` (starting from buffer `offset`),
+		then invoke `callback` with the amount of bytes written.
+	**/
+	function write(buffer:Bytes, offset:Int, length:Int, callback:Callback<Int>):Void;
+
+	/**
+		Force all buffered data to be committed.
+	**/
+	function flush(callback:Callback<NoData>):Void;
+
+	/**
+		Close this stream.
+	**/
+	function close(callback:Callback<NoData>):Void;
+}

std/asyncio/IoError.hx

@@ -0,0 +1,17 @@
+package asyncio;
+
+import asyncio.IoErrorType;
+import haxe.Error;
+import haxe.PosInfos;
+
+class IoError extends Error {
+	/**
+		Error type
+	**/
+	public final type:IoErrorType;
+
+	public function new(type:IoErrorType, ?pos:PosInfos) {
+		super(type.toString(), pos);
+		this.type = type;
+	}
+}

std/asyncio/IoErrorType.hx

@@ -0,0 +1,80 @@
+package asyncio;
+
+import asyncio.CErrNo;
+
+/**
+	Error types
+**/
+@:using(asyncio.IoErrorType.IoErrorTypeTools)
+enum IoErrorType {
+	/** File or directory not found */
+	FileNotFound;
+	/** File or directory already exist */
+	FileExists;
+	/** No such process */
+	ProcessNotFound;
+	/** Permission denied */
+	AccessDenied;
+	/** The given path was not a directory as expected */
+	NotDirectory;
+	/** The given path is a directory, but a file was expected */
+	IsDirectory;
+	/** Too many open files */
+	TooManyOpenFiles;
+	/** Broken pipe */
+	BrokenPipe;
+	/** Directory not empty */
+	NotEmpty;
+	/** Requested address is not available */
+	AddressNotAvailable;
+	/** Connection reset by peer */
+	ConnectionReset;
+	/** Operation timed out */
+	TimedOut;
+	/** Connection refused */
+	ConnectionRefused;
+	/** Other errors from system calls described in <error.h> */
+	CError(errNo:CErrNo);
+	/** Any other error */
+	CustomError(message:String);
+}
+
+class IoErrorTypeTools {
+	/**
+		Error type description
+	**/
+	static public function toString(type:IoErrorType):String {
+		return switch type {
+			case FileNotFound:
+				"File or directory not found";
+			case FileExists:
+				"File or directory already exists";
+			case ProcessNotFound:
+				"No such process";
+			case AccessDenied:
+				"Permission denied";
+			case NotDirectory:
+				"The given path was not a directory as expected";
+			case IsDirectory:
+				"The given path is a directory, but a file was expected";
+			case TooManyOpenFiles:
+				"Too many open files";
+			case BrokenPipe:
+				"Broken pipe";
+			case NotEmpty:
+				"Directory not empty";
+			case AddressNotAvailable:
+				"Address already in use";
+			case ConnectionReset:
+				"Connection reset by peer";
+			case TimedOut:
+				"Operation timed out";
+			case ConnectionRefused:
+				"Connection refused";
+			case CError(errNo):
+				errNo.toString();
+			case CustomError(message):
+				message;
+		}
+	}
+}

std/asyncio/Stream.hx

@@ -0,0 +1,17 @@
+package asyncio;
+
+import asyncio.IDuplex;
+import asyncio.IReadable;
+import asyncio.IWritable;
+
+/**
+	Enum which is used to stay type-safe when a stream can be of any type.
+**/
+enum Stream {
+	/** Read-only stream. */
+	Read(stream:IReadable);
+	/** Write-only stream. */
+	Write(stream:IWritable);
+	/** The stream is both readable and writable. */
+	ReadWrite(stream:IDuplex);
+}

std/asyncio/filesystem/Directory.hx

@@ -0,0 +1,39 @@
+package asyncio.filesystem;
+
+import haxe.NoData;
+import haxe.errors.NotImplemented;
+import haxe.Callback;
+
+/**
+	Represents a directory.
+**/
+class Directory {
+	/**
+		Path to this directory.
+	**/
+	public final path:FilePath;
+	/**
+		How many entries are buffered internally when reading from the directory.
+		Higher numbers improve performance, but increase memory usage.
+	**/
+	public var buffer:Int = 32;
+
+	//TODO: this is a dummy constructor to make the compiler shut up about uninitialized finals.
+	function new() {
+		path = cast null;
+	}
+
+	/**
+		Read next directory entry.
+	**/
+	public function next(callback:Callback<Null<FilePath>>):Void {
+		callback.fail(new NotImplemented());
+	}
+
+	/**
+		Close the directory.
+	**/
+	public function close(callback:Callback<NoData>) {
+		callback.fail(new NotImplemented());
+	}
+}

std/asyncio/filesystem/File.hx

@@ -0,0 +1,101 @@
+package asyncio.filesystem;
+
+import haxe.Int64;
+import haxe.io.Bytes;
+import haxe.NoData;
+import haxe.Callback;
+import haxe.errors.NotImplemented;
+import asyncio.IWritable;
+import asyncio.IReadable;
+
+class File implements IDuplex {
+	/**
+		Path to this file.
+	**/
+	public final path:FilePath;
+
+	//TODO: this is a dummy constructor to make the compiler shut up about uninitialized finals.
+	function new() {
+		path = cast null;
+	}
+
+	/**
+		Change file position pointer.
+		The pointer position is used in read and write operations as the starting byte
+		of reading or writing respectively.
+
+		If `whence` is `SeekSet(offset)` set the pointer to the exact position
+		specified by `offset`.
+	 	If `whence` is `SeekEnd` move the pointer to the end-of-file.
+		If `whence` is `SeekMove(offset)` move the pointer by `offset` bytes
+		relative to the current position.
+	**/
+	public function seek(whence:FileSeek) {
+		throw new NotImplemented();
+	}
+
+	/**
+		Get current position pointer offset.
+	**/
+	public function getOffset():Int64 {
+		throw new NotImplemented();
+	}
+
+	/**
+		Write up to `length` bytes from `buffer` (starting from buffer `offset`),
+		then invoke `callback` with the amount of bytes written.
+	**/
+	public function write(buffer:Bytes, offset:Int, length:Int, callback:Callback<Int>) {
+		callback.fail(new NotImplemented());
+	}
+
+	/**
+		Read up to `length` bytes and write them into `buffer` starting from `offset`
+		position in `buffer`, then invoke `callback` with the amount of bytes read.
+	**/
+	public function read(buffer:Bytes, offset:Int, length:Int, callback:Callback<Int>) {
+		callback.fail(new NotImplemented());
+	}
+
+	/**
+		Force all buffered data to be written to disk.
+	**/
+	public function flush(callback:Callback<NoData>) {
+		callback.fail(new NotImplemented());
+	}
+
+	/**
+		Synchronize file in-memory state with the storage device.
+	**/
+	public function sync(callback:Callback<NoData>) {
+		callback.fail(new NotImplemented());
+	}
+
+	/**
+		Close the file.
+	**/
+	public function close(callback:Callback<NoData>) {
+		callback.fail(new NotImplemented());
+	}
+}
+
+/**
+	Limits file operations to reading.
+	@see asyncio.filesystem.File
+**/
+@:forward(path,seek,read,close)
+abstract FileRead(File) from File to IReadable {}
+
+/**
+	Limits file operations to writing.
+	@see asyncio.filesystem.File
+**/
+@:forward(path,seek,write,flush,sync,close)
+abstract FileWrite(File) from File to IWritable {}
+
+/**
+	Limits file operations to writing at the end of file.
+	@see asyncio.filesystem.File
+**/
+@:forward(path,write,flush,sync,close)
+abstract FileAppend(File) from File to IWritable {}