Fix javadoc in org.eclipse.jgit.lfs

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

org.eclipse.jgit.lfs/src/org/eclipse/jgit/lfs/CleanFilter.java

  */
 public class CleanFilter extends FilterCommand {
 	/**
-	 * The factory is responsible for creating instances of {@link CleanFilter}
+	 * The factory is responsible for creating instances of
+	 * {@link org.eclipse.jgit.lfs.CleanFilter}
 	 */
 	public final static FilterCommandFactory FACTORY = new FilterCommandFactory() {
 
 	private Path tmpFile;
 
 	/**
+	 * Constructor for CleanFilter.
+	 *
 	 * @param db
 	 *            the repository
 	 * @param in
-	 *            an {@link InputStream} providing the original content
+	 *            an {@link java.io.InputStream} providing the original content
 	 * @param out
-	 *            the {@link OutputStream} into which the content of the pointer
-	 *            file should be written. That's the content which will be added
-	 *            to the git repository
-	 * @throws IOException
+	 *            the {@link java.io.OutputStream} into which the content of the
+	 *            pointer file should be written. That's the content which will
+	 *            be added to the git repository
+	 * @throws java.io.IOException
 	 *             when the creation of the temporary file fails or when no
-	 *             {@link OutputStream} for this file can be created
+	 *             {@link java.io.OutputStream} for this file can be created
 	 */
 	public CleanFilter(Repository db, InputStream in, OutputStream out)
 			throws IOException {
 		this.aOut = new AtomicObjectOutputStream(tmpFile.toAbsolutePath());
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public int run() throws IOException {
 		try {

org.eclipse.jgit.lfs/src/org/eclipse/jgit/lfs/Lfs.java

 	private Path tmpDir;
 
 	/**
+	 * Constructor for Lfs.
+	 *
 	 * @param root
 	 *            the path to the LFS media directory. Will be "<repo>/.git/lfs"
 	 */
 	}
 
 	/**
+	 * Get the LFS root directory
+	 *
 	 * @return the path to the LFS directory
 	 */
 	public Path getLfsRoot() {
 	}
 
 	/**
-	 * @return the path to the temp directory used by LFS. Will be
-	 *         "<repo>/.git/lfs/tmp"
+	 * Get the path to the temporary directory used by LFS.
+	 *
+	 * @return the path to the temporary directory used by LFS. Will be
+	 *         {@code <repo>/.git/lfs/tmp}
 	 */
 	public Path getLfsTmpDir() {
 		if (tmpDir == null) {
 	}
 
 	/**
+	 * Get the object directory used by LFS
+	 *
 	 * @return the path to the object directory used by LFS. Will be
-	 *         "<repo>/.git/lfs/objects"
+	 *         {@code <repo>/.git/lfs/objects}
 	 */
 	public Path getLfsObjDir() {
 		if (objDir == null) {
 	}
 
 	/**
+	 * Get the media file which stores the original content
+	 *
 	 * @param id
 	 *            the id of the mediafile
 	 * @return the file which stores the original content. This will be files
 	 * Create a new temp file in the LFS directory
 	 *
 	 * @return a new temporary file in the LFS directory
-	 * @throws IOException
+	 * @throws java.io.IOException
 	 *             when the temp file could not be created
 	 */
 	public Path createTmpFile() throws IOException {

org.eclipse.jgit.lfs/src/org/eclipse/jgit/lfs/LfsPointer.java

 	private long size;
 
 	/**
+	 * <p>Constructor for LfsPointer.</p>
+	 *
 	 * @param oid
 	 *            the id of the content
 	 * @param size
 	}
 
 	/**
+	 * <p>Getter for the field <code>oid</code>.</p>
+	 *
 	 * @return the id of the content
 	 */
 	public AnyLongObjectId getOid() {
 	}
 
 	/**
+	 * <p>Getter for the field <code>size</code>.</p>
+	 *
 	 * @return the size of the content
 	 */
 	public long getSize() {
 	 * Encode this object into the LFS format defined by {@link #VERSION}
 	 *
 	 * @param out
-	 *            the {@link OutputStream} into which the encoded data should be
+	 *            the {@link java.io.OutputStream} into which the encoded data should be
 	 *            written
 	 */
 	public void encode(OutputStream out) {
 	 * {@link #VERSION}
 	 *
 	 * @param in
-	 *            the {@link InputStream} from where to read the data
-	 * @return an {@link LfsPointer} or <code>null</code> if the stream was not
-	 *         parseable as LfsPointer
-	 * @throws IOException
+	 *            the {@link java.io.InputStream} from where to read the data
+	 * @return an {@link org.eclipse.jgit.lfs.LfsPointer} or <code>null</code>
+	 *         if the stream was not parseable as LfsPointer
+	 * @throws java.io.IOException
 	 */
 	@Nullable
 	public static LfsPointer parseLfsPointer(InputStream in)
 		return null;
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public String toString() {
 		return "LfsPointer: oid=" + oid.name() + ", size=" //$NON-NLS-1$ //$NON-NLS-2$

org.eclipse.jgit.lfs/src/org/eclipse/jgit/lfs/SmudgeFilter.java

  */
 public class SmudgeFilter extends FilterCommand {
 	/**
-	 * The factory is responsible for creating instances of {@link SmudgeFilter}
+	 * The factory is responsible for creating instances of
+	 * {@link org.eclipse.jgit.lfs.SmudgeFilter}
 	 */
 	public final static FilterCommandFactory FACTORY = new FilterCommandFactory() {
 		@Override
 	private Lfs lfs;
 
 	/**
+	 * Constructor for SmudgeFilter.
+	 *
 	 * @param db
+	 *            a {@link org.eclipse.jgit.lib.Repository} object.
 	 * @param in
+	 *            a {@link java.io.InputStream} object.
 	 * @param out
-	 * @throws IOException
+	 *            a {@link java.io.OutputStream} object.
+	 * @throws java.io.IOException
 	 */
 	public SmudgeFilter(Repository db, InputStream in, OutputStream out)
 			throws IOException {
 		}
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public int run() throws IOException {
 		int b;

org.eclipse.jgit.lfs/src/org/eclipse/jgit/lfs/errors/CorruptLongObjectException.java

 	 *            id of the long object
 	 * @param contentHash
 	 *            hash of the long object's content
-	 *
-	 * @param message
+	 * @param message a {@link java.lang.String} object.
 	 */
 	public CorruptLongObjectException(AnyLongObjectId id,
 			AnyLongObjectId contentHash,
 	}
 
 	/**
+	 * Get the <code>id</code> of the object.
+	 *
 	 * @return the id of the object, i.e. the expected hash of the object's
 	 *         content
 	 */
 	}
 
 	/**
+	 * Get the <code>contentHash</code>.
+	 *
 	 * @return the actual hash of the object's content which doesn't match the
 	 *         object's id when this exception is thrown which signals that the
 	 *         object has been corrupted

org.eclipse.jgit.lfs/src/org/eclipse/jgit/lfs/errors/CorruptMediaFile.java

 	private long size;
 
 	/**
-	 * @param mediaFile
-	 * @param expectedSize
-	 * @param size
+	 * <p>Constructor for CorruptMediaFile.</p>
+	 *
+	 * @param mediaFile a {@link java.nio.file.Path} object.
+	 * @param expectedSize a long.
+	 * @param size a long.
 	 */
 	@SuppressWarnings("boxing")
 	public CorruptMediaFile(Path mediaFile, long expectedSize,
 	}
 
 	/**
+	 * Get the <code>mediaFile</code>.
+	 *
 	 * @return the media file which seems to be corrupt
 	 */
 	public Path getMediaFile() {
 	}
 
 	/**
+	 * Get the <code>expectedSize</code>.
+	 *
 	 * @return the expected size of the media file
 	 */
 	public long getExpectedSize() {
 	}
 
 	/**
+	 * Get the <code>size</code>.
+	 *
 	 * @return the actual size of the media file in the file system
 	 */
 	public long getSize() {

org.eclipse.jgit.lfs/src/org/eclipse/jgit/lfs/errors/InvalidLongObjectIdException.java

 	}
 
 	/**
+	 * <p>Constructor for InvalidLongObjectIdException.</p>
+	 *
 	 * @param idString
 	 *            String containing the invalid id
 	 */

org.eclipse.jgit.lfs/src/org/eclipse/jgit/lfs/errors/LfsBandwidthLimitExceeded.java

  * Thrown when the bandwidth limit for the user or repository has been exceeded.
  *
  * @since 4.5
- *
  */
 public class LfsBandwidthLimitExceeded extends LfsException {
 	private static final long serialVersionUID = 1L;
 
 	/**
+	 * <p>Constructor for LfsBandwidthLimitExceeded.</p>
+	 *
 	 * @param message
 	 *            error message, which may be shown to an end-user.
 	 */

org.eclipse.jgit.lfs/src/org/eclipse/jgit/lfs/errors/LfsException.java

 	private static final long serialVersionUID = 1L;
 
 	/**
+	 * <p>Constructor for LfsException.</p>
+	 *
 	 * @param message
 	 *            error message, which may be shown to an end-user.
 	 */

org.eclipse.jgit.lfs/src/org/eclipse/jgit/lfs/errors/LfsInsufficientStorage.java

  * Thrown when there is insufficient storage on the server.
  *
  * @since 4.5
- *
  */
 public class LfsInsufficientStorage extends LfsException {
 	private static final long serialVersionUID = 1L;
 
 	/**
+	 * <p>Constructor for LfsInsufficientStorage.</p>
+	 *
 	 * @param message
 	 *            error message, which may be shown to an end-user.
 	 */

org.eclipse.jgit.lfs/src/org/eclipse/jgit/lfs/errors/LfsRateLimitExceeded.java

  * Thrown when the user has hit a rate limit with the server.
  *
  * @since 4.5
- *
  */
 public class LfsRateLimitExceeded extends LfsException {
 	private static final long serialVersionUID = 1L;
 
 	/**
+	 * <p>Constructor for LfsRateLimitExceeded.</p>
+	 *
 	 * @param message
 	 *            error message, which may be shown to an end-user.
 	 */

org.eclipse.jgit.lfs/src/org/eclipse/jgit/lfs/errors/LfsRepositoryNotFound.java

 	private static final long serialVersionUID = 1L;
 
 	/**
+	 * <p>Constructor for LfsRepositoryNotFound.</p>
+	 *
 	 * @param name
 	 *            the repository name.
-	 *
 	 */
 	public LfsRepositoryNotFound(String name) {
 		super(MessageFormat.format(LfsText.get().repositoryNotFound, name));

org.eclipse.jgit.lfs/src/org/eclipse/jgit/lfs/errors/LfsRepositoryReadOnly.java

 	private static final long serialVersionUID = 1L;
 
 	/**
+	 * <p>Constructor for LfsRepositoryReadOnly.</p>
+	 *
 	 * @param name
 	 *            the repository name.
 	 */

org.eclipse.jgit.lfs/src/org/eclipse/jgit/lfs/errors/LfsUnauthorized.java

 	private static final long serialVersionUID = 1L;
 
 	/**
+	 * <p>Constructor for LfsUnauthorized.</p>
+	 *
 	 * @param operation
 	 *            the operation that was attempted.
 	 * @param name

org.eclipse.jgit.lfs/src/org/eclipse/jgit/lfs/errors/LfsUnavailable.java

 	private static final long serialVersionUID = 1L;
 
 	/**
+	 * Constructor for LfsUnavailable.
+	 *
 	 * @param name
 	 *            the repository name.
 	 */

org.eclipse.jgit.lfs/src/org/eclipse/jgit/lfs/errors/LfsValidationError.java

 	private static final long serialVersionUID = 1L;
 
 	/**
+	 * Constructor for LfsValidationError.
+	 *
 	 * @param message
 	 *            error message, which may be shown to an end-user.
 	 */

org.eclipse.jgit.lfs/src/org/eclipse/jgit/lfs/internal/AtomicObjectOutputStream.java

 import org.eclipse.jgit.lfs.lib.LongObjectId;
 
 /**
- * Output stream writing content to a {@link LockFile} which is committed on
- * close(). The stream checks if the hash of the stream content matches the
- * id.
+ * Output stream writing content to a
+ * {@link org.eclipse.jgit.internal.storage.file.LockFile} which is committed on
+ * close(). The stream checks if the hash of the stream content matches the id.
  */
 public class AtomicObjectOutputStream extends OutputStream {
 
 	private AnyLongObjectId id;
 
 	/**
+	 * Constructor for AtomicObjectOutputStream.
+	 *
 	 * @param path
+	 *            a {@link java.nio.file.Path} object.
 	 * @param id
-	 * @throws IOException
+	 *            a {@link org.eclipse.jgit.lfs.lib.AnyLongObjectId} object.
+	 * @throws java.io.IOException
 	 */
 	public AtomicObjectOutputStream(Path path, AnyLongObjectId id)
 			throws IOException {
 	}
 
 	/**
+	 * Constructor for AtomicObjectOutputStream.
+	 *
 	 * @param path
-	 * @throws IOException
+	 *            a {@link java.nio.file.Path} object.
+	 * @throws java.io.IOException
 	 */
 	public AtomicObjectOutputStream(Path path) throws IOException {
 		this(path, null);
 	}
 
 	/**
+	 * Get the <code>id</code>.
+	 *
 	 * @return content hash of the object which was streamed through this
-	 *         stream. May return {@code null} if called before closing this stream.
+	 *         stream. May return {@code null} if called before closing this
+	 *         stream.
 	 */
 	public @Nullable AnyLongObjectId getId() {
 		return id;
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public void write(int b) throws IOException {
 		out.write(b);
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public void write(byte[] b) throws IOException {
 		out.write(b);
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public void write(byte[] b, int off, int len) throws IOException {
 		out.write(b, off, len);
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public void close() throws IOException {
 		out.close();

org.eclipse.jgit.lfs/src/org/eclipse/jgit/lfs/internal/LfsText.java

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

org.eclipse.jgit.lfs/src/org/eclipse/jgit/lfs/lib/AbbreviatedLongObjectId.java

 
 import org.eclipse.jgit.lfs.errors.InvalidLongObjectIdException;
 import org.eclipse.jgit.lfs.internal.LfsText;
-import org.eclipse.jgit.lib.AbbreviatedObjectId;
-import org.eclipse.jgit.lib.AnyObjectId;
-import org.eclipse.jgit.lib.ObjectId;
 import org.eclipse.jgit.util.NB;
 import org.eclipse.jgit.util.RawParseUtils;
 
 /**
- * A prefix abbreviation of an {@link LongObjectId}.
+ * A prefix abbreviation of an {@link org.eclipse.jgit.lfs.lib.LongObjectId}.
  * <p>
  * Enable abbreviating SHA-256 strings used by Git LFS, using sufficient leading
  * digits from the LongObjectId name to still be unique within the repository
  * This class converts the hex string into a binary form, to make it more
  * efficient for matching against an object.
  *
- * Ported to SHA-256 from {@link AbbreviatedObjectId}
+ * Ported to SHA-256 from {@link org.eclipse.jgit.lib.AbbreviatedObjectId}
  *
  * @since 4.3
  */
 	}
 
 	/**
-	 * Convert an AbbreviatedObjectId from an {@link AnyObjectId}.
+	 * Convert an AbbreviatedObjectId from an
+	 * {@link org.eclipse.jgit.lib.AnyObjectId}.
 	 * <p>
 	 * This method copies over all bits of the Id, and is therefore complete
 	 * (see {@link #isComplete()}).
 	 *
 	 * @param id
-	 *            the {@link ObjectId} to convert from.
+	 *            the {@link org.eclipse.jgit.lib.ObjectId} to convert from.
 	 * @return the converted object id.
 	 */
 	public static final AbbreviatedLongObjectId fromLongObjectId(
 		w4 = new_4;
 	}
 
-	/** @return number of hex digits appearing in this id */
+	/**
+	 * Get length
+	 *
+	 * @return number of hex digits appearing in this id.
+	 */
 	public int length() {
 		return nibbles;
 	}
 
-	/** @return true if this ObjectId is actually a complete id. */
+	/**
+	 * Check if this id is complete
+	 *
+	 * @return true if this ObjectId is actually a complete id.
+	 */
 	public boolean isComplete() {
 		return length() == Constants.LONG_OBJECT_ID_STRING_LENGTH;
 	}
 
-	/** @return a complete ObjectId; null if {@link #isComplete()} is false */
+	/**
+	 * Convert to LongObjectId
+	 *
+	 * @return a complete ObjectId; null if {@link #isComplete()} is false.
+	 */
 	public LongObjectId toLongObjectId() {
 		return isComplete() ? new LongObjectId(w1, w2, w3, w4) : null;
 	}
 		return NB.compareUInt64(w4, mask(4, bs[p + 3]));
 	}
 
-	/** @return value for a fan-out style map, only valid of length &gt;= 2. */
+	/**
+	 * Get the first byte of this id
+	 *
+	 * @return value for a fan-out style map, only valid of length &gt;= 2.
+	 */
 	public final int getFirstByte() {
 		return (int) (w1 >>> 56);
 	}
 		return mask(nibbles, word, v);
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public int hashCode() {
 		return (int) (w1 >> 32);
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public boolean equals(final Object o) {
 		if (o instanceof AbbreviatedLongObjectId) {
 	}
 
 	/**
+	 * <p>name.</p>
+	 *
 	 * @return string form of the abbreviation, in lower case hexadecimal.
 	 */
 	public final String name() {
 		return new String(b, 0, nibbles);
 	}
 
+	/** {@inheritDoc} */
 	@SuppressWarnings("nls")
 	@Override
 	public String toString() {

org.eclipse.jgit.lfs/src/org/eclipse/jgit/lfs/lib/AnyLongObjectId.java

 import java.nio.ByteBuffer;
 
 import org.eclipse.jgit.lib.AnyObjectId;
-import org.eclipse.jgit.lib.ObjectReader;
 import org.eclipse.jgit.util.NB;
 
 /**
  * A (possibly mutable) SHA-256 abstraction.
  * <p>
- * If this is an instance of {@link MutableLongObjectId} the concept of equality
+ * If this is an instance of
+ * {@link org.eclipse.jgit.lfs.lib.MutableLongObjectId} the concept of equality
  * with this instance can alter at any time, if this instance is modified to
  * represent a different object name.
  *
- * Ported to SHA-256 from {@link AnyObjectId}
+ * Ported to SHA-256 from {@link org.eclipse.jgit.lib.AnyObjectId}
  *
  * @since 4.3
  */
 	 * @param index
 	 *            index of the byte to obtain from the raw form of the
 	 *            LongObjectId. Must be in range [0,
-	 *            {@link Constants#LONG_OBJECT_ID_LENGTH}).
+	 *            {@link org.eclipse.jgit.lfs.lib.Constants#LONG_OBJECT_ID_LENGTH}).
 	 * @return the value of the requested byte at {@code index}. Returned values
 	 *         are unsigned and thus are in the range [0,255] rather than the
 	 *         signed byte range of [-128, 127].
-	 * @throws ArrayIndexOutOfBoundsException
+	 * @throws java.lang.ArrayIndexOutOfBoundsException
 	 *             {@code index} is less than 0, equal to
-	 *             {@link Constants#LONG_OBJECT_ID_LENGTH}, or greater than
-	 *             {@link Constants#LONG_OBJECT_ID_LENGTH}.
+	 *             {@link org.eclipse.jgit.lfs.lib.Constants#LONG_OBJECT_ID_LENGTH},
+	 *             or greater than
+	 *             {@link org.eclipse.jgit.lfs.lib.Constants#LONG_OBJECT_ID_LENGTH}.
 	 */
 	public final int getByte(int index) {
 		long w;
 	}
 
 	/**
-	 * Compare this LongObjectId to another and obtain a sort ordering.
+	 * {@inheritDoc}
 	 *
-	 * @param other
-	 *            the other id to compare to. Must not be null.
-	 * @return &lt; 0 if this id comes before other; 0 if this id is equal to
-	 *         other; &gt; 0 if this id comes after other.
+	 * Compare this LongObjectId to another and obtain a sort ordering.
 	 */
 	@Override
 	public final int compareTo(final AnyLongObjectId other) {
 		return abbr.prefixCompare(this) == 0;
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public final int hashCode() {
 		return (int) (w1 >> 32);
 		return other != null ? equals(this, other) : false;
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public final boolean equals(final Object o) {
 		if (o instanceof AnyLongObjectId)
 	 *
 	 * @param w
 	 *            the stream to write to.
-	 * @throws IOException
+	 * @throws java.io.IOException
 	 *             the stream writing failed.
 	 */
 	public void copyRawTo(final OutputStream w) throws IOException {
 	 *
 	 * @param w
 	 *            the stream to copy to.
-	 * @throws IOException
+	 * @throws java.io.IOException
 	 *             the stream writing failed.
 	 */
 	public void copyTo(final OutputStream w) throws IOException {
 	 *
 	 * @param w
 	 *            the stream to copy to.
-	 * @throws IOException
+	 * @throws java.io.IOException
 	 *             the stream writing failed.
 	 */
 	public void copyTo(final Writer w) throws IOException {
 	 *            of object id (64 characters or larger).
 	 * @param w
 	 *            the stream to copy to.
-	 * @throws IOException
+	 * @throws java.io.IOException
 	 *             the stream writing failed.
 	 */
 	public void copyTo(final char[] tmp, final Writer w) throws IOException {
 			dst[o--] = '0';
 	}
 
+	/** {@inheritDoc} */
 	@SuppressWarnings("nls")
 	@Override
 	public String toString() {
 	}
 
 	/**
+	 * Get string form of the SHA-256
+	 *
 	 * @return string form of the SHA-256, in lower case hexadecimal.
 	 */
 	public final String name() {
 	}
 
 	/**
+	 * Get string form of the SHA-256
+	 *
 	 * @return string form of the SHA-256, in lower case hexadecimal.
 	 */
 	public final String getName() {
 	 * Return an abbreviation (prefix) of this object SHA-256.
 	 * <p>
 	 * This implementation does not guarantee uniqueness. Callers should instead
-	 * use {@link ObjectReader#abbreviate(AnyObjectId, int)} to obtain a unique
-	 * abbreviation within the scope of a particular object database.
+	 * use
+	 * {@link org.eclipse.jgit.lib.ObjectReader#abbreviate(AnyObjectId, int)} to
+	 * obtain a unique abbreviation within the scope of a particular object
+	 * database.
 	 *
 	 * @param len
 	 *            length of the abbreviated string.
 	 * Obtain an immutable copy of this current object.
 	 * <p>
 	 * Only returns <code>this</code> if this instance is an unsubclassed
-	 * instance of {@link LongObjectId}; otherwise a new instance is returned
-	 * holding the same value.
+	 * instance of {@link org.eclipse.jgit.lfs.lib.LongObjectId}; otherwise a
+	 * new instance is returned holding the same value.
 	 * <p>
 	 * This method is useful to shed any additional memory that may be tied to
 	 * the subclass, yet retain the unique identity of the object id for future

org.eclipse.jgit.lfs/src/org/eclipse/jgit/lfs/lib/Constants.java

  * Misc. constants used throughout JGit LFS extension.
  *
  * @since 4.3
- **/
+ */
 @SuppressWarnings("nls")
 public final class Constants {
 	/**
 	 * Create a new digest function for objects.
 	 *
 	 * @return a new digest object.
-	 * @throws RuntimeException
+	 * @throws java.lang.RuntimeException
 	 *             this Java virtual machine does not support the required hash
 	 *             function. Very unlikely given that JGit uses a hash function
 	 *             that is in the Java reference specification.

org.eclipse.jgit.lfs/src/org/eclipse/jgit/lfs/lib/LfsPointerFilter.java

 	private LfsPointer pointer;
 
 	/**
-	 * @return {@link LfsPointer} or {@code null}
+	 * Get the field <code>pointer</code>.
+	 *
+	 * @return {@link org.eclipse.jgit.lfs.LfsPointer} or {@code null}
 	 */
 	public LfsPointer getPointer() {
 		return pointer;
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public boolean include(TreeWalk walk) throws MissingObjectException,
 			IncorrectObjectTypeException, IOException {
 		}
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public boolean shouldBeRecursive() {
 		return false;
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public TreeFilter clone() {
 		return new LfsPointerFilter();

org.eclipse.jgit.lfs/src/org/eclipse/jgit/lfs/lib/LongObjectId.java

 import java.io.Serializable;
 
 import org.eclipse.jgit.lfs.errors.InvalidLongObjectIdException;
-import org.eclipse.jgit.lib.ObjectId;
 import org.eclipse.jgit.util.NB;
 import org.eclipse.jgit.util.RawParseUtils;
 
 /**
  * A SHA-256 abstraction.
  *
- * Ported to SHA-256 from {@link ObjectId}
+ * Ported to SHA-256 from {@link org.eclipse.jgit.lib.ObjectId}
  *
  * @since 4.3
  */
 		w4 = src.w4;
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public LongObjectId toObjectId() {
 		return this;

org.eclipse.jgit.lfs/src/org/eclipse/jgit/lfs/lib/MutableLongObjectId.java

 
 import org.eclipse.jgit.lfs.errors.InvalidLongObjectIdException;
 import org.eclipse.jgit.lfs.internal.LfsText;
-import org.eclipse.jgit.lib.MutableObjectId;
 import org.eclipse.jgit.util.NB;
 import org.eclipse.jgit.util.RawParseUtils;
 
 /**
  * A mutable SHA-256 abstraction.
  *
- * Ported to SHA-256 from {@link MutableObjectId}
+ * Ported to SHA-256 from {@link org.eclipse.jgit.lib.MutableObjectId}
  *
  * @since 4.3
  */
 	 *
 	 * @param index
 	 *            index of the byte to set in the raw form of the ObjectId. Must
-	 *            be in range [0, {@link Constants#LONG_OBJECT_ID_LENGTH}).
+	 *            be in range [0,
+	 *            {@link org.eclipse.jgit.lfs.lib.Constants#LONG_OBJECT_ID_LENGTH}).
 	 * @param value
 	 *            the value of the specified byte at {@code index}. Values are
 	 *            unsigned and thus are in the range [0,255] rather than the
 	 *            signed byte range of [-128, 127].
-	 * @throws ArrayIndexOutOfBoundsException
+	 * @throws java.lang.ArrayIndexOutOfBoundsException
 	 *             {@code index} is less than 0, equal to
-	 *             {@link Constants#LONG_OBJECT_ID_LENGTH}, or greater than
-	 *             {@link Constants#LONG_OBJECT_ID_LENGTH}.
+	 *             {@link org.eclipse.jgit.lfs.lib.Constants#LONG_OBJECT_ID_LENGTH},
+	 *             or greater than
+	 *             {@link org.eclipse.jgit.lfs.lib.Constants#LONG_OBJECT_ID_LENGTH}.
 	 */
 	public void setByte(int index, int value) {
 		switch (index >> 3) {
 		}
 	}
 
-	/** Make this id match {@link LongObjectId#zeroId()}. */
+	/**
+	 * Make this id match
+	 * {@link org.eclipse.jgit.lfs.lib.LongObjectId#zeroId()}.
+	 */
 	public void clear() {
 		w1 = 0;
 		w2 = 0;
 	}
 
 	/**
-	 * Copy an LongObjectId into this mutable buffer.
+	 * Copy a LongObjectId into this mutable buffer.
 	 *
 	 * @param src
 	 *            the source id to copy from.
 	}
 
 	/**
-	 * Convert an LongObjectId from raw binary representation.
+	 * Convert a LongObjectId from raw binary representation.
 	 *
 	 * @param bs
 	 *            the raw byte buffer to read from. At least 32 bytes must be
 	}
 
 	/**
-	 * Convert an LongObjectId from raw binary representation.
+	 * Convert a LongObjectId from raw binary representation.
 	 *
 	 * @param bs
 	 *            the raw byte buffer to read from. At least 32 bytes after p
 	}
 
 	/**
-	 * Convert an LongObjectId from binary representation expressed in integers.
+	 * Convert a LongObjectId from binary representation expressed in integers.
 	 *
 	 * @param longs
 	 *            the raw long buffer to read from. At least 4 longs must be
 	}
 
 	/**
-	 * Convert an LongObjectId from binary representation expressed in longs.
+	 * Convert a LongObjectId from binary representation expressed in longs.
 	 *
 	 * @param longs
 	 *            the raw int buffer to read from. At least 4 longs after p must
 	 *            be available within this longs array.
 	 * @param p
 	 *            position to read the first integer of data from.
-	 *
 	 */
 	public void fromRaw(final long[] longs, final int p) {
 		w1 = longs[p];
 	}
 
 	/**
-	 * Convert an LongObjectId from hex characters (US-ASCII).
+	 * Convert a LongObjectId from hex characters (US-ASCII).
 	 *
 	 * @param buf
 	 *            the US-ASCII buffer to read from. At least 32 bytes after
 	}
 
 	/**
-	 * Convert an LongObjectId from hex characters.
+	 * Convert a LongObjectId from hex characters.
 	 *
 	 * @param str
 	 *            the string to read from. Must be 64 characters long.
 		}
 	}
 
+	/** {@inheritDoc} */
 	@Override
 	public LongObjectId toObjectId() {
 		return new LongObjectId(this);