Uses of Interface org.activeio.Disposable (ActiveIO 1.0 API)

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES

## Uses of Interface
org.activeio.Disposable

Packages that use Disposable
org.activeio | The core activeio API is centered around having Channels that move Packets of data.
org.activeio.adapter | The Adapter package provides classes that make it easy ot bridge between the the SynchChannel, AsyncChannel, InputStream, OutputStream, Socket, and ServerSocket domains.
org.activeio.filter | Some simple filters that may be added to your channels.
org.activeio.journal.active | The Active Journal is a high performance Journal implemenation which does not place limits on how big the data being logged can be.
org.activeio.net | A set of Channel implementations that are implemented using the Socket and DatagramSocket classes.
org.activeio.oneport | This package provides the implementing classes that allow you to run multiple protocols from a sigle port.
org.activeio.packet | Implementations of the Packet class.

Uses of Disposable in org.activeio

Subinterfaces of Disposable in org.activeio
`interface` | `AsynchChannel` AsynchChannel objets asynchronously push 'up' `org.activeio.channel.Packet` objects to a registered `org.activeio.ChannelConsumer`.
`interface` | `AsynchChannelServer` AsynchChannelServer objets asynchronously accept and create `org.activeio.channel.Channel` objects and then delivers those objects to a `org.activeio.AcceptConsumer`.
`interface` | `Channel` A Channel provides a standard procedure for regulating data transmission between applications.
`interface` | `ChannelServer` A ChannelServer is used to accept incoming requests to establish new Channel sessions.
`interface` | `InputAsynchChannel` InputAsynchChannel objets asynchronously push 'up' `org.activeio.channel.Packet` objects to a registered `AsynchChannelListener`.
`interface` | `InputSynchChannel` SynchChannel objets allow threadd to synchronously block on the `read` method to get `org.activeio.channel.Packet` objects when they arrive from the peer.
`interface` | `OutputChannel`
`interface` | `Packet` Provides a ByteBuffer like interface to work with IO channel packets of data.
`interface` | `RequestChannel` RequestChannel are used to model the request/reponse exchange that is used by higher level protcols such as HTTP and RMI.
`interface` | `SynchChannel` SynchChannel objets allow threadd to synchronously block on the `receiveUpPacket` method to get 'up' `org.activeio.channel.Packet` objects when they arrive.
`interface` | `SynchChannelServer` A SynchChannelServer object provides an `accept` method to synchronously accept and create `org.activeio.channel.Channel` objects.

Classes in org.activeio that implement Disposable
`class` | `FilterAsynchChannel` A AsynchChannelFilter can be used as a filter between a `AsynchChannel` and it's `org.activeio.ChannelConsumer`.
`class` | `FilterAsynchChannelServer` A AsynchChannelFilter can be used as a filter between a `AsynchChannel` and it's `org.activeio.ChannelConsumer`.
`class` | `FilterSynchChannel` A SynchChannelFilter can be used as a filter another `SynchChannel` Most `SynchChannel` that are not directly accessing the network will extends the SynchChannelFilter since they act as a filter between the client and the network.
`class` | `FilterSynchChannelServer` A SynchChannelFilter can be used as a filter another `SynchChannel` Most `SynchChannel` that are not directly accessing the network will extends the SynchChannelFilter since they act as a filter between the client and the network.

Uses of Disposable in org.activeio.adapter

Classes in org.activeio.adapter that implement Disposable
`class` | `AsynchChannelToClientRequestChannel` Creates a `RequestChannel` out of a `SynchChannel`.
`class` | `AsynchChannelToConcurrentRequestChannel` Creates a `RequestChannel` out of a `AsynchChannel`.
`class` | `AsynchChannelToServerRequestChannel` Creates a `RequestChannel` out of a `AsynchChannel`.
`class` | `AsynchToSynchChannelAdapter` Adapts a `AsynchChannel` so that it provides an `SynchChannel` interface.
`class` | `AsynchToSynchChannelServerAdapter` Adapts a `AsynchChannelServer` so that it provides an `SynchChannelServer` interface.
`class` | `AsynchWriteAsynchChannelAdapter`
`class` | `SynchToAsynchChannelAdapter` Adapts a `SynchChannel` so that it provides an `AsynchChannel` interface.
`class` | `SynchToAsynchChannelServerAdapter` Adapts a `org.activeio,SynchChannelServer` so that it provides an `AsynchChannelServer` interface.

Uses of Disposable in org.activeio.filter

Classes in org.activeio.filter that implement Disposable
`class` | `CounterAsyncChannel` A CounterAsyncChannel is a simple `org.activeio.AsynchChannelFilter` that counts the number bytes that been sent down and up through the channel.
`class` | `PacketAggregatingAsynchChannel` This PacketAggregatingAsynchChannel can be used when the client is sending a 'record' style packet down the channel stack and needs receiving end to receive the same 'record' packets.
`class` | `PacketAggregatingSynchChannel` This PacketAggregatingSynchChannel can be used when the client is sending a 'record' style packet down the channel stack and needs receiving end to receive the same 'record' packets.
`class` | `PushbackSynchChannel`
`class` | `SynchornizedAsynchChannel` Used to synchronize concurrent access to an ASynchChannel.
`class` | `SynchornizedSynchChannel` Used to synchronize concurrent access to a SynchChannel.
`class` | `WriteBufferedAsynchChannel`
`class` | `WriteBufferedSynchChannel`

Uses of Disposable in org.activeio.journal.active

Classes in org.activeio.journal.active that implement Disposable
`class` | `ControlFile` Control file holds the last known good state of the journal.
`class` | `JournalImpl` A high speed Journal implementation.
`class` | `LogFile` Allows read/append access to a LogFile.
`class` | `Record` Serializes/Deserializes data records.

Uses of Disposable in org.activeio.net

Classes in org.activeio.net that implement Disposable
`class` | `AIOAsynchChannel`
`class` | `AIOSynchChannelServer`
`class` | `DatagramSocketSynchChannel` A `SynchChannel`implementation that uses TCP to talk to the network.
`class` | `NIOAsynchChannel`
`class` | `NIOAsynchChannelServer` A SynchChannelServer that creates `org.activeio.net.TcpSynchChannel`objects from accepted tcp socket connections.
`class` | `NIOBaseChannel` Base class for the Asynch and Synch implementations of NIO channels.
`class` | `NIOSynchChannel` A `SynchChannel` implementation that uses a `SocketChannel` to talk to the network.
`class` | `NIOSynchChannelServer` A SynchChannelServer that creates `org.activeio.net.TcpSynchChannel`objects from accepted tcp socket connections.
`class` | `SocketSynchChannel` A `SynchChannel` implementation that uses a `Socket` to talk to the network.
`class` | `SocketSynchChannelServer` A SynchChannelServer that creates `org.activeio.net.TcpSynchChannel`objects from accepted tcp socket connections.
`static class` | `VMPipeAsynchChannelFactory.ClassloaderAsynchChannelAdapter` Used to marshal calls to a PipeChannel in a different classloader.
`static class` | `VMPipeAsynchChannelPipe.PipeChannel`
`class` | `VMPipeAsynchChannelServer`

Uses of Disposable in org.activeio.oneport

Classes in org.activeio.oneport that implement Disposable
`class` | `OnePortAsynchChannelServer` Allows multiple protocols share a single ChannelServer.

Uses of Disposable in org.activeio.packet

Classes in org.activeio.packet that implement Disposable
`class` | `AppendedPacket` Appends two packets together.
`class` | `ByteArrayPacket` Provides a Packet implementation that is directly backed by a `byte[]`.
`class` | `ByteBufferPacket` Provides a Packet implementation that is backed by a `ByteBuffer`
`class` | `BytePacket` Provides a Packet implementation that is directly backed by a `byte`.
`class` | `EmptyPacket` Provides a Packet implementation that is directly backed by a `byte[0]`.
`class` | `EOSPacket` Provides a Packet implementation that is used to represent the end of a stream.
`class` | `FilterPacket` Provides a Packet implementation that filters operations to another packet.
`class` | `PacketPool.PooledPacket`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV NEXT | FRAMES NO FRAMES

Copyright © -2005 The ActiveIO Project. All Rights Reserved.