Overview

Packages
ceylon.io	This package lets you create `FileDescriptor` objects, which represent open streams, such as files, sockets, or pipes. Y
ceylon.io.readers

Dependencies
`ceylon.buffer`	`1.3.0`
`ceylon.collection`	`1.3.0`
`ceylon.file`	`1.3.0`
`ceylon.interop.java`	`1.3.0`
`java.base`	`8`
`java.tls`	`8`

This package lets you create FileDescriptor objects, which represent open streams, such as files, sockets, or pipes. You can read and write bytes from and to those streams in synchronous or asynchronous mode, using Buffer objects, and you can convert bytes to String objects using Charset objects.

Here's how you can get a Socket to a remote host in a blocking way:

// connect to example.com on port 80
value connector = newSocketConnector(SocketAddress("example.com", 80));
value socket = connector.connect();

Sample usage for reading all the available bytes from a remote socket in a blocking way:

void readResponse(Socket socket) {
    // create a new decoder from ASCII bytes
    Decoder decoder = ascii.newDecoder();
    // read,decode it all, blocking
    socket.readFully((ByteBuffer buffer) => decoder.decode(buffer));
    // print it all
    process.write(decoder.done());
}

Here's the same code, but in an asynchronous way, using a Selector object to treat read events:

void readResponseAsync(Socket socket) {
    // create a new selector for reading from this socket
    Selector select = newSelector();
    // read, decode, print as we get data
    socket.readAsync(select, byteConsumerToStringConsumer(utf8, (String string) => process.write(string)));
    // run the event loop
    select.process();
}

Here's how you could write a request to a Socket in a blocking way:

void writeRequest(String data, Socket socket) {
    // encode it in one go
    value requestBuffer = ascii.encode(data);
    // write it all, blocking
    socket.writeFully(requestBuffer);
}

Here's how you would write a request to a Socket in an asynchronous way:

void writeRequestAsync(String request, Socket socket) {
    Selector select = newSelector();
    // encode and write as we can
    socket.writeAsync(select, stringToByteProducer(ascii, request));
    // run the event loop
    select.process();
}

Finally, here's how you can read and write asynchronously to the same socket:

void readAndWriteAsync(String request, Socket socket) {
    Selector select = newSelector();
    // encode and write as we can
    socket.writeAsync(select, stringToByteProducer(ascii, request));
    // read, decode and print as we can
    socket.readAsync(select, byteConsumerToStringConsumer(utf8, (String string) => process.write(string)));
    // run the event loop
    select.process();
}

By: Stéphane Épardaud

Values
`standardError`	Source Code`shared WritableFileDescriptor standardError` A `WritableFileDescriptor` for the virtual machine's standard error stream. Aliases: `stderr`
`standardInput`	Source Code`shared ReadableFileDescriptor standardInput` A `ReadableFileDescriptor` for the virtual machine's standard input stream. Aliases: `stdin`
`standardOutput`	Source Code`shared WritableFileDescriptor standardOutput` A `WritableFileDescriptor` for the virtual machine's standard output stream. Aliases: `stdout`
`stderr`	See `standardError`
`stdin`	See `standardInput`
`stdout`	See `standardOutput`

Functions
`byteConsumerToStringConsumer`	Source Code `shared Anything(ByteBuffer)Go to Callable abbreviation X(Y,Z) means Callable<X,[Y,Z]> Go to Tuple abbreviation [X,Y] means Tuple<X\|Y,X,Tuple<Y,Y,[]>> byteConsumerToStringConsumer(Charset charset, void consumer(String buffer))` Transforms a [consumer] method that accepts `String`s into a consumer method that accepts `ByteBuffer`s, according to the given `charset`. Another way to see it is that this method returns a method which accepts `ByteBuffer` parameters, decodes them using the given `charset`, and passes them on to the given `consumer()` method which accepts decoded `String` objects. By: Stéphane Épardaud
`newOpenFile`	Source Code `shared OpenFile newOpenFile(Resource resource)` Creates a new `OpenFile` to read/write to the given `resource`. See also `OpenFile`
`newSelector`	Source Code`shared Selector newSelector()` Creates a new `Selector`. See also `Selector`
`newServerSocket`	Source Code`shared ServerSocket newServerSocket(SocketAddress?Go to Null abbreviations X? means Null\|X address = null, Integer backlog = 0)` Instantiates and binds a new server socket. Parameters: `address = null` `backlog = 0` See also `ServerSocket`
`newSocketConnector`	Source Code `shared SocketConnector newSocketConnector(SocketAddress address)` Creates a new `SocketConnector` to connect to the given `address`. See also `SocketConnector`
`newSslSocketConnector`	Source Code `shared SslSocketConnector newSslSocketConnector(SocketAddress address)`
`stringToByteProducer`	Source Code `shared Anything(ByteBuffer)Go to Callable abbreviation X(Y,Z) means Callable<X,[Y,Z]> Go to Tuple abbreviation [X,Y] means Tuple<X\|Y,X,Tuple<Y,Y,[]>> stringToByteProducer(Charset charset, String string)` Transforms a `string` into a producer method that produces `ByteBuffer`s, according to the given `charset`. Another way to see it is that this method returns a method which accepts `ByteBuffer` parameters, and fills them with the given `string`, encoded using the given `charset`. By: Stéphane Épardaud

Interfaces
`Closeable`	Source Code`shared Closeable`
`FileDescriptor`	Source Code`shared FileDescriptor` Represents anything that you can read/write to, much like the UNIX notion of file descriptor. This supports synchronous and asynchronous reading.
`OpenFile`	Source Code`shared OpenFile` Represents a file object we can read from and write to.
`ReadableFileDescriptor`	Source Code`shared ReadableFileDescriptor` Represents anything that you can read from, much like the UNIX notion of file descriptor.
`SelectableFileDescriptor`	Source Code`shared SelectableFileDescriptor` Represents a `FileDescriptor` that you can `select`. This means that you can register listeners for this file descriptor on a given `Selector` object that will be called whenever there is data available to be read or written without blocking the reading/writing thread.
`Selector`	Source Code`shared Selector` Supports registration of listeners that are notified of events raised directly by the operating system, of the following kinds: read, write, connect, and accept. A listener may be registered for: read/write events on `SelectableFileDescriptor`, accept events on `ServerSocket`, or connect events on `SocketConnector`. The listener will then be notified by this selector when you invoke `Selector.process()` until there are no more listeners. Every listener can signal the selector object that it is no longer interested in notifications by returning `false` when invoked, except for `connect` listeners which are only notified once (since a given `Socket` is connected once at most ). Listeners should be registered with: `Selector.addConsumer()` for `read` events, `Selector.addProducer()` for `write` events, `Selector.addConnectListener()` for `connect` events, and `Selector.addAcceptListener()` for `accept` events. A new instance of `Selector` may be obtained by calling `newSelector()`.
`ServerSocket`	Source Code`shared ServerSocket` Represents a server socket: a socket open on the current host that accepts incoming connections from other hosts. This supports synchronous and asynchronous modes of operations. The server socket is bound immediately to the specified address (or to every local network interface if not set), but it will only accept incoming connections when you call `ServerSocket.accept()` or `ServerSocket.acceptAsync()`. New server sockets are created with `newServerSocket()`.
`Socket`	Source Code`shared Socket` Represents a network socket.
`SocketConnector`	Source Code`shared SocketConnector` An object that connects to a remote host, returning a `Socket`, either synchronously or asynchronously: use `SocketConnector.connect()` to block until the socket is connected, or use `SocketConnector.connectAsync()` to register a listener that will be invoked when the socket is connected.
`SslSocket`	Source Code`shared SslSocket` Represents an SSL network socket.
`SslSocketConnector`	Source Code`shared SslSocketConnector` An object that connects to a remote host, returning an `SslSocket`, either synchronously or asynchronously: use `SslSocketConnector.connect()` to block until the socket is connected, or use `SocketConnector.connectAsync()` to register a listener that will be invoked when the socket is connected.
`WritableFileDescriptor`	Source Code`shared WritableFileDescriptor` Represents anything that you can write to, much like the UNIX notion of file descriptor.

Classes
`SocketAddress`	Source Code`shared SocketAddress` Represents an Internet socket address, consisting of an IP address or host name together with a TCP port.

Keyboard Shortcuts

Documentation:

Search page:

Filter declarations by tags