andreacavalli/netty5
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Add javadocs and cleanup

Browse Source
This commit is contained in:
Norman Maurer 2012-12-23 19:24:20 +01:00
parent ae859c2de9
commit 71b089cb3b
8 changed files with 127 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
transport/src/main/java/io/netty/channel/Channel.java
View File

@ -271,7 +271,7 @@ public interface Channel extends AttributeMap, ChannelOutboundInvoker, ChannelPr
/**
* Send a {@link FileRegion} to the remote peer and notify the {@link ChannelFuture} once it completes
* or an error was detected. Once the {@link FileRegion} was transfered or an error was thrown it will
* automaticly closed via {@link io.netty.channel.FileRegion#close()}.
* automaticly closed via {@link FileRegion#close()}.
*/
void sendFile(FileRegion region, ChannelFuture future);
}

69
transport/src/main/java/io/netty/channel/ChannelOperationHandlerAdapter.java
View File

@ -19,68 +19,131 @@ import java.net.SocketAddress;
public class ChannelOperationHandlerAdapter implements ChannelOperationHandler {
/**
* Do nothing by default, sub-classes may override this method.
*/
@Override
public void beforeAdd(ChannelHandlerContext ctx) throws Exception {
// NOOP
}
/**
* Do nothing by default, sub-classes may override this method.
*/
@Override
public void afterAdd(ChannelHandlerContext ctx) throws Exception {
// NOOP
}
/**
* Do nothing by default, sub-classes may override this method.
*/
@Override
public void beforeRemove(ChannelHandlerContext ctx) throws Exception {
// NOOP
}
/**
* Do nothing by default, sub-classes may override this method.
*/
@Override
public void afterRemove(ChannelHandlerContext ctx) throws Exception {
// NOOP
}
/**
* Calls {@link ChannelHandlerContext#fireExceptionCaught(Throwable)} to forward
* to the next {@link ChannelHandler} in the {@link ChannelPipeline}.
*
* Sub-classes may override this method to change behavior.
*/
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
throws Exception {
ctx.fireExceptionCaught(cause);
}
/**
* Calls {@link ChannelHandlerContext#fireUserEventTriggered(Object)} to forward
* to the next {@link ChannelHandler} in the {@link ChannelPipeline}.
*
* Sub-classes may override this method to change behavior.
*/
@Override
public void userEventTriggered(ChannelHandlerContext ctx, Object evt)
throws Exception {
ctx.fireUserEventTriggered(evt);
}
/**
* Calls {@link ChannelHandlerContext#bind(SocketAddress, ChannelFuture)} to forward
* to the next {@link ChannelOperationHandler} in the {@link ChannelPipeline}.
*
* Sub-classes may override this method to change behavior.
*/
@Override
public void bind(ChannelHandlerContext ctx, SocketAddress localAddress,
ChannelFuture future) throws Exception {
ctx.bind(localAddress, future);
}
/**
* Calls {@link ChannelHandlerContext#connect(SocketAddress, SocketAddress, ChannelFuture)} to forward
* to the next {@link ChannelOperationHandler} in the {@link ChannelPipeline}.
*
* Sub-classes may override this method to change behavior.
*/
@Override
public void connect(ChannelHandlerContext ctx, SocketAddress remoteAddress,
SocketAddress localAddress, ChannelFuture future) throws Exception {
ctx.connect(remoteAddress, localAddress, future);
}
/**
* Calls {@link ChannelHandlerContext#disconnect(ChannelFuture)} to forward
* to the next {@link ChannelOperationHandler} in the {@link ChannelPipeline}.
*
* Sub-classes may override this method to change behavior.
*/
@Override
public void disconnect(ChannelHandlerContext ctx, ChannelFuture future)
throws Exception {
ctx.disconnect(future);
}
/**
* Calls {@link ChannelHandlerContext#close(ChannelFuture)} to forward
* to the next {@link ChannelOperationHandler} in the {@link ChannelPipeline}.
*
* Sub-classes may override this method to change behavior.
*/
@Override
public void close(ChannelHandlerContext ctx, ChannelFuture future)
throws Exception {
ctx.close(future);
}
/**
* Calls {@link ChannelHandlerContext#close(ChannelFuture)} to forward
* to the next {@link ChannelOperationHandler} in the {@link ChannelPipeline}.
*
* Sub-classes may override this method to change behavior.
*/
@Override
public void deregister(ChannelHandlerContext ctx, ChannelFuture future)
throws Exception {
ctx.deregister(future);
}
/**
* Calls {@link ChannelHandlerContext#flush(ChannelFuture)} to forward
* to the next {@link ChannelOperationHandler} in the {@link ChannelPipeline}.
*
* Sub-classes may override this method to change behavior.
*
* Be aware that if your class also implement {@link ChannelOutboundHandler} it need to {@code override} this
* method!
*/
@Override
public void flush(ChannelHandlerContext ctx, ChannelFuture future)
throws Exception {
@ -92,6 +155,12 @@ public class ChannelOperationHandlerAdapter implements ChannelOperationHandler {
ctx.flush(future);
}
/**
* Calls {@link ChannelHandlerContext#sendFile(FileRegion, ChannelFuture)} to forward
* to the next {@link ChannelOperationHandler} in the {@link ChannelPipeline}.
*
* Sub-classes may override this method to change behavior.
*/
@Override
public void sendFile(ChannelHandlerContext ctx, FileRegion region, ChannelFuture future) throws Exception {
ctx.sendFile(region, future);

8
transport/src/main/java/io/netty/channel/FailedChannelFuture.java
View File

@ -17,7 +17,6 @@ package io.netty.channel;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
/**
* The {@link CompleteChannelFuture} which is failed already. It is
@ -53,7 +52,7 @@ final class FailedChannelFuture extends CompleteChannelFuture {
}
@Override
public ChannelFuture sync() throws InterruptedException {
public ChannelFuture sync() {
return rethrow();
}
@ -75,13 +74,12 @@ final class FailedChannelFuture extends CompleteChannelFuture {
}
@Override
public Void get() throws InterruptedException, ExecutionException {
public Void get() throws ExecutionException {
throw new ExecutionException(cause);
}
@Override
public Void get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException,
TimeoutException {
public Void get(long timeout, TimeUnit unit) throws ExecutionException {
throw new ExecutionException(cause);
}
}

2
transport/src/main/java/io/netty/channel/socket/SctpMessage.java
View File

@ -40,7 +40,7 @@ public final class SctpMessage {
this.protocolIdentifier = protocolIdentifier;
this.streamIdentifier = streamIdentifier;
this.payloadBuffer = payloadBuffer;
this.msgInfo = null;
msgInfo = null;
}
public SctpMessage(MessageInfo msgInfo, ByteBuf payloadBuffer) {

19
transport/src/main/java/io/netty/channel/socket/nio/NioDatagramChannel.java
View File

@ -44,7 +44,8 @@ import java.util.List;
import java.util.Map;
/**
* Provides an NIO based {@link io.netty.channel.socket.DatagramChannel}.
* Provides an NIO based {@link io.netty.channel.socket.DatagramChannel} which can be used
* to send and receive {@link DatagramPacket}'s.
*/
public final class NioDatagramChannel
extends AbstractNioMessageChannel implements io.netty.channel.socket.DatagramChannel {
@ -79,18 +80,34 @@ public final class NioDatagramChannel
}
}
/**
* Create a new instance which will use the Operation Systems default {@link InternetProtocolFamily}.
*/
public NioDatagramChannel() {
this(newSocket());
}
/**
* Create a new instance using the given {@link InternetProtocolFamily}. If {@code null} is used it will depend
* on the Operation Systems default which will be chosen.
*/
public NioDatagramChannel(InternetProtocolFamily ipFamily) {
this(newSocket(ipFamily));
}
/**
* Create a new instance from the given {@link DatagramChannel}.
*/
public NioDatagramChannel(DatagramChannel socket) {
this(null, socket);
}
/**
* Create a new instance from the given {@link DatagramChannel}.
*
* @param id the id to use for this instance or {@code null} if a new one should be generated.
* @param socket the {@link DatagramChannel} which will be used
*/
public NioDatagramChannel(Integer id, DatagramChannel socket) {
super(null, id, socket, SelectionKey.OP_READ);
config = new NioDatagramChannelConfig(socket);

15
transport/src/main/java/io/netty/channel/socket/nio/NioSctpChannel.java
View File

@ -69,14 +69,29 @@ public class NioSctpChannel extends AbstractNioMessageChannel implements io.nett
}
}
/**
* Create a new instance
*/
public NioSctpChannel() {
this(newSctpChannel());
}
/**
* Create a new instance using {@link SctpChannel}
*/
public NioSctpChannel(SctpChannel sctpChannel) {
this(null, null, sctpChannel);
}
/**
* Create a new instance
*
* @param parent the {@link Channel} which is the parent of this {@link NioSctpChannel}
* or {@code null}.
* @param id the id to use for this instance or {@code null} if a new once should be
* generated
* @param sctpChannel the underlying {@link SctpChannel}
*/
public NioSctpChannel(Channel parent, Integer id, SctpChannel sctpChannel) {
super(parent, id, sctpChannel, SelectionKey.OP_READ);
try {

4
transport/src/main/java/io/netty/channel/socket/nio/NioServerSocketChannel.java
View File

@ -29,6 +29,10 @@ import java.nio.channels.SelectionKey;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
/**
* A {@link io.netty.channel.socket.ServerSocketChannel} implementation which uses
* NIO selector based implementation to accept new connections.
*/
public class NioServerSocketChannel extends AbstractNioMessageChannel
implements io.netty.channel.socket.ServerSocketChannel {

16
transport/src/main/java/io/netty/channel/socket/nio/NioSocketChannel.java
View File

@ -32,6 +32,9 @@ import java.net.SocketAddress;
import java.nio.channels.SelectionKey;
import java.nio.channels.SocketChannel;
/**
* {@link io.netty.channel.socket.SocketChannel} which uses NIO selector based implementation.
*/
public class NioSocketChannel extends AbstractNioByteChannel implements io.netty.channel.socket.SocketChannel {
private static final ChannelMetadata METADATA = new ChannelMetadata(BufType.BYTE, false);
@ -48,14 +51,27 @@ public class NioSocketChannel extends AbstractNioByteChannel implements io.netty
}
}
/**
* Create a new instance
*/
public NioSocketChannel() {
this(newSocket());
}
/**
* Create a new instance using the given {@link SocketChannel}.
*/
public NioSocketChannel(SocketChannel socket) {
this(null, null, socket);
}
/**
* Create a new instance
*
* @param parent the {@link Channel} which created this instance or {@code null} if it was created by the user
* @param id the id to use for this instance or {@code null} if a new one should be generated
* @param socket the {@link SocketChannel} which will be used
*/
public NioSocketChannel(Channel parent, Integer id, SocketChannel socket) {
super(parent, id, socket);
try {