Fix javadoc in org.eclipse.jgit.lfs.server

Change-Id: I0c52536ebeeb8e71d95c6420f6db7055ff082dfa
Signed-off-by: Matthias Sohn <matthias.sohn@sap.com>

org.eclipse.jgit.lfs.server/src/org/eclipse/jgit/lfs/server/LargeFileRepository.java

 public interface LargeFileRepository {
 
 	/**
+	 * Get download action
+	 *
 	 * @param id
 	 *            id of the object to download
 	 * @return Action for downloading the object
 	public Response.Action getDownloadAction(AnyLongObjectId id);
 
 	/**
+	 * Get upload action
+	 *
 	 * @param id
 	 *            id of the object to upload
 	 * @param size
 	public Response.Action getUploadAction(AnyLongObjectId id, long size);
 
 	/**
+	 * Get verify action
+	 *
 	 * @param id
 	 *            id of the object to be verified
 	 * @return Action for verifying the object, or {@code null} if the server
 	public @Nullable Response.Action getVerifyAction(AnyLongObjectId id);
 
 	/**
+	 * Get size of an object
+	 *
 	 * @param id
 	 *            id of the object
 	 * @return length of the object content in bytes, -1 if the object doesn't
 	 *         exist
-	 * @throws IOException
+	 * @throws java.io.IOException
 	 */
 	public long getSize(AnyLongObjectId id) throws IOException;
 }

org.eclipse.jgit.lfs.server/src/org/eclipse/jgit/lfs/server/LfsObject.java

 	long size;
 
 	/**
+	 * Get the <code>oid</code> of this object.
+	 *
 	 * @return the object ID.
 	 */
 	public String getOid() {
 	}
 
 	/**
+	 * Get the <code>size</code> of this object.
+	 *
 	 * @return the object size.
 	 */
 	public long getSize() {

org.eclipse.jgit.lfs.server/src/org/eclipse/jgit/lfs/server/LfsProtocolServlet.java

 	 *            the request
 	 * @param path
 	 *            the path
-	 *
 	 * @return the large file repository storing large files.
-	 * @throws LfsException
+	 * @throws org.eclipse.jgit.lfs.errors.LfsException
 	 *             implementations should throw more specific exceptions to
 	 *             signal which type of error occurred:
 	 *             <dl>
-	 *             <dt>{@link LfsValidationError}</dt>
+	 *             <dt>{@link org.eclipse.jgit.lfs.errors.LfsValidationError}</dt>
 	 *             <dd>when there is a validation error with one or more of the
 	 *             objects in the request</dd>
-	 *             <dt>{@link LfsRepositoryNotFound}</dt>
+	 *             <dt>{@link org.eclipse.jgit.lfs.errors.LfsRepositoryNotFound}</dt>
 	 *             <dd>when the repository does not exist for the user</dd>
-	 *             <dt>{@link LfsRepositoryReadOnly}</dt>
+	 *             <dt>{@link org.eclipse.jgit.lfs.errors.LfsRepositoryReadOnly}</dt>
 	 *             <dd>when the user has read, but not write access. Only
 	 *             applicable when the operation in the request is "upload"</dd>
-	 *             <dt>{@link LfsRateLimitExceeded}</dt>
+	 *             <dt>{@link org.eclipse.jgit.lfs.errors.LfsRateLimitExceeded}</dt>
 	 *             <dd>when the user has hit a rate limit with the server</dd>
-	 *             <dt>{@link LfsBandwidthLimitExceeded}</dt>
+	 *             <dt>{@link org.eclipse.jgit.lfs.errors.LfsBandwidthLimitExceeded}</dt>
 	 *             <dd>when the bandwidth limit for the user or repository has
 	 *             been exceeded</dd>
-	 *             <dt>{@link LfsInsufficientStorage}</dt>
+	 *             <dt>{@link org.eclipse.jgit.lfs.errors.LfsInsufficientStorage}</dt>
 	 *             <dd>when there is insufficient storage on the server</dd>
-	 *             <dt>{@link LfsUnavailable}</dt>
+	 *             <dt>{@link org.eclipse.jgit.lfs.errors.LfsUnavailable}</dt>
 	 *             <dd>when LFS is not available</dd>
-	 *             <dt>{@link LfsException}</dt>
+	 *             <dt>{@link org.eclipse.jgit.lfs.errors.LfsException}</dt>
 	 *             <dd>when an unexpected internal server error occurred</dd>
 	 *             </dl>
 	 * @since 4.5
 	 *            the path
 	 * @param auth
 	 *            the Authorization HTTP header
-	 *
 	 * @return the large file repository storing large files.
-	 * @throws LfsException
+	 * @throws org.eclipse.jgit.lfs.errors.LfsException
 	 *             implementations should throw more specific exceptions to
 	 *             signal which type of error occurred:
 	 *             <dl>
-	 *             <dt>{@link LfsValidationError}</dt>
+	 *             <dt>{@link org.eclipse.jgit.lfs.errors.LfsValidationError}</dt>
 	 *             <dd>when there is a validation error with one or more of the
 	 *             objects in the request</dd>
-	 *             <dt>{@link LfsRepositoryNotFound}</dt>
+	 *             <dt>{@link org.eclipse.jgit.lfs.errors.LfsRepositoryNotFound}</dt>
 	 *             <dd>when the repository does not exist for the user</dd>
-	 *             <dt>{@link LfsRepositoryReadOnly}</dt>
+	 *             <dt>{@link org.eclipse.jgit.lfs.errors.LfsRepositoryReadOnly}</dt>
 	 *             <dd>when the user has read, but not write access. Only
 	 *             applicable when the operation in the request is "upload"</dd>
-	 *             <dt>{@link LfsRateLimitExceeded}</dt>
+	 *             <dt>{@link org.eclipse.jgit.lfs.errors.LfsRateLimitExceeded}</dt>
 	 *             <dd>when the user has hit a rate limit with the server</dd>
-	 *             <dt>{@link LfsBandwidthLimitExceeded}</dt>
+	 *             <dt>{@link org.eclipse.jgit.lfs.errors.LfsBandwidthLimitExceeded}</dt>
 	 *             <dd>when the bandwidth limit for the user or repository has
 	 *             been exceeded</dd>
-	 *             <dt>{@link LfsInsufficientStorage}</dt>
+	 *             <dt>{@link org.eclipse.jgit.lfs.errors.LfsInsufficientStorage}</dt>
 	 *             <dd>when there is insufficient storage on the server</dd>
-	 *             <dt>{@link LfsUnavailable}</dt>
+	 *             <dt>{@link org.eclipse.jgit.lfs.errors.LfsUnavailable}</dt>
 	 *             <dd>when LFS is not available</dd>
-	 *             <dt>{@link LfsException}</dt>
+	 *             <dt>{@link org.eclipse.jgit.lfs.errors.LfsException}</dt>
 	 *             <dd>when an unexpected internal server error occurred</dd>
 	 *             </dl>
 	 * @since 4.7
 		}
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	protected void doPost(HttpServletRequest req, HttpServletResponse res)
 			throws ServletException, IOException {

org.eclipse.jgit.lfs.server/src/org/eclipse/jgit/lfs/server/fs/FileLfsRepository.java

 	private final Path dir;
 
 	/**
+	 * <p>Constructor for FileLfsRepository.</p>
+	 *
 	 * @param url
 	 *            external URL of this repository
 	 * @param dir
 	 *            storage directory
-	 * @throws IOException
+	 * @throws java.io.IOException
 	 */
 	public FileLfsRepository(String url, Path dir) throws IOException {
 		this.url = url;
 		Files.createDirectories(dir);
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public Response.Action getDownloadAction(AnyLongObjectId id) {
 		return getAction(id);
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public Action getUploadAction(AnyLongObjectId id, long size) {
 		return getAction(id);
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public @Nullable Action getVerifyAction(AnyLongObjectId id) {
 		return null;
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public long getSize(AnyLongObjectId id) throws IOException {
 		Path p = getPath(id);

org.eclipse.jgit.lfs.server/src/org/eclipse/jgit/lfs/server/fs/FileLfsServlet.java

 	private final long timeout;
 
 	/**
+	 * <p>Constructor for FileLfsServlet.</p>
+	 *
 	 * @param repository
 	 *            the repository storing the large objects
 	 * @param timeout
 	}
 
 	/**
-	 * Handles object downloads
+	 * {@inheritDoc}
 	 *
-	 * @param req
-	 *            servlet request
-	 * @param rsp
-	 *            servlet response
-	 * @throws ServletException
-	 *             if a servlet-specific error occurs
-	 * @throws IOException
-	 *             if an I/O error occurs
+	 * Handle object downloads
 	 */
 	@Override
 	protected void doGet(HttpServletRequest req,
 	 *            servlet response
 	 * @return object id, or <code>null</code> if the object id could not be
 	 *         retrieved
-	 * @throws IOException
+	 * @throws java.io.IOException
 	 *             if an I/O error occurs
-         * @since 4.6
+	 * @since 4.6
 	 */
 	protected AnyLongObjectId getObjectToTransfer(HttpServletRequest req,
 			HttpServletResponse rsp) throws IOException {
 	}
 
 	/**
-	 * Handle object uploads
+	 * {@inheritDoc}
 	 *
-	 * @param req
-	 *            servlet request
-	 * @param rsp
-	 *            servlet response
-	 * @throws ServletException
-	 *             if a servlet-specific error occurs
-	 * @throws IOException
-	 *             if an I/O error occurs
+	 * Handle object uploads
 	 */
 	@Override
 	protected void doPut(HttpServletRequest req,
 	 *            HTTP status code
 	 * @param message
 	 *            error message
-	 * @throws IOException
+	 * @throws java.io.IOException
 	 *             on failure to send the response
 	 * @since 4.6
 	 */

org.eclipse.jgit.lfs.server/src/org/eclipse/jgit/lfs/server/fs/ObjectDownloadListener.java

 	private final ByteBuffer buffer = ByteBuffer.allocateDirect(8192);
 
 	/**
+	 * <p>Constructor for ObjectDownloadListener.</p>
+	 *
 	 * @param repository
 	 *            the repository storing large objects
 	 * @param context
 	 *            the servlet response
 	 * @param id
 	 *            id of the object to be downloaded
-	 * @throws IOException
+	 * @throws java.io.IOException
 	 */
 	public ObjectDownloadListener(FileLfsRepository repository,
 			AsyncContext context, HttpServletResponse response,
 	}
 
 	/**
-	 * Write file content
+	 * {@inheritDoc}
 	 *
-	 * @throws IOException
+	 * Write file content
 	 */
 	@Override
 	public void onWritePossible() throws IOException {
 	}
 
 	/**
-	 * Handle errors
+	 * {@inheritDoc}
 	 *
-	 * @param e
-	 *            the cause
+	 * Handle errors
 	 */
 	@Override
 	public void onError(Throwable e) {

org.eclipse.jgit.lfs.server/src/org/eclipse/jgit/lfs/server/fs/ObjectUploadListener.java

 	private final ByteBuffer buffer = ByteBuffer.allocateDirect(8192);
 
 	/**
+	 * Constructor for ObjectUploadListener.
+	 *
 	 * @param repository
 	 *            the repository storing large objects
 	 * @param context
+	 *            a {@link javax.servlet.AsyncContext} object.
 	 * @param request
+	 *            a {@link javax.servlet.http.HttpServletRequest} object.
 	 * @param response
+	 *            a {@link javax.servlet.http.HttpServletResponse} object.
 	 * @param id
-	 * @throws FileNotFoundException
-	 * @throws IOException
+	 *            a {@link org.eclipse.jgit.lfs.lib.AnyLongObjectId} object.
+	 * @throws java.io.FileNotFoundException
+	 * @throws java.io.IOException
 	 */
 	public ObjectUploadListener(FileLfsRepository repository,
 			AsyncContext context, HttpServletRequest request,
 	}
 
 	/**
-	 * Writes all the received data to the output channel
+	 * {@inheritDoc}
 	 *
-	 * @throws IOException
+	 * Writes all the received data to the output channel
 	 */
 	@Override
 	public void onDataAvailable() throws IOException {
 		}
 	}
 
-	/**
-	 * @throws IOException
-	 */
+	/** {@inheritDoc} */
 	@Override
 	public void onAllDataRead() throws IOException {
 		close();
 	}
 
 	/**
-	 * @throws IOException
+	 * Close resources held by this listener
+	 *
+	 * @throws java.io.IOException
 	 */
 	protected void close() throws IOException {
 		try {
 		}
 	}
 
-	/**
-	 * @param e
-	 *            the exception that caused the problem
-	 */
+	/** {@inheritDoc} */
 	@Override
 	public void onError(Throwable e) {
 		try {

org.eclipse.jgit.lfs.server/src/org/eclipse/jgit/lfs/server/internal/LfsGson.java

 import com.google.gson.JsonSyntaxException;
 
 /**
- * Wrapper for {@link Gson} used by LFS servlets.
+ * Wrapper for {@link com.google.gson.Gson} used by LFS servlets.
  *
+ * @since 4.10.0
  */
 public class LfsGson {
 	private static final Gson gson = new GsonBuilder()
 	 * @param src
 	 *            the object for which Json representation is to be created. If
 	 *            this is a String, it is wrapped in an instance of
-	 *            {@link Error}.
+	 *            {@link org.eclipse.jgit.lfs.server.internal.LfsGson.Error}.
 	 * @param writer
 	 *            Writer to which the Json representation needs to be written
-	 * @throws JsonIOException
+	 * @throws com.google.gson.JsonIOException
 	 *             if there was a problem writing to the writer
 	 * @see Gson#toJson(Object, Appendable)
 	 */
 	 * @param classOfT
 	 *            specified type to deserialize
 	 * @return an Object of type T
-	 * @throws JsonIOException
+	 * @throws com.google.gson.JsonIOException
 	 *             if there was a problem reading from the Reader
-	 * @throws JsonSyntaxException
+	 * @throws com.google.gson.JsonSyntaxException
 	 *             if json is not a valid representation for an object of type
 	 * @see Gson#fromJson(Reader, java.lang.reflect.Type)
+	 * @param <T>
+	 *            a T object.
 	 */
 	public static <T> T fromJson(Reader json, Class<T> classOfT)
 			throws JsonSyntaxException, JsonIOException {

org.eclipse.jgit.lfs.server/src/org/eclipse/jgit/lfs/server/internal/LfsServerText.java

 public class LfsServerText extends TranslationBundle {
 
 	/**
+	 * Get an instance of this translation bundle
+	 *
 	 * @return an instance of this translation bundle
 	 */
 	public static LfsServerText get() {

org.eclipse.jgit.lfs.server/src/org/eclipse/jgit/lfs/server/s3/S3Config.java

 	private final boolean disableSslVerify;
 
 	/**
+	 * <p>Constructor for S3Config.</p>
+	 *
 	 * @param region
 	 *            AWS region
 	 * @param bucket
 	}
 
 	/**
+	 * Get the <code>region</code>.
+	 *
 	 * @return Get name of AWS region this bucket resides in
 	 */
 	public String getRegion() {
 	}
 
 	/**
+	 * Get the <code>bucket</code>.
+	 *
 	 * @return Get S3 storage bucket name
 	 */
 	public String getBucket() {
 	}
 
 	/**
+	 * Get the <code>storageClass</code>.
+	 *
 	 * @return S3 storage class to use for objects stored in this bucket
 	 */
 	public String getStorageClass() {
 	}
 
 	/**
+	 * Get the <code>accessKey</code>.
+	 *
 	 * @return access key for authenticating to AWS
 	 */
 	public String getAccessKey() {
 	}
 
 	/**
+	 * Get the <code>secretKey</code>.
+	 *
 	 * @return secret key for authenticating to AWS
 	 */
 	public String getSecretKey() {
 	}
 
 	/**
+	 * Get the <code>expirationSeconds</code>.
+	 *
 	 * @return period in seconds after which requests signed for this bucket
 	 *         will expire
 	 */

org.eclipse.jgit.lfs.server/src/org/eclipse/jgit/lfs/server/s3/S3Repository.java

 		this.s3Config = config;
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public Response.Action getDownloadAction(AnyLongObjectId oid) {
 		URL endpointUrl = getObjectUrl(oid);
 		return a;
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public Response.Action getUploadAction(AnyLongObjectId oid, long size) {
 		cacheObjectMetaData(oid, size);
 		return a;
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public Action getVerifyAction(AnyLongObjectId id) {
 		return null; // TODO(ms) implement this
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public long getSize(AnyLongObjectId oid) throws IOException {
 		URL endpointUrl = getObjectUrl(oid);