private void advertiseAnyOnce(RevObject obj, string refName)
{
if (!obj.has(ADVERTISED))
{
advertiseAny(obj, refName);
}
}
public void testWritePack3()
{
_writer.ReuseDeltas = false;
var forcedOrder = new[]
{
ObjectId.FromString("82c6b885ff600be425b4ea96dee75dca255b69e7"),
ObjectId.FromString("c59759f143fb1fe21c197981df75a7ee00290799"),
ObjectId.FromString("aabf2ffaec9b497f0950352b3e582d73035c2035"),
ObjectId.FromString("902d5476fa249b7abc9d84c611577a81381f0327"),
ObjectId.FromString("5b6e7c66c276e7610d4a73c70ec1a1f7c1003259"),
ObjectId.FromString("6ff87c4664981e4397625791c8ea3bbb5f2279a3")
};
var parser = new GitSharp.Core.RevWalk.RevWalk(db);
var forcedOrderRevs = new RevObject[forcedOrder.Length];
for (int i = 0; i < forcedOrder.Length; i++)
{
forcedOrderRevs[i] = parser.parseAny(forcedOrder[i]);
}
CreateVerifyOpenPack(forcedOrderRevs.AsEnumerable());
Assert.AreEqual(forcedOrder.Length, _writer.getObjectsNumber());
VerifyObjectsOrder(forcedOrder);
Assert.AreEqual("ed3f96b8327c7c66b0f8f70056129f0769323d86", _writer.computeName().Name);
}
/// <summary>
/// Remove all entries from a map which key is the id of an object referenced
/// by the given ObjectWalk
/// </summary>
/// <param name="id2File"></param>
/// <param name="w"></param>
/// <exception cref="NGit.Errors.MissingObjectException">NGit.Errors.MissingObjectException
/// </exception>
/// <exception cref="NGit.Errors.IncorrectObjectTypeException">NGit.Errors.IncorrectObjectTypeException
/// </exception>
/// <exception cref="System.IO.IOException">System.IO.IOException</exception>
private void RemoveReferenced(IDictionary <ObjectId, FilePath> id2File, ObjectWalk
w)
{
RevObject ro = w.Next();
while (ro != null)
{
if (Sharpen.Collections.Remove(id2File, ro.Id) != null)
{
if (id2File.IsEmpty())
{
return;
}
}
ro = w.Next();
}
ro = w.NextObject();
while (ro != null)
{
if (Sharpen.Collections.Remove(id2File, ro.Id) != null)
{
if (id2File.IsEmpty())
{
return;
}
}
ro = w.NextObject();
}
}
/// <exception cref="System.IO.IOException"></exception>
private bool WantSatisfied(RevObject want)
{
if (want.Has(SATISFIED))
{
return(true);
}
walk.ResetRetain(SAVE);
walk.MarkStart((RevCommit)want);
if (oldestTime != 0)
{
walk.SetRevFilter(CommitTimeRevFilter.After(oldestTime * 1000L));
}
for (; ;)
{
RevCommit c = walk.Next();
if (c == null)
{
break;
}
if (c.Has(PEER_HAS))
{
AddCommonBase(c);
want.Add(SATISFIED);
return(true);
}
}
return(false);
}
private void Want(RevObject o)
{
if (o.has(WANT))
{
return;
}
o.add(WANT);
_wantAll.Add(o);
RevTag oTag = (o as RevTag);
while (oTag != null)
{
o = oTag.getObject();
oTag = (o as RevTag);
}
RevCommit oComm = (o as RevCommit);
if (oComm != null)
{
_wantCommits.Add(oComm);
}
}
private int MaxTimeWanted(ICollection <Ref> wants)
{
int maxTime = 0;
foreach (Ref r in wants)
{
try
{
RevObject obj = walk.ParseAny(r.GetObjectId());
if (obj is RevCommit)
{
int cTime = ((RevCommit)obj).CommitTime;
if (maxTime < cTime)
{
maxTime = cTime;
}
}
}
catch (IOException)
{
}
}
// We don't have it, but we want to fetch (thus fixing error).
return(maxTime);
}
private void ProcessTree(RevObject obj)
{
try
{
_treeWalk.reset(obj);
while (_treeWalk.next())
{
FileMode mode = _treeWalk.getFileMode(0);
int sType = (int)mode.ObjectType;
switch (sType)
{
case Constants.OBJ_BLOB:
case Constants.OBJ_TREE:
_treeWalk.getObjectId(_idBuffer, 0);
Needs(_revWalk.lookupAny(_idBuffer, sType));
continue;
default:
if (FileMode.GitLink.Equals(sType))
{
continue;
}
_treeWalk.getObjectId(_idBuffer, 0);
throw new CorruptObjectException("Invalid mode " + mode.ObjectType + " for " + _idBuffer.Name + " " +
_treeWalk.getPathString() + " in " + obj.getId().Name + ".");
}
}
}
catch (IOException ioe)
{
throw new TransportException("Cannot Read tree " + obj.Name, ioe);
}
obj.add(COMPLETE);
}
private void Want(RevObject o)
{
if (o.has(WANT))
{
return;
}
o.add(WANT);
_wantAll.Add(o);
if (o is RevCommit)
{
_wantCommits.Add((RevCommit)o);
}
else if (o is RevTag)
{
do
{
o = ((RevTag)o).getObject();
} while (o is RevTag);
if (o is RevCommit)
{
Want(o);
}
}
}
private RefUpdateResult UpdateImpl(RevWalk.RevWalk walk, StoreBase store)
{
if (isNameConflicting())
{
return(RefUpdateResult.LockFailure);
}
var @lock = new LockFile(_looseFile);
if ([email protected]())
{
return(RefUpdateResult.LockFailure);
}
try
{
OldObjectId = _db.IdOf(Name);
if (_expValue != null)
{
ObjectId o = OldObjectId ?? ObjectId.ZeroId;
if (!AnyObjectId.equals(_expValue, o))
{
return(RefUpdateResult.LockFailure);
}
}
if (OldObjectId == null)
{
return(store.Store(@lock, RefUpdateResult.New));
}
RevObject newObj = SafeParse(walk, _newValue);
RevObject oldObj = SafeParse(walk, OldObjectId);
if (newObj == oldObj)
{
return(store.Store(@lock, RefUpdateResult.NoChange));
}
RevCommit newCom = (newObj as RevCommit);
RevCommit oldCom = (oldObj as RevCommit);
if (newCom != null && oldCom != null)
{
if (walk.isMergedInto(oldCom, newCom))
{
return(store.Store(@lock, RefUpdateResult.FastForward));
}
}
if (IsForceUpdate)
{
return(store.Store(@lock, RefUpdateResult.Forced));
}
return(RefUpdateResult.Rejected);
}
finally
{
@lock.Unlock();
}
}
private void QueueWants(IEnumerable <Ref> want)
{
var inWorkQueue = new List <ObjectId>();
foreach (Ref r in want)
{
ObjectId id = r.ObjectId;
try
{
RevObject obj = _revWalk.parseAny(id);
if (obj.has(COMPLETE))
{
continue;
}
inWorkQueue.Add(id);
obj.add(IN_WORK_QUEUE);
_workQueue.AddLast(obj);
}
catch (MissingObjectException)
{
inWorkQueue.Add(id);
_workQueue.AddLast(id);
}
catch (IOException e)
{
throw new TransportException("Cannot Read " + id.Name, e);
}
}
}
public virtual void TestObjectMovedWithinPack()
{
// Create an object and pack it.
//
Repository eden = CreateBareRepository();
RevObject o1 = WriteBlob(eden, "o1");
FilePath[] out1 = Pack(eden, o1);
NUnit.Framework.Assert.AreEqual(o1.Name, Parse(o1).Name);
// Force close the old pack.
//
WhackCache();
// Now overwrite the old pack in place. This method of creating a
// different pack under the same file name is partially broken. We
// should also have a different file name because the list of objects
// within the pack has been modified.
//
RevObject o2 = WriteBlob(eden, "o2");
PackWriter pw = new PackWriter(eden);
pw.AddObject(o2);
pw.AddObject(o1);
Write(out1, pw);
pw.Release();
// Try the old name, then the new name. The old name should cause the
// pack to reload when it opens and the index and pack mismatch.
//
NUnit.Framework.Assert.AreEqual(o1.Name, Parse(o1).Name);
NUnit.Framework.Assert.AreEqual(o2.Name, Parse(o2).Name);
}
/// <exception cref="System.IO.IOException"></exception>
private void MarkLocalObjComplete(RevObject obj)
{
while (obj.Type == Constants.OBJ_TAG)
{
obj.Add(COMPLETE);
obj = ((RevTag)obj).GetObject();
revWalk.ParseHeaders(obj);
}
switch (obj.Type)
{
case Constants.OBJ_BLOB:
{
obj.Add(COMPLETE);
break;
}
case Constants.OBJ_COMMIT:
{
PushLocalCommit((RevCommit)obj);
break;
}
case Constants.OBJ_TREE:
{
MarkTreeComplete((RevTree)obj);
break;
}
}
}
/// <exception cref="NGit.Errors.TransportException"></exception>
private void QueueWants(ICollection <Ref> want)
{
HashSet <ObjectId> inWorkQueue = new HashSet <ObjectId>();
foreach (Ref r in want)
{
ObjectId id = r.GetObjectId();
try
{
RevObject obj = revWalk.ParseAny(id);
if (obj.Has(COMPLETE))
{
continue;
}
if (inWorkQueue.AddItem(id))
{
obj.Add(IN_WORK_QUEUE);
workQueue.AddItem(obj);
}
}
catch (MissingObjectException)
{
if (inWorkQueue.AddItem(id))
{
workQueue.AddItem(id);
}
}
catch (IOException e)
{
throw new TransportException(MessageFormat.Format(JGitText.Get().cannotRead, id.Name
), e);
}
}
}
private void ProcessTag(RevObject obj)
{
RevTag tag = (RevTag)obj;
Needs(tag.GetObject());
obj.Add(COMPLETE);
}
private void MarkLocalObjComplete(RevObject obj)
{
while (obj.Type == Constants.OBJ_TAG)
{
obj.add(COMPLETE);
obj.DisposeBody();
obj = ((RevTag)obj).getObject();
_revWalk.parseHeaders(obj);
}
switch (obj.Type)
{
case Constants.OBJ_BLOB:
obj.add(COMPLETE);
break;
case Constants.OBJ_COMMIT:
PushLocalCommit((RevCommit)obj);
break;
case Constants.OBJ_TREE:
MarkTreeComplete(obj);
break;
}
}
public virtual int Compare(Ref o1, Ref o2)
{
try
{
RevObject obj1 = this._enclosing.ParseAny(o1.GetObjectId());
RevObject obj2 = this._enclosing.ParseAny(o2.GetObjectId());
long t1 = this.Timeof(obj1);
long t2 = this.Timeof(obj2);
if (t1 > t2)
{
return(-1);
}
if (t1 < t2)
{
return(1);
}
}
catch (IOException)
{
}
// ignore
int cmp = this.Kind(o1) - this.Kind(o2);
if (cmp == 0)
{
cmp = Sharpen.Runtime.CompareOrdinal(o1.GetName(), o2.GetName());
}
return(cmp);
}
public void testObjectMovedToNewPack1()
{
// Create an object and pack it. Then remove that pack and put the
// object into a different pack file, with some other object. We
// still should be able to access the objects.
//
Core.Repository eden = createBareRepository();
RevObject o1 = WriteBlob(eden, "o1");
FileInfo[] out1 = Pack(eden, o1);
Assert.AreEqual(o1.Name, Parse(o1).Name);
RevObject o2 = WriteBlob(eden, "o2");
Pack(eden, o2, o1);
// Force close, and then delete, the old pack.
//
WhackCache();
Delete(out1);
// Now here is the interesting thing. Will git figure the new
// object exists in the new pack, and not the old one.
//
Assert.AreEqual(o2.Name, Parse(o2).Name);
Assert.AreEqual(o1.Name, Parse(o1).Name);
}
private void ProcessTag(RevObject obj)
{
var tag = (RevTag)obj;
Needs(tag.getObject());
obj.add(COMPLETE);
}
/// <summary>
/// Mark an element which used to be shallow in the client, but which
/// should now be considered a full commit.
/// </summary>
/// <remarks>
/// Mark an element which used to be shallow in the client, but which
/// should now be considered a full commit. Any ancestors of this commit
/// should be included in the walk, even if they are the ancestor of an
/// uninteresting commit.
/// </remarks>
/// <param name="c">Commit to mark</param>
/// <exception cref="NGit.Errors.MissingObjectException">NGit.Errors.MissingObjectException
/// </exception>
/// <exception cref="NGit.Errors.IncorrectObjectTypeException">NGit.Errors.IncorrectObjectTypeException
/// </exception>
/// <exception cref="System.IO.IOException">System.IO.IOException</exception>
public virtual void MarkUnshallow(RevObject c)
{
if (c is RevCommit)
{
c.Add(UNSHALLOW);
}
base.MarkStart(c);
}
private void ProcessBlob(RevObject obj)
{
if (!_local.HasObject(obj))
{
throw new TransportException("Cannot Read blob " + obj.Name, new MissingObjectException(obj, Constants.TYPE_BLOB));
}
obj.add(COMPLETE);
}
private void AddCommonBase(RevObject o)
{
if (o.has(COMMON))
{
return;
}
o.add(COMMON);
_commonBase.Add(o);
}
private void AddCommonBase(RevObject o)
{
if (!o.Has(COMMON))
{
o.Add(COMMON);
commonBase.AddItem(o);
okToGiveUp = null;
}
}
private void Process(ObjectId id)
{
RevObject obj;
try
{
RevObject ro = (id as RevObject);
if (ro != null)
{
obj = ro;
if (obj.has(COMPLETE))
{
return;
}
_revWalk.parseHeaders(obj);
}
else
{
obj = _revWalk.parseAny(id);
if (obj.has(COMPLETE))
{
return;
}
}
}
catch (IOException e)
{
throw new TransportException("Cannot Read " + id.Name, e);
}
obj.DisposeBody();
switch (obj.Type)
{
case Constants.OBJ_BLOB:
ProcessBlob(obj);
break;
case Constants.OBJ_TREE:
ProcessTree(obj);
break;
case Constants.OBJ_COMMIT:
ProcessCommit(obj);
break;
case Constants.OBJ_TAG:
ProcessTag(obj);
break;
default:
throw new TransportException("Unknown object type " + id.Name + " (" + obj.Type + ")");
}
_fetchErrors.Remove(id.Copy());
}
/*
* Construct an annotated tag object pointing at another object.
* <p>
* The tagger is the committer identity, at the current time as specified by
* {@link #tick(int)}. The time is not increased.
* <p>
* The tag message is empty.
*
* @param name
* name of the tag. Traditionally a tag name should not start
* with {@code refs/tags/}.
* @param dst
* object the tag should be pointed at.
* @return the annotated tag object.
* @throws Exception
*/
public RevTag tag(String name, RevObject dst)
{
global::GitSharp.Core.Tag t = new global::GitSharp.Core.Tag(db);
t.TagType = (Constants.typeString(dst.Type));
t.Id = (dst.ToObjectId());
t.TagName = (name);
t.Tagger = (new PersonIdent(committer, now.MillisToUtcDateTime()));
t.Message = ("");
return((RevTag)pool.lookupAny(writer.WriteTag(t), Constants.OBJ_TAG));
}
public void testObjectInNewPack()
{
// Create a new object in a new pack, and test that it is present.
//
Core.Repository eden = createBareRepository();
RevObject o1 = WriteBlob(eden, "o1");
Pack(eden, o1);
Assert.AreEqual(o1.Name, Parse(o1).Name);
}
private void MarkCommon(RevObject obj)
{
obj.add(COMMON);
RevCommit oComm = (obj as RevCommit);
if (oComm != null)
{
oComm.carry(COMMON);
}
}
public virtual void TestObjectInNewPack()
{
// Create a new object in a new pack, and test that it is present.
//
Repository eden = CreateBareRepository();
RevObject o1 = WriteBlob(eden, "o1");
Pack(eden, o1);
NUnit.Framework.Assert.AreEqual(o1.Name, Parse(o1).Name);
}
private void ProcessCommit(RevObject obj)
{
var commit = (RevCommit)obj;
MarkLocalCommitsComplete(commit.CommitTime);
Needs(commit.Tree);
foreach (RevCommit p in commit.Parents)
{
Needs(p);
}
obj.add(COMPLETE);
}
private void Needs(RevObject obj)
{
if (obj.Has(COMPLETE))
{
return;
}
if (!obj.Has(IN_WORK_QUEUE))
{
obj.Add(IN_WORK_QUEUE);
workQueue.AddItem(obj);
}
}
protected RevTag Tag(string name, RevObject dst)
{
var t = new Core.Tag(db)
{
TagType = Constants.typeString(dst.Type),
Id = dst.ToObjectId(),
TagName = name,
Tagger = new PersonIdent(committer, (nowTick).MillisToDateTime()),
Message = string.Empty
};
return((RevTag)rw.lookupAny(_ow.WriteTag(t), Constants.OBJ_TAG));
}
public void add(RevObject c)
{
Block b = tail;
if (b == null)
{
b = free.newBlock();
b.add(c);
head = b;
tail = b;
return;
}
else if (b.isFull())
{
b = free.newBlock();
tail.next = b;
tail = b;
}
b.add(c);
}
public void add(RevObject c)
{
objects[tailIndex++] = c;
}
