*/
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 {
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 {
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$
*/
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;
* 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
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() {
}
/**
+ * <p>Constructor for InvalidLongObjectIdException.</p>
+ *
* @param idString
* String containing the invalid id
*/
* 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.
*/
private static final long serialVersionUID = 1L;
/**
+ * <p>Constructor for LfsException.</p>
+ *
* @param message
* error message, which may be shown to an end-user.
*/
* 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.
*/
* 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.
*/
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));
private static final long serialVersionUID = 1L;
/**
+ * <p>Constructor for LfsRepositoryReadOnly.</p>
+ *
* @param name
* the repository name.
*/
private static final long serialVersionUID = 1L;
/**
+ * <p>Constructor for LfsUnauthorized.</p>
+ *
* @param operation
* the operation that was attempted.
* @param name
private static final long serialVersionUID = 1L;
/**
+ * Constructor for LfsUnavailable.
+ *
* @param name
* the repository name.
*/
private static final long serialVersionUID = 1L;
/**
+ * Constructor for LfsValidationError.
+ *
* @param message
* error message, which may be shown to an end-user.
*/
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();
public class LfsText extends TranslationBundle {
/**
+ * Get an instance of this translation bundle.
+ *
* @return an instance of this translation bundle
*/
public static LfsText get() {
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 >= 2. */
+ /**
+ * Get the first byte of this id
+ *
+ * @return value for a fan-out style map, only valid of length >= 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() {
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 < 0 if this id comes before other; 0 if this id is equal to
- * other; > 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
* 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.
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();
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;
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);
projects / jgit.git / commitdiff