Codota Logo
RevCommitList.size
Code IndexAdd Codota to your IDE (free)

How to use
size
method
in
org.eclipse.jgit.revwalk.RevCommitList

Best Java code snippets using org.eclipse.jgit.revwalk.RevCommitList.size (Showing top 20 results out of 315)

  • Add the Codota plugin to your IDE and get smart completions
private void myMethod () {
OutputStreamWriter o =
  • Codota IconOutputStream out;new OutputStreamWriter(out)
  • Codota IconOutputStream out;String charsetName;new OutputStreamWriter(out, charsetName)
  • Codota IconHttpURLConnection connection;new OutputStreamWriter(connection.getOutputStream())
  • Smart code suggestions by Codota
}
origin: org.eclipse.jgit/org.eclipse.jgit

/**
 * Find the next commit that has the given flag set.
 *
 * @param flag
 *            the flag to test commits against.
 * @param begin
 *            first commit index to test at. Applications may wish to begin
 *            at 0, to test the first commit in the list.
 * @return index of the first commit at or after index <code>begin</code>
 *         that has the specified flag set on it; -1 if no match is found.
 */
public int indexOf(RevFlag flag, int begin) {
  while (begin < size()) {
    int index = begin;
    Block s = contents;
    while (s.shift > 0) {
      final int i = index >> s.shift;
      index -= i << s.shift;
      s = (Block) s.contents[i];
    }
    while (begin++ < size() && index < BLOCK_SIZE) {
      final RevCommit c = (RevCommit) s.contents[index++];
      if (c.has(flag))
        return begin;
    }
  }
  return -1;
}
origin: org.eclipse.jgit/org.eclipse.jgit

/**
 * Remove the given flag from all commits.
 * <p>
 * Same as <code>clearFlag(flag, 0, size())</code>, but without the
 * incremental behavior.
 *
 * @param flag
 *            the flag to remove. Applications are responsible for
 *            allocating this flag from the source RevWalk.
 */
public void clearFlag(RevFlag flag) {
  clearFlag(flag, 0, size());
}
origin: org.eclipse.jgit/org.eclipse.jgit

  throws MissingObjectException, IncorrectObjectTypeException,
  IOException {
applyFlag(matching, flag, 0, size());
origin: org.eclipse.jgit/org.eclipse.jgit

/**
 * Find the next commit that has the given flag set.
 *
 * @param flag
 *            the flag to test commits against.
 * @param begin
 *            first commit index to test at. Applications may wish to begin
 *            at <code>size()-1</code>, to test the last commit in the
 *            list.
 * @return index of the first commit at or before index <code>begin</code>
 *         that has the specified flag set on it; -1 if no match is found.
 */
public int lastIndexOf(RevFlag flag, int begin) {
  begin = Math.min(begin, size() - 1);
  while (begin >= 0) {
    int index = begin;
    Block s = contents;
    while (s.shift > 0) {
      final int i = index >> s.shift;
      index -= i << s.shift;
      s = (Block) s.contents[i];
    }
    while (begin-- >= 0 && index >= 0) {
      final RevCommit c = (RevCommit) s.contents[index--];
      if (c.has(flag))
        return begin;
    }
  }
  return -1;
}
origin: org.eclipse.jgit/org.eclipse.jgit

  IncorrectObjectTypeException, IOException {
final RevWalk w = flag.getRevWalk();
rangeEnd = Math.min(rangeEnd, size());
while (rangeBegin < rangeEnd) {
  int index = rangeBegin;
origin: berlam/github-bucket

/**
 * Remove the given flag from all commits.
 * <p>
 * Same as <code>clearFlag(flag, 0, size())</code>, but without the
 * incremental behavior.
 *
 * @param flag
 *            the flag to remove. Applications are responsible for
 *            allocating this flag from the source RevWalk.
 */
public void clearFlag(RevFlag flag) {
  clearFlag(flag, 0, size());
}
origin: theonedev/onedev

/**
 * Find the next commit that has the given flag set.
 *
 * @param flag
 *            the flag to test commits against.
 * @param begin
 *            first commit index to test at. Applications may wish to begin
 *            at 0, to test the first commit in the list.
 * @return index of the first commit at or after index <code>begin</code>
 *         that has the specified flag set on it; -1 if no match is found.
 */
public int indexOf(RevFlag flag, int begin) {
  while (begin < size()) {
    int index = begin;
    Block s = contents;
    while (s.shift > 0) {
      final int i = index >> s.shift;
      index -= i << s.shift;
      s = (Block) s.contents[i];
    }
    while (begin++ < size() && index < BLOCK_SIZE) {
      final RevCommit c = (RevCommit) s.contents[index++];
      if (c.has(flag))
        return begin;
    }
  }
  return -1;
}
origin: sonia.jgit/org.eclipse.jgit

/**
 * Remove the given flag from all commits.
 * <p>
 * Same as <code>clearFlag(flag, 0, size())</code>, but without the
 * incremental behavior.
 *
 * @param flag
 *            the flag to remove. Applications are responsible for
 *            allocating this flag from the source RevWalk.
 */
public void clearFlag(final RevFlag flag) {
  clearFlag(flag, 0, size());
}
origin: theonedev/onedev

/**
 * Remove the given flag from all commits.
 * <p>
 * Same as <code>clearFlag(flag, 0, size())</code>, but without the
 * incremental behavior.
 *
 * @param flag
 *            the flag to remove. Applications are responsible for
 *            allocating this flag from the source RevWalk.
 */
public void clearFlag(RevFlag flag) {
  clearFlag(flag, 0, size());
}
origin: sonia.jgit/org.eclipse.jgit

/**
 * Find the next commit that has the given flag set.
 *
 * @param flag
 *            the flag to test commits against.
 * @param begin
 *            first commit index to test at. Applications may wish to begin
 *            at 0, to test the first commit in the list.
 * @return index of the first commit at or after index <code>begin</code>
 *         that has the specified flag set on it; -1 if no match is found.
 */
public int indexOf(final RevFlag flag, int begin) {
  while (begin < size()) {
    int index = begin;
    Block s = contents;
    while (s.shift > 0) {
      final int i = index >> s.shift;
      index -= i << s.shift;
      s = (Block) s.contents[i];
    }
    while (begin++ < size() && index < BLOCK_SIZE) {
      final RevCommit c = (RevCommit) s.contents[index++];
      if (c.has(flag))
        return begin;
    }
  }
  return -1;
}
origin: berlam/github-bucket

/**
 * Find the next commit that has the given flag set.
 *
 * @param flag
 *            the flag to test commits against.
 * @param begin
 *            first commit index to test at. Applications may wish to begin
 *            at 0, to test the first commit in the list.
 * @return index of the first commit at or after index <code>begin</code>
 *         that has the specified flag set on it; -1 if no match is found.
 */
public int indexOf(RevFlag flag, int begin) {
  while (begin < size()) {
    int index = begin;
    Block s = contents;
    while (s.shift > 0) {
      final int i = index >> s.shift;
      index -= i << s.shift;
      s = (Block) s.contents[i];
    }
    while (begin++ < size() && index < BLOCK_SIZE) {
      final RevCommit c = (RevCommit) s.contents[index++];
      if (c.has(flag))
        return begin;
    }
  }
  return -1;
}
origin: berlam/github-bucket

/**
 * Find the next commit that has the given flag set.
 *
 * @param flag
 *            the flag to test commits against.
 * @param begin
 *            first commit index to test at. Applications may wish to begin
 *            at <code>size()-1</code>, to test the last commit in the
 *            list.
 * @return index of the first commit at or before index <code>begin</code>
 *         that has the specified flag set on it; -1 if no match is found.
 */
public int lastIndexOf(RevFlag flag, int begin) {
  begin = Math.min(begin, size() - 1);
  while (begin >= 0) {
    int index = begin;
    Block s = contents;
    while (s.shift > 0) {
      final int i = index >> s.shift;
      index -= i << s.shift;
      s = (Block) s.contents[i];
    }
    while (begin-- >= 0 && index >= 0) {
      final RevCommit c = (RevCommit) s.contents[index--];
      if (c.has(flag))
        return begin;
    }
  }
  return -1;
}
origin: berlam/github-bucket

  throws MissingObjectException, IncorrectObjectTypeException,
  IOException {
applyFlag(matching, flag, 0, size());
origin: sonia.jgit/org.eclipse.jgit

/**
 * Find the next commit that has the given flag set.
 *
 * @param flag
 *            the flag to test commits against.
 * @param begin
 *            first commit index to test at. Applications may wish to begin
 *            at <code>size()-1</code>, to test the last commit in the
 *            list.
 * @return index of the first commit at or before index <code>begin</code>
 *         that has the specified flag set on it; -1 if no match is found.
 */
public int lastIndexOf(final RevFlag flag, int begin) {
  begin = Math.min(begin, size() - 1);
  while (begin >= 0) {
    int index = begin;
    Block s = contents;
    while (s.shift > 0) {
      final int i = index >> s.shift;
      index -= i << s.shift;
      s = (Block) s.contents[i];
    }
    while (begin-- >= 0 && index >= 0) {
      final RevCommit c = (RevCommit) s.contents[index--];
      if (c.has(flag))
        return begin;
    }
  }
  return -1;
}
origin: theonedev/onedev

  throws MissingObjectException, IncorrectObjectTypeException,
  IOException {
applyFlag(matching, flag, 0, size());
origin: theonedev/onedev

/**
 * Find the next commit that has the given flag set.
 *
 * @param flag
 *            the flag to test commits against.
 * @param begin
 *            first commit index to test at. Applications may wish to begin
 *            at <code>size()-1</code>, to test the last commit in the
 *            list.
 * @return index of the first commit at or before index <code>begin</code>
 *         that has the specified flag set on it; -1 if no match is found.
 */
public int lastIndexOf(RevFlag flag, int begin) {
  begin = Math.min(begin, size() - 1);
  while (begin >= 0) {
    int index = begin;
    Block s = contents;
    while (s.shift > 0) {
      final int i = index >> s.shift;
      index -= i << s.shift;
      s = (Block) s.contents[i];
    }
    while (begin-- >= 0 && index >= 0) {
      final RevCommit c = (RevCommit) s.contents[index--];
      if (c.has(flag))
        return begin;
    }
  }
  return -1;
}
origin: sonia.jgit/org.eclipse.jgit

  throws MissingObjectException, IncorrectObjectTypeException,
  IOException {
applyFlag(matching, flag, 0, size());
origin: sonia.jgit/org.eclipse.jgit

  IncorrectObjectTypeException, IOException {
final RevWalk w = flag.getRevWalk();
rangeEnd = Math.min(rangeEnd, size());
while (rangeBegin < rangeEnd) {
  int index = rangeBegin;
origin: theonedev/onedev

  IncorrectObjectTypeException, IOException {
final RevWalk w = flag.getRevWalk();
rangeEnd = Math.min(rangeEnd, size());
while (rangeBegin < rangeEnd) {
  int index = rangeBegin;
origin: berlam/github-bucket

  IncorrectObjectTypeException, IOException {
final RevWalk w = flag.getRevWalk();
rangeEnd = Math.min(rangeEnd, size());
while (rangeBegin < rangeEnd) {
  int index = rangeBegin;
org.eclipse.jgit.revwalkRevCommitListsize

Popular methods of RevCommitList

  • add
  • applyFlag
    Apply a flag to all commits matching the specified filter. This version allows incremental testing a
  • clearFlag
    Remove the given flag from all commits. This method is actually implemented in terms of:applyFlag(Re
  • enter
    Optional callback invoked when commits enter the list by fillTo. This method is only called during #
  • <init>
  • clear
  • source
    Set the revision walker this list populates itself from.

Popular in Java

  • Updating database using SQL prepared statement
  • scheduleAtFixedRate (Timer)
  • startActivity (Activity)
  • getSharedPreferences (Context)
  • Format (java.text)
    The base class for all formats. This is an abstract base class which specifies the protocol for clas
  • Deque (java.util)
    A linear collection that supports element insertion and removal at both ends. The name deque is shor
  • Executor (java.util.concurrent)
    An object that executes submitted Runnable tasks. This interface provides a way of decoupling task s
  • ServletException (javax.servlet)
    Defines a general exception a servlet can throw when it encounters difficulty.
  • Options (org.apache.commons.cli)
    Main entry-point into the library. Options represents a collection of Option objects, which describ
  • Location (org.springframework.beans.factory.parsing)
    Class that models an arbitrary location in a Resource.Typically used to track the location of proble
Codota Logo
  • Products

    Search for Java codeSearch for JavaScript codeEnterprise
  • IDE Plugins

    IntelliJ IDEAWebStormAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimAtomGoLandRubyMineEmacsJupyter
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogCodota Academy Plugin user guide Terms of usePrivacy policyJava Code IndexJavascript Code Index
Get Codota for your IDE now