Eclipse
/
jetty.project
mirror of https://github.com/jetty/jetty.project.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

#2056 javadoc warning fixes WIP 

Signed-off-by: olivier lamy <olamy@webtide.com>
This commit is contained in:
olivier lamy 2017-12-18 14:27:55 +11:00
parent 0c021f2599
commit 3a189ab254
10 changed files with 37 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
jetty-http/src/main/java/org/eclipse/jetty/http/GZIPContentDecoder.java
View File

@ -400,7 +400,8 @@ public class GZIPContentDecoder implements Destroyable
}
/**
* @return An indirect buffer of the configured buffersize either from the pool or freshly allocated.
* @param capacity capacity capacity of the allocated ByteBuffer
* @return An indirect buffer of the configured buffersize either from the pool or freshly allocated.
*/
public ByteBuffer acquire(int capacity)
{

1
jetty-http/src/main/java/org/eclipse/jetty/http/MetaData.java
View File

@ -61,6 +61,7 @@ public class MetaData implements Iterable<HttpField>
/**
* @deprecated use {@link #getHttpVersion()} instead
* @return the HTTP version of this MetaData object
*/
@Deprecated
public HttpVersion getVersion()

4
jetty-server/src/main/java/org/eclipse/jetty/server/ConnectionLimit.java
View File

@ -30,12 +30,12 @@ import org.eclipse.jetty.util.log.Log;
import org.eclipse.jetty.util.log.Logger;
/**
* A Connection Listener that limits the number of Connections.
* <p>A Connection Listener that limits the number of Connections.</p>
* <p>This listener applies a limit to the number of connections, which when
* exceeded results in a call to {@link AbstractConnector#setAccepting(boolean)}
* to prevent further connections being received. It can be applied to an
* entire server or to a specific connector.
* <p>
* </p>
* @see Connection.Listener
*/
@ManagedObject

8
jetty-server/src/main/java/org/eclipse/jetty/server/ForwardedRequestCustomizer.java
View File

@ -86,10 +86,10 @@ public class ForwardedRequestCustomizer implements Customizer
}
/**
* Configure to only support the RFC7239 Forwarded header and to
* not support any {@code X-Forwarded-} headers. This convenience method
* clears all the non RFC headers if passed true and sets them to
* the default values (if not already set) if passed false.
* @param rfc7239only Configure to only support the RFC7239 Forwarded header and to
* not support any {@code X-Forwarded-} headers. This convenience method
* clears all the non RFC headers if passed true and sets them to
* the default values (if not already set) if passed false.
*/
public void setForwardedOnly(boolean rfc7239only)
{

3
jetty-server/src/main/java/org/eclipse/jetty/server/HttpChannelState.java
View File

@ -1249,6 +1249,7 @@ public class HttpChannelState
* Called to indicate that more content may be available,
* but that a handling thread may need to produce (fill/parse)
* it. Typically called by the async read success callback.
* @return <code>true</code> if more content may be available
*/
public boolean onReadPossible()
{
@ -1279,7 +1280,7 @@ public class HttpChannelState
/**
* Called to signal that a read has read -1.
* Will wake if the read was called while in ASYNC_WAIT state
* @return true if woken
* @return <code>true</code> if woken
*/
public boolean onReadEof()
{

21
jetty-server/src/main/java/org/eclipse/jetty/server/HttpInput.java
View File

@ -44,23 +44,27 @@ import org.eclipse.jetty.util.log.Logger;
/**
* {@link HttpInput} provides an implementation of {@link ServletInputStream} for {@link HttpChannel}.
* <p>
* Content may arrive in patterns such as [content(), content(), messageComplete()] so that this class maintains two states: the content state that tells
* whether there is content to consume and the EOF state that tells whether an EOF has arrived. Only once the content has been consumed the content state is
* moved to the EOF state.
* Content may arrive in patterns such as [content(), content(), messageComplete()]
* so that this class maintains two states: the content state that tells
* whether there is content to consume and the EOF state that tells whether an EOF has arrived.
* Only once the content has been consumed the content state is moved to the EOF state.
* </p>
*/
public class HttpInput extends ServletInputStream implements Runnable
{
/**
* An interceptor for HTTP Request input.
* <p>
* Unlike inputstream wrappers that can be applied by filters, an interceptor
* Unlike InputStream wrappers that can be applied by filters, an interceptor
* is entirely transparent and works with async IO APIs.
* </p>
* <p>
* An Interceptor may consume data from the passed content and the interceptor
* will continue to be called for the same content until the interceptor returns
* null or an empty content. Thus even if the passed content is completely consumed
* null or an empty content. Thus even if the passed content is completely consumed
* the interceptor will be called with the same content until it can no longer
* produce more content.
* produce more content.
* </p>
* @see HttpInput#setInterceptor(Interceptor)
* @see HttpInput#addInterceptor(Interceptor)
*/
@ -77,8 +81,8 @@ public class HttpInput extends ServletInputStream implements Runnable
/**
* An {@link Interceptor} that chains two other {@link Interceptor}s together.
* The {@link #readFrom(Content)} calls the previous {@link Interceptor}'s
* {@link #readFrom(Content)} and then passes any {@link Content} returned
* The {@link Interceptor#readFrom(Content)} calls the previous {@link Interceptor}'s
* {@link Interceptor#readFrom(Content)} and then passes any {@link Content} returned
* to the next {@link Interceptor}.
*/
public static class ChainedInterceptor implements Interceptor, Destroyable
@ -335,6 +339,7 @@ public class HttpInput extends ServletInputStream implements Runnable
/**
* Called by channel when asynchronous IO needs to produce more content
* @throws IOException
* if unable to produce content
*/
public void asyncReadProduce() throws IOException
{

10
jetty-server/src/main/java/org/eclipse/jetty/server/ServerConnector.java
View File

@ -57,14 +57,18 @@ import org.eclipse.jetty.util.thread.Scheduler;
* use all the commons services (eg {@link Executor}, {@link Scheduler}) of the
* passed {@link Server} instance, but all services may also be constructor injected
* into the connector so that it may operate with dedicated or otherwise shared services.
* </p>
* <h2>Connection Factories</h2>
* <p>
* Various convenience constructors are provided to assist with common configurations of
* ConnectionFactories, whose generic use is described in {@link AbstractConnector}.
* If no connection factories are passed, then the connector will
* default to use a {@link HttpConnectionFactory}. If an non null {@link SslContextFactory}
* instance is passed, then this used to instantiate a {@link SslConnectionFactory} which is
* prepended to the other passed or default factories.
* </p>
* <h2>Selectors</h2>
* <p>
* The connector will use the {@link Executor} service to execute a number of Selector Tasks,
* which are implemented to each use a NIO {@link Selector} instance to asynchronously
* schedule a set of accepted connections. It is the selector thread that will call the
@ -72,10 +76,12 @@ import org.eclipse.jetty.util.thread.Scheduler;
* {@link EndPoint#write(Callback, java.nio.ByteBuffer...)} methods. It is expected
* that these callbacks may do some non-blocking IO work, but will always dispatch to the
* {@link Executor} service any blocking, long running or application tasks.
* </p>
* <p>
* The default number of selectors is equal to half of the number of processors available to the JVM,
* which should allow optimal performance even if all the connections used are performing
* significant non-blocking work in the callback tasks.
* </p>
*/
@ManagedObject("HTTP connector using NIO ByteChannels and Selectors")
public class ServerConnector extends AbstractNetworkConnector
@ -281,7 +287,7 @@ public class ServerConnector extends AbstractNetworkConnector
* This open method can be called before starting the connector to pass it a ServerSocketChannel
* that will be used instead of one returned from {@link #openAcceptChannel()}
* @param acceptChannel the channel to use
* @throws IOException
* @throws IOException if the server channel cannot be bound
*/
public void open(ServerSocketChannel acceptChannel) throws IOException
{
@ -311,7 +317,7 @@ public class ServerConnector extends AbstractNetworkConnector
/**
* Called by {@link #open()} to obtain the accepting channel.
* @return ServerSocketChannel used to accept connections.
* @throws IOException
* @throws IOException if unable to obtain or configure the server channel
*/
protected ServerSocketChannel openAcceptChannel() throws IOException
{

1
jetty-util/src/main/java/org/eclipse/jetty/util/MultiReleaseJarFile.java
View File

@ -49,6 +49,7 @@ public class MultiReleaseJarFile implements Closeable
/**
* Construct a multi release jar file for the current JVM version, ignoring directories.
* @param file The file to open
* @throws IOException if the jar file cannot be read
*/
public MultiReleaseJarFile(File file) throws IOException
{

1
jetty-util/src/main/java/org/eclipse/jetty/util/thread/Locker.java
View File

@ -49,6 +49,7 @@ public class Locker
/**
* @deprecated use {@link #lock()} instead
* @return the lock to unlock
*/
@Deprecated
public Lock lockIfNotHeld()

5
jetty-util/src/main/java/org/eclipse/jetty/util/thread/ReservedThreadExecutor.java
View File

@ -89,8 +89,9 @@ public class ReservedThreadExecutor extends AbstractLifeCycle implements Executo
/**
* @param executor The executor to use to obtain threads
* @param capacity The number of threads to preallocate. If less than 0 then capacity
* is calculated based on a heuristic from the number of available processors and
* thread pool size.
* is calculated based on a heuristic from the number of available processors and
* thread pool size.
* @param owner the owner of the instance. Only used for debugging purpose withing the {@link #toString()} method
*/
public ReservedThreadExecutor(Executor executor,int capacity, Object owner)
{