/// <summary> /// Delete the ref. /// </summary> /// <param name="walk"> /// a RevWalk instance this delete command can borrow to perform /// the merge test. The walk will be reset to perform the test. /// </param> /// <returns>the result status of the delete.</returns> public RefUpdateResult delete(RevWalk.RevWalk walk) { string myName = Ref.getLeaf().getName(); if (myName.StartsWith(Constants.R_HEADS)) { Ref head = getRefDatabase().getRef(Constants.HEAD); while (head.isSymbolic()) { head = head.getTarget(); if (myName.Equals(head.getName())) { return(result = RefUpdateResult.REJECTED_CURRENT_BRANCH); } } } try { return(result = updateImpl(walk, new DeleteStore(this))); } catch (IOException) { result = RefUpdateResult.IO_FAILURE; throw; } }
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); }
/// <returns> /// true if the {@code Constants#HEAD} reference needs to be linked /// to the new destination name. /// </returns> protected bool needToUpdateHEAD() { Ref head = source.getRefDatabase().getRef(Constants.HEAD); if (head.isSymbolic()) { head = head.getTarget(); return(head.getName().Equals(source.getName())); } return(false); }
/// <summary> /// Replace this reference with a symbolic reference to another reference. /// <para/> /// This exact reference (not its traversed leaf) is replaced with a symbolic /// reference to the requested name. /// </summary> /// <param name="target"> /// name of the new target for this reference. The new target name /// must be absolute, so it must begin with {@code refs/}. /// </param> /// <returns><see cref="RefUpdateResult.NEW"/> or <see cref="RefUpdateResult.FORCED"/> on success.</returns> public RefUpdateResult link(string target) { if (!target.StartsWith(Constants.R_REFS)) { throw new ArgumentException("Not " + Constants.R_REFS); } if (getRefDatabase().isNameConflicting(Name)) { return(RefUpdateResult.LOCK_FAILURE); } try { if (!tryLock(false)) { return(RefUpdateResult.LOCK_FAILURE); } Ref old = getRefDatabase().getRef(Name); if (old != null && old.isSymbolic()) { Ref dst = old.getTarget(); if (target.Equals(dst.getName())) { return(result = RefUpdateResult.NO_CHANGE); } } if (old != null && old.getObjectId() != null) { OldObjectId = (old.getObjectId()); } Ref dst2 = getRefDatabase().getRef(target); if (dst2 != null && dst2.getObjectId() != null) { NewObjectId = (dst2.getObjectId()); } return(result = doLink(target)); } catch (IOException) { result = RefUpdateResult.IO_FAILURE; throw; } finally { unlock(); } }
private Ref resolve(Ref @ref, int depth, string prefix, RefList <LooseRef> loose, RefList <Ref> packed) { if (@ref.isSymbolic()) { Ref dst = @ref.getTarget(); if (MAX_SYMBOLIC_REF_DEPTH <= depth) { return(null); // claim it doesn't exist } // If the cached value can be assumed to be current due to a // recent scan of the loose directory, use it. if (loose != null && dst.getName().StartsWith(prefix)) { int idx; if (0 <= (idx = loose.find(dst.getName()))) { dst = loose.get(idx); } else if (0 <= (idx = packed.find(dst.getName()))) { dst = packed.get(idx); } else { return(@ref); } } else { dst = readRef(dst.getName(), packed); if (dst == null) { return(@ref); } } dst = resolve(dst, depth + 1, prefix, loose, packed); if (dst == null) { return(null); } return(new SymbolicRef(@ref.getName(), dst)); } return(@ref); }
public override string ToString() { var r = new StringBuilder(); r.Append("SymbolicRef["); Ref cur = this; while (cur.isSymbolic()) { r.Append(cur.getName()); r.Append(" -> "); cur = cur.getTarget(); } r.Append(cur.getName()); r.Append('='); r.Append(ObjectId.ToString(cur.getObjectId())); r.Append("]"); return(r.ToString()); }