/// <summary>Writes merged file content to the working tree.</summary>
/// <remarks>
/// Writes merged file content to the working tree. In case
/// <see cref="inCore">inCore</see>
/// is set and we don't have a working tree the content is written to a
/// temporary file
/// </remarks>
/// <param name="result">the result of the content merge</param>
/// <returns>the file to which the merged content was written</returns>
/// <exception cref="System.IO.FileNotFoundException">System.IO.FileNotFoundException
/// </exception>
/// <exception cref="System.IO.IOException">System.IO.IOException</exception>
private FilePath WriteMergedFile(MergeResult <RawText> result)
{
MergeFormatter fmt = new MergeFormatter();
FilePath of = null;
FileOutputStream fos;
if (!inCore)
{
FilePath workTree = db.WorkTree;
if (workTree == null)
{
// TODO: This should be handled by WorkingTreeIterators which
// support write operations
throw new NGit.Errors.NotSupportedException();
}
of = new FilePath(workTree, tw.PathString);
FilePath parentFolder = of.GetParentFile();
if (!parentFolder.Exists())
{
parentFolder.Mkdirs();
}
fos = new FileOutputStream(of);
try
{
fmt.FormatMerge(fos, result, Arrays.AsList(commitNames), Constants.CHARACTER_ENCODING
);
}
finally
{
fos.Close();
}
}
else
{
if (!result.ContainsConflicts())
{
// When working inCore, only trivial merges can be handled,
// so we generate objects only in conflict free cases
of = FilePath.CreateTempFile("merge_", "_temp", null);
fos = new FileOutputStream(of);
try
{
fmt.FormatMerge(fos, result, Arrays.AsList(commitNames), Constants.CHARACTER_ENCODING
);
}
finally
{
fos.Close();
}
}
}
return(of);
}
/// <exception cref="System.IO.IOException"></exception>
private string Merge(string commonBase, string ours, string theirs)
{
MergeResult <RawText> r = new MergeAlgorithm().Merge(RawTextComparator.DEFAULT, RT(commonBase
), RT(ours), RT(theirs));
ByteArrayOutputStream bo = new ByteArrayOutputStream(50);
fmt.FormatMerge(bo, r, "B", "O", "T", Constants.CHARACTER_ENCODING);
return(Sharpen.Runtime.GetStringForBytes(bo.ToByteArray(), Constants.CHARACTER_ENCODING
));
}
/// <exception cref="System.IO.FileNotFoundException"></exception>
/// <exception cref="System.InvalidOperationException"></exception>
/// <exception cref="System.IO.IOException"></exception>
private bool ContentMerge(CanonicalTreeParser @base, CanonicalTreeParser ours, CanonicalTreeParser
theirs)
{
MergeFormatter fmt = new MergeFormatter();
RawText baseText = @base == null ? RawText.EMPTY_TEXT : GetRawText(@base.EntryObjectId
, db);
// do the merge
MergeResult<RawText> result = mergeAlgorithm.Merge(RawTextComparator.DEFAULT, baseText
, GetRawText(ours.EntryObjectId, db), GetRawText(theirs.EntryObjectId, db));
FilePath of = null;
FileOutputStream fos;
if (!inCore)
{
FilePath workTree = db.WorkTree;
if (workTree == null)
{
// TODO: This should be handled by WorkingTreeIterators which
// support write operations
throw new NotSupportedException();
}
of = new FilePath(workTree, tw.PathString);
fos = new FileOutputStream(of);
try
{
fmt.FormatMerge(fos, result, Arrays.AsList(commitNames), Constants.CHARACTER_ENCODING
);
}
finally
{
fos.Close();
}
}
else
{
if (!result.ContainsConflicts())
{
// When working inCore, only trivial merges can be handled,
// so we generate objects only in conflict free cases
of = FilePath.CreateTempFile("merge_", "_temp", null);
fos = new FileOutputStream(of);
try
{
fmt.FormatMerge(fos, result, Arrays.AsList(commitNames), Constants.CHARACTER_ENCODING
);
}
finally
{
fos.Close();
}
}
}
if (result.ContainsConflicts())
{
// a conflict occured, the file will contain conflict markers
// the index will be populated with the three stages and only the
// workdir (if used) contains the halfways merged content
Add(tw.RawPath, @base, DirCacheEntry.STAGE_1);
Add(tw.RawPath, ours, DirCacheEntry.STAGE_2);
Add(tw.RawPath, theirs, DirCacheEntry.STAGE_3);
mergeResults.Put(tw.PathString, result.Upcast ());
return false;
}
else
{
// no conflict occured, the file will contain fully merged content.
// the index will be populated with the new merged version
DirCacheEntry dce = new DirCacheEntry(tw.PathString);
dce.FileMode = tw.GetFileMode(0);
dce.LastModified = of.LastModified();
dce.SetLength((int)of.Length());
InputStream @is = new FileInputStream(of);
try
{
dce.SetObjectId(oi.Insert(Constants.OBJ_BLOB, of.Length(), @is));
}
finally
{
@is.Close();
if (inCore)
{
FileUtils.Delete(of);
}
}
builder.Add(dce);
return true;
}
}
/// <exception cref="System.IO.FileNotFoundException"></exception>
/// <exception cref="System.InvalidOperationException"></exception>
/// <exception cref="System.IO.IOException"></exception>
private bool ContentMerge(CanonicalTreeParser @base, CanonicalTreeParser ours, CanonicalTreeParser
theirs)
{
MergeFormatter fmt = new MergeFormatter();
RawText baseText = @base == null ? RawText.EMPTY_TEXT : GetRawText(@base.EntryObjectId
, db);
// do the merge
MergeResult <RawText> result = mergeAlgorithm.Merge(RawTextComparator.DEFAULT, baseText
, GetRawText(ours.EntryObjectId, db), GetRawText(theirs.EntryObjectId, db));
FilePath of = null;
FileOutputStream fos;
if (!inCore)
{
FilePath workTree = db.WorkTree;
if (workTree == null)
{
// TODO: This should be handled by WorkingTreeIterators which
// support write operations
throw new NotSupportedException();
}
of = new FilePath(workTree, tw.PathString);
fos = new FileOutputStream(of);
try
{
fmt.FormatMerge(fos, result, Arrays.AsList(commitNames), Constants.CHARACTER_ENCODING
);
}
finally
{
fos.Close();
}
}
else
{
if (!result.ContainsConflicts())
{
// When working inCore, only trivial merges can be handled,
// so we generate objects only in conflict free cases
of = FilePath.CreateTempFile("merge_", "_temp", null);
fos = new FileOutputStream(of);
try
{
fmt.FormatMerge(fos, result, Arrays.AsList(commitNames), Constants.CHARACTER_ENCODING
);
}
finally
{
fos.Close();
}
}
}
if (result.ContainsConflicts())
{
// a conflict occurred, the file will contain conflict markers
// the index will be populated with the three stages and only the
// workdir (if used) contains the halfways merged content
Add(tw.RawPath, @base, DirCacheEntry.STAGE_1);
Add(tw.RawPath, ours, DirCacheEntry.STAGE_2);
Add(tw.RawPath, theirs, DirCacheEntry.STAGE_3);
mergeResults.Put(tw.PathString, result.Upcast());
return(false);
}
else
{
// no conflict occurred, the file will contain fully merged content.
// the index will be populated with the new merged version
DirCacheEntry dce = new DirCacheEntry(tw.PathString);
dce.FileMode = tw.GetFileMode(0);
dce.LastModified = of.LastModified();
dce.SetLength((int)of.Length());
InputStream @is = new FileInputStream(of);
try
{
dce.SetObjectId(oi.Insert(Constants.OBJ_BLOB, of.Length(), @is));
}
finally
{
@is.Close();
if (inCore)
{
FileUtils.Delete(of);
}
}
builder.Add(dce);
return(true);
}
}
/// <summary>Writes merged file content to the working tree.</summary>
/// <remarks>
/// Writes merged file content to the working tree. In case
/// <see cref="inCore">inCore</see>
/// is set and we don't have a working tree the content is written to a
/// temporary file
/// </remarks>
/// <param name="result">the result of the content merge</param>
/// <returns>the file to which the merged content was written</returns>
/// <exception cref="System.IO.FileNotFoundException">System.IO.FileNotFoundException
/// </exception>
/// <exception cref="System.IO.IOException">System.IO.IOException</exception>
private FilePath WriteMergedFile(MergeResult<RawText> result)
{
MergeFormatter fmt = new MergeFormatter();
FilePath of = null;
FileOutputStream fos;
if (!inCore)
{
FilePath workTree = db.WorkTree;
if (workTree == null)
{
// TODO: This should be handled by WorkingTreeIterators which
// support write operations
throw new NGit.Errors.NotSupportedException();
}
of = new FilePath(workTree, tw.PathString);
fos = new FileOutputStream(of);
try
{
fmt.FormatMerge(fos, result, Arrays.AsList(commitNames), Constants.CHARACTER_ENCODING
);
}
finally
{
fos.Close();
}
}
else
{
if (!result.ContainsConflicts())
{
// When working inCore, only trivial merges can be handled,
// so we generate objects only in conflict free cases
of = FilePath.CreateTempFile("merge_", "_temp", null);
fos = new FileOutputStream(of);
try
{
fmt.FormatMerge(fos, result, Arrays.AsList(commitNames), Constants.CHARACTER_ENCODING
);
}
finally
{
fos.Close();
}
}
}
return of;
}
