Java Note类代码示例

import org.eclipse.jgit.notes.Note; //导入依赖的package包/类
/**
 * Storing revisions in Git Notes causes object hash computation, which is expensive.
 */
public AssetRevision getRevisionGitNotes(File file) throws IOException {
    AssetRevision rev = file2rev.get(file);
    if (rev == null) {
        ObjectId workingId = getObjectId(file);

        try (RevWalk walk = new RevWalk(localRepo)) {
            Ref ref = localRepo.findRef(NOTES_REF);
            if (ref != null) {
                RevCommit notesCommit = walk.parseCommit(ref.getObjectId());
                NoteMap notes = NoteMap.read(walk.getObjectReader(), notesCommit);
                Note note = notes.getNote(workingId);
                if (note != null) {
                    ObjectLoader loader = localRepo.open(note.getData());
                    String noteStr = new String(loader.getBytes()).trim();
                    rev = parseAssetRevision(noteStr);
                    file2rev.put(file, rev);
                    return rev;
                }
            }
        }
    }

    return rev;
}
 

import org.eclipse.jgit.notes.Note; //导入依赖的package包/类
/**
 * Retrieves all the reviews in the current project's repository by commit hash.
 */
public Map<String, Review> listReviews() throws GitClientException {
  // Get the most up-to-date list of reviews.
  syncCommentsAndReviews();

  Map<String, Review> reviews = new LinkedHashMap<>();

  Git git = new Git(repo);
  try {
    ListNotesCommand cmd = git.notesList();
    cmd.setNotesRef(REVIEWS_REF);
    List<Note> notes = cmd.call();
    for (Note note : notes) {
      String rawNoteDataStr = noteToString(repo, note);
      Review latest = extractLatestReviewFromNotes(rawNoteDataStr);
      if (latest != null) {
        reviews.put(note.getName(), latest);
      }
    }
  } catch (Exception e) {
    throw new GitClientException(e);
  } finally {
    git.close();
  }
  return reviews;
}
 

import org.eclipse.jgit.notes.Note; //导入依赖的package包/类
/**
 * Reads a single note out as a string from the given commit hash.
 * Returns null if the note isn't found.
 */
private String readOneNote(Git git, String notesRef, String hash) throws GitClientException {
  try (RevWalk walker = new RevWalk(git.getRepository())) {
    ShowNoteCommand cmd = git.notesShow();
    cmd.setNotesRef(notesRef);
    ObjectId ref = git.getRepository().resolve(hash);
    RevCommit commit = walker.parseCommit(ref);
    cmd.setObjectId(commit);
    Note note = cmd.call();
    if (note == null) {
      return null;
    }
    return noteToString(repo, note);
  } catch (Exception e) {
    throw new GitClientException(e);
  }
}
 

import org.eclipse.jgit.notes.Note; //导入依赖的package包/类
@Override
public Note merge(Note base, Note ours, Note theirs, ObjectReader reader, ObjectInserter inserter)
    throws IOException {
  if (ours == null) {
    return theirs;
  }
  if (theirs == null) {
    return ours;
  }
  if (ours.getData().equals(theirs.getData())) {
    return ours;
  }

  ObjectLoader lo = reader.open(ours.getData());
  byte[] sep = new byte[] {'\n'};
  ObjectLoader lt = reader.open(theirs.getData());
  try (ObjectStream os = lo.openStream();
      ByteArrayInputStream b = new ByteArrayInputStream(sep);
      ObjectStream ts = lt.openStream();
      UnionInputStream union = new UnionInputStream(os, b, ts)) {
    ObjectId noteData =
        inserter.insert(Constants.OBJ_BLOB, lo.getSize() + sep.length + lt.getSize(), union);
    return new Note(ours, noteData);
  }
}
 

import org.eclipse.jgit.notes.Note; //导入依赖的package包/类
static RevisionNoteMap<ChangeRevisionNote> parse(
    ChangeNoteUtil noteUtil,
    Change.Id changeId,
    ObjectReader reader,
    NoteMap noteMap,
    PatchLineComment.Status status)
    throws ConfigInvalidException, IOException {
  Map<RevId, ChangeRevisionNote> result = new HashMap<>();
  for (Note note : noteMap) {
    ChangeRevisionNote rn =
        new ChangeRevisionNote(noteUtil, changeId, reader, note.getData(), status);
    rn.parse();
    result.put(new RevId(note.name()), rn);
  }
  return new RevisionNoteMap<>(noteMap, ImmutableMap.copyOf(result));
}
 

import org.eclipse.jgit.notes.Note; //导入依赖的package包/类
/** Reads and returns all external IDs. */
private Set<ExternalId> all(Repository repo, ObjectId rev) throws IOException {
  if (rev.equals(ObjectId.zeroId())) {
    return ImmutableSet.of();
  }

  try (Timer0.Context ctx = readAllLatency.start();
      RevWalk rw = new RevWalk(repo)) {
    NoteMap noteMap = readNoteMap(rw, rev);
    Set<ExternalId> extIds = new HashSet<>();
    for (Note note : noteMap) {
      byte[] raw =
          rw.getObjectReader().open(note.getData(), OBJ_BLOB).getCachedBytes(MAX_NOTE_SZ);
      try {
        extIds.add(ExternalId.parse(note.getName(), raw, note.getData()));
      } catch (Exception e) {
        log.error(String.format("Ignoring invalid external ID note %s", note.getName()), e);
      }
    }
    return extIds;
  }
}
 

import org.eclipse.jgit.notes.Note; //导入依赖的package包/类
/**
 * Parse the git note containing SDR numbers associated with the note.
 *
 * @param  note   Git note
 * @return List of bug IDs, or null if none found
 */
private List<String> getBugIds(Note note) {
    List<String> bugs = new ArrayList<String>();

    ObjectId noteObj = note.getData();
    String noteId = noteObj.getName();
    String noteText = noteObj.toString();
    if (noteText != null) {
        // Parse the delimited list of bug IDs from the note data
        noteText = noteText.trim();
        StringTokenizer st = new StringTokenizer(noteText);
        while (st.hasMoreTokens()) {
            bugs.add(st.nextToken());
        }
    }

    return bugs;
}
 

import org.eclipse.jgit.notes.Note; //导入依赖的package包/类
/** {@inheritDoc} */
public void appendNote(String note, String namespace) throws GitException {
    try (Repository repo = getRepository()) {
        ObjectId head = repo.resolve(HEAD); // commit to put a note on

        ShowNoteCommand cmd = git(repo).notesShow();
        cmd.setNotesRef(qualifyNotesNamespace(namespace));
        try (ObjectReader or = repo.newObjectReader();
             RevWalk walk = new RevWalk(or)) {
            cmd.setObjectId(walk.parseAny(head));
            Note n = cmd.call();

            if (n==null) {
                addNote(note,namespace);
            } else {
                ObjectLoader ol = or.open(n.getData());
                StringWriter sw = new StringWriter();
                IOUtils.copy(new InputStreamReader(ol.openStream(),CHARSET),sw);
                sw.write("\n");
                addNote(sw.toString() + normalizeNote(note), namespace);
            }
        }
    } catch (GitAPIException | IOException e) {
        throw new GitException(e);
    }
}
 

import org.eclipse.jgit.notes.Note; //导入依赖的package包/类
/**  커밋에 붙어있는 GIT 노트를 가져옴
 * @param commit
 * @return
 */
public String getNote(String commit){
	String str = new String();
	try{
		Note note = git.notesShow().setObjectId(CommitUtils.getCommit(git.getRepository(), commit)).call();
		ObjectLoader loader = this.localRepo.open(note.getData());
		str = new String(loader.getBytes());
	}finally{
		return str;
	}
}
 

import org.eclipse.jgit.notes.Note; //导入依赖的package包/类
/**
 * Utility method that converts a note to a string (assuming it's UTF-8).
 */
private String noteToString(Repository repo, Note note)
    throws MissingObjectException, IOException, UnsupportedEncodingException {
  ObjectLoader loader = repo.open(note.getData());
  ByteArrayOutputStream baos = new ByteArrayOutputStream();
  loader.copyTo(baos);
  return new String(baos.toByteArray(), "UTF-8");
}
 

import org.eclipse.jgit.notes.Note; //导入依赖的package包/类
private void add(T noteRecord)
    throws MissingObjectException, IncorrectObjectTypeException, IOException, RuntimeException {
  ObjectId noteContent = createNoteContent(noteRecord);
  if (ours.contains(reviewCommit)) {
    // merge the existing and the new note as if they are both new
    // means: base == null
    // there is not really a common ancestry for these two note revisions
    // use the same NoteMerger that is used from the NoteMapMerger
    NoteMerger noteMerger = new DefaultNoteMerger();
    Note newNote = new Note(reviewCommit, noteContent);
    noteContent =
        noteMerger.merge(null, newNote, ours.getNote(reviewCommit), reader, inserter).getData();
  }
  ours.set(reviewCommit, noteContent);
}
 

import org.eclipse.jgit.notes.Note; //导入依赖的package包/类
private List<PGPPublicKeyRing> get(long keyId, byte[] fp) throws IOException {
  if (reader == null) {
    load();
  }
  if (notes == null) {
    return Collections.emptyList();
  }
  Note note = notes.getNote(keyObjectId(keyId));
  if (note == null) {
    return Collections.emptyList();
  }

  List<PGPPublicKeyRing> keys = new ArrayList<>();
  try (InputStream in = reader.open(note.getData(), OBJ_BLOB).openStream()) {
    while (true) {
      @SuppressWarnings("unchecked")
      Iterator<Object> it = new BcPGPObjectFactory(new ArmoredInputStream(in)).iterator();
      if (!it.hasNext()) {
        break;
      }
      Object obj = it.next();
      if (obj instanceof PGPPublicKeyRing) {
        PGPPublicKeyRing kr = (PGPPublicKeyRing) obj;
        if (fp == null || Arrays.equals(fp, kr.getPublicKey().getFingerprint())) {
          keys.add(kr);
        }
      }
      checkState(!it.hasNext(), "expected one PGP object per ArmoredInputStream");
    }
    return keys;
  }
}
 

import org.eclipse.jgit.notes.Note; //导入依赖的package包/类
private void addNewNotes(NoteMap notes) throws IOException {
  for (Note n : notes) {
    if (!ours.contains(n)) {
      ours.set(n, n.getData());
    }
  }
}
 

import org.eclipse.jgit.notes.Note; //导入依赖的package包/类
private void addAllNotes(NoteMap notes) throws IOException {
  for (Note n : notes) {
    if (ours.contains(n)) {
      // Merge the existing and the new note as if they are both new,
      // means: base == null
      // There is no really a common ancestry for these two note revisions
      ObjectId noteContent =
          getNoteMerger().merge(null, n, ours.getNote(n), reader, inserter).getData();
      ours.set(n, noteContent);
    } else {
      ours.set(n, n.getData());
    }
  }
}
 

import org.eclipse.jgit.notes.Note; //导入依赖的package包/类
static RevisionNoteMap<RobotCommentsRevisionNote> parseRobotComments(
    ChangeNoteUtil noteUtil, ObjectReader reader, NoteMap noteMap)
    throws ConfigInvalidException, IOException {
  Map<RevId, RobotCommentsRevisionNote> result = new HashMap<>();
  for (Note note : noteMap) {
    RobotCommentsRevisionNote rn =
        new RobotCommentsRevisionNote(noteUtil, reader, note.getData());
    rn.parse();
    result.put(new RevId(note.name()), rn);
  }
  return new RevisionNoteMap<>(noteMap, ImmutableMap.copyOf(result));
}