public static ArrayMemory valueOf(Ref ref) { ArrayMemory memory = new ArrayMemory(); memory.refOfIndex("name").assign(ref.getName()); memory.refOfIndex("peeled").assign(ref.isPeeled()); memory.refOfIndex("symbolic").assign(ref.isSymbolic()); memory.refOfIndex("objectId").assign(valueOf(ref.getObjectId())); memory.refOfIndex("storage").assign(valueOf(ref.getStorage())); return memory; }
private static boolean equals(Ref r1, Ref r2) { if (r1 == null || r2 == null) { return false; } if (r1.isSymbolic()) { return r2.isSymbolic() && r1.getTarget().getName() .equals(r2.getTarget().getName()); } return !r2.isSymbolic() && Objects.equals(r1.getObjectId(), r2.getObjectId()); }
private static void append(StringBuilder s, Ref r, String nullName) { if (r == null) { s.append(nullName); } else if (r.isSymbolic()) { s.append(r.getTarget().getName()); } else { ObjectId id = r.getObjectId(); if (id != null) { s.append(id.name()); } } }
/** {@inheritDoc} */ @Override public Ref exactRef(String name) throws IOException { lock.lock(); try { Reftable table = reader(); Ref ref = table.exactRef(name); if (ref != null && ref.isSymbolic()) { return table.resolve(ref); } return ref; } finally { lock.unlock(); } }
private static void findSymrefs( final RefAdvertiser adv, final Map<String, Ref> refs) { Ref head = refs.get(Constants.HEAD); if (head != null && head.isSymbolic()) { adv.addSymref(Constants.HEAD, head.getLeaf().getName()); } }
@Override int valueType() { if (ref.isSymbolic()) { return VALUE_SYMREF; } else if (ref.getStorage() == NEW && ref.getObjectId() == null) { return VALUE_NONE; } else if (ref.getPeeledObjectId() != null) { return VALUE_2ID; } else { return VALUE_1ID; } }
/** {@inheritDoc} */ @Override @NonNull public Ref getLeaf() { Ref dst = getTarget(); while (dst.isSymbolic()) dst = dst.getTarget(); return dst; }
private static void format(StringBuilder s, @Nullable Ref r, String n) { if (r == null) { s.append(n); } else if (r.isSymbolic()) { s.append(r.getTarget().getName()); } else { ObjectId id = r.getObjectId(); if (id != null) { s.append(id.abbreviate(8).name()); } } } }
private String getShortBranchName(Ref headRef) { if (headRef.isSymbolic()) { return Repository.shortenRefName(headRef.getTarget().getName()); } // Detached HEAD. Every non-symbolic ref in the ref database has an // object id, so this cannot be null. ObjectId id = headRef.getObjectId(); if (id == null) { throw new NullPointerException(); } return id.getName(); }
private static Ref recreate(Ref old, Ref leaf) { if (old.isSymbolic()) { Ref dst = recreate(old.getTarget(), leaf); return new SymbolicRef(old.getName(), dst); } return leaf; }
static Ref recreate(Ref old, Ref leaf) { if (old.isSymbolic()) { Ref dst = recreate(old.getTarget(), leaf); return new SymbolicRef(old.getName(), dst); } return leaf; }
private static String getHeadName(Ref head) { String headName; if (head.isSymbolic()) { headName = head.getTarget().getName(); } else { ObjectId headId = head.getObjectId(); // the callers are checking this already assert headId != null; headName = headId.getName(); } return headName; }
private void indexRef(Ref ref, long blockPos) { if (indexObjects && !ref.isSymbolic()) { indexId(ref.getObjectId(), blockPos); indexId(ref.getPeeledObjectId(), blockPos); } }
private static Ref recreate(Ref old, ObjectIdRef leaf) { if (old.isSymbolic()) { Ref dst = recreate(old.getTarget(), leaf); return new SymbolicRef(old.getName(), dst); } return leaf; }
/** {@inheritDoc} */ @Override public RefUpdate newUpdate(String refName, boolean detach) throws IOException { boolean detachingSymbolicRef = false; Ref ref = exactRef(refName); if (ref == null) ref = new ObjectIdRef.Unpeeled(NEW, refName, null); else detachingSymbolicRef = detach && ref.isSymbolic(); DfsRefUpdate update = new DfsRefUpdate(this, ref); if (detachingSymbolicRef) update.setDetachingSymbolicRef(); return update; }
/** {@inheritDoc} */ @Override protected boolean tryLock(boolean deref) throws IOException { dstRef = getRef(); if (deref) dstRef = dstRef.getLeaf(); if (dstRef.isSymbolic()) setOldObjectId(null); else setOldObjectId(dstRef.getObjectId()); return true; }
private static void cleanupPeeledRef(DirCacheEditor ed, Ref ref) { if (ref != null && !ref.isSymbolic() && (!ref.isPeeled() || ref.getPeeledObjectId() != null)) { ed.add(new DeletePath(peeledPath(ref.getName()))); } }
private Ref resolve(ObjectReader reader, Ref ref, int depth) throws IOException { if (ref.isSymbolic() && depth < MAX_SYMBOLIC_REF_DEPTH) { Ref r = readRef(reader, ref.getTarget().getName()); if (r == null) { return ref; } Ref dst = resolve(reader, r, depth + 1); return new SymbolicRef(ref.getName(), dst); } return ref; }
private Ref resolve(Ref ref, int depth, RefList<Ref> loose) throws IOException { if (!ref.isSymbolic()) return ref; Ref dst = ref.getTarget(); if (MAX_SYMBOLIC_REF_DEPTH <= depth) return null; // claim it doesn't exist dst = loose.get(dst.getName()); if (dst == null) return ref; dst = resolve(dst, depth + 1, loose); if (dst == null) return null; return new SymbolicRef(ref.getName(), dst); }
private static boolean matchOld(ReceiveCommand cmd, @Nullable Ref ref) { if (ref == null) { return AnyObjectId.equals(ObjectId.zeroId(), cmd.getOldId()) && cmd.getOldSymref() == null; } else if (ref.isSymbolic()) { return ref.getTarget().getName().equals(cmd.getOldSymref()); } ObjectId id = ref.getObjectId(); if (id == null) { id = ObjectId.zeroId(); } return cmd.getOldId().equals(id); }