ThreeWayMerger merger = MergeStrategy.RECURSIVE.newMerger(db, true);
merger.setBase(parent.getTree());
if (merger.merge(head, commit)) {
- if (AnyObjectId.equals(head.getTree(), merger.getResultTreeId()))
+ if (AnyObjectId.isEqual(head.getTree(), merger.getResultTreeId()))
return null;
tick(1);
org.eclipse.jgit.lib.CommitBuilder b =
return;
}
- if (!AnyObjectId.equals(exp.getObjectId(), act.getObjectId())) {
+ if (!AnyObjectId.isEqual(exp.getObjectId(), act.getObjectId())) {
throw die(String.format("expected %s to be %s, found %s",
exp.getName(),
id(exp.getObjectId()),
}
if (exp.getPeeledObjectId() != null
- && !AnyObjectId.equals(exp.getPeeledObjectId(), act.getPeeledObjectId())) {
+ && !AnyObjectId.isEqual(exp.getPeeledObjectId(),
+ act.getPeeledObjectId())) {
throw die(String.format("expected %s to be %s, found %s",
exp.getName(),
id(exp.getPeeledObjectId()),
rw.markStart(rw.parseCommit(ref.getObjectId()));
}
for (RevCommit next; (next = rw.next()) != null;) {
- if (AnyObjectId.equals(next, id)) {
+ if (AnyObjectId.isEqual(next, id)) {
return true;
}
}
assertEquals(a1.hashCode(), a2.hashCode());
assertEquals(b1.hashCode(), b2.hashCode());
- assertTrue(AnyObjectId.equals(a1, a2));
- assertTrue(AnyObjectId.equals(b1, b2));
+ assertTrue(AnyObjectId.isEqual(a1, a2));
+ assertTrue(AnyObjectId.isEqual(b1, b2));
}
@Test
merger.setCommitNames(new String[] { "BASE", ourName, //$NON-NLS-1$
cherryPickName });
if (merger.merge(newHead, srcCommit)) {
- if (AnyObjectId.equals(newHead.getTree().getId(), merger
- .getResultTreeId()))
+ if (AnyObjectId.isEqual(newHead.getTree().getId(),
+ merger.getResultTreeId()))
continue;
DirCacheCheckout dco = new DirCacheCheckout(repo,
newHead.getTree(), repo.lockDirCache(),
ObjectId headId = getHead().getObjectId();
// getHead() checks for null
assert headId != null;
- if (!AnyObjectId.equals(headId, newParents.get(0)))
+ if (!AnyObjectId.isEqual(headId, newParents.get(0)))
checkoutCommit(headId.getName(), newParents.get(0));
// Use the cherry-pick strategy if all non-first parents did not
+ "This reverts commit " + srcCommit.getId().getName() //$NON-NLS-1$
+ ".\n"; //$NON-NLS-1$
if (merger.merge(headCommit, srcParent)) {
- if (AnyObjectId.equals(headCommit.getTree().getId(), merger
- .getResultTreeId()))
+ if (AnyObjectId.isEqual(headCommit.getTree().getId(),
+ merger.getResultTreeId()))
continue;
DirCacheCheckout dco = new DirCacheCheckout(repo,
headCommit.getTree(), repo.lockDirCache(),
}
private static boolean equals(@Nullable ObjectId a, LogIndex b) {
- return a != null && b != null && AnyObjectId.equals(a, b);
+ return a != null && b != null && AnyObjectId.isEqual(a, b);
}
/**
Ref oldRef = remote.remove(name);
ObjectId oldId = getId(oldRef);
ObjectId newId = tw.getObjectId(0);
- if (!AnyObjectId.equals(oldId, newId)) {
+ if (!AnyObjectId.isEqual(oldId, newId)) {
delta.add(new ReceiveCommand(oldId, newId, name));
}
}
return UNKNOWN;
}
- if (AnyObjectId.equals(remoteId, ObjectId.zeroId())) {
+ if (AnyObjectId.isEqual(remoteId, ObjectId.zeroId())) {
// Replica does not have the txnAccepted reference.
return LAGGING;
}
private static boolean isExpectedValue(Map<String, Ref> adv,
RemoteRefUpdate u) {
Ref r = adv.get(u.getRemoteName());
- if (!AnyObjectId.equals(getId(r), u.getExpectedOldObjectId())) {
+ if (!AnyObjectId.isEqual(getId(r), u.getExpectedOldObjectId())) {
((RemoteCommand) u).cmd.setResult(LOCK_FAILURE);
return false;
}
try (RevWalk rw = new RevWalk(git);
TreeWalk tw = new TreeWalk(rw.getObjectReader());
ObjectInserter ins = git.newObjectInserter()) {
- if (AnyObjectId.equals(oldTree, ObjectId.zeroId())) {
+ if (AnyObjectId.isEqual(oldTree, ObjectId.zeroId())) {
tw.addTree(new EmptyTreeIterator());
} else {
tw.addTree(rw.parseTree(oldTree));
private static boolean matchOld(ReceiveCommand cmd, @Nullable Ref ref) {
if (ref == null) {
- return AnyObjectId.equals(ObjectId.zeroId(), cmd.getOldId())
+ return AnyObjectId.isEqual(ObjectId.zeroId(), cmd.getOldId())
&& cmd.getOldSymref() == null;
} else if (ref.isSymbolic()) {
return ref.getTarget().getName().equals(cmd.getOldSymref());
String name = cmd.getRefName();
ObjectId newId = cmd.getNewId();
String newSymref = cmd.getNewSymref();
- if (AnyObjectId.equals(ObjectId.zeroId(), newId)
+ if (AnyObjectId.isEqual(ObjectId.zeroId(), newId)
&& newSymref == null) {
refs.add(new ObjectIdRef.Unpeeled(NEW, name, null));
continue;
if (obj == null)
break;
- if (AnyObjectId.equals(obj, toFind))
+ if (AnyObjectId.isEqual(obj, toFind))
return true;
if (++i == ids.length())
continue;
}
- if (AnyObjectId.equals(obj, toAdd))
+ if (AnyObjectId.isEqual(obj, toAdd))
return true;
if (++i == ids.length())
public abstract class AnyObjectId implements Comparable<AnyObjectId> {
/**
- * Compare to object identifier byte sequences for equality.
+ * Compare two object identifier byte sequences for equality.
*
* @param firstObjectId
* the first identifier to compare. Must not be null.
* @param secondObjectId
* the second identifier to compare. Must not be null.
* @return true if the two identifiers are the same.
+ * @deprecated use {@link #isEqual(AnyObjectId, AnyObjectId)} instead
*/
+ @Deprecated
+ @SuppressWarnings("AmbiguousMethodReference")
public static boolean equals(final AnyObjectId firstObjectId,
final AnyObjectId secondObjectId) {
- if (firstObjectId == secondObjectId)
- return true;
+ return isEqual(firstObjectId, secondObjectId);
+ }
+ /**
+ * Compare two object identifier byte sequences for equality.
+ *
+ * @param firstObjectId
+ * the first identifier to compare. Must not be null.
+ * @param secondObjectId
+ * the second identifier to compare. Must not be null.
+ * @return true if the two identifiers are the same.
+ * @since 5.4
+ */
+ public static boolean isEqual(final AnyObjectId firstObjectId,
+ final AnyObjectId secondObjectId) {
+ if (firstObjectId == secondObjectId) {
+ return true;
+ }
// We test word 3 first since the git file-based ODB
// uses the first byte of w1, and we use w2 as the
// hash code, one of those probably came up with these
// Therefore the first two words are very likely to be
// identical. We want to break away from collisions as
// quickly as possible.
- //
return firstObjectId.w3 == secondObjectId.w3
&& firstObjectId.w4 == secondObjectId.w4
&& firstObjectId.w5 == secondObjectId.w5
* the other id to compare to. May be null.
* @return true only if both ObjectIds have identical bits.
*/
- @SuppressWarnings("NonOverridingEquals")
+ @SuppressWarnings({ "NonOverridingEquals", "AmbiguousMethodReference" })
public final boolean equals(AnyObjectId other) {
- return other != null ? equals(this, other) : false;
+ return other != null ? isEqual(this, other) : false;
}
/** {@inheritDoc} */
V obj;
while ((obj = tbl[i]) != null) {
- if (AnyObjectId.equals(obj, toFind))
+ if (AnyObjectId.isEqual(obj, toFind)) {
return obj;
+ }
i = (i + 1) & msk;
}
return null;
V obj;
while ((obj = tbl[i]) != null) {
- if (AnyObjectId.equals(obj, newValue))
+ if (AnyObjectId.isEqual(obj, newValue))
return obj;
i = (i + 1) & msk;
}
if (expValue != null) {
final ObjectId o;
o = oldValue != null ? oldValue : ObjectId.zeroId();
- if (!AnyObjectId.equals(expValue, o)) {
+ if (!AnyObjectId.isEqual(expValue, o)) {
return Result.LOCK_FAILURE;
}
}
private static boolean sameNote(Note a, Note b) {
if (a == null && b == null)
return true;
- return a != null && b != null && AnyObjectId.equals(a, b);
+ return a != null && b != null && AnyObjectId.isEqual(a, b);
}
private static boolean sameContent(Note a, Note b) {
if (a == null && b == null)
return true;
return a != null && b != null
- && AnyObjectId.equals(a.getData(), b.getData());
+ && AnyObjectId.isEqual(a.getData(), b.getData());
}
private static InMemoryNoteBucket addIfNotNull(InMemoryNoteBucket result,
this.newId = ObjectId.zeroId();
this.newSymref = newSymref;
this.name = name;
- if (AnyObjectId.equals(ObjectId.zeroId(), oldId)) {
+ if (AnyObjectId.isEqual(ObjectId.zeroId(), oldId)) {
type = Type.CREATE;
} else if (newSymref != null) {
type = Type.UPDATE;
this.name = name;
if (oldSymref == null) {
type = Type.CREATE;
- } else if (!AnyObjectId.equals(ObjectId.zeroId(), newId)) {
+ } else if (!AnyObjectId.isEqual(ObjectId.zeroId(), newId)) {
type = Type.UPDATE;
} else {
type = Type.DELETE;
public void updateType(RevWalk walk) throws IOException {
if (typeIsCorrect)
return;
- if (type == Type.UPDATE && !AnyObjectId.equals(oldId, newId)) {
+ if (type == Type.UPDATE && !AnyObjectId.isEqual(oldId, newId)) {
RevObject o = walk.parseAny(oldId);
RevObject n = walk.parseAny(newId);
if (!(o instanceof RevCommit)
private RefUpdate.Result decode(ReceiveCommand.Result status) {
switch (status) {
case OK:
- if (AnyObjectId.equals(oldObjectId, newObjectId))
+ if (AnyObjectId.isEqual(oldObjectId, newObjectId))
return RefUpdate.Result.NO_CHANGE;
switch (getType()) {
case CREATE:
}
ObjectId act = inserter.insert(type, raw);
- if (!AnyObjectId.equals(id, act)) {
+ if (!AnyObjectId.isEqual(id, act)) {
throw new TransportException(MessageFormat.format(
JGitText.get().incorrectHashFor, id.name(), act.name(),
Constants.typeString(type),
continue;
}
- if (AnyObjectId.equals(ObjectId.zeroId(), u.getNewObjectId()))
+ if (AnyObjectId.isEqual(ObjectId.zeroId(), u.getNewObjectId()))
deleteCommand(u);
else
updates.add(u);
if (r.getName().equals(ref.getName())) {
final ObjectId a = r.getObjectId();
final ObjectId b = ref.getObjectId();
- if (a != null && b != null && AnyObjectId.equals(a, b))
+ if (a != null && b != null
+ && AnyObjectId.isEqual(a, b)) {
return true;
+ }
}
}
}
projects / jgit.git / commitdiff