/// <summary>Commit this change and release the lock.</summary>
/// <remarks>
/// Commit this change and release the lock.
/// <p>
/// If this method fails (returns false) the lock is still released.
/// </remarks>
/// <returns>
/// true if the commit was successful and the file contains the new
/// data; false if the commit failed and the file remains with the
/// old data.
/// </returns>
/// <exception cref="System.InvalidOperationException">the lock is not held.</exception>
public virtual bool Commit()
{
LockFile tmp = myLock;
RequireLocked(tmp);
myLock = null;
if (!tmp.Commit())
{
return(false);
}
snapshot = tmp.GetCommitSnapshot();
return(true);
}
/// <summary>Commit this change and release the lock.</summary>
/// <remarks>
/// Commit this change and release the lock.
/// <p>
/// If this method fails (returns false) the lock is still released.
/// </remarks>
/// <returns>
/// true if the commit was successful and the file contains the new
/// data; false if the commit failed and the file remains with the
/// old data.
/// </returns>
/// <exception cref="System.InvalidOperationException">the lock is not held.</exception>
public virtual bool Commit()
{
LockFile tmp = myLock;
RequireLocked(tmp);
myLock = null;
if (!tmp.Commit())
{
return(false);
}
snapshot = tmp.GetCommitSnapshot();
if (indexChangedListener != null && !Arrays.Equals(readIndexChecksum, writeIndexChecksum
))
{
indexChangedListener.OnIndexChanged(new IndexChangedEvent());
}
return(true);
}
/// <exception cref="System.IO.IOException"></exception>
internal virtual void WriteTo(OutputStream os)
{
MessageDigest foot = Constants.NewMessageDigest();
DigestOutputStream dos = new DigestOutputStream(os, foot);
bool extended = false;
for (int i = 0; i < entryCnt; i++)
{
extended |= sortedEntries[i].IsExtended;
}
// Write the header.
//
byte[] tmp = new byte[128];
System.Array.Copy(SIG_DIRC, 0, tmp, 0, SIG_DIRC.Length);
NB.EncodeInt32(tmp, 4, extended ? 3 : 2);
NB.EncodeInt32(tmp, 8, entryCnt);
dos.Write(tmp, 0, 12);
// Write the individual file entries.
int smudge_s;
int smudge_ns;
if (myLock != null)
{
// For new files we need to smudge the index entry
// if they have been modified "now". Ideally we'd
// want the timestamp when we're done writing the index,
// so we use the current timestamp as a approximation.
myLock.CreateCommitSnapshot();
snapshot = myLock.GetCommitSnapshot();
smudge_s = (int)(snapshot.LastModified() / 1000);
smudge_ns = ((int)(snapshot.LastModified() % 1000)) * 1000000;
}
else
{
// Used in unit tests only
smudge_ns = 0;
smudge_s = 0;
}
// Check if tree is non-null here since calling updateSmudgedEntries
// will automatically build it via creating a DirCacheIterator
bool writeTree = tree != null;
if (repository != null && entryCnt > 0)
{
UpdateSmudgedEntries();
}
for (int i_1 = 0; i_1 < entryCnt; i_1++)
{
DirCacheEntry e = sortedEntries[i_1];
if (e.MightBeRacilyClean(smudge_s, smudge_ns))
{
e.SmudgeRacilyClean();
}
e.Write(dos);
}
if (writeTree)
{
TemporaryBuffer bb = new TemporaryBuffer.LocalFile();
tree.Write(tmp, bb);
bb.Close();
NB.EncodeInt32(tmp, 0, EXT_TREE);
NB.EncodeInt32(tmp, 4, (int)bb.Length());
dos.Write(tmp, 0, 8);
bb.WriteTo(dos, null);
}
writeIndexChecksum = foot.Digest();
os.Write(writeIndexChecksum);
os.Close();
}