internal Entry(byte[] raw, int pos) { oldId = ObjectId.FromString(raw, pos); pos += Constants.OBJECT_ID_STRING_LENGTH; if (raw[pos++] != ' ') { throw new ArgumentException(JGitText.Get().rawLogMessageDoesNotParseAsLogEntry); } newId = ObjectId.FromString(raw, pos); pos += Constants.OBJECT_ID_STRING_LENGTH; if (raw[pos++] != ' ') { throw new ArgumentException(JGitText.Get().rawLogMessageDoesNotParseAsLogEntry); } who = RawParseUtils.ParsePersonIdentOnly(raw, pos); int p0 = RawParseUtils.Next(raw, pos, '\t'); if (p0 >= raw.Length) { comment = string.Empty; } else { // personident has no \t, no comment present int p1 = RawParseUtils.NextLF(raw, p0); comment = p1 > p0 ? RawParseUtils.Decode(raw, p0, p1 - 1) : string.Empty; } }
/// <summary>Create submodule status</summary> /// <param name="type"></param> /// <param name="path"></param> /// <param name="indexId"></param> /// <param name="headId"></param> public SubmoduleStatus(SubmoduleStatusType type, string path, ObjectId indexId, ObjectId headId) { this.type = type; this.path = path; this.indexId = indexId; this.headId = headId; }
internal TrackingRefUpdate(bool canForceUpdate, string remoteName, string localName , AnyObjectId oldValue, AnyObjectId newValue) { this.remoteName = remoteName; this.localName = localName; this.forceUpdate = canForceUpdate; this.oldObjectId = oldValue.Copy(); this.newObjectId = newValue.Copy(); }
internal static LocalObjectRepresentation NewDelta(PackFile f, long p, long n, ObjectId @base) { LocalObjectRepresentation r = new LocalObjectRepresentation.Delta(); r.pack = f; r.offset = p; r.length = n; r.baseId = @base; return r; }
/// <exception cref="System.InvalidOperationException"></exception> /// <exception cref="System.IO.IOException"></exception> private void PrescanTwoTrees(ObjectId head, ObjectId merge) { DirCache dc = db.LockDirCache(); try { dco = new DirCacheCheckout(db, head, dc, merge); dco.PreScanTwoTrees(); } finally { dc.Unlock(); } }
private static InputStream Inflate(InputStream @in, long size, ObjectId id) { Inflater inf = InflaterCache.Get(); return new _InflaterInputStream_307(size, id, @in, inf); }
// // // private string MakeDiffHeaderModeChange(string pathA, string pathB, ObjectId aId, ObjectId bId, string modeA, string modeB) { string a = aId.Abbreviate(8).Name; string b = bId.Abbreviate(8).Name; return DIFF + "a/" + pathA + " " + "b/" + pathB + "\n" + "old mode " + modeA + "\n" + "new mode " + modeB + "\n" + "index " + a + ".." + b + "\n" + "--- a/" + pathA + "\n" + "+++ b/" + pathB + "\n"; }
private string MakeDiffHeader(string pathA, string pathB, ObjectId aId, ObjectId bId) { string a = aId.Abbreviate(8).Name; string b = bId.Abbreviate(8).Name; return DIFF + "a/" + pathA + " " + "b/" + pathB + "\n" + "index " + a + ".." + b + " " + REGULAR_FILE + "\n" + "--- a/" + pathA + "\n" + "+++ b/" + pathB + "\n"; }
/// <summary> /// Create a new command for /// <see cref="BaseReceivePack">BaseReceivePack</see> /// . /// </summary> /// <param name="oldId"> /// the old object id; must not be null. Use /// <see cref="NGit.ObjectId.ZeroId()">NGit.ObjectId.ZeroId()</see> /// to indicate a ref creation. /// </param> /// <param name="newId"> /// the new object id; must not be null. Use /// <see cref="NGit.ObjectId.ZeroId()">NGit.ObjectId.ZeroId()</see> /// to indicate a ref deletion. /// </param> /// <param name="name">name of the ref being affected.</param> /// <param name="type">type of the command.</param> /// <since>2.0</since> public ReceiveCommand(ObjectId oldId, ObjectId newId, string name, ReceiveCommand.Type type) { this.oldId = oldId; this.newId = newId; this.name = name; this.type = type; }
public RevisionObjectIdPair(RevCommit revision, ObjectId objectId) { this.Commit = revision; this.ObjectId = objectId; }
/// <summary>Construct a MissingObjectException for the specified object id.</summary> /// <remarks> /// Construct a MissingObjectException for the specified object id. Expected /// type is reported to simplify tracking down the problem. /// </remarks> /// <param name="id">SHA-1</param> /// <param name="type">object type</param> public MissingObjectException(AbbreviatedObjectId id, int type) : base(MessageFormat .Format(JGitText.Get().missingObject, Constants.TypeString(type), id.Name)) { missing = null; }
/// <summary>Set the identity of the object, if its not already set.</summary> /// <remarks>Set the identity of the object, if its not already set.</remarks> /// <param name="id">the id of the object that is too large to process.</param> public virtual void SetObjectId(AnyObjectId id) { if (objectId == null) { objectId = id.Copy(); } }
/// <exception cref="System.IO.IOException"></exception> private static RawText GetRawText(ObjectId id, Repository db) { if (id.Equals(ObjectId.ZeroId)) { return new RawText(new byte[] { }); } return new RawText(db.Open(id, Constants.OBJ_BLOB).GetCachedBytes()); }
/// <exception cref="NGit.Errors.StopWalkException"></exception> /// <exception cref="NGit.Errors.MissingObjectException"></exception> /// <exception cref="NGit.Errors.IncorrectObjectTypeException"></exception> /// <exception cref="System.IO.IOException"></exception> public override bool Include(RevWalk walker, RevCommit c) { // Reset the tree filter to scan this commit and parents. // RevCommit[] pList = c.parents; int nParents = pList.Length; TreeWalk tw = pathFilter; ObjectId[] trees = new ObjectId[nParents + 1]; for (int i = 0; i < nParents; i++) { RevCommit p = c.parents[i]; if ((p.flags & PARSED) == 0) { p.ParseHeaders(walker); } trees[i] = p.Tree; } trees[nParents] = c.Tree; tw.Reset(trees); if (nParents == 1) { // We have exactly one parent. This is a very common case. // int chgs = 0; int adds = 0; while (tw.Next()) { chgs++; if (tw.GetRawMode(0) == 0 && tw.GetRawMode(1) != 0) { adds++; } else { break; } } // no point in looking at this further. if (chgs == 0) { // No changes, so our tree is effectively the same as // our parent tree. We pass the buck to our parent. // c.flags |= REWRITE; return false; } else { // We have interesting items, but neither of the special // cases denoted above. // if (adds > 0 && tw.Filter is FollowFilter) { // One of the paths we care about was added in this // commit. We need to update our filter to its older // name, if we can discover it. Find out what that is. // UpdateFollowFilter(trees); } return true; } } else { if (nParents == 0) { // We have no parents to compare against. Consider us to be // REWRITE only if we have no paths matching our filter. // if (tw.Next()) { return true; } c.flags |= REWRITE; return false; } } // We are a merge commit. We can only be REWRITE if we are same // to _all_ parents. We may also be able to eliminate a parent if // it does not contribute changes to us. Such a parent may be an // uninteresting side branch. // int[] chgs_1 = new int[nParents]; int[] adds_1 = new int[nParents]; while (tw.Next()) { int myMode = tw.GetRawMode(nParents); for (int i_1 = 0; i_1 < nParents; i_1++) { int pMode = tw.GetRawMode(i_1); if (myMode == pMode && tw.IdEqual(i_1, nParents)) { continue; } chgs_1[i_1]++; if (pMode == 0 && myMode != 0) { adds_1[i_1]++; } } } bool same = false; bool diff = false; for (int i_2 = 0; i_2 < nParents; i_2++) { if (chgs_1[i_2] == 0) { // No changes, so our tree is effectively the same as // this parent tree. We pass the buck to only this one // parent commit. // RevCommit p = pList[i_2]; if ((p.flags & UNINTERESTING) != 0) { // This parent was marked as not interesting by the // application. We should look for another parent // that is interesting. // same = true; continue; } c.flags |= REWRITE; c.parents = new RevCommit[] { p }; return false; } if (chgs_1[i_2] == adds_1[i_2]) { // All of the differences from this parent were because we // added files that they did not have. This parent is our // "empty tree root" and thus their history is not relevant. // Cut our grandparents to be an empty list. // pList[i_2].parents = RevCommit.NO_PARENTS; } // We have an interesting difference relative to this parent. // diff = true; } if (diff && !same) { // We did not abort above, so we are different in at least one // way from all of our parents. We have to take the blame for // that difference. // return true; } // We are the same as all of our parents. We must keep them // as they are and allow those parents to flow into pending // for further scanning. // c.flags |= REWRITE; return false; }
/// <exception cref="NGit.Errors.MissingObjectException"></exception> /// <exception cref="NGit.Errors.IncorrectObjectTypeException"></exception> /// <exception cref="NGit.Errors.CorruptObjectException"></exception> /// <exception cref="System.IO.IOException"></exception> private void UpdateFollowFilter(ObjectId[] trees) { TreeWalk tw = pathFilter; FollowFilter oldFilter = (FollowFilter)tw.Filter; tw.Filter = TreeFilter.ANY_DIFF; tw.Reset(trees); IList<DiffEntry> files = DiffEntry.Scan(tw); RenameDetector rd = new RenameDetector(repository); rd.AddAll(files); files = rd.Compute(); TreeFilter newFilter = oldFilter; foreach (DiffEntry ent in files) { if (IsRename(ent) && ent.GetNewPath().Equals(oldFilter.GetPath())) { newFilter = FollowFilter.Create(ent.GetOldPath()); RenameCallback callback = oldFilter.GetRenameCallback(); if (callback != null) { callback.Renamed(ent); // forward the callback to the new follow filter ((FollowFilter)newFilter).SetRenameCallback(callback); } break; } } tw.Filter = newFilter; }
/// <exception cref="System.IO.IOException"></exception> private void CreateBranch(ObjectId objectId, string branchName) { RefUpdate updateRef = db.UpdateRef(branchName); updateRef.SetNewObjectId(objectId); updateRef.Update(); }
/// <exception cref="System.IO.IOException"></exception> internal override FileObjectDatabase.InsertLooseObjectResult InsertUnpackedObject (FilePath tmp, ObjectId objectId, bool createDuplicate) { FileObjectDatabase.InsertLooseObjectResult result = wrapped.InsertUnpackedObject( tmp, objectId, createDuplicate); switch (result) { case FileObjectDatabase.InsertLooseObjectResult.INSERTED: case FileObjectDatabase.InsertLooseObjectResult.EXISTS_LOOSE: { if (!unpackedObjects.Contains(objectId)) { unpackedObjects.Add(objectId); } break; } case FileObjectDatabase.InsertLooseObjectResult.EXISTS_PACKED: case FileObjectDatabase.InsertLooseObjectResult.FAILURE: { break; } } return result; }
/// <exception cref="System.Exception"></exception> private static byte[] Entry(FileMode mode, string name, ObjectId id) { ByteArrayOutputStream @out = new ByteArrayOutputStream(); mode.CopyTo(@out); @out.Write(' '); @out.Write(Constants.Encode(name)); @out.Write(0); id.CopyRawTo(@out); return @out.ToByteArray(); }
public _InflaterInputStream_307(long size, ObjectId id, InputStream baseArg1, Inflater baseArg2) : base(baseArg1, baseArg2) { this.size = size; this.id = id; this.remaining = size; }
/// <summary>Construct a MissingObjectException for the specified object id.</summary> /// <remarks> /// Construct a MissingObjectException for the specified object id. /// Expected type is reported to simplify tracking down the problem. /// </remarks> /// <param name="id">SHA-1</param> /// <param name="type">object type</param> public MissingObjectException(ObjectId id, string type) : base(MessageFormat.Format (JGitText.Get().missingObject, type, id.Name)) { missing = id.Copy(); }
internal LargeObject(int type, long size, FilePath path, AnyObjectId id, FileObjectDatabase db) { this.type = type; this.size = size; this.path = path; this.id = id.Copy(); this.source = db; }
public static void HardReset (NGit.Repository repo, ObjectId newHead) { DirCache dc = null; try { // Reset head to upstream RefUpdate ru = repo.UpdateRef (Constants.HEAD); ru.SetNewObjectId (newHead); ru.SetForceUpdate (true); RefUpdate.Result rc = ru.Update (); switch (rc) { case RefUpdate.Result.NO_CHANGE: case RefUpdate.Result.NEW: case RefUpdate.Result.FAST_FORWARD: case RefUpdate.Result.FORCED: break; case RefUpdate.Result.REJECTED: case RefUpdate.Result.LOCK_FAILURE: throw new ConcurrentRefUpdateException (JGitText.Get ().couldNotLockHEAD, ru.GetRef (), rc); default: throw new JGitInternalException ("Reference update failed: " + rc); } dc = repo.LockDirCache (); RevWalk rw = new RevWalk (repo); RevCommit c = rw.ParseCommit (newHead); DirCacheCheckout checkout = new DirCacheCheckout (repo, null, dc, c.Tree); checkout.Checkout (); } catch { if (dc != null) dc.Unlock (); throw; } }
/// <exception cref="System.IO.IOException"></exception> protected internal override bool MergeImpl() { bool implicitDirCache = false; if (dircache == null) { dircache = GetRepository().LockDirCache(); implicitDirCache = true; } try { builder = dircache.Builder(); DirCacheBuildIterator buildIt = new DirCacheBuildIterator(builder); tw = new NameConflictTreeWalk(db); tw.AddTree(MergeBase()); tw.AddTree(sourceTrees[0]); tw.AddTree(sourceTrees[1]); tw.AddTree(buildIt); if (workingTreeIterator != null) { tw.AddTree(workingTreeIterator); } while (tw.Next()) { if (!ProcessEntry(tw.GetTree<CanonicalTreeParser>(T_BASE), tw.GetTree<CanonicalTreeParser >(T_OURS), tw.GetTree<CanonicalTreeParser>(T_THEIRS), tw.GetTree<DirCacheBuildIterator >(T_INDEX), (workingTreeIterator == null) ? null : tw.GetTree<WorkingTreeIterator >(T_FILE))) { CleanUp(); return false; } if (tw.IsSubtree && enterSubtree) { tw.EnterSubtree(); } } if (!inCore) { // All content-merges are successfully done. If we can now write the // new index we are on quite safe ground. Even if the checkout of // files coming from "theirs" fails the user can work around such // failures by checking out the index again. if (!builder.Commit()) { CleanUp(); throw new IndexWriteException(); } builder = null; // No problem found. The only thing left to be done is to checkout // all files from "theirs" which have been selected to go into the // new index. Checkout(); } else { builder.Finish(); builder = null; } if (GetUnmergedPaths().IsEmpty()) { resultTree = dircache.WriteTree(oi); return true; } else { resultTree = null; return false; } } finally { if (implicitDirCache) { dircache.Unlock(); } } }
/// <summary>Write an ObjectId and LF to the temporary file.</summary> /// <remarks>Write an ObjectId and LF to the temporary file.</remarks> /// <param name="id"> /// the id to store in the file. The id will be written in hex, /// followed by a sole LF. /// </param> /// <exception cref="System.IO.IOException"> /// the temporary file could not be written. The lock is released /// before throwing the underlying IO exception to the caller. /// </exception> /// <exception cref="Sharpen.RuntimeException"> /// the temporary file could not be written. The lock is released /// before throwing the underlying exception to the caller. /// </exception> public virtual void Write(ObjectId id) { byte[] buf = new byte[Constants.OBJECT_ID_STRING_LENGTH + 1]; id.CopyTo(buf, 0); buf[Constants.OBJECT_ID_STRING_LENGTH] = (byte)('\n'); Write(buf); }
/// <exception cref="System.IO.IOException"></exception> protected internal virtual void CreateBranch(ObjectId objectId, string branchName ) { RefUpdate updateRef = db.UpdateRef(branchName); updateRef.SetNewObjectId(objectId); updateRef.Update(); }
/// <exception cref="System.IO.IOException"></exception> private void WriteReflog(Repository db, ObjectId newId, string msg, string refName ) { RefDirectory refs = (RefDirectory)db.RefDatabase; RefDirectoryUpdate update = ((RefDirectoryUpdate)refs.NewUpdate(refName, true)); update.SetNewObjectId(newId); refs.Log(update, msg, true); }
/// <summary>Construct a MissingObjectException for the specified object id.</summary> /// <remarks> /// Construct a MissingObjectException for the specified object id. /// Expected type is reported to simplify tracking down the problem. /// </remarks> /// <param name="id">SHA-1</param> /// <param name="type">object type</param> public MissingObjectException(ObjectId id, int type) : this(id, Constants.TypeString (type)) { }
/// <summary>Construct a PackedObjectInfo instance for this parser.</summary> /// <remarks>Construct a PackedObjectInfo instance for this parser.</remarks> /// <param name="id">identity of the object to be tracked.</param> /// <param name="delta"> /// if the object was previously an unresolved delta, this is the /// delta object that was tracking it. Otherwise null. /// </param> /// <param name="deltaBase"> /// if the object was previously an unresolved delta, this is the /// ObjectId of the base of the delta. The base may be outside of /// the pack stream if the stream was a thin-pack. /// </param> /// <returns>info object containing this object's data.</returns> protected internal virtual PackedObjectInfo NewInfo(AnyObjectId id, PackParser.UnresolvedDelta delta, ObjectId deltaBase) { PackedObjectInfo oe = new PackedObjectInfo(id); if (delta != null) { oe.SetCRC(delta.crc); } return oe; }
/// <summary> /// Create a new command for /// <see cref="BaseReceivePack">BaseReceivePack</see> /// . /// </summary> /// <param name="oldId"> /// the old object id; must not be null. Use /// <see cref="NGit.ObjectId.ZeroId()">NGit.ObjectId.ZeroId()</see> /// to indicate a ref creation. /// </param> /// <param name="newId"> /// the new object id; must not be null. Use /// <see cref="NGit.ObjectId.ZeroId()">NGit.ObjectId.ZeroId()</see> /// to indicate a ref deletion. /// </param> /// <param name="name">name of the ref being affected.</param> public ReceiveCommand(ObjectId oldId, ObjectId newId, string name) { this.oldId = oldId; this.newId = newId; this.name = name; type = ReceiveCommand.Type.UPDATE; if (ObjectId.ZeroId.Equals(oldId)) { type = ReceiveCommand.Type.CREATE; } if (ObjectId.ZeroId.Equals(newId)) { type = ReceiveCommand.Type.DELETE; } status = ReceiveCommand.Result.NOT_ATTEMPTED; }
/// <summary>Convert an ObjectId into a hex string representation.</summary> /// <remarks>Convert an ObjectId into a hex string representation.</remarks> /// <param name="i">the id to convert. May be null.</param> /// <returns>the hex string conversion of this id's content.</returns> public static string ToString(NGit.ObjectId i) { return(i != null ? i.Name : ZEROID_STR); }
public _PathEdit_93(ObjectId id, string baseArg1) : base(baseArg1) { this.id = id; }
static ObjectId() { ZEROID = new NGit.ObjectId(0, 0, 0, 0, 0); ZEROID_STR = ZEROID.Name; }