* first parsed version string.
* @param b
* second parsed version string.
- * @return <0 if a is before b; 0 if a equals b; >0 if a is after b.
+ * @return < 0 if a is before b; 0 if a equals b; >0 if a is after b.
*/
public static int compare(int[] a, int[] b) {
for (int i = 0; i < a.length && i < b.length; i++) {
* <li>Commit graph and short message</li>
* <li>Author name and email address</li>
* <li>Author date and time</li>
- * </ul>
+ * </ol>
*/
public class CommitGraphPane extends JTable {
private static final long serialVersionUID = 1L;
* @return if there's a tag that points to the commit being described, this
* tag name is returned. Otherwise additional suffix is added to the
* nearest tag, just like git-describe(1).
- * <p/>
+ * <p>
* If none of the ancestors of the commit being described has any
* tags at all, then this method returns null, indicating that
* there's no way to describe this tag.
/**
* The modes available for fast forward merges corresponding to the
* <code>--ff</code>, <code>--no-ff</code> and <code>--ff-only</code>
- * options under <code>branch.<name>.mergeoptions</code>.
+ * options under <code>branch.<name>.mergeoptions</code>.
*/
public enum FastForwardMode implements ConfigEnum {
/**
*
* @param ffMode
* the <code>FastForwardMode</code> value to be mapped
- * @return the mapped code>FastForwardMode.Merge</code> value
+ * @return the mapped <code>FastForwardMode.Merge</code> value
*/
public static Merge valueOf(FastForwardMode ffMode) {
switch (ffMode) {
*
* @param ffMode
* the <code>FastForwardMode.Merge</code> value to be mapped
- * @return the mapped code>FastForwardMode</code> value
+ * @return the mapped <code>FastForwardMode</code> value
*/
public static FastForwardMode valueOf(FastForwardMode.Merge ffMode) {
switch (ffMode) {
* file to a two-dimensional int-array of line-numbers telling where in the
* file conflict markers for which merged commit can be found.
* <p>
- * If the returned value contains a mapping "path"->[x][y]=z then this means
+ * If the returned value contains a mapping "path"->[x][y]=z then this
+ * means
* <ul>
* <li>the file with path "path" contains conflicts</li>
- * <li>if y < "number of merged commits": for conflict number x in this file
- * the chunk which was copied from commit number y starts on line number z.
- * All numberings and line numbers start with 0.</li>
+ * <li>if y < "number of merged commits": for conflict number x in this
+ * file the chunk which was copied from commit number y starts on line
+ * number z. All numberings and line numbers start with 0.</li>
* <li>if y == "number of merged commits": the first non-conflicting line
* after conflict number x starts at line number z</li>
* </ul>
* <p>
* Example code how to parse this data:
- * <pre> MergeResult m=...;
- * Map<String, int[][]> allConflicts = m.getConflicts();
+ *
+ * <pre>
+ * MergeResult m=...;
+ * Map<String, int[][]> allConflicts = m.getConflicts();
* for (String path : allConflicts.keySet()) {
* int[][] c = allConflicts.get(path);
* System.out.println("Conflicts in file " + path);
* for (int i = 0; i < c.length; ++i) {
* System.out.println(" Conflict #" + i);
- * for (int j = 0; j < (c[i].length) - 1; ++j) {
+ * for (int j = 0; j < (c[i].length) - 1; ++j) {
* if (c[i][j] >= 0)
* System.out.println(" Chunk for "
* + m.getMergedCommits()[j] + " starts on line #"
* + c[i][j]);
* }
* }
- * }</pre>
+ * }
+ * </pre>
*
* @return the conflicts or <code>null</code> if no conflict occurred
*/
/**
* Set if rebase should be used after fetching. If set to true, rebase is
- * used instead of merge. This is equivalent to --rebase on the command line.
- * <p/>
- * If set to false, merge is used after fetching, overriding the configuration
- * file. This is equivalent to --no-rebase on the command line.
- * <p/>
- * This setting overrides the settings in the configuration file.
- * By default, the setting in the repository configuration file is used.
- * <p/>
- * A branch can be configured to use rebase by default.
- * See branch.[name].rebase and branch.autosetuprebase.
+ * used instead of merge. This is equivalent to --rebase on the command
+ * line.
+ * <p>
+ * If set to false, merge is used after fetching, overriding the
+ * configuration file. This is equivalent to --no-rebase on the command
+ * line.
+ * <p>
+ * This setting overrides the settings in the configuration file. By
+ * default, the setting in the repository configuration file is used.
+ * <p>
+ * A branch can be configured to use rebase by default. See
+ * branch.[name].rebase and branch.autosetuprebase.
*
* @param useRebase
* @return {@code this}
* <li><i>file modify</i>: always {@link #getOldPath()}</li>
* <li><i>file delete</i>: always <code>/dev/null</code></li>
* <li><i>file copy</i>: destination file the copy ends up at</li>
- * <li><i>file rename</i>: destination file the rename ends up at/li>
+ * <li><i>file rename</i>: destination file the rename ends up at</li>
* </ul>
*
* @return new name for this file.
* <pre>
* TreeFilter filterA = ...;
* TreeFilter filterB = ...;
- * List<DiffEntry> entries = DiffEntry.scan(walk, false, filterA, filterB);
+ * List<DiffEntry> entries = DiffEntry.scan(walk, false, filterA, filterB);
* DiffEntry entry = entries.get(0);
* boolean filterAMatched = entry.isMarked(0);
* boolean filterBMatched = entry.isMarked(1);
* Regions should be specified using 0 based notation, so add 1 to the start and
* end marks for line numbers in a file.
* <p>
- * An edit where <code>beginA == endA && beginB < endB</code> is an insert edit,
- * that is sequence B inserted the elements in region
+ * An edit where <code>beginA == endA && beginB < endB</code> is an insert
+ * edit, that is sequence B inserted the elements in region
* <code>[beginB, endB)</code> at <code>beginA</code>.
* <p>
- * An edit where <code>beginA < endA && beginB == endB</code> is a delete edit,
- * that is sequence B has removed the elements between
+ * An edit where <code>beginA < endA && beginB == endB</code> is a delete
+ * edit, that is sequence B has removed the elements between
* <code>[beginA, endA)</code>.
* <p>
- * An edit where <code>beginA < endA && beginB < endB</code> is a replace edit,
- * that is sequence B has replaced the range of elements between
+ * An edit where <code>beginA < endA && beginB < endB</code> is a replace
+ * edit, that is sequence B has replaced the range of elements between
* <code>[beginA, endA)</code> with those found in <code>[beginB, endB)</code>.
*/
public class Edit {
* @param as
* beginA: start of region in sequence A; 0 based.
* @param ae
- * endA: end of region in sequence A; must be >= as.
+ * endA: end of region in sequence A; must be >= as.
* @param bs
* beginB: start of region in sequence B; 0 based.
* @param be
- * endB: end of region in sequence B; must be >= bs.
+ * endB: end of region in sequence B; must be > = bs.
*/
public Edit(final int as, final int ae, final int bs, final int be) {
beginA = as;
}
/**
- * Calculates the differences between a given part of A against another given part of B
- * @param beginA start of the part of A which should be compared (0<=beginA<sizeof(A))
- * @param endA end of the part of A which should be compared (beginA<=endA<sizeof(A))
- * @param beginB start of the part of B which should be compared (0<=beginB<sizeof(B))
- * @param endB end of the part of B which should be compared (beginB<=endB<sizeof(B))
+ * Calculates the differences between a given part of A against another
+ * given part of B
+ *
+ * @param beginA
+ * start of the part of A which should be compared
+ * (0<=beginA<sizeof(A))
+ * @param endA
+ * end of the part of A which should be compared
+ * (beginA<=endA<sizeof(A))
+ * @param beginB
+ * start of the part of B which should be compared
+ * (0<=beginB<sizeof(B))
+ * @param endB
+ * end of the part of B which should be compared
+ * (beginB<=endB<sizeof(B))
*/
protected void calculateEdits(int beginA, int endA,
int beginB, int endB) {
}
/**
- * Locate the position a path's entry is at in the index.
- * For details refer to #findEntry(byte[], int).
+ * Locate the position a path's entry is at in the index. For details refer
+ * to #findEntry(byte[], int).
*
* @param path
* the path to search for.
- * @return if >= 0 then the return value is the position of the entry in the
- * index; pass to {@link #getEntry(int)} to obtain the entry
- * information. If < 0 the entry does not exist in the index.
+ * @return if >= 0 then the return value is the position of the entry in
+ * the index; pass to {@link #getEntry(int)} to obtain the entry
+ * information. If < 0 the entry does not exist in the index.
*/
public int findEntry(final String path) {
final byte[] p = Constants.encode(path);
* the byte array starting with the path to search for.
* @param pLen
* the length of the path in bytes
- * @return if >= 0 then the return value is the position of the entry in the
- * index; pass to {@link #getEntry(int)} to obtain the entry
- * information. If < 0 the entry does not exist in the index.
+ * @return if >= 0 then the return value is the position of the entry in
+ * the index; pass to {@link #getEntry(int)} to obtain the entry
+ * information. If < 0 the entry does not exist in the index.
* @since 3.4
*/
public int findEntry(final byte[] p, final int pLen) {
* returned tree identity.
* @return identity for the root tree.
* @throws UnmergedPathException
- * one or more paths contain higher-order stages (stage > 0),
+ * one or more paths contain higher-order stages (stage > 0),
* which cannot be stored in a tree object.
* @throws IllegalStateException
* one or more paths contain an invalid mode which should never
* <p>
* Note that this is the length of the file in the working directory, which
* may differ from the size of the decompressed blob if work tree filters
- * are being used, such as LF<->CRLF conversion.
+ * are being used, such as LF<->CRLF conversion.
* <p>
* Note also that for very large files, this is the size of the on-disk file
* truncated to 32 bits, i.e. modulo 4294967296. If that value is larger
* </ul>
* e. g. [[:xdigit:]]</li>
* </ul>
- * </p>
* Any character can be escaped by prepending it with a \
*/
public class FileNameMatcher {
* <li>by providing iterator of {@link RevObject} specifying exact list and
* order of objects in pack</li>
* </ul>
+ * <p>
* Typical usage consists of creating instance intended for some pack,
* configuring options, preparing the list of objects by calling
* {@link #preparePack(Iterator)} or
* {@link #preparePack(ProgressMonitor, Collection, Collection)}, and finally
- * producing the stream with {@link #writePack(ProgressMonitor, ProgressMonitor, OutputStream)}.
+ * producing the stream with
+ * {@link #writePack(ProgressMonitor, ProgressMonitor, OutputStream)}.
* </p>
* <p>
* Class provide set of configurable options and {@link ProgressMonitor}
return NB.compareUInt32(w5, mask(5, bs[p + 4]));
}
- /** @return value for a fan-out style map, only valid of length >= 2. */
+ /** @return value for a fan-out style map, only valid of length >= 2. */
public final int getFirstByte() {
return w1 >>> 24;
}
*
* @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.
+ * @return < 0 if this id comes before other; 0 if this id is equal to
+ * other; > 0 if this id comes after other.
*/
public final int compareTo(final AnyObjectId other) {
if (this == other)
/** Permissible values for {@code core.autocrlf}. */
public static enum AutoCRLF {
- /** Automatic CRLF->LF conversion is disabled. */
+ /** Automatic CRLF->LF conversion is disabled. */
FALSE,
- /** Automatic CRLF->LF conversion is enabled. */
+ /** Automatic CRLF->LF conversion is enabled. */
TRUE,
- /** CRLF->LF performed, but no LF->CRLF. */
+ /** CRLF->LF performed, but no LF->CRLF. */
INPUT;
}
/**
* Sorts the collection of refs, returning a new collection.
- *
+ *
* @param refs
* collection to be sorted
* @return sorted collection of refs
/**
* Compare a reference to a name.
- *
+ *
* @param o1
* the reference instance.
* @param o2
* the name to compare to.
- * @return standard Comparator result of < 0, 0, > 0.
+ * @return standard Comparator result of < 0, 0, > 0.
*/
public static int compareTo(Ref o1, String o2) {
return o1.getName().compareTo(o2);
/**
* Compare two references by name.
- *
+ *
* @param o1
* the reference instance.
* @param o2
* the other reference instance.
- * @return standard Comparator result of < 0, 0, > 0.
+ * @return standard Comparator result of < 0, 0, > 0.
*/
public static int compareTo(final Ref o1, final Ref o2) {
return o1.getName().compareTo(o2.getName());
* @param lasta '/' if a is a tree, else NUL
* @param lastb '/' if b is a tree, else NUL
*
- * @return < 0 if a is sorted before b, 0 if they are the same, else b
+ * @return < 0 if a is sorted before b, 0 if they are the same, else b
*/
public static final int compareNames(final byte[] a, final byte[] b, final int lasta,final int lastb) {
return compareNames(a, b, 0, b.length, lasta, lastb);
}
/**
- * Add a link to a submodule commit, mode is {@link #GITLINK}.
+ * Add a link to a submodule commit, mode is {@link FileMode#GITLINK}.
*
* @param name
* name of the entry.
}
/**
- * Add a subtree, mode is {@link #TREE}.
+ * Add a subtree, mode is {@link FileMode#TREE}.
*
* @param name
* name of the entry.
}
/**
- * Add a regular file, mode is {@link #REGULAR_FILE}.
+ * Add a regular file, mode is {@link FileMode#REGULAR_FILE}.
*
* @param name
* name of the entry.
* the merge result which should be presented
* @param seqName
* When a conflict is reported each conflicting range will get a
- * name. This name is following the "<<<<<<< " or ">>>>>>> "
+ * name. This name is following the "<<<<<<< " or ">>>>>>> "
* conflict markers. The names for the sequences are given in
* this list
* @param charsetName
* Extract the email address (if present) from the footer.
* <p>
* If there is an email address looking string inside of angle brackets
- * (e.g. "<a@b>"), the return value is the part extracted from inside the
+ * (e.g. "<a@b>"), the return value is the part extracted from inside the
* brackets. If no brackets are found, then {@link #getValue()} is returned
* if the value contains an '@' sign. Otherwise, null.
*
* walker specified by {@link #source(RevWalk)} is pumped until the
* specified commit is loaded. Callers can test the final size of the list
* by {@link #size()} to determine if the high water mark specified was met.
- * <p/>
+ * <p>
+ *
* @param commitToLoad
* commit the caller wants this list to contain when the fill
* operation is complete.
* Default setting: 0 (auto-detect processors)
*
* @param threads
- * number of threads to use. If <= 0 the number of available
+ * number of threads to use. If <= 0 the number of available
* processors for this JVM is used.
*/
public void setThreads(int threads) {
/**
* This URI like construct used for referencing Git archives over the net, as
* well as locally stored archives. It is similar to RFC 2396 URI's, but also
- * support SCP and the malformed file://<path> syntax (as opposed to the correct
- * file:<path> syntax.
+ * support SCP and the malformed file://<path> syntax (as opposed to the correct
+ * file:<path> syntax.
*/
public class URIish implements Serializable {
/**
/**
* Get the "humanish" part of the path. Some examples of a 'humanish' part
* for a full path:
- * <table>
+ * <table summary="path vs humanish path" border="1">
* <tr>
* <th>Path</th>
* <th>Humanish part</th>
/**
* @return the parent of this tree parser
- * @internal
+ * @deprecated internal use only
*/
public CanonicalTreeParser getParent() {
return (CanonicalTreeParser) parent;
* end with '/' prior to invocation.
* @param pLen
* number of bytes from <code>buf</code> to test.
- * @return < 0 if p is before the current path; 0 if p matches the current
+ * @return < 0 if p is before the current path; 0 if p matches the current
* path; 1 if the current path is past p and p will never match
* again on this tree walk.
*/
* the method fails. Furthermore if the destination exists and is a file
* then the file will be deleted and then the rename is retried.
* <p>
- * This operation is <em>not</me> atomic.
+ * This operation is <em>not</em> atomic.
*
* @see FS#retryFailedLockFileCommit()
* @param src
* @param fd
* the stream to skip bytes from.
* @param toSkip
- * total number of bytes to be discarded. Must be >= 0.
+ * total number of bytes to be discarded. Must be >= 0.
* @throws EOFException
* the stream ended before the requested number of bytes were
* skipped.
package org.eclipse.jgit.util;
-/** A more efficient List<Integer> using a primitive integer array. */
+/** A more efficient List<Integer> using a primitive integer array. */
public class IntList {
private int[] entries;
import java.util.Arrays;
-/** A more efficient List<Long> using a primitive long array. */
+/** A more efficient List<Long> using a primitive long array. */
public class LongList {
private long[] entries;
* the first value to compare.
* @param b
* the second value to compare.
- * @return < 0 if a < b; 0 if a == b; > 0 if a > b.
+ * @return < 0 if a < b; 0 if a == b; > 0 if a > b.
*/
public static int compareUInt32(final int a, final int b) {
final int cmp = (a >>> 1) - (b >>> 1);
* Decode a region of the buffer under the ISO-8859-1 encoding.
*
* Each byte is treated as a single character in the 8859-1 character
- * encoding, performing a raw binary->char conversion.
+ * encoding, performing a raw binary->char conversion.
*
* @param buffer
* buffer to pull raw bytes from.
*
* @param timeout
* number of milliseconds before the interrupt should trigger.
- * Must be > 0.
+ * Must be > 0.
*/
public void begin(final int timeout) {
if (timeout <= 0)
/**
* @param millis
- * number of milliseconds before aborting a read. Must be > 0.
+ * number of milliseconds before aborting a read. Must be > 0.
*/
public void setTimeout(final int millis) {
if (millis < 0)
/**
* @param millis
- * number of milliseconds before aborting a write. Must be > 0.
+ * number of milliseconds before aborting a write. Must be > 0.
*/
public void setTimeout(final int millis) {
if (millis < 0)
projects / jgit.git / commitdiff