private ExecutionBlock ScriptDifferences(Differences differences)
{
var work = new Work();
work.BuildFromDifferences(differences, Options.Default, true);
ExecutionBlock block = work.ExecutionBlock;
return block;
}
/// <summary>
/// Build a code that can be used to transform one version of a file into another.
/// </summary>
public static string BuildDiffCode(Differences differences)
{
var sb = new StringBuilder();
int pos = 0;
int del = 0;
string ins = "";
foreach (Fragment frag in differences) {
if (frag.Type == Differences.FragmentType.Unchanged) {
pos += del;
pos -= ins.Length;
if (del > 0 || ins.Length > 0) {
WriteDiffCode(sb, pos-del, del, ins);
}
pos += frag.Length;
del = 0;
ins = "";
} else if (frag.Type == Differences.FragmentType.Deleted) {
del += frag.Length;
} else if (frag.Type == Differences.FragmentType.Inserted) {
pos += frag.Length;
ins += frag.SplitPart;
} else {
throw new Exception("broken frag type");
}
}
// Don't forget the last one!
if (del > 0 || ins.Length > 0) {
WriteDiffCode(sb, pos - del, del, ins);
}
return sb.ToString();
}
public Fragment(Differences.FragmentType ThisType, string Part, int Location)
{
sb = new StringBuilder();
Type = ThisType;
Position = Location;
sb.Append(Part);
}
public virtual AttributeNode GetClosestMatch(AttributeNode/*!*/ nd1, AttributeList/*!*/ list1, AttributeList list2, int list1pos, ref int list2start,
TrivialHashtable/*!*/ matchedNodes, out Differences closestDifferences, out int list2pos) {
closestDifferences = null; list2pos = -1;
if (list2 == null) return null;
if (nd1 == null || list1 == null || matchedNodes == null || list1pos < 0 || list1pos >= list1.Count || list2start < 0 || list2start >= list2.Count) {
Debug.Assert(false); return null;
}
AttributeNode closest = null;
Differences winnerSoFar = null;
for (int j = list2start, m = list2.Count; j < m; j++){
AttributeNode nd2 = list2[j];
if (list2start == j) list2start++;
if (nd2 == null) continue;
if (matchedNodes[nd2.UniqueKey] != null) continue;
Differences diff = this.GetDifferences(nd1, nd2);
if (diff == null){Debug.Assert(false); continue;}
if (diff.Similarity <= 0.5){
//Not a good enough match
if (list2start == j+1) list2start--; //The next call to GetClosestMatch will start looking at list2start, so this node will be considered then
continue; //ignore it for the rest of this call
}
if (winnerSoFar != null && winnerSoFar.Similarity >= diff.Similarity) continue;
winnerSoFar = closestDifferences = diff;
closest = nd2;
list2pos = j;
if (diff.NumberOfDifferences == 0) return closest; //Perfect match, no need to look for other matches
}
if (closest != null){
//^ assert winnerSoFar != null;
//closest is closer to nd1 than any other node in list2, but this is no good if some other node in list1 has a better claim on closest
for (int i = list1pos+1, n = list1.Count; i < n; i++){
AttributeNode nd1alt = list1[i];
if (nd1alt == null) continue;
if (matchedNodes[nd1alt.UniqueKey] != null) continue;
Differences diff = this.GetDifferences(nd1alt, closest);
if (diff == null){Debug.Assert(false); continue;}
if (diff.Similarity <= winnerSoFar.Similarity) continue;
//nd1alt has a better claim on closest. See if it wants closest.
Differences diff2;
int j, k = list2start;
AttributeNode nd2alt = this.GetClosestMatch(nd1alt, list1, list2, i, ref k, matchedNodes, out diff2, out j);
if (nd2alt != closest){
Debug.Assert(nd2alt != null && diff2 != null && diff2.Similarity >= diff.Similarity);
continue; //nd1alt prefers nd2alt to closest, so closest is still available
}
//nd1alt wants closest, take it out of the running
matchedNodes[closest.UniqueKey] = nd1alt;
//Now that closest is out of the running, try again
k = list2start;
AttributeNode newClosest = this.GetClosestMatch(nd1, list1, list2, i, ref k, matchedNodes, out winnerSoFar, out list2pos);
//put closest back in the running so that the next call to this routine will pick it up
matchedNodes[closest.UniqueKey] = closest;
closest = newClosest;
break;
}
}
closestDifferences = winnerSoFar;
return closest;
}
/// <summary>
/// Compare an enumeration
/// </summary>
/// <param name="object1">The object1.</param>
/// <param name="object2">The object2.</param>
/// <param name="breadCrumb">The bread crumb.</param>
private void CompareEnum(object object1, object object2, string breadCrumb)
{
if (object1.ToString() != object2.ToString())
{
string currentBreadCrumb = AddBreadCrumb(breadCrumb, object1.GetType().Name, string.Empty, -1);
Differences.Add(string.Format("object1{0} != object2{0} ({1},{2})", currentBreadCrumb, object1, object2));
}
}
/// <summary>
/// Compare an array or something that implements IList
/// </summary>
/// <param name="object1"></param>
/// <param name="object2"></param>
/// <param name="breadCrumb"></param>
private void CompareIList(object object1, object object2, string breadCrumb)
{
_parents.Add(object1);
_parents.Add(object2);
IList ilist1 = object1 as IList;
IList ilist2 = object2 as IList;
if (ilist1 == null) //This should never happen, null check happens one level up
{
throw new ArgumentNullException("object1");
}
if (ilist2 == null) //This should never happen, null check happens one level up
{
throw new ArgumentNullException("object2");
}
//Objects must be the same length
if (ilist1.Count != ilist2.Count)
{
Differences.Add(string.Format("object1{0}.Count != object2{0}.Count ({1},{2})", breadCrumb, ilist1.Count, ilist2.Count));
if (Differences.Count >= MaxDifferences)
{
return;
}
}
IEnumerator enumerator1 = ilist1.GetEnumerator();
IEnumerator enumerator2 = ilist2.GetEnumerator();
int count = 0;
while (enumerator1.MoveNext() && enumerator2.MoveNext())
{
string currentBreadCrumb = AddBreadCrumb(breadCrumb, string.Empty, string.Empty, count);
bool object1IsParent = enumerator1.Current != null && (enumerator1.Current == object1 || _parents.Contains(enumerator1.Current));
bool object2IsParent = enumerator2.Current != null && (enumerator2.Current == object2 || _parents.Contains(enumerator2.Current));
//Skip properties where both point to the corresponding parent
if ((enumerator1.Current != null) &&
(IsClass(enumerator1.Current.GetType())) &&
(object1IsParent && object2IsParent))
{
continue;
}
Compare(enumerator1.Current, enumerator2.Current, currentBreadCrumb);
if (Differences.Count >= MaxDifferences)
{
return;
}
count++;
}
}
private void CompareDataRow(object expected, object actual, string breadCrumb)
{
DataRow dataRow1 = expected as DataRow;
DataRow dataRow2 = actual as DataRow;
if (dataRow1 == null) //This should never happen, null check happens one level up
{
throw new ArgumentNullException("expected");
}
if (dataRow2 == null) //This should never happen, null check happens one level up
{
throw new ArgumentNullException("actual");
}
for (int i = 0; i < dataRow1.Table.Columns.Count; i++)
{
//If we should ignore it, skip it
if (ElementsToIgnore.Contains(dataRow1.Table.Columns[i].ColumnName))
{
continue;
}
//If we should ignore read only, skip it
if (!CompareReadOnly && dataRow1.Table.Columns[i].ReadOnly)
{
continue;
}
//Both are null
if (dataRow1.IsNull(i) && dataRow2.IsNull(i))
{
continue;
}
string currentBreadCrumb = AddBreadCrumb(breadCrumb, string.Empty, string.Empty, dataRow1.Table.Columns[i].ColumnName);
//Check if one of them is null
if (dataRow1.IsNull(i))
{
Differences.Add(string.Format("expected{0} == null && actual{0} != null ((null),{1})", currentBreadCrumb, cStr(actual)));
return;
}
if (dataRow2.IsNull(i))
{
Differences.Add(string.Format("expected{0} != null && actual{0} == null ({1},(null))", currentBreadCrumb, cStr(expected)));
return;
}
Compare(dataRow1[i], dataRow2[i], currentBreadCrumb);
if (Differences.Count >= MaxDifferences)
{
return;
}
}
}
private void CompareDataTable(object expected, object actual, string breadCrumb)
{
DataTable dataTable1 = expected as DataTable;
DataTable dataTable2 = actual as DataTable;
if (dataTable1 == null) //This should never happen, null check happens one level up
{
throw new ArgumentNullException("expected");
}
if (dataTable2 == null) //This should never happen, null check happens one level up
{
throw new ArgumentNullException("actual");
}
//If we should ignore it, skip it
if (ElementsToIgnore.Contains(dataTable1.TableName))
{
return;
}
//There must be the same amount of rows in the datatable
if (dataTable1.Rows.Count != dataTable2.Rows.Count)
{
Differences.Add(string.Format("expected{0}.Rows.Count != actual{0}.Rows.Count ({1},{2})", breadCrumb,
dataTable1.Rows.Count, dataTable2.Rows.Count));
if (Differences.Count >= MaxDifferences)
{
return;
}
}
//There must be the same amount of columns in the datatable
if (dataTable1.Columns.Count != dataTable2.Columns.Count)
{
Differences.Add(string.Format("expected{0}.Columns.Count != actual{0}.Columns.Count ({1},{2})", breadCrumb,
dataTable1.Columns.Count, dataTable2.Columns.Count));
if (Differences.Count >= MaxDifferences)
{
return;
}
}
for (int i = 0; i < dataTable1.Rows.Count; i++)
{
string currentBreadCrumb = AddBreadCrumb(breadCrumb, "Rows", string.Empty, i);
CompareDataRow(dataTable1.Rows[i], dataTable2.Rows[i], currentBreadCrumb);
if (Differences.Count >= MaxDifferences)
{
return;
}
}
}
private bool ZipChanged(Differences differences)
{
bool result =
differences.Added.Any() ||
differences.Changed.Any() ||
differences.Removed.Any();
return(result);
}
/// <summary>
/// Compare two objects of the same type to each other.
/// </summary>
/// <remarks>
/// Check the Differences or DifferencesString Properties for the differences.
/// Default MaxDifferences is 1 for performance
/// </remarks>
/// <param name="expected"></param>
/// <param name="actual"></param>
/// <returns>True if they are equal</returns>
public bool Compare(object expected, object actual)
{
string defaultBreadCrumb = string.Empty;
Differences.Clear();
Compare(expected, actual, defaultBreadCrumb);
return(Differences.Count == 0);
}
/// <summary>
/// Compare two objects of the same type to each other.
/// </summary>
/// <remarks>
/// Check the Differences or DifferencesString Properties for the differences.
/// Default MaxDifferences is 1 for performance
/// </remarks>
/// <param name="object1"></param>
/// <param name="object2"></param>
/// <returns>True if they are equal</returns>
public bool Compare(object object1, object object2)
{
string defaultBreadCrumb = string.Empty;
Differences.Clear();
Compare(object1, object2, defaultBreadCrumb);
return(Differences.Count == 0);
}
/// <summary>
/// Compare an array or something that implements IList
/// </summary>
/// <param name="object1"></param>
/// <param name="object2"></param>
/// <param name="breadCrumb"></param>
private void CompareIList(object object1, object object2, string breadCrumb)
{
var ilist1 = object1 as IList;
var ilist2 = object2 as IList;
if (ilist1 == null) //This should never happen, null check happens one level up
{
throw new ArgumentNullException("object1");
}
if (ilist2 == null) //This should never happen, null check happens one level up
{
throw new ArgumentNullException("object2");
}
try {
_parents.Add(object1);
_parents.Add(object2);
//Objects must be the same length
if (ilist1.Count != ilist2.Count)
{
Differences.Add(string.Format("object1{0}.Count != object2{0}.Count ({1},{2})",
breadCrumb,
ilist1.Count,
ilist2.Count));
if (Differences.Count >= MaxDifferences)
{
return;
}
}
IEnumerator enumerator1 = ilist1.GetEnumerator();
IEnumerator enumerator2 = ilist2.GetEnumerator();
int count = 0;
while (enumerator1.MoveNext() &&
enumerator2.MoveNext())
{
string currentBreadCrumb = AddBreadCrumb(breadCrumb, string.Empty, string.Empty, count);
Compare(enumerator1.Current, enumerator2.Current, currentBreadCrumb);
if (Differences.Count >= MaxDifferences)
{
return;
}
count++;
}
}
finally {
_parents.Remove(object1);
_parents.Remove(object2);
}
}
/// --------------------------------------------------------------------------------
/// <summary>
/// Recheck for differences. Useful in ReplaceCurWithRev tests.
/// You could call DetectDifferences() directly to do the recheck, but his method
/// provides cleaner error reporting in case the test didn't revert all
/// original diffs first.
/// </summary>
/// --------------------------------------------------------------------------------
public void DetectDifferences_ReCheck()
{
// the caller should have already reviewed all diffs
Assert.AreEqual(0, Differences.Count);
// re-init our output list, for a fresh start
Differences.Clear();
base.DetectDifferences(new DummyProgressDlg());
}
/// <summary>
/// Compare a pointer struct
/// </summary>
/// <param name="object1"></param>
/// <param name="object2"></param>
/// <param name="breadCrumb"></param>
private void ComparePointer(object object1, object object2, string breadCrumb)
{
if (
(object1.GetType() == typeof(IntPtr) && object2.GetType() == typeof(IntPtr) && ((IntPtr)object1) != ((IntPtr)object2)) ||
(object1.GetType() == typeof(UIntPtr) && object2.GetType() == typeof(UIntPtr) && ((UIntPtr)object1) != ((UIntPtr)object2))
)
{
Differences.Add(string.Format("object1{0} != object2{0}", breadCrumb));
}
}
private void ExerciseOutputBuilders(Differences diff)
{
Assert.IsNotNull(diff);
this.ExerciseHtmlBuilder(diff);
this.ExerciseJsonBuilder(diff);
this.ExerciseXmlBuilder(diff);
this.ExerciseXmlBuilder2(diff);
this.ExerciseTextBuilder(diff);
}
private void GetDifferencesCommandExecuted(object obj)
{
Differences.Clear();
var differences = FileDifferenceChecker.GetFileVersionDifferences(FilePath1, FilePath2);
foreach (var difference in differences)
{
Differences.Add(difference);
}
}
void CompareIList(object object1, object object2, string breadCrumb)
{
IList ilist1 = object1 as IList;
IList ilist2 = object2 as IList;
if (ilist1 == null)
{
throw new ArgumentNullException("object1");
}
if (ilist2 == null)
{
throw new ArgumentNullException("object2");
}
try
{
_parents.Add(object1);
_parents.Add(object2);
if (ilist1.Count != ilist2.Count)
{
Differences.Add(string.Format("object1{0}.Count != object2{0}.Count ({1},{2})", breadCrumb,
ilist1.Count, ilist2.Count));
if (Differences.Count >= MaxDifferences)
{
return;
}
}
IEnumerator enumerator1 = ilist1.GetEnumerator();
IEnumerator enumerator2 = ilist2.GetEnumerator();
int count = 0;
while (enumerator1.MoveNext() && enumerator2.MoveNext())
{
string currentBreadCrumb = AddBreadCrumb(breadCrumb, string.Empty, string.Empty, count);
Compare(enumerator1.Current, enumerator2.Current, currentBreadCrumb);
if (Differences.Count >= MaxDifferences)
{
return;
}
count++;
}
}
finally
{
_parents.Remove(object1);
_parents.Remove(object2);
}
}
/// --------------------------------------------------------------------------------
/// <summary>
/// Expose the DetectDifferencesInListOfStTexts for testing.
/// </summary>
/// <param name="stTextsCurr"></param>
/// <param name="stTextsRev"></param>
/// --------------------------------------------------------------------------------
new public void DetectDifferencesInListOfStTexts(List <IStText> stTextsCurr, List <IStText> stTextsRev)
{
// init our cluster differences list
ClusterDiffs = new List <Difference>();
base.DetectDifferencesInListOfStTexts(stTextsCurr, stTextsRev);
// copy differences to the master list, where it's easy to verify them
Differences.Clear();
Differences.AddRange(ClusterDiffs);
}
internal void Save(Differences differences)
{
var find = collection.Find(x => x.Id == differences.Id);
if (find.Any())
{
collection.ReplaceOne(Builders <Differences> .Filter.Eq("Id", differences.Id), differences);
}
else
{
collection.InsertOne(differences);
}
}
private void ExerciseTextBuilder(Differences diff)
{
Assert.IsNotNull(diff);
using (var stream = new MemoryStream())
using (var writer = new StreamWriter(stream))
{
var builder = new TextBuilder();
builder.Build(writer, diff);
Assert.IsTrue(writer.BaseStream.Length > 0);
}
}
private static void NormalDiffChecker()
{
Differences differences = CLIGetFileSystemDifferences();
Console.WriteLine($"deletions: {differences.Left.Count()}");
File.WriteAllLines("deletions.txt", differences.Left);
Console.WriteLine($"common: {differences.Common.Count()}");
File.WriteAllLines("common.txt", differences.Common);
Console.WriteLine($"additions: {differences.Right.Count()}");
File.WriteAllLines("insertions.txt", differences.Right);
}
public void Test_diff_bettwen_two_equals_text_files()
{
string input = @"Lorem ipsum dolor sit amet, consectetur adipiscing elit.
Nullam tristique massa sed semper lobortis.
In facilisis risus ut feugiat lacinia.
Pellentesque a dui ut nunc efficitur tempus nec sit amet metus.";
var diffs = new Differences(input, input);
Assert.Equal(0, diffs.RemovedLines);
Assert.Equal(0, diffs.AddLines);
Assert.Equal(4, diffs.EqualLines);
}
/// <summary>
/// Compare a dictionary
/// </summary>
/// <param name="object1"></param>
/// <param name="object2"></param>
/// <param name="breadCrumb"></param>
private void CompareIDictionary(object object1, object object2, string breadCrumb)
{
IDictionary iDict1 = object1 as IDictionary;
IDictionary iDict2 = object2 as IDictionary;
if (iDict1 == null) //This should never happen, null check happens one level up
{
throw new ArgumentNullException("object1");
}
if (iDict2 == null) //This should never happen, null check happens one level up
{
throw new ArgumentNullException("object2");
}
//Objects must be the same length
if (iDict1.Count != iDict2.Count)
{
Differences.Add(string.Format("object1{0}.Count != object2{0}.Count ({1},{2})", breadCrumb, iDict1.Count, iDict2.Count));
if (Differences.Count >= MaxDifferences)
{
return;
}
}
IDictionaryEnumerator enumerator1 = iDict1.GetEnumerator();
IDictionaryEnumerator enumerator2 = iDict2.GetEnumerator();
while (enumerator1.MoveNext() && enumerator2.MoveNext())
{
string currentBreadCrumb = AddBreadCrumb(breadCrumb, "Key", string.Empty, -1);
Compare(enumerator1.Key, enumerator2.Key, currentBreadCrumb);
if (Differences.Count >= MaxDifferences)
{
return;
}
currentBreadCrumb = AddBreadCrumb(breadCrumb, "Value", string.Empty, -1);
Compare(enumerator1.Value, enumerator2.Value, currentBreadCrumb);
if (Differences.Count >= MaxDifferences)
{
return;
}
}
}
public override void Build(StreamWriter writer, Differences diff)
{
var entries = new List <ZipEntry>();
entries.AddRange(diff.Added.Values);
entries.AddRange(diff.Changed.Values.Select(x => x[1]));
var zipOut = new ZipOutputStream(writer.BaseStream);
var zipFile = new ZipFile(diff.File2);
foreach (var entry in entries)
{
var zipEntry = zipFile.GetEntry(entry.Name);
using (var stream = zipFile.GetInputStream(zipEntry))
{
var count = 0x800;
var buffer = new byte[0x800];
zipOut.PutNextEntry(new ZipEntry(entry.Name));
while (true)
{
count = stream.Read(buffer, 0, buffer.Length);
if (count <= 0)
{
break;
}
zipOut.Write(buffer, 0, count);
}
zipOut.CloseEntry();
buffer = null;
}
}
zipFile.Close();
if (_includeRemovedFile && diff.Removed.Count > 0)
{
var removedItems = Encoding.UTF8.GetBytes(string.Join("\r\n", diff.Removed.Keys));
zipOut.PutNextEntry(new ZipEntry("___removed.txt"));
zipOut.Write(removedItems, 0, removedItems.Length);
zipOut.CloseEntry();
}
zipOut.Finish();
zipOut.Flush();
}
public void Close()
{
if (AskClose())
{
ActiveDesigner = null;
ActiveDesigners = null;
if (_differences != null)
{
_differences.Close();
_differences = null;
}
_documentManager.Close();
}
}
/// <summary>
/// Compare a simple type
/// </summary>
/// <param name="object1"></param>
/// <param name="object2"></param>
/// <param name="breadCrumb"></param>
private void CompareSimpleType(object object1, object object2, string breadCrumb)
{
///////////////////////////////////////////////////////////////
// Modified by Raiford D. Brookshire to allow better DateTime compares and ignore milliseconds
////////////////////////////////////////////////////////////////
if (IgnoreDateTimeMilliseconds)
{
if (object1.GetType() == typeof(DateTime))
{
DateTime dt1 = (DateTime)object1;
dt1 = new DateTime((dt1.Ticks / TimeSpan.TicksPerSecond) * TimeSpan.TicksPerSecond);
object1 = dt1;
}
if (object2.GetType() == typeof(DateTime))
{
DateTime dt2 = (DateTime)object2;
dt2 = new DateTime((dt2.Ticks / TimeSpan.TicksPerSecond) * TimeSpan.TicksPerSecond);
object2 = dt2;
}
}
///////////////////////////////////////////////////////////////
// End of Modification:
////////////////////////////////////////////////////////////////
if (object2 == null) //This should never happen, null check happens one level up
{
throw new ArgumentNullException("object2");
}
IComparable valOne = object1 as IComparable;
if (valOne == null) //This should never happen, null check happens one level up
{
throw new ArgumentNullException("object1");
}
if (valOne.CompareTo(object2) != 0)
{
Differences.Add(string.Format("object1{0} != object2{0} ({1},{2})", breadCrumb, object1, object2));
}
}
private void CompareDataset(object object1, object object2, string breadCrumb)
{
var dataSet1 = object1 as DataSet;
var dataSet2 = object2 as DataSet;
if (dataSet1 == null) //This should never happen, null check happens one level up
{
throw new ArgumentNullException("object1");
}
if (dataSet2 == null) //This should never happen, null check happens one level up
{
throw new ArgumentNullException("object2");
}
//There must be the same amount of tables in the dataset
if (dataSet1.Tables.Count != dataSet2.Tables.Count)
{
Differences.Add(string.Format("object1{0}.Tables.Count != object2{0}.Tables.Count ({1},{2})",
breadCrumb,
dataSet1.Tables.Count,
dataSet2.Tables.Count));
if (Differences.Count >= MaxDifferences)
{
return;
}
}
for (int i = 0; i < dataSet1.Tables.Count; i++)
{
string currentBreadCrumb = AddBreadCrumb(breadCrumb,
"Tables",
string.Empty,
dataSet1.Tables[i].TableName);
CompareDataTable(dataSet1.Tables[i], dataSet2.Tables[i], currentBreadCrumb);
if (Differences.Count >= MaxDifferences)
{
return;
}
}
}
// return difference 8*8 block (taret - reference) and absolute diffrence
private Differences CalDifferences(double[,] reference, double[,] target)
{
var diffs = new Differences
{
AbsoluteDifference = 0,
DifferenceBlock = new double[N, N]
};
for (int row = 0; row < N; ++row)
{
for (int col = 0; col < N; ++col)
{
diffs.DifferenceBlock[row, col] = target[row, col] - reference[row, col];
diffs.AbsoluteDifference += Math.Abs(diffs.DifferenceBlock[row, col]);
}
}
return(diffs);
}
private void CompareWithCustomComparer(object object1,
object object2,
string breadCrumb,
Type t1,
Delegate customComparer)
{
if (TypesToIgnore.Contains(t1))
{
return;
}
CustomComparerDelegateWithDifferenceRecording customComparerDelegateWithDifferenceRecording = customComparer as CustomComparerDelegateWithDifferenceRecording;
CustomComparerDelegate customComparerDelegate = customComparer as CustomComparerDelegate;
if (customComparerDelegateWithDifferenceRecording != null)
{
// Compare with a custom comparator
List <string> differences = customComparerDelegateWithDifferenceRecording.Invoke(object1, object2);
if (differences.Count > 0)
{
Differences.AddRange(differences);
}
}
else
{
if (customComparerDelegate != null)
{
// Compare with a custom comparator
if (!customComparerDelegate.Invoke(object1, object2))
{
Differences.Add(string.Format("object1{0} != object2{0} ({1},{2})", breadCrumb, object1, object2));
}
}
else
{
throw new InvalidOperationException("Bad custom comparer specified.");
}
}
if (Differences.Count >= MaxDifferences)
{
return;
}
}
public void RunExample()
{
using (Database stagingDB = new Database(), productionDB = new Database())
{
ConnectionProperties sourceConnectionProperties = Program.StagingConnectionProperties;
ConnectionProperties targetConnectionProperties = Program.ProductionConnectionProperties;
Console.WriteLine("Registering database " + sourceConnectionProperties.DatabaseName);
try
{
stagingDB.Register(sourceConnectionProperties, Options.Default);
}
catch (SqlException e)
{
//e.WarnUserAboutDatabaseRegistryFailure(sourceConnectionProperties);
return;
}
Console.WriteLine("Registering database " + targetConnectionProperties.DatabaseName);
try
{
productionDB.Register(targetConnectionProperties, Options.Default);
}
catch (SqlException e)
{
//e.WarnUserAboutDatabaseRegistryFailure(targetConnectionProperties);
return;
}
// Compare WidgetStaging against WidgetProduction
Differences stagingVsProduction = stagingDB.CompareWith(productionDB, Options.Default);
// Display the results on the console
foreach (Difference difference in stagingVsProduction)
{
Console.WriteLine("{0} {1} {2}", difference.Type, difference.DatabaseObjectType, difference.Name);
}
}
}
public void DifferencesViewer()
{
_differences = new Differences();
string executablePath = GetExecutableFilePath();
Icon icon = Icon.ExtractAssociatedIcon(executablePath);
Bitmap bitmap = icon.ToBitmap();
IntPtr hBitmap = bitmap.GetHbitmap();
ImageSource wpfBitmap =
Imaging.CreateBitmapSourceFromHBitmap(
hBitmap, IntPtr.Zero, System.Windows.Int32Rect.Empty,
BitmapSizeOptions.FromEmptyOptions());
_differences.Icon = wpfBitmap;
_differences.Title = $"{GetProductName()} - Differences";
_differences.Show();
}
/// <summary>
/// Compare a simple type
/// </summary>
/// <param name="object1"></param>
/// <param name="object2"></param>
/// <param name="breadCrumb"></param>
private void CompareSimpleType(object object1, object object2, string breadCrumb)
{
if (object2 == null) //This should never happen, null check happens one level up
{
throw new ArgumentNullException("object2");
}
var valOne = object1 as IComparable;
if (valOne == null) //This should never happen, null check happens one level up
{
throw new ArgumentNullException("object1");
}
if (valOne.CompareTo(object2) != 0)
{
Differences.Add(string.Format("object1{0} != object2{0} ({1},{2})", breadCrumb, object1, object2));
}
}
protected void Page_Load(object sender, EventArgs e)
{
string left = File.ReadAllText(Server.MapPath("~/Examples/DeOfficiis.txt"));
//string left = File.ReadAllText(Server.MapPath("~/Examples/DeOfficiis_Recombined.txt"));
string right = File.ReadAllText(Server.MapPath("~/Examples/DeOfficiis_Altered.txt"));
//string right = File.ReadAllText(Server.MapPath("~/Examples/DeOfficiis_Minor_Altered.txt"));
//string right = File.ReadAllText(Server.MapPath("~/Examples/TotallyDifferent.txt"));
GC.Collect(3, GCCollectionMode.Forced); // give the algorithm a fair shot...
var sw = new System.Diagnostics.Stopwatch();
sw.Start();
var differences = new Differences(left, right, Differences.PerWord);
sw.Stop();
Repeater1.DataSource = from d in differences
select new Fragment(d.Type,
HttpContext.Current.Server.HtmlEncode(d.SplitPart).Replace("\n", "<br/>"), d.Position);
Repeater1.DataBind();
Response.Write("DocDiff took " + sw.Elapsed.TotalSeconds + " seconds<br/>");
// This gives a code to convert LEFT into RIGHT
// Is a revision repository, the older file would be RIGHT, and the newer be LEFT.
sw.Reset();
sw.Start();
byte[] final_out = DiffCode.StorageDiffCode(differences);
sw.Stop();
Response.Write("DocDiff-code took " + sw.Elapsed.TotalSeconds + " seconds<br/>");
double sizePc = ((double)final_out.Length / right.Length) * 100.0;
Response.Write("<br/>DocDiff code size: " + (final_out.Length / 1024) + "KiB which is " + sizePc.ToString("0.0") + "% of the resulting file");
Response.Write("<br/>diff code contains " + differences.Count() + " alterations.");
sw.Reset();
sw.Start();
File.WriteAllText(Server.MapPath("~/Examples/DeOfficiis_Recombined.txt"),
DiffCode.BuildRevision(left, DiffCode.BuildDiffCode(differences)));
sw.Stop();
Response.Write("<br/>Rebuild and write took " + sw.Elapsed.TotalSeconds + " seconds<br/>");
}
void CompareSimpleType(object object1, object object2, string breadCrumb)
{
if (object2 == null)
{
throw new ArgumentNullException("object2");
}
var valOne = object1 as IComparable;
if (valOne == null)
{
throw new ArgumentNullException("object1");
}
if (valOne.CompareTo(object2) != 0)
{
Differences.Add(string.Format("object1{0} != object2{0} ({1},{2})", breadCrumb, object1, object2));
}
}
public override void Build(StreamWriter writer, Differences diff)
{
var entries = new List <ZipEntry>();
entries.AddRange(diff.Added.Values);
entries.AddRange(diff.Changed.Values.Select(x => x[1]));
var zipOut = new ZipOutputStream(writer.BaseStream);
var zipFile = new ZipFile(diff.File2);
foreach (var entry in entries)
{
var zipEntry = zipFile.GetEntry(entry.Name);
using (var stream = zipFile.GetInputStream(zipEntry))
{
var count = 0x800;
var buffer = new byte[0x800];
zipOut.PutNextEntry(new ZipEntry(entry.Name));
while (true)
{
count = stream.Read(buffer, 0, buffer.Length);
if (count <= 0)
{
break;
}
zipOut.Write(buffer, 0, count);
}
zipOut.CloseEntry();
buffer = null;
}
}
zipFile.Close();
zipOut.Finish();
zipOut.Flush();
}
private void LogChanges(string zipFilePath, Differences differences)
{
Console.WriteLine("In {0}...", zipFilePath);
Logger.Info("In {0}...", zipFilePath);
var added = differences.Added;
var changed = differences.Changed;
var removed = differences.Removed;
int numberOfDifferences = added.Count + changed.Count + removed.Count;
if (numberOfDifferences > 0)
{
Console.WriteLine("Number of differences = {0}.", numberOfDifferences);
Logger.Info("Number of differences = {0}.", numberOfDifferences);
}
if (added.Any())
{
Console.WriteLine("Added...");
Logger.Info("Added...");
added.Keys.ToList().ForEach(k => { Console.WriteLine(k); Logger.Info(k); });
}
if (changed.Any())
{
Console.WriteLine("Changed...");
Logger.Info("Changed...");
changed.Keys.ToList().ForEach(k => { Console.WriteLine(k); Logger.Info(k); });
}
if (removed.Any())
{
Console.WriteLine("Removed...");
Logger.Info("Removed...");
removed.Keys.ToList().ForEach(k => { Console.WriteLine(k); Logger.Info(k); });
}
}
public virtual Differences VisitQueryQuantifier(QueryQuantifier qq1, QueryQuantifier qq2){
Differences differences = new Differences(qq1, qq2);
if (qq1 == null || qq2 == null){
if (qq1 != qq2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++;
return differences;
}
QueryQuantifier changes = (QueryQuantifier)qq2.Clone();
QueryQuantifier deletions = (QueryQuantifier)qq2.Clone();
QueryQuantifier insertions = (QueryQuantifier)qq2.Clone();
// qq1.Expression;
// qq1.Target;
if (differences.NumberOfDifferences == 0){
differences.Changes = null;
differences.Deletions = null;
differences.Insertions = null;
}else{
differences.Changes = changes;
differences.Deletions = deletions;
differences.Insertions = insertions;
}
return differences;
}
public virtual Differences GetMemberDifferences(Member member1, Member member2) {
if (member1 == null || member2 == null) return new Differences(member1, member2);
if (this.memberDifferencesMapFor == null) this.memberDifferencesMapFor = new TrivialHashtable();
TrivialHashtable map = this.memberDifferencesMapFor[member1.UniqueKey] as TrivialHashtable;
if (map == null) this.memberDifferencesMapFor[member1.UniqueKey] = map = new TrivialHashtable();
Differences differences = map[member2.UniqueKey] as Differences;
if (differences == null){
map[member2.UniqueKey] = differences = new Differences(member1, member2);
if (member1 == member2) differences.NumberOfSimilarities++;
}
return differences;
}
public virtual Differences VisitQueryUpdate(QueryUpdate update1, QueryUpdate update2){
Differences differences = new Differences(update1, update2);
if (update1 == null || update2 == null){
if (update1 != update2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++;
return differences;
}
QueryUpdate changes = (QueryUpdate)update2.Clone();
QueryUpdate deletions = (QueryUpdate)update2.Clone();
QueryUpdate insertions = (QueryUpdate)update2.Clone();
// update1.Context;
// update1.Source;
// update1.UpdateList;
if (differences.NumberOfDifferences == 0){
differences.Changes = null;
differences.Deletions = null;
differences.Insertions = null;
}else{
differences.Changes = changes;
differences.Deletions = deletions;
differences.Insertions = insertions;
}
return differences;
}
public virtual Differences VisitQueryTypeFilter(QueryTypeFilter filter1, QueryTypeFilter filter2){
Differences differences = new Differences(filter1, filter2);
if (filter1 == null || filter2 == null){
if (filter1 != filter2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++;
return differences;
}
QueryTypeFilter changes = (QueryTypeFilter)filter2.Clone();
QueryTypeFilter deletions = (QueryTypeFilter)filter2.Clone();
QueryTypeFilter insertions = (QueryTypeFilter)filter2.Clone();
// filter1.Constraint;
// filter1.Source;
if (differences.NumberOfDifferences == 0){
differences.Changes = null;
differences.Deletions = null;
differences.Insertions = null;
}else{
differences.Changes = changes;
differences.Deletions = deletions;
differences.Insertions = insertions;
}
return differences;
}
public virtual Differences VisitQuerySingleton(QuerySingleton singleton1, QuerySingleton singleton2){
Differences differences = new Differences(singleton1, singleton2);
if (singleton1 == null || singleton2 == null){
if (singleton1 != singleton2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++;
return differences;
}
QuerySingleton changes = (QuerySingleton)singleton2.Clone();
QuerySingleton deletions = (QuerySingleton)singleton2.Clone();
QuerySingleton insertions = (QuerySingleton)singleton2.Clone();
//singleton1.Source;
if (differences.NumberOfDifferences == 0){
differences.Changes = null;
differences.Deletions = null;
differences.Insertions = null;
}else{
differences.Changes = changes;
differences.Deletions = deletions;
differences.Insertions = insertions;
}
return differences;
}
public virtual Differences VisitQueryIterator(QueryIterator iterator1, QueryIterator iterator2){
Differences differences = new Differences(iterator1, iterator2);
if (iterator1 == null || iterator2 == null){
if (iterator1 != iterator2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++;
return differences;
}
QueryIterator changes = (QueryIterator)iterator2.Clone();
QueryIterator deletions = (QueryIterator)iterator2.Clone();
QueryIterator insertions = (QueryIterator)iterator2.Clone();
// iterator1.ElementType;
// iterator1.Expression;
// iterator1.HintList;
// iterator1.Name;
if (differences.NumberOfDifferences == 0){
differences.Changes = null;
differences.Deletions = null;
differences.Insertions = null;
}else{
differences.Changes = changes;
differences.Deletions = deletions;
differences.Insertions = insertions;
}
return differences;
}
public virtual Differences VisitQueryInsert(QueryInsert insert1, QueryInsert insert2){
Differences differences = new Differences(insert1, insert2);
if (insert1 == null || insert2 == null){
if (insert1 != insert2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++;
return differences;
}
QueryInsert changes = (QueryInsert)insert2.Clone();
QueryInsert deletions = (QueryInsert)insert2.Clone();
QueryInsert insertions = (QueryInsert)insert2.Clone();
// insert1.HintList;
// insert1.InsertList;
// insert1.IsBracket;
// insert1.Location;
// insert1.Position;
if (differences.NumberOfDifferences == 0){
differences.Changes = null;
differences.Deletions = null;
differences.Insertions = null;
}else{
differences.Changes = changes;
differences.Deletions = deletions;
differences.Insertions = insertions;
}
return differences;
}
public virtual Differences VisitQueryGeneratedType(QueryGeneratedType qgt1, QueryGeneratedType qgt2){
Differences differences = new Differences(qgt1, qgt2);
if (qgt1 == null || qgt2 == null){
if (qgt1 != qgt2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++;
return differences;
}
QueryGeneratedType changes = (QueryGeneratedType)qgt2.Clone();
QueryGeneratedType deletions = (QueryGeneratedType)qgt2.Clone();
QueryGeneratedType insertions = (QueryGeneratedType)qgt2.Clone();
//qgt1.Type;
if (differences.NumberOfDifferences == 0){
differences.Changes = null;
differences.Deletions = null;
differences.Insertions = null;
}else{
differences.Changes = changes;
differences.Deletions = deletions;
differences.Insertions = insertions;
}
return differences;
}
public virtual Differences VisitQueryGroupBy(QueryGroupBy groupby1, QueryGroupBy groupby2){
Differences differences = new Differences(groupby1, groupby2);
if (groupby1 == null || groupby2 == null){
if (groupby1 != groupby2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++;
return differences;
}
QueryGroupBy changes = (QueryGroupBy)groupby2.Clone();
QueryGroupBy deletions = (QueryGroupBy)groupby2.Clone();
QueryGroupBy insertions = (QueryGroupBy)groupby2.Clone();
// groupby1.AggregateList;
// groupby1.GroupContext;
// groupby1.GroupList;
// groupby1.Having;
// groupby1.HavingContext;
// groupby1.Source;
if (differences.NumberOfDifferences == 0){
differences.Changes = null;
differences.Deletions = null;
differences.Insertions = null;
}else{
differences.Changes = changes;
differences.Deletions = deletions;
differences.Insertions = insertions;
}
return differences;
}
public virtual Differences VisitQueryExists(QueryExists exists1, QueryExists exists2){
Differences differences = new Differences(exists1, exists2);
if (exists1 == null || exists2 == null){
if (exists1 != exists2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++;
return differences;
}
QueryExists changes = (QueryExists)exists2.Clone();
QueryExists deletions = (QueryExists)exists2.Clone();
QueryExists insertions = (QueryExists)exists2.Clone();
// exists1.Source;
if (differences.NumberOfDifferences == 0){
differences.Changes = null;
differences.Deletions = null;
differences.Insertions = null;
}else{
differences.Changes = changes;
differences.Deletions = deletions;
differences.Insertions = insertions;
}
return differences;
}
public virtual Differences VisitQueryDistinct(QueryDistinct distinct1, QueryDistinct distinct2){
Differences differences = new Differences(distinct1, distinct2);
if (distinct1 == null || distinct2 == null){
if (distinct1 != distinct2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++;
return differences;
}
QueryDistinct changes = (QueryDistinct)distinct2.Clone();
QueryDistinct deletions = (QueryDistinct)distinct2.Clone();
QueryDistinct insertions = (QueryDistinct)distinct2.Clone();
// distinct1.Context;
// distinct1.Group;
// distinct1.GroupTarget;
// distinct1.Source;
if (differences.NumberOfDifferences == 0){
differences.Changes = null;
differences.Deletions = null;
differences.Insertions = null;
}else{
differences.Changes = changes;
differences.Deletions = deletions;
differences.Insertions = insertions;
}
return differences;
}
public virtual Differences VisitQueryQuantifiedExpression(QueryQuantifiedExpression qqe1, QueryQuantifiedExpression qqe2){
Differences differences = new Differences(qqe1, qqe2);
if (qqe1 == null || qqe2 == null){
if (qqe1 != qqe2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++;
return differences;
}
QueryQuantifiedExpression changes = (QueryQuantifiedExpression)qqe2.Clone();
QueryQuantifiedExpression deletions = (QueryQuantifiedExpression)qqe2.Clone();
QueryQuantifiedExpression insertions = (QueryQuantifiedExpression)qqe2.Clone();
// qqe1.Expression;
// qqe1.Left;
// qqe1.Right;
if (differences.NumberOfDifferences == 0){
differences.Changes = null;
differences.Deletions = null;
differences.Insertions = null;
}else{
differences.Changes = changes;
differences.Deletions = deletions;
differences.Insertions = insertions;
}
return differences;
}
public virtual Differences VisitQuerySelect(QuerySelect select1, QuerySelect select2){
Differences differences = new Differences(select1, select2);
if (select1 == null || select2 == null){
if (select1 != select2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++;
return differences;
}
QuerySelect changes = (QuerySelect)select2.Clone();
QuerySelect deletions = (QuerySelect)select2.Clone();
QuerySelect insertions = (QuerySelect)select2.Clone();
// select1.Access;
// select1.Direction;
// select1.Source;
if (differences.NumberOfDifferences == 0){
differences.Changes = null;
differences.Deletions = null;
differences.Insertions = null;
}else{
differences.Changes = changes;
differences.Deletions = deletions;
differences.Insertions = insertions;
}
return differences;
}
public virtual Differences VisitQueryLimit(QueryLimit limit1, QueryLimit limit2){
Differences differences = new Differences(limit1, limit2);
if (limit1 == null || limit2 == null){
if (limit1 != limit2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++;
return differences;
}
QueryLimit changes = (QueryLimit)limit2.Clone();
QueryLimit deletions = (QueryLimit)limit2.Clone();
QueryLimit insertions = (QueryLimit)limit2.Clone();
// limit1.Expression;
// limit1.IsPercent;
// limit1.IsWithTies;
if (differences.NumberOfDifferences == 0){
differences.Changes = null;
differences.Deletions = null;
differences.Insertions = null;
}else{
differences.Changes = changes;
differences.Deletions = deletions;
differences.Insertions = insertions;
}
return differences;
}
public virtual Differences VisitQueryTransact(QueryTransact qt1, QueryTransact qt2){
Differences differences = new Differences(qt1, qt2);
if (qt1 == null || qt2 == null){
if (qt1 != qt2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++;
return differences;
}
QueryTransact changes = (QueryTransact)qt2.Clone();
QueryTransact deletions = (QueryTransact)qt2.Clone();
QueryTransact insertions = (QueryTransact)qt2.Clone();
// qt1.Body;
// qt1.CommitBody;
// qt1.Isolation;
// qt1.RollbackBody;
// qt1.Transaction;
if (differences.NumberOfDifferences == 0){
differences.Changes = null;
differences.Deletions = null;
differences.Insertions = null;
}else{
differences.Changes = changes;
differences.Deletions = deletions;
differences.Insertions = insertions;
}
return differences;
}
public virtual Differences VisitQueryOrderBy(QueryOrderBy orderby1, QueryOrderBy orderby2){
Differences differences = new Differences(orderby1, orderby2);
if (orderby1 == null || orderby2 == null){
if (orderby1 != orderby2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++;
return differences;
}
QueryOrderBy changes = (QueryOrderBy)orderby2.Clone();
QueryOrderBy deletions = (QueryOrderBy)orderby2.Clone();
QueryOrderBy insertions = (QueryOrderBy)orderby2.Clone();
// orderby1.Context;
// orderby1.OrderList;
// orderby1.Source;
if (differences.NumberOfDifferences == 0){
differences.Changes = null;
differences.Deletions = null;
differences.Insertions = null;
}else{
differences.Changes = changes;
differences.Deletions = deletions;
differences.Insertions = insertions;
}
return differences;
}
public virtual Differences VisitQueryUnion(QueryUnion union1, QueryUnion union2){
Differences differences = new Differences(union1, union2);
if (union1 == null || union2 == null){
if (union1 != union2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++;
return differences;
}
QueryUnion changes = (QueryUnion)union2.Clone();
QueryUnion deletions = (QueryUnion)union2.Clone();
QueryUnion insertions = (QueryUnion)union2.Clone();
// union1.LeftSource;
// union1.RightSource;
if (differences.NumberOfDifferences == 0){
differences.Changes = null;
differences.Deletions = null;
differences.Insertions = null;
}else{
differences.Changes = changes;
differences.Deletions = deletions;
differences.Insertions = insertions;
}
return differences;
}
public virtual Differences VisitQueryOrderItem(QueryOrderItem item1, QueryOrderItem item2){
Differences differences = new Differences(item1, item2);
if (item1 == null || item2 == null){
if (item1 != item2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++;
return differences;
}
QueryOrderItem changes = (QueryOrderItem)item2.Clone();
QueryOrderItem deletions = (QueryOrderItem)item2.Clone();
QueryOrderItem insertions = (QueryOrderItem)item2.Clone();
// item1.Expression;
// item1.OrderType;
if (differences.NumberOfDifferences == 0){
differences.Changes = null;
differences.Deletions = null;
differences.Insertions = null;
}else{
differences.Changes = changes;
differences.Deletions = deletions;
differences.Insertions = insertions;
}
return differences;
}
public virtual Differences VisitQueryYielder(QueryYielder yielder1, QueryYielder yielder2){
Differences differences = new Differences(yielder1, yielder2);
if (yielder1 == null || yielder2 == null){
if (yielder1 != yielder2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++;
return differences;
}
QueryYielder changes = (QueryYielder)yielder2.Clone();
QueryYielder deletions = (QueryYielder)yielder2.Clone();
QueryYielder insertions = (QueryYielder)yielder2.Clone();
// yielder1.Body;
// yielder1.Source;
// yielder1.State;
// yielder1.Target;
if (differences.NumberOfDifferences == 0){
differences.Changes = null;
differences.Deletions = null;
differences.Insertions = null;
}else{
differences.Changes = changes;
differences.Deletions = deletions;
differences.Insertions = insertions;
}
return differences;
}
public virtual Differences VisitQueryPosition(QueryPosition position1, QueryPosition position2){
Differences differences = new Differences(position1, position2);
if (position1 == null || position2 == null){
if (position1 != position2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++;
return differences;
}
QueryPosition changes = (QueryPosition)position2.Clone();
QueryPosition deletions = (QueryPosition)position2.Clone();
QueryPosition insertions = (QueryPosition)position2.Clone();
//position1.Context;
if (differences.NumberOfDifferences == 0){
differences.Changes = null;
differences.Deletions = null;
differences.Insertions = null;
}else{
differences.Changes = changes;
differences.Deletions = deletions;
differences.Insertions = insertions;
}
return differences;
}
public virtual Differences Visit(Node node1, Node node2) {
if (node1 == null){
Differences differences = new Differences(null, node2);
if (node2 != null) differences.NumberOfDifferences++;
return differences;
}
switch (node1.NodeType){
case NodeType.AddressDereference:
return this.VisitAddressDereference((AddressDereference)node1, node2 as AddressDereference);
case NodeType.AliasDefinition :
return this.VisitAliasDefinition((AliasDefinition)node1, node2 as AliasDefinition);
case NodeType.AnonymousNestedFunction:
return this.VisitAnonymousNestedFunction((AnonymousNestedFunction)node1, node2 as AnonymousNestedFunction);
case NodeType.ApplyToAll :
return this.VisitApplyToAll((ApplyToAll)node1, node2 as ApplyToAll);
case NodeType.Arglist :
return this.VisitExpression((Expression)node1, node2 as Expression);
case NodeType.ArrayType :
Debug.Assert(false); return null;
case NodeType.Assembly :
return this.VisitAssembly((AssemblyNode)node1, node2 as AssemblyNode);
case NodeType.AssemblyReference :
return this.VisitAssemblyReference((AssemblyReference)node1, node2 as AssemblyReference);
case NodeType.Assertion:
return this.VisitAssertion((Assertion)node1, node2 as Assertion);
case NodeType.AssignmentExpression:
return this.VisitAssignmentExpression((AssignmentExpression)node1, node2 as AssignmentExpression);
case NodeType.AssignmentStatement :
return this.VisitAssignmentStatement((AssignmentStatement)node1, node2 as AssignmentStatement);
case NodeType.Attribute :
return this.VisitAttributeNode((AttributeNode)node1, node2 as AttributeNode);
case NodeType.Base :
return this.VisitBase((Base)node1, node2 as Base);
case NodeType.Block :
return this.VisitBlock((Block)node1, node2 as Block);
case NodeType.BlockExpression :
return this.VisitBlockExpression((BlockExpression)node1, node2 as BlockExpression);
case NodeType.Branch :
Debug.Assert(false); return null;
case NodeType.Compilation:
return this.VisitCompilation((Compilation)node1, node2 as Compilation);
case NodeType.CompilationUnit:
return this.VisitCompilationUnit((CompilationUnit)node1, node2 as CompilationUnit);
case NodeType.CompilationUnitSnippet:
return this.VisitCompilationUnitSnippet((CompilationUnitSnippet)node1, node2 as CompilationUnitSnippet);
#if ExtendedRuntime
case NodeType.ConstrainedType:
return this.VisitConstrainedType((ConstrainedType)node1, node2 as ConstrainedType);
#endif
case NodeType.Continue :
return this.VisitContinue((Continue)node1, node2 as Continue);
case NodeType.CurrentClosure :
return this.VisitCurrentClosure((CurrentClosure)node1, node2 as CurrentClosure);
case NodeType.DebugBreak :
return null;
case NodeType.Call :
case NodeType.Calli :
case NodeType.Callvirt :
case NodeType.Jmp :
case NodeType.MethodCall :
return this.VisitMethodCall((MethodCall)node1, node2 as MethodCall);
case NodeType.Catch :
return this.VisitCatch((Catch)node1, node2 as Catch);
case NodeType.Class :
if (node2 is Class)
return this.VisitClass((Class)node1, node2 as Class);
else
return this.VisitTypeNode((TypeNode)node1, node2 as TypeNode);
case NodeType.CoerceTuple :
return this.VisitCoerceTuple((CoerceTuple)node1, node2 as CoerceTuple);
case NodeType.CollectionEnumerator :
return this.VisitCollectionEnumerator((CollectionEnumerator)node1, node2 as CollectionEnumerator);
case NodeType.Composition :
return this.VisitComposition((Composition)node1, node2 as Composition);
case NodeType.Comprehension:
return this.VisitComprehension((Comprehension)node1, (Comprehension)node2);
case NodeType.ComprehensionBinding:
return this.VisitComprehensionBinding((ComprehensionBinding)node1, (ComprehensionBinding)node2);
case NodeType.Construct :
return this.VisitConstruct((Construct)node1, node2 as Construct);
case NodeType.ConstructArray :
return this.VisitConstructArray((ConstructArray)node1, node2 as ConstructArray);
case NodeType.ConstructDelegate :
return this.VisitConstructDelegate((ConstructDelegate)node1, node2 as ConstructDelegate);
case NodeType.ConstructFlexArray :
return this.VisitConstructFlexArray((ConstructFlexArray)node1, node2 as ConstructFlexArray);
case NodeType.ConstructIterator :
return this.VisitConstructIterator((ConstructIterator)node1, node2 as ConstructIterator);
case NodeType.ConstructTuple :
return this.VisitConstructTuple((ConstructTuple)node1, node2 as ConstructTuple);
case NodeType.DelegateNode :
return this.VisitDelegateNode((DelegateNode)node1, node2 as DelegateNode);
case NodeType.DoWhile:
return this.VisitDoWhile((DoWhile)node1, node2 as DoWhile);
case NodeType.Dup :
return this.VisitExpression((Expression)node1, node2 as Expression);
case NodeType.EndFilter :
return this.VisitEndFilter((EndFilter)node1, node2 as EndFilter);
case NodeType.EndFinally:
return this.VisitEndFinally((EndFinally)node1, node2 as EndFinally);
case NodeType.EnumNode :
return this.VisitEnumNode((EnumNode)node1, node2 as EnumNode);
case NodeType.Event:
return this.VisitEvent((Event)node1, node2 as Event);
case NodeType.Exit :
return this.VisitExit((Exit)node1, node2 as Exit);
case NodeType.ExpressionSnippet:
return this.VisitExpressionSnippet((ExpressionSnippet)node1, node2 as ExpressionSnippet);
case NodeType.ExpressionStatement :
return this.VisitExpressionStatement((ExpressionStatement)node1, node2 as ExpressionStatement);
case NodeType.FaultHandler :
return this.VisitFaultHandler((FaultHandler)node1, node2 as FaultHandler);
case NodeType.Field :
return this.VisitField((Field)node1, node2 as Field);
case NodeType.FieldInitializerBlock:
return this.VisitFieldInitializerBlock((FieldInitializerBlock)node1, node2 as FieldInitializerBlock);
case NodeType.Finally :
return this.VisitFinally((Finally)node1, node2 as Finally);
case NodeType.Filter :
return this.VisitFilter((Filter)node1, node2 as Filter);
case NodeType.Fixed :
return this.VisitFixed((Fixed)node1, node2 as Fixed);
case NodeType.For :
return this.VisitFor((For)node1, node2 as For);
case NodeType.ForEach :
return this.VisitForEach((ForEach)node1, node2 as ForEach);
case NodeType.FunctionDeclaration:
return this.VisitFunctionDeclaration((FunctionDeclaration)node1, node2 as FunctionDeclaration);
case NodeType.Goto :
return this.VisitGoto((Goto)node1, node2 as Goto);
case NodeType.GotoCase :
return this.VisitGotoCase((GotoCase)node1, node2 as GotoCase);
case NodeType.Identifier :
return this.VisitIdentifier((Identifier)node1, node2 as Identifier);
case NodeType.If :
return this.VisitIf((If)node1, node2 as If);
case NodeType.ImplicitThis :
return this.VisitImplicitThis((ImplicitThis)node1, node2 as ImplicitThis);
case NodeType.Indexer :
return this.VisitIndexer((Indexer)node1, node2 as Indexer);
case NodeType.InstanceInitializer :
return this.VisitInstanceInitializer((InstanceInitializer)node1, node2 as InstanceInitializer);
case NodeType.StaticInitializer :
return this.VisitStaticInitializer((StaticInitializer)node1, node2 as StaticInitializer);
case NodeType.Method:
return this.VisitMethod((Method)node1, node2 as Method);
case NodeType.Interface :
if (node2 is Interface)
return this.VisitInterface((Interface)node1, node2 as Interface);
else
return this.VisitTypeNode((TypeNode)node1, node2 as TypeNode);
case NodeType.LabeledStatement :
return this.VisitLabeledStatement((LabeledStatement)node1, node2 as LabeledStatement);
case NodeType.Literal:
return this.VisitLiteral((Literal)node1, node2 as Literal);
case NodeType.Local :
return this.VisitLocal((Local)node1, node2 as Local);
case NodeType.LocalDeclaration:
return this.VisitLocalDeclaration((LocalDeclaration)node1, node2 as LocalDeclaration);
case NodeType.LocalDeclarationsStatement:
return this.VisitLocalDeclarationsStatement((LocalDeclarationsStatement)node1, node2 as LocalDeclarationsStatement);
case NodeType.Lock:
return this.VisitLock((Lock)node1, node2 as Lock);
case NodeType.LRExpression:
return this.VisitLRExpression((LRExpression)node1, node2 as LRExpression);
case NodeType.MemberBinding :
return this.VisitMemberBinding((MemberBinding)node1, node2 as MemberBinding);
case NodeType.TemplateInstance:
return this.VisitTemplateInstance((TemplateInstance)node1, node2 as TemplateInstance);
case NodeType.StackAlloc:
return this.VisitStackAlloc((StackAlloc)node1, node2 as StackAlloc);
case NodeType.Module :
return this.VisitModule((Module)node1, node2 as Module);
case NodeType.ModuleReference :
return this.VisitModuleReference((ModuleReference)node1, node2 as ModuleReference);
case NodeType.NameBinding :
return this.VisitNameBinding((NameBinding)node1, node2 as NameBinding);
case NodeType.NamedArgument :
return this.VisitNamedArgument((NamedArgument)node1, node2 as NamedArgument);
case NodeType.Namespace :
return this.VisitNamespace((Namespace)node1, node2 as Namespace);
case NodeType.Nop :
return null;
case NodeType.OptionalModifier:
case NodeType.RequiredModifier:
return this.VisitTypeModifier((TypeModifier)node1, node2 as TypeModifier);
case NodeType.Parameter :
return this.VisitParameter((Parameter)node1, node2 as Parameter);
case NodeType.Pop :
return this.VisitExpression((Expression)node1, node2 as Expression);
case NodeType.PrefixExpression:
return this.VisitPrefixExpression((PrefixExpression)node1, node2 as PrefixExpression);
case NodeType.PostfixExpression:
return this.VisitPostfixExpression((PostfixExpression)node1, node2 as PostfixExpression);
case NodeType.Property:
return this.VisitProperty((Property)node1, node2 as Property);
case NodeType.QualifiedIdentifer :
return this.VisitQualifiedIdentifier((QualifiedIdentifier)node1, node2 as QualifiedIdentifier);
case NodeType.Rethrow :
case NodeType.Throw :
return this.VisitThrow((Throw)node1, node2 as Throw);
case NodeType.Return:
return this.VisitReturn((Return)node1, node2 as Return);
case NodeType.Repeat:
return this.VisitRepeat((Repeat)node1, node2 as Repeat);
case NodeType.ResourceUse:
return this.VisitResourceUse((ResourceUse)node1, node2 as ResourceUse);
case NodeType.SecurityAttribute:
return this.VisitSecurityAttribute((SecurityAttribute)node1, node2 as SecurityAttribute);
case NodeType.SetterValue:
return this.VisitSetterValue((SetterValue)node1, node2 as SetterValue);
case NodeType.StatementSnippet:
return this.VisitStatementSnippet((StatementSnippet)node1, node2 as StatementSnippet);
case NodeType.Struct :
if (node2 is Struct)
return this.VisitStruct((Struct)node1, node2 as Struct);
else
return this.VisitTypeNode((TypeNode)node1, node2 as TypeNode);
case NodeType.Switch :
return this.VisitSwitch((Switch)node1, node2 as Switch);
case NodeType.SwitchCase :
return this.VisitSwitchCase((SwitchCase)node1, node2 as SwitchCase);
case NodeType.SwitchInstruction :
return this.VisitSwitchInstruction((SwitchInstruction)node1, node2 as SwitchInstruction);
case NodeType.Typeswitch :
return this.VisitTypeswitch((Typeswitch)node1, node2 as Typeswitch);
case NodeType.TypeswitchCase :
return this.VisitTypeswitchCase((TypeswitchCase)node1, node2 as TypeswitchCase);
case NodeType.This :
return this.VisitThis((This)node1, node2 as This);
case NodeType.Try :
return this.VisitTry((Try)node1, node2 as Try);
#if ExtendedRuntime
case NodeType.TupleType:
return this.VisitTupleType((TupleType)node1, node2 as TupleType);
case NodeType.TypeAlias:
return this.VisitTypeAlias((TypeAlias)node1, node2 as TypeAlias);
case NodeType.TypeIntersection:
return this.VisitTypeIntersection((TypeIntersection)node1, node2 as TypeIntersection);
#endif
case NodeType.TypeMemberSnippet:
return this.VisitTypeMemberSnippet((TypeMemberSnippet)node1, node2 as TypeMemberSnippet);
case NodeType.ClassParameter:
case NodeType.TypeParameter:
return this.VisitTypeNode((TypeNode)node1, node2 as TypeNode);
#if ExtendedRuntime
case NodeType.TypeUnion:
return this.VisitTypeUnion((TypeUnion)node1, node2 as TypeUnion);
#endif
case NodeType.TypeReference:
return this.VisitTypeReference((TypeReference)node1, node2 as TypeReference);
case NodeType.UsedNamespace :
return this.VisitUsedNamespace((UsedNamespace)node1, node2 as UsedNamespace);
case NodeType.VariableDeclaration:
return this.VisitVariableDeclaration((VariableDeclaration)node1, node2 as VariableDeclaration);
case NodeType.While:
return this.VisitWhile((While)node1, node2 as While);
case NodeType.Yield:
return this.VisitYield((Yield)node1, node2 as Yield);
case NodeType.Conditional :
case NodeType.Cpblk :
case NodeType.Initblk :
return this.VisitTernaryExpression((TernaryExpression)node1, node2 as TernaryExpression);
case NodeType.Add :
case NodeType.Add_Ovf :
case NodeType.Add_Ovf_Un :
case NodeType.AddEventHandler :
case NodeType.And :
case NodeType.As :
case NodeType.Box :
case NodeType.Castclass :
case NodeType.Ceq :
case NodeType.Cgt :
case NodeType.Cgt_Un :
case NodeType.Clt :
case NodeType.Clt_Un :
case NodeType.Comma :
case NodeType.Div :
case NodeType.Div_Un :
case NodeType.Eq :
case NodeType.ExplicitCoercion :
case NodeType.Ge :
case NodeType.Gt :
case NodeType.Is :
case NodeType.Iff :
case NodeType.Implies :
case NodeType.Isinst :
case NodeType.Ldvirtftn :
case NodeType.Le :
case NodeType.LogicalAnd :
case NodeType.LogicalOr :
case NodeType.Lt :
case NodeType.Mkrefany :
case NodeType.Mul :
case NodeType.Mul_Ovf :
case NodeType.Mul_Ovf_Un :
case NodeType.Ne :
case NodeType.Or :
case NodeType.Range :
case NodeType.Refanyval :
case NodeType.Rem :
case NodeType.Rem_Un :
case NodeType.RemoveEventHandler :
case NodeType.Shl :
case NodeType.Shr :
case NodeType.Shr_Un :
case NodeType.Sub :
case NodeType.Sub_Ovf :
case NodeType.Sub_Ovf_Un :
case NodeType.Unbox :
case NodeType.UnboxAny :
case NodeType.Xor :
return this.VisitBinaryExpression((BinaryExpression)node1, node2 as BinaryExpression);
case NodeType.AddressOf:
case NodeType.OutAddress:
case NodeType.RefAddress:
case NodeType.Ckfinite :
case NodeType.Conv_I :
case NodeType.Conv_I1 :
case NodeType.Conv_I2 :
case NodeType.Conv_I4 :
case NodeType.Conv_I8 :
case NodeType.Conv_Ovf_I :
case NodeType.Conv_Ovf_I1 :
case NodeType.Conv_Ovf_I1_Un :
case NodeType.Conv_Ovf_I2 :
case NodeType.Conv_Ovf_I2_Un :
case NodeType.Conv_Ovf_I4 :
case NodeType.Conv_Ovf_I4_Un :
case NodeType.Conv_Ovf_I8 :
case NodeType.Conv_Ovf_I8_Un :
case NodeType.Conv_Ovf_I_Un :
case NodeType.Conv_Ovf_U :
case NodeType.Conv_Ovf_U1 :
case NodeType.Conv_Ovf_U1_Un :
case NodeType.Conv_Ovf_U2 :
case NodeType.Conv_Ovf_U2_Un :
case NodeType.Conv_Ovf_U4 :
case NodeType.Conv_Ovf_U4_Un :
case NodeType.Conv_Ovf_U8 :
case NodeType.Conv_Ovf_U8_Un :
case NodeType.Conv_Ovf_U_Un :
case NodeType.Conv_R4 :
case NodeType.Conv_R8 :
case NodeType.Conv_R_Un :
case NodeType.Conv_U :
case NodeType.Conv_U1 :
case NodeType.Conv_U2 :
case NodeType.Conv_U4 :
case NodeType.Conv_U8 :
case NodeType.Decrement :
case NodeType.DefaultValue:
case NodeType.Increment :
case NodeType.Ldftn :
case NodeType.Ldlen :
case NodeType.Ldtoken :
case NodeType.Localloc :
case NodeType.LogicalNot :
case NodeType.Neg :
case NodeType.Not :
case NodeType.Parentheses :
case NodeType.Refanytype :
case NodeType.Sizeof :
case NodeType.SkipCheck :
case NodeType.Typeof :
case NodeType.UnaryPlus :
return this.VisitUnaryExpression((UnaryExpression)node1, node2 as UnaryExpression);
#if ExtendedRuntime
// query node1 types
case NodeType.QueryAggregate:
return this.VisitQueryAggregate((QueryAggregate)node1, node2 as QueryAggregate);
case NodeType.QueryAlias:
return this.VisitQueryAlias((QueryAlias)node1, node2 as QueryAlias);
case NodeType.QueryAll:
case NodeType.QueryAny:
return this.VisitQueryQuantifier((QueryQuantifier)node1, node2 as QueryQuantifier);
case NodeType.QueryAxis:
return this.VisitQueryAxis((QueryAxis)node1, node2 as QueryAxis);
case NodeType.QueryCommit:
return this.VisitQueryCommit((QueryCommit)node1, node2 as QueryCommit);
case NodeType.QueryContext:
return this.VisitQueryContext((QueryContext)node1, node2 as QueryContext);
case NodeType.QueryDelete:
return this.VisitQueryDelete((QueryDelete)node1, node2 as QueryDelete);
case NodeType.QueryDifference:
return this.VisitQueryDifference((QueryDifference)node1, node2 as QueryDifference);
case NodeType.QueryDistinct:
return this.VisitQueryDistinct((QueryDistinct)node1, node2 as QueryDistinct);
case NodeType.QueryExists:
return this.VisitQueryExists((QueryExists)node1, node2 as QueryExists);
case NodeType.QueryFilter:
return this.VisitQueryFilter((QueryFilter)node1, node2 as QueryFilter);
case NodeType.QueryGeneratedType:
return this.VisitQueryGeneratedType((QueryGeneratedType)node1, node2 as QueryGeneratedType);
case NodeType.QueryGroupBy:
return this.VisitQueryGroupBy((QueryGroupBy)node1, node2 as QueryGroupBy);
case NodeType.QueryInsert:
return this.VisitQueryInsert((QueryInsert)node1, node2 as QueryInsert);
case NodeType.QueryIntersection:
return this.VisitQueryIntersection((QueryIntersection)node1, node2 as QueryIntersection);
case NodeType.QueryIterator:
return this.VisitQueryIterator((QueryIterator)node1, node2 as QueryIterator);
case NodeType.QueryJoin:
return this.VisitQueryJoin((QueryJoin)node1, node2 as QueryJoin);
case NodeType.QueryLimit:
return this.VisitQueryLimit((QueryLimit)node1, node2 as QueryLimit);
case NodeType.QueryOrderBy:
return this.VisitQueryOrderBy((QueryOrderBy)node1, node2 as QueryOrderBy);
case NodeType.QueryOrderItem:
return this.VisitQueryOrderItem((QueryOrderItem)node1, node2 as QueryOrderItem);
case NodeType.QueryPosition:
return this.VisitQueryPosition((QueryPosition)node1, node2 as QueryPosition);
case NodeType.QueryProject:
return this.VisitQueryProject((QueryProject)node1, node2 as QueryProject);
case NodeType.QueryQuantifiedExpression:
return this.VisitQueryQuantifiedExpression((QueryQuantifiedExpression)node1, node2 as QueryQuantifiedExpression);
case NodeType.QueryRollback:
return this.VisitQueryRollback((QueryRollback)node1, node2 as QueryRollback);
case NodeType.QuerySelect:
return this.VisitQuerySelect((QuerySelect)node1, node2 as QuerySelect);
case NodeType.QuerySingleton:
return this.VisitQuerySingleton((QuerySingleton)node1, node2 as QuerySingleton);
case NodeType.QueryTransact:
return this.VisitQueryTransact((QueryTransact)node1, node2 as QueryTransact);
case NodeType.QueryTypeFilter:
return this.VisitQueryTypeFilter((QueryTypeFilter)node1, node2 as QueryTypeFilter);
case NodeType.QueryUnion:
return this.VisitQueryUnion((QueryUnion)node1, node2 as QueryUnion);
case NodeType.QueryUpdate:
return this.VisitQueryUpdate((QueryUpdate)node1, node2 as QueryUpdate);
case NodeType.QueryYielder:
return this.VisitQueryYielder((QueryYielder)node1, node2 as QueryYielder);
#endif
default:
return this.VisitUnknownNodeType(node1, node2);
}
}
public virtual Differences VisitQueryProject(QueryProject project1, QueryProject project2){
Differences differences = new Differences(project1, project2);
if (project1 == null || project2 == null){
if (project1 != project2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++;
return differences;
}
QueryProject changes = (QueryProject)project2.Clone();
QueryProject deletions = (QueryProject)project2.Clone();
QueryProject insertions = (QueryProject)project2.Clone();
// project1.Context;
// project1.Members;
// project1.ProjectedType;
// project1.ProjectionList;
if (differences.NumberOfDifferences == 0){
differences.Changes = null;
differences.Deletions = null;
differences.Insertions = null;
}else{
differences.Changes = changes;
differences.Deletions = deletions;
differences.Insertions = insertions;
}
return differences;
}
public virtual Differences VisitQueryJoin(QueryJoin join1, QueryJoin join2){
Differences differences = new Differences(join1, join2);
if (join1 == null || join2 == null){
if (join1 != join2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++;
return differences;
}
QueryJoin changes = (QueryJoin)join2.Clone();
QueryJoin deletions = (QueryJoin)join2.Clone();
QueryJoin insertions = (QueryJoin)join2.Clone();
// join1.JoinContext;
// join1.JoinExpression;
// join1.JoinType;
// join1.LeftOperand;
// join1.RightOperand;
if (differences.NumberOfDifferences == 0){
differences.Changes = null;
differences.Deletions = null;
differences.Insertions = null;
}else{
differences.Changes = changes;
differences.Deletions = deletions;
differences.Insertions = insertions;
}
return differences;
}
public virtual Differences VisitQueryRollback(QueryRollback qr1, QueryRollback qr2){
Differences differences = new Differences(qr1, qr2);
if (qr1 == null || qr2 == null){
if (qr1 != qr2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++;
}else
differences.Changes = null;
return differences;
}
