111 lines
4.2 KiB
Haxe
111 lines
4.2 KiB
Haxe
package eval.luv;
|
||
|
||
@:coreType abstract TStream<T> to Stream {}
|
||
// typedef TStream<T> = Stream;
|
||
|
||
enum SendHandle {
|
||
TCP(tcp:Tcp);
|
||
PIPE(pipe:Pipe);
|
||
}
|
||
|
||
/**
|
||
Streams.
|
||
|
||
@see https://aantron.github.io/luv/luv/Luv/Stream
|
||
**/
|
||
@:coreType abstract Stream to Handle {
|
||
/**
|
||
Shuts down the write side of the stream.
|
||
**/
|
||
extern static public function shutdown(stream:Stream, callback:(result:Result<Result.NoData>)->Void):Void;
|
||
|
||
/**
|
||
Starts listening for incoming connections.
|
||
|
||
`backlog` indicates the number of connections the kernel might queue.
|
||
When a new incoming connection is received the `callback` is called.
|
||
**/
|
||
extern static public function listen(stream:Stream, callback:(result:Result<Result.NoData>)->Void, ?backlog:Int):Void;
|
||
|
||
/**
|
||
This call is used in conjunction with `Stream.listen()` to accept incoming
|
||
connections. Call this function after receiving a `callback` of `listen(callback)`
|
||
to accept the connection. Before calling this function the client handle
|
||
must be initialized.
|
||
|
||
When the `callback` of `listen(callback)` is called it is guaranteed that
|
||
this function will complete successfully the first time.
|
||
|
||
`client` should be a freshly-initialized stream.
|
||
**/
|
||
extern static public function accept<T>(server:TStream<T>, client:TStream<T>):Result<Result.NoData>;
|
||
|
||
/**
|
||
Calls the `callback` whenever data is available on the stream.
|
||
|
||
The amount of data read is equal to the length of the buffer passed to
|
||
the `callback`. `allocate` is called immediately before each call to the
|
||
main `callback`, to create buffer, into which the data will be read.
|
||
|
||
The end of the stream (typically, when the remote peer closes or shuts down
|
||
the connection) is indicated by `UVError.UV_EOF` being passed to the `callback`.
|
||
Note that this behavior is different from `eval.luv.File.read`.
|
||
|
||
Zero-length reads are possible, and do not indicate the end of stream. Instead,
|
||
they usually indicate `UVError.UV_EAGAIN` inside libuv; libuv still calls the
|
||
`callback` in order to give the C user a chance to deallocate the data buffer.
|
||
This is not usually an issue in OCaml (which is the backend for eval target of
|
||
Haxe), so a wrapper of this function can usually simply ignore zero-length reads.
|
||
It is then also safe to convert `UVError.UV_EOF` to zero-length reads in a
|
||
higher-level API, for consistency with reading files, and in accordance with OS
|
||
API convention.
|
||
|
||
To read only once, call `eval.luv.Stream.readStop` immediately, in the `callback`.
|
||
Otherwise, the main callback will be called repeatedly.
|
||
**/
|
||
extern static public function readStart(stream:Stream, callback:(result:Result<Buffer>)->Void, ?allocate:(size:Int)->Buffer):Void;
|
||
|
||
/**
|
||
Stops reading.
|
||
**/
|
||
extern static public function readStop(stream:Stream):Result<Result.NoData>;
|
||
|
||
/**
|
||
Writes the given buffer to the stream.
|
||
|
||
The second argument passed to the `callback` is the number of bytes written.
|
||
libuv has an internal queue of writes, in part to implement retry. This means
|
||
that writes can be partial at the libuv API level, so it is possible to receive
|
||
both an `UVError` result, and for some data to have been successfully written.
|
||
**/
|
||
extern static public function write(stream:Stream, data:Array<Buffer>, callback:(result:Result<Result.NoData>, bytesWritten:Int)->Void):Result<Result.NoData>;
|
||
|
||
/**
|
||
Like `eval.luv.Stream.write`, but allows sending a TCP socket or pipe over the
|
||
stream.
|
||
**/
|
||
extern static public function write2(stream:TStream<Pipe>, data:Array<Buffer>, sendHandle:SendHandle, callback:(result:Result<Result.NoData>, bytesWritten:Int)->Void):Result<Result.NoData>;
|
||
|
||
/**
|
||
Same as `eval.luv.Stream.write()`, but won’t queue a write request if it can’t
|
||
be completed immediately.
|
||
|
||
Returns the number of bytes written.
|
||
**/
|
||
extern static public function tryWrite(stream:Stream, data:Array<Buffer>):Result<Int>;
|
||
|
||
/**
|
||
Indicates whether the stream is readable (has data).
|
||
**/
|
||
extern static public function isReadable(stream:Stream):Bool;
|
||
|
||
/**
|
||
Indicates whether the stream is writable (has space in buffers).
|
||
**/
|
||
extern static public function isWritable(stream:Stream):Bool;
|
||
|
||
/**
|
||
Sets the blocking mode of the stream.
|
||
**/
|
||
extern static public function setBlocking(stream:Stream, block:Bool):Result<Result.NoData>;
|
||
} |