/// <summary>
/// Merges two array differences to a unified difference.
/// </summary>
public static PositionArrayDiff Merge(PositionArrayDiff left, PositionArrayDiff right)
{
List <int> keys = left.Operations.Keys.ToList <int>();
foreach (var kvp in right.Operations)
{
if (!left.Operations.ContainsKey(kvp.Key))
{
keys.Add(kvp.Key);
}
}
PositionArrayDiff h = new PositionArrayDiff();
foreach (int key in keys)
{
if (left.Operations.ContainsKey(key) && right.Operations.ContainsKey(key))
{
h.Operations[key] = DiffOperation.Merge(left.Operations[key], right.Operations[key]);
}
else if (left.Operations.ContainsKey(key))
{
h.Operations[key] = left.Operations[key];
}
else if (right.Operations.ContainsKey(key))
{
h.Operations[key] = right.Operations[key];
}
}
return(h);
}
// Shows the difference between two arrays that use the position-merge method.
private void DisplayDiff(ArrayList a, ArrayList b, PositionArrayDiff diff, int indent)
{
int n = Math.Max(a.Count, b.Count);
for (int i = 0; i < n; ++i)
{
object ao = i < a.Count ? a[i] : null;
object bo = i < b.Count ? b[i] : null;
DisplayArrayDiff(ao, bo, diff.Operations.GetValueOrDefault(i, null), indent);
}
}
/// <summary>
/// Finds the difference operation between two Json value items.
/// </summary>
private static DiffOperation DiffValue(object first, object second)
{
if (first == null && second == null)
{
return(null);
}
else if (second == null)
{
return(new RemoveOperation());
}
else if (first == null)
{
return(new ChangeOperation(second));
}
else if (first.GetType() != second.GetType())
{
return(new ChangeOperation(second));
}
else if (first is double)
{
return((double)first == (double)second ? null : new ChangeOperation(second));
}
else if (first is bool)
{
return((bool)first == (bool)second ? null : new ChangeOperation(second));
}
else if (first is string)
{
return((string)first == (string)second ? null : new ChangeOperation(second));
}
else if (first is Hashtable)
{
HashDiff subdiff = Diff(first as Hashtable, second as Hashtable);
return(subdiff.Empty() ? null : new ChangeObjectOperation(subdiff));
}
else if (first is ArrayList)
{
if (AreIdArrays(first as ArrayList, second as ArrayList))
{
HashDiff subdiff = IdDiff(first as ArrayList, second as ArrayList);
return(subdiff.Empty() ? null : new ChangeIdArrayOperation(subdiff));
}
else
{
PositionArrayDiff subdiff = PositionDiff(first as ArrayList, second as ArrayList);
return(subdiff.Empty() ? null : new ChangePositionArrayOperation(subdiff));
}
}
else
{
throw new System.Exception("error");
}
}
/// <summary>
/// Finds the difference between two Json arrays based on positions.
/// </summary>
public static PositionArrayDiff PositionDiff(ArrayList a, ArrayList b)
{
PositionArrayDiff diff = new PositionArrayDiff();
int n = Math.Max(a.Count, b.Count);
for (int i = 0; i < n; ++i)
{
object first_value = i >= a.Count ? null : a[i];
object second_value = i >= b.Count ? null : b[i];
DiffOperation op = DiffValue(first_value, second_value);
if (op != null)
{
diff.Operations[i] = op;
}
}
return(diff);
}
public static ChangePositionArrayOperation Merge(ChangePositionArrayOperation left, ChangePositionArrayOperation right)
{
PositionArrayDiff diff = PositionArrayDiff.Merge(left.Diff, right.Diff);
return(new ChangePositionArrayOperation(diff));
}
public ChangePositionArrayOperation(PositionArrayDiff diff)
{
Diff = diff;
}
// Shows the difference between a and b in the text box.
private void DisplayDiff(RichTextBox rtb, IFormatter f, ArrayList a, ArrayList b, PositionArrayDiff diff,
int indent, string path)
{
int n = Math.Max(a.Count, b.Count);
for (int i = 0; i < n; ++i)
{
object ao = i < a.Count ? a[i] : null;
object bo = i < b.Count ? b[i] : null;
string subpath = string.Format("{0}.{1}", path, i);
DisplayArrayDiff(rtb, f, ao, bo, diff.Operations.GetValueOrDefault(i, null), indent, subpath);
}
}
