Overview

Packages
ceylon.io	This package lets you create `FileDescriptor` objects, which represent open streams, such as files, sockets, or…
ceylon.io.base64	Functions for encoding and decoding in base64 according to [RFC 4648][rfc4648].
ceylon.io.buffer	Defines byte buffers and character buffers.
ceylon.io.charset	This package contains everything required to convert bytes to `String`s according to character sets.
ceylon.io.readers	This package contains reader/writer objects that can read and write to/from `FileDescriptor` objects.

Dependencies
`ceylon.collection`	`1.2.0`
`ceylon.file`	`1.2.0`
`ceylon.interop.java`	`1.2.0`
`java.base`	`7`
`java.tls`	`7`

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

Functions
`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)`

Interfaces
`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.
`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.

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