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; }