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

Prefer {@code ...} to <code>...</code> / Fix deprecation warnings

Browse Source
This commit is contained in:
Trustin Lee 2012-11-12 11:51:23 +09:00
parent b195190b2a
commit ea4a0e3535
20 changed files with 61 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
buffer/src/main/java/io/netty/buffer/ChannelBuf.java
View File

@ -22,7 +22,7 @@ public interface ChannelBuf {
ChannelBufType type();
/**
* Return <code>true</code> if the ChannelBuf is pooled.
* Return {@code true} if the ChannelBuf is pooled.
*
*/
boolean isPooled();

3
buffer/src/main/java/io/netty/buffer/DefaultCompositeByteBuf.java
View File

@ -247,6 +247,9 @@ public class DefaultCompositeByteBuf extends AbstractByteBuf implements Composit
final int capacity = components.get(numComponents - 1).endOffset;
ByteBuf consolidated = components.get(numComponents - 1).buf.unsafe().newBuffer(capacity);
// We're not using foreach to avoid creating an iterator.
// noinspection ForLoopReplaceableByForEach
for (int i = 0; i < numComponents; i ++) {
ByteBuf b = components.get(i).buf;
consolidated.writeBytes(b);

2
codec-http/src/main/java/io/netty/handler/codec/http/QueryStringDecoder.java
View File

@ -295,7 +295,7 @@ public class QueryStringDecoder {
* {@code 0xC3 0xA9}) is encoded as {@code %C3%A9} or {@code %c3%a9}.
* <p>
* This is essentially equivalent to calling
* <code>{@link URLDecoder#decode(String, String) URLDecoder.decode}(s, charset.name())</code>
* {@link URLDecoder#decode(String, String) URLDecoder.decode(s, charset.name())}
* except that it's over 2x faster and generates less garbage for the GC.
* Actually this function doesn't allocate any memory if there's nothing
* to decode, the argument itself is returned.

4
codec/src/main/java/io/netty/handler/codec/FixedLengthFrameDecoder.java
View File

@ -41,7 +41,7 @@ public class FixedLengthFrameDecoder extends ByteToMessageDecoder<Object> {
private final boolean allocateFullBuffer;
/**
* Calls {@link #FixedLengthFrameDecoder(int, boolean)} with <code>false</code>
* Calls {@link #FixedLengthFrameDecoder(int, boolean)} with {@code false}
*/
public FixedLengthFrameDecoder(int frameLength) {
this(frameLength, false);
@ -53,7 +53,7 @@ public class FixedLengthFrameDecoder extends ByteToMessageDecoder<Object> {
* @param frameLength
* the length of the frame
* @param allocateFullBuffer
* <code>true</code> if the cumulative {@link ByteBuf} should use the
* {@code true} if the cumulative {@link ByteBuf} should use the
* {@link #frameLength} as its initial size
*/
public FixedLengthFrameDecoder(int frameLength, boolean allocateFullBuffer) {

2
common/src/main/java/io/netty/util/internal/DetectionUtil.java
View File

@ -85,7 +85,7 @@ public final class DetectionUtil {
}
/**
* Return <code>true</code> if the JVM is running on Windows
* Return {@code true} if the JVM is running on Windows
*/
public static boolean isWindows() {
return IS_WINDOWS;

8
example/src/main/java/io/netty/example/http/file/HttpStaticFileServerHandler.java
View File

@ -59,13 +59,13 @@ import static io.netty.handler.codec.http.HttpVersion.*;
* Web browser caching works with HTTP headers as illustrated by the following
* sample:
* <ol>
* <li>Request #1 returns the content of <code>/file1.txt</code>.</li>
* <li>Contents of <code>/file1.txt</code> is cached by the browser.</li>
* <li>Request #2 for <code>/file1.txt</code> does return the contents of the
* <li>Request #1 returns the content of {@code /file1.txt}.</li>
* <li>Contents of {@code /file1.txt} is cached by the browser.</li>
* <li>Request #2 for {@code /file1.txt} does return the contents of the
* file again. Rather, a 304 Not Modified is returned. This tells the
* browser to use the contents stored in its cache.</li>
* <li>The server knows the file has not been modified because the
* <code>If-Modified-Since</code> date is the same as the file's last
* {@code If-Modified-Since} date is the same as the file's last
* modified date.</li>
* </ol>
*

4
example/src/main/java/io/netty/example/http/websocketx/autobahn/package-info.java
View File

@ -36,7 +36,7 @@
* <p>06. Create a directory for test configuration and results: <tt>mkdir autobahn</tt> <tt>cd autobahn</tt>.
*
* <p>07. Create <tt>fuzzing_clinet_spec.json</tt> in the above directory
* <code>
* {@code
* {
* "options": {"failByDrop": false},
* "outdir": "./reports/servers",
@ -51,7 +51,7 @@
* "exclude-cases": [],
* "exclude-agent-cases": {}
* }
* </code>
* }
*
* <p>08. Run the <tt>AutobahnServer</tt> located in this package. If you are in Eclipse IDE, right click on
* <tt>AutobahnServer.java</tt> and select Run As > Java Application.

4
example/src/main/java/io/netty/example/http/websocketx/sslserver/package-info.java
View File

@ -20,11 +20,11 @@
* <dl>
* <dt>Step 1. Generate Your Key
* <dd>
* <code>keytool -genkey -keystore mySrvKeystore -keyalg RSA</code>.
* {@code keytool -genkey -keystore mySrvKeystore -keyalg RSA}.
* Make sure that you set the key password to be the same the key file password.
* <dt>Step 2. Specify your key store file and password as system properties
* <dd>
* <code>-Dkeystore.file.path=&lt;path to mySrvKeystore&gt; -Dkeystore.file.password=&lt;password&gt;</code>
* {@code -Dkeystore.file.path=<path to mySrvKeystore> -Dkeystore.file.password=<password>}
* <dt>Step 3. Run WebSocketSslServer as a Java application
* <dd>
* Once started, you can test the web server against your browser by navigating to https://localhost:8081/

12
handler/src/main/java/io/netty/handler/ssl/SslHandler.java
View File

@ -68,7 +68,7 @@ import javax.net.ssl.SSLException;
* If {@link #isIssueHandshake()} is {@code false}
* (default) you will need to take care of calling {@link #handshake()} by your own. In most
* situations were {@link SslHandler} is used in 'client mode' you want to issue a handshake once
* the connection was established. if {@link #setIssueHandshake(boolean)} is set to <code>true</code>
* the connection was established. if {@link #setIssueHandshake(boolean)} is set to {@code true}
* you don't need to worry about this as the {@link SslHandler} will take care of it.
* <p>
*
@ -656,14 +656,14 @@ public class SslHandler
}
/**
* Returns <code>true</code> if the given {@link ByteBuf} is encrypted. Be aware that this method
* Returns {@code true} if the given {@link ByteBuf} is encrypted. Be aware that this method
* will not increase the readerIndex of the given {@link ByteBuf}.
*
* @param buffer
* The {@link ByteBuf} to read from. Be aware that it must have at least 5 bytes to read,
* otherwise it will throw an {@link IllegalArgumentException}.
* @return encrypted
* <code>true</code> if the {@link ByteBuf} is encrypted, <code>false</code> otherwise.
* @return encrypted
* {@code true} if the {@link ByteBuf} is encrypted, {@code false} otherwise.
* @throws IllegalArgumentException
* Is thrown if the given {@link ByteBuf} has not at least 5 bytes to read.
*/
@ -678,9 +678,9 @@ public class SslHandler
* @param buffer
* The {@link ByteBuf} to read from. Be aware that it must have at least 5 bytes to read,
* otherwise it will throw an {@link IllegalArgumentException}.
* @return length
* @return length
* The length of the encrypted packet that is included in the buffer. This will
* return <code>-1</code> if the given {@link ByteBuf} is not encrypted at all.
* return {@code -1} if the given {@link ByteBuf} is not encrypted at all.
* @throws IllegalArgumentException
* Is thrown if the given {@link ByteBuf} has not at least 5 bytes to read.
*/

2
handler/src/main/java/io/netty/handler/stream/ChunkedWriteHandler.java
View File

@ -309,7 +309,7 @@ public class ChunkedWriteHandler
* Read the next {@link ChunkedInput} and transfer it the the outbound buffer.
* @param ctx the {@link ChannelHandlerContext} this handler is bound to
* @param chunks the {@link ChunkedInput} to read from
* @return read <code>true</code> if something could be transfered to the outbound buffer
* @return read {@code true} if something could be transfered to the outbound buffer
* @throws Exception if something goes wrong
*/
@SuppressWarnings("unchecked")

2
testsuite/src/test/java/io/netty/testsuite/util/TestUtils.java
View File

@ -77,7 +77,7 @@ public final class TestUtils {
}
/**
* Return <code>true</code> if SCTP is supported by the running os.
* Return {@code true} if SCTP is supported by the running os.
*
*/
public static boolean isSctpSupported() {

2
transport/src/main/java/io/netty/bootstrap/AbstractBootstrap.java
View File

@ -124,7 +124,7 @@ public abstract class AbstractBootstrap<B extends AbstractBootstrap<?>> {
/**
* Allow to specify a {@link ChannelOption} which is used for the {@link Channel} instances once they got
* created. Use a value of <code>null</code> to remove a previous set {@link ChannelOption}.
* created. Use a value of {@code null} to remove a previous set {@link ChannelOption}.
*/
@SuppressWarnings("unchecked")
public <T> B option(ChannelOption<T> option, T value) {

2
transport/src/main/java/io/netty/bootstrap/ServerBootstrap.java
View File

@ -108,7 +108,7 @@ public class ServerBootstrap extends AbstractBootstrap<ServerBootstrap> {
/**
* Allow to specify a {@link ChannelOption} which is used for the {@link Channel} instances once they get created
* (after the acceptor accepted the {@link Channel}). Use a value of <code>null</code> to remove a previous set
* (after the acceptor accepted the {@link Channel}). Use a value of {@code null} to remove a previous set
* {@link ChannelOption}.
*/
public <T> ServerBootstrap childOption(ChannelOption<T> childOption, T value) {

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

@ -205,13 +205,13 @@ public interface Channel extends AttributeMap, ChannelOutboundInvoker, ChannelFu
/**
* Return the {@link SocketAddress} to which is bound local or
* <code>null</code> if none.
* {@code null} if none.
*/
SocketAddress localAddress();
/**
* Return the {@link SocketAddress} to which is bound remote or
* <code>null</code> if none is bound yet.
* {@code null} if none is bound yet.
*/
SocketAddress remoteAddress();
@ -230,7 +230,7 @@ public interface Channel extends AttributeMap, ChannelOutboundInvoker, ChannelFu
/**
* Connect the {@link Channel} of the given {@link ChannelFuture} with the given remote {@link SocketAddress}.
* If a specific local {@link SocketAddress} should be used it need to be given as argument. Otherwise just
* pass <code>null</code> to it.
* pass {@code null} to it.
*
* The {@link ChannelFuture} will get notified once the connect operation was complete.
*/

4
transport/src/main/java/io/netty/channel/ChannelFutureFactory.java
View File

@ -28,14 +28,14 @@ public interface ChannelFutureFactory {
/**
* Create a new {@link ChannelFuture} which is marked as successes already. So {@link ChannelFuture#isSuccess()}
* will return <code>true</code>. All {@link ChannelFutureListener} added to it will be notified directly. Also
* will return {@code true}. All {@link ChannelFutureListener} added to it will be notified directly. Also
* every call of blocking methods will just return without blocking.
*/
ChannelFuture newSucceededFuture();
/**
* Create a new {@link ChannelFuture} which is marked as fakued already. So {@link ChannelFuture#isSuccess()}
* will return <code>false</code>. All {@link ChannelFutureListener} added to it will be notified directly. Also
* will return {@code false}. All {@link ChannelFutureListener} added to it will be notified directly. Also
* every call of blocking methods will just return without blocking.
*/
ChannelFuture newFailedFuture(Throwable cause);

36
transport/src/main/java/io/netty/channel/ChannelHandlerContext.java
View File

@ -160,114 +160,114 @@ public interface ChannelHandlerContext
Set<ChannelHandlerType> types();
/**
* Return <code>true</code> if the {@link ChannelHandlerContext} has an {@link ByteBuf} bound for inbound
* Return {@code true} if the {@link ChannelHandlerContext} has an {@link ByteBuf} bound for inbound
* which can be used.
*/
boolean hasInboundByteBuffer();
/**
* Return <code>true</code> if the {@link ChannelHandlerContext} has a {@link MessageBuf} bound for inbound
* Return {@code true} if the {@link ChannelHandlerContext} has a {@link MessageBuf} bound for inbound
* which can be used.
*/
boolean hasInboundMessageBuffer();
/**
* Return the bound {@link ByteBuf} for inbound data if {@link #hasInboundByteBuffer()} returned
* <code>true</code>. If {@link #hasInboundByteBuffer()} returned <code>false</code> it will throw a
* {@code true}. If {@link #hasInboundByteBuffer()} returned {@code false} it will throw a
* {@link UnsupportedOperationException}
*/
ByteBuf inboundByteBuffer();
/**
* Return the bound {@link MessageBuf} for inbound data if {@link #hasInboundMessageBuffer()} returned
* <code>true</code>. If {@link #hasInboundMessageBuffer()} returned <code>false</code> it will throw a
* {@code true}. If {@link #hasInboundMessageBuffer()} returned {@code false} it will throw a
* {@link UnsupportedOperationException}.
*/
<T> MessageBuf<T> inboundMessageBuffer();
/**
* Return <code>true</code> if the {@link ChannelHandlerContext} has an {@link ByteBuf} bound for outbound
* Return {@code true} if the {@link ChannelHandlerContext} has an {@link ByteBuf} bound for outbound
* data which can be used.
*
*/
boolean hasOutboundByteBuffer();
/**
* Return <code>true</code> if the {@link ChannelHandlerContext} has a {@link MessageBuf} bound for outbound
* Return {@code true} if the {@link ChannelHandlerContext} has a {@link MessageBuf} bound for outbound
* which can be used.
*/
boolean hasOutboundMessageBuffer();
/**
* Return the bound {@link ByteBuf} for outbound data if {@link #hasOutboundByteBuffer()} returned
* <code>true</code>. If {@link #hasOutboundByteBuffer()} returned <code>false</code> it will throw
* {@code true}. If {@link #hasOutboundByteBuffer()} returned {@code false} it will throw
* a {@link UnsupportedOperationException}.
*/
ByteBuf outboundByteBuffer();
/**
* Return the bound {@link MessageBuf} for outbound data if {@link #hasOutboundMessageBuffer()} returned
* <code>true</code>. If {@link #hasOutboundMessageBuffer()} returned <code>false</code> it will throw a
* {@code true}. If {@link #hasOutboundMessageBuffer()} returned {@code false} it will throw a
* {@link UnsupportedOperationException}
*/
<T> MessageBuf<T> outboundMessageBuffer();
/**
* Return <code>true</code> if the next {@link ChannelHandlerContext} has a {@link ByteBuf} for handling
* Return {@code true} if the next {@link ChannelHandlerContext} has a {@link ByteBuf} for handling
* inbound data.
*/
boolean hasNextInboundByteBuffer();
/**
* Return <code>true</code> if the next {@link ChannelHandlerContext} has a {@link MessageBuf} for handling
* Return {@code true} if the next {@link ChannelHandlerContext} has a {@link MessageBuf} for handling
* inbound data.
*/
boolean hasNextInboundMessageBuffer();
/**
* Return the {@link ByteBuf} of the next {@link ChannelHandlerContext} if {@link #hasNextInboundByteBuffer()}
* returned <code>true</code>, otherwise a {@link UnsupportedOperationException} is thrown.
* returned {@code true}, otherwise a {@link UnsupportedOperationException} is thrown.
*/
ByteBuf nextInboundByteBuffer();
/**
* Return the {@link MessageBuf} of the next {@link ChannelHandlerContext} if
* {@link #hasNextInboundMessageBuffer()} returned <code>true</code>, otherwise a
* {@link #hasNextInboundMessageBuffer()} returned {@code true}, otherwise a
* {@link UnsupportedOperationException} is thrown.
*/
MessageBuf<Object> nextInboundMessageBuffer();
/**
* Return <code>true</code> if the next {@link ChannelHandlerContext} has a {@link ByteBuf} for handling outbound
* Return {@code true} if the next {@link ChannelHandlerContext} has a {@link ByteBuf} for handling outbound
* data.
*/
boolean hasNextOutboundByteBuffer();
/**
* Return <code>true</code> if the next {@link ChannelHandlerContext} has a {@link MessageBuf} for handling
* Return {@code true} if the next {@link ChannelHandlerContext} has a {@link MessageBuf} for handling
* outbound data.
*/
boolean hasNextOutboundMessageBuffer();
/**
* Return the {@link ByteBuf} of the next {@link ChannelHandlerContext} if {@link #hasNextOutboundByteBuffer()}
* returned <code>true</code>, otherwise a {@link UnsupportedOperationException} is thrown.
* returned {@code true}, otherwise a {@link UnsupportedOperationException} is thrown.
*/
ByteBuf nextOutboundByteBuffer();
/**
* Return the {@link MessageBuf} of the next {@link ChannelHandlerContext} if
* {@link #hasNextOutboundMessageBuffer()} returned <code>true</code>, otherwise a
* {@link #hasNextOutboundMessageBuffer()} returned {@code true}, otherwise a
* {@link UnsupportedOperationException} is thrown.
*/
MessageBuf<Object> nextOutboundMessageBuffer();
/**
* Return <code>true</code> if the {@link ChannelHandlerContext} was marked as readable. This basically means
* Return {@code true} if the {@link ChannelHandlerContext} was marked as readable. This basically means
* that once its not readable anymore no new data will be read from the transport and passed down the
* {@link ChannelPipeline}.
*
* Only if all {@link ChannelHandlerContext}'s {@link #isReadable()} return <code>true</code>, the data is
* Only if all {@link ChannelHandlerContext}'s {@link #isReadable()} return {@code true}, the data is
* passed again down the {@link ChannelPipeline}.
*/
boolean isReadable();

4
transport/src/main/java/io/netty/channel/ChannelInboundMessageHandlerAdapter.java
View File

@ -88,10 +88,10 @@ public abstract class ChannelInboundMessageHandlerAdapter<I>
/**
* Will get notified once {@link #inboundBufferUpdated(ChannelHandlerContext)} was called.
*
* If this method returns <code>false</code> no further processing of the {@link MessageBuf}
* If this method returns {@code false} no further processing of the {@link MessageBuf}
* will be done until the next call of {@link #inboundBufferUpdated(ChannelHandlerContext)}.
*
* This will return <code>true</code> by default, and may get overriden by sub-classes for
* This will return {@code true} by default, and may get overriden by sub-classes for
* special handling.
*/
public boolean beginMessageReceived(ChannelHandlerContext ctx) throws Exception {

6
transport/src/main/java/io/netty/channel/EventExecutor.java
View File

@ -34,7 +34,7 @@ public interface EventExecutor extends EventExecutorGroup, ScheduledExecutorServ
/**
* Return the {@link EventExecutorGroup} which is the parent of this {@link EventExecutor},
* or <code>null</code> if it has no parent
* or {@code null} if it has no parent
*/
EventExecutorGroup parent();
@ -45,8 +45,8 @@ public interface EventExecutor extends EventExecutorGroup, ScheduledExecutorServ
boolean inEventLoop();
/**
* Return <code>true</code> if the given {@link Thread} is executed in the event loop,
* <code>false</code> otherwise.
* Return {@code true} if the given {@link Thread} is executed in the event loop,
* {@code false} otherwise.
*/
boolean inEventLoop(Thread thread);
}

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

@ -36,7 +36,7 @@ public final class SctpNotificationEvent {
/**
* Return the attachment of this {@link SctpNotificationEvent}, or
* <code>null</code> if no attachment was provided
* {@code null} if no attachment was provided
*/
public Object attachment() {
return attachment;

11
transport/src/main/java/io/netty/channel/socket/aio/AioSocketChannelConfig.java
View File

@ -15,7 +15,6 @@
*/
package io.netty.channel.socket.aio;
import static io.netty.channel.ChannelOption.*;
import io.netty.channel.ChannelException;
import io.netty.channel.ChannelOption;
import io.netty.channel.DefaultChannelConfig;
@ -27,6 +26,8 @@ import java.nio.channels.InterruptedByTimeoutException;
import java.nio.channels.NetworkChannel;
import java.util.Map;
import static io.netty.channel.ChannelOption.*;
/**
* The default {@link SocketChannelConfig} implementation.
*/
@ -262,7 +263,7 @@ final class AioSocketChannelConfig extends DefaultChannelConfig
* Once such an exception was detected it will get propagated to the handlers first. After that the channel
* will get closed as it may be in an unknown state.
*
* To disable it just use <code>0</code>.
* To disable it just use {@code 0}.
*/
public void setReadTimeout(long readTimeoutInMillis) {
if (readTimeoutInMillis < 0) {
@ -276,7 +277,7 @@ final class AioSocketChannelConfig extends DefaultChannelConfig
* Once such an exception was detected it will get propagated to the handlers first. After that the channel
* will get closed as it may be in an unknown state.
*
* To disable it just use <code>0</code>.
* To disable it just use {@code 0}.
*/
public void setWriteTimeout(long writeTimeoutInMillis) {
if (writeTimeoutInMillis < 0) {
@ -288,7 +289,7 @@ final class AioSocketChannelConfig extends DefaultChannelConfig
/**
* Return the read timeout in milliseconds after which a {@link InterruptedByTimeoutException} will get thrown.
*
* The default is <code>0</code>
* The default is {@code 0}
*/
public long getReadTimeout() {
return readTimeoutInMillis;
@ -297,7 +298,7 @@ final class AioSocketChannelConfig extends DefaultChannelConfig
/**
* Return the write timeout in milliseconds after which a {@link InterruptedByTimeoutException} will get thrown.
*
* The default is <code>0</code>
* The default is {@code 0}
*/
public long getWriteTimeout() {
return writeTimeoutInMillis;