public IDiff <TType> MergeDiffs(IDiff <TType> left, IDiff <TType> right, IConflictContainer conflicts)
{
if (this.aMergeItemsDiffs == null)
{
this.aMergeItemsDiffs = this.aMergerImplementation.Partial.Algorithms.GetMergeDiffsAlgorithm <TItemType>();
}
List <IDiffItem> ret = new List <IDiffItem>();
foreach (var(leftItems, rightItems) in new MergeJoin(new Chunker(left.Cast <IDiffOrderedCollectionItem>()), new Chunker(right.Cast <IDiffOrderedCollectionItem>())))
{
if (leftItems == null)
{
ret.AddRange(rightItems);
}
else if (rightItems == null)
{
ret.AddRange(leftItems);
}
else
{
this.ProcessConflicts(ret, leftItems, rightItems, conflicts);
}
}
return(new Diff <TType>(ret));
}
public IDiff <TType> MergeDiffs(IDiff <TType> left, IDiff <TType> right, IConflictContainer conflicts)
{
if (this.aIdAccessor == null)
{
if (this.aIdProperty == null)
{
ParameterExpression obj = Expression.Parameter(typeof(TItemType), "obj");
Expression <Func <TItemType, TIdType> > identityFunction = Expression.Lambda <Func <TItemType, TIdType> >(
obj, obj
);
this.aIdAccessor = identityFunction.Compile();
}
else
{
this.aIdAccessor = IdHelpers.CreateIdAccessor <TItemType, TIdType>(this.aIdProperty);
}
this.aMergeItemsDiffs = this.aMergerImplementation.Partial.Algorithms.GetMergeDiffsAlgorithm <TItemType>();
}
Dictionary <TIdType, IDiffUnorderedCollectionItem> rightIndex = new Dictionary <TIdType, IDiffUnorderedCollectionItem>(right.Count);
foreach (IDiffItem item in right)
{
rightIndex[this.GetID(item)] = (IDiffUnorderedCollectionItem)item;
}
List <IDiffItem> ret = new List <IDiffItem>(left.Count + right.Count);
foreach (var leftItem in left.Cast <IDiffUnorderedCollectionItem>())
{
IDiffUnorderedCollectionItem rightItem;
TIdType id = this.GetID(leftItem);
if (rightIndex.TryGetValue(id, out rightItem))
{
rightIndex.Remove(id);
this.ProcessConflict(id, leftItem, rightItem, ret, conflicts);
}
else
{
ret.Add(leftItem);
}
}
ret.AddRange(rightIndex.Values);
return(new Diff <TType>(ret));
}
public IDiff <TType> MergeDiffs(IDiff <TType> left, IDiff <TType> right, IConflictContainer conflicts)
{
if (this.aCompiled == null)
{
var compiled = this.Compile();
this.aCompiled = compiled.Compile();
}
var ret = this.aCompiled(left, right, conflicts);
return(new Diff <TType>(ret));
}
public IDiff <TType> MergeDiffs(IDiff <TType> left, IDiff <TType> right, IConflictContainer conflicts)
{
List <IDiffItem> ret = new List <IDiffItem>(1);
if (!left.HasChanges && right.HasChanges)
{
ret.AddRange(right);
}
else if (left.HasChanges && !right.HasChanges)
{
ret.AddRange(left);
}
else if (left.HasChanges && right.HasChanges)
{
this.ProcessConflict((IDiffValue)left.First(), (IDiffValue)right.First(), ret, conflicts);
}
return(new Diff <TType>(ret));
}
public IDiff <TType> MergeDiffs(IDiff <TType> left, IDiff <TType> right, IConflictContainer conflicts)
{
if (this.aMergeItemsDiffs == null)
{
this.aMergeItemsDiffs = this.aMergerImplementation.Partial.Algorithms.GetMergeDiffsAlgorithm <TItemType>();
}
Dictionary <TKeyType, IDiffKeyValueCollectionItem <TKeyType> > rightIndex = new Dictionary <TKeyType, IDiffKeyValueCollectionItem <TKeyType> >(right.Count);
foreach (IDiffItem item in right)
{
rightIndex[((IDiffKeyValueCollectionItem <TKeyType>)item).Key] = (IDiffKeyValueCollectionItem <TKeyType>)item;
}
List <IDiffItem> ret = new List <IDiffItem>(left.Count + right.Count);
foreach (var leftItem in left.Cast <IDiffKeyValueCollectionItem <TKeyType> >())
{
IDiffKeyValueCollectionItem <TKeyType> rightItem;
if (rightIndex.TryGetValue(leftItem.Key, out rightItem))
{
rightIndex.Remove(leftItem.Key);
this.ProcessConflict(leftItem.Key, leftItem, rightItem, ret, conflicts);
}
else
{
ret.Add(leftItem);
}
}
ret.AddRange(rightIndex.Values);
return(new Diff <TType>(ret));
}
IDiff IMergeDiffsAlgorithm.MergeDiffs(IDiff left, IDiff right, IConflictContainer conflicts)
{
return(this.MergeDiffs((IDiff <TType>)left, (IDiff <TType>)right, conflicts));
}
private void ProcessConflicts(List <IDiffItem> ret, List <IDiffOrderedCollectionItem> left, List <IDiffOrderedCollectionItem> right, IConflictContainer conflicts)
{
List <IDiffOrderedCollectionItem> addedLeft;
List <IDiffOrderedCollectionItem> addedRight;
IDiffOrderedCollectionItem otherLeft;
IDiffOrderedCollectionItem otherRight;
this.SepareAdditions(left, out addedLeft, out otherLeft);
this.SepareAdditions(right, out addedRight, out otherRight);
if (addedRight != null && addedLeft != null)
{
if (addedLeft.Count == addedRight.Count && addedLeft.Zip(addedRight, (a, b) => a.IsSame(b)).All(x => x))
{
ret.AddRange(addedLeft);
}
else
{
DiffAnyConflicted conflict = new DiffAnyConflicted(addedLeft, addedRight);
ret.Add(conflict);
conflicts.RegisterConflict(conflict);
}
}
else if (addedLeft != null)
{
ret.AddRange(addedLeft);
}
else if (addedRight != null)
{
ret.AddRange(addedRight);
}
if (otherLeft != null && otherRight != null)
{
ret.Add(this.ProcessConflict(otherLeft, otherRight, conflicts));
}
else if (otherLeft != null)
{
ret.Add(otherLeft);
}
else if (otherRight != null)
{
ret.Add(otherRight);
}
}
private IDiffItem ProcessConflict(IDiffOrderedCollectionItem left, IDiffOrderedCollectionItem right, IConflictContainer conflicts)
{
if (left is IDiffItemChanged && right is IDiffItemChanged)
{
IDiff <TItemType> diff = this.aMergeItemsDiffs.MergeDiffs(
((IDiffItemChanged <TItemType>)left).ValueDiff,
((IDiffItemChanged <TItemType>)right).ValueDiff,
conflicts
);
return(new DiffOrderedCollectionChanged <TItemType>(left.ItemIndex, diff));
}
else if (left.IsSame(right))
{
return(left);
}
DiffAnyConflicted conflict = new DiffAnyConflicted(left, right);
conflicts.RegisterConflict(conflict);
return(conflict);
}
public IDiff <TType> MergeDiffs <TType>(IDiff <TType> left, IDiff <TType> right, out IConflictContainer conflicts)
{
conflicts = new ConflictContainer();
return(this.MergeDiffs(left, right, conflicts));
}
public IDiff <TType> MergeDiffs <TType>(IDiff <TType> left, IDiff <TType> right, IConflictContainer conflicts)
{
IMergeDiffsAlgorithm <TType> algorithm = this.Algorithms.GetMergeDiffsAlgorithm <TType>();
return(algorithm.MergeDiffs(left, right, conflicts));
}
private void ProcessConflict(TIdType id, IDiffUnorderedCollectionItem leftItem, IDiffUnorderedCollectionItem rightItem, List <IDiffItem> ret, IConflictContainer conflicts)
{
if (leftItem is IDiffItemAdded && rightItem is IDiffItemAdded && leftItem.IsSame(rightItem))
{
ret.Add(leftItem);
}
else if (leftItem is IDiffItemRemoved && rightItem is IDiffItemRemoved)
{
ret.Add(leftItem);
}
else if (leftItem is IDiffItemChanged && rightItem is IDiffItemChanged)
{
IDiff <TItemType> diffLeft = ((IDiffItemChanged <TItemType>)leftItem).ValueDiff;
IDiff <TItemType> diffRight = ((IDiffItemChanged <TItemType>)rightItem).ValueDiff;
IDiff <TItemType> result = this.aMergeItemsDiffs.MergeDiffs(diffLeft, diffRight, conflicts);
ret.Add(new DiffUnorderedCollectionChanged <TIdType, TItemType>(id, result));
}
else if (leftItem is IDiffItemReplaced && rightItem is IDiffItemReplaced && leftItem.IsSame(rightItem))
{
ret.Add(leftItem);
}
else if (leftItem is IDiffItemUnchanged)
{
ret.Add(rightItem);
}
else if (rightItem is IDiffItemUnchanged)
{
ret.Add(leftItem);
}
else
{
DiffAnyConflicted conflict = new DiffAnyConflicted(leftItem, rightItem);
ret.Add(conflict);
conflicts.RegisterConflict(conflict);
}
}
private void ProcessConflict(IDiffValue leftItem, IDiffValue rightItem, List <IDiffItem> ret, IConflictContainer conflicts)
{
if (leftItem is IDiffItemReplaced && rightItem is IDiffItemReplaced && leftItem.IsSame(rightItem))
{
ret.Add(leftItem);
}
else if (leftItem is IDiffItemChanged leftChanged && rightItem is IDiffItemChanged rightChanged)
{
Type itemType = leftItem.ValueType;
IMergeDiffsAlgorithm mergeItemsDiffs = this.aMergerImplementation.Partial.Algorithms.GetMergeDiffsAlgorithm(itemType, this.aRules);
IDiff diffLeft = leftChanged.ValueDiff;
IDiff diffRight = rightChanged.ValueDiff;
IDiff result = mergeItemsDiffs.MergeDiffs(diffLeft, diffRight, conflicts);
ret.Add(new DiffValueChanged <TType>(itemType, (IDiff <TType>)result));
}
