/// <summary>
/// Check if the value are equals for the given property and the two objects.
/// First implementation was using an expression but the call to compile was way to long comparing to the actual
/// comparison
/// </summary>
/// <typeparam name="TInput">Input type</typeparam>
/// <typeparam name="TOuput">Output type</typeparam>
/// <param name="funcEvaluation">
/// The actual function being evaluated. We could compile the property name expression but
/// this would have an impact on performance
/// </param>
/// <param name="propertyName">Name of property being compared</param>
/// <param name="comparison">Comparison</param>
/// <param name="areEquals">Method used to compare the two values of type TOutput</param>
/// <param name="formatter">Formatter used to format the output value</param>
protected void CompareValues <TInput, TOuput>(Func <TInput, TOuput> funcEvaluation, string propertyName, IComparison <TInput> comparison, Func <TOuput, TOuput, bool> areEquals, Func <TInput, TOuput, string> formatter) where TInput : class
{
var object1 = comparison.Object1;
var object2 = comparison.Object2;
var value1 = funcEvaluation(object1);
var value2 = funcEvaluation(object2);
if (areEquals(value1, value2))
{
return;
}
var formattedValue1 = formatter(object1, value1);
var formattedValue2 = formatter(object2, value2);
var diffItem = new PropertyValueDiffItem
{
Object1 = comparison.Object1,
Object2 = comparison.Object2,
CommonAncestor = comparison.CommonAncestor,
PropertyName = propertyName,
FormattedValue1 = formattedValue1,
FormattedValue2 = formattedValue2,
Description = Captions.Diff.PropertyDiffers(propertyName, formattedValue1, formattedValue2)
};
comparison.Add(diffItem);
}
public void CompareEnumerables <TParent, TItem>(IComparison <TParent> comparison,
Func <TParent, IEnumerable <TItem> > getEnumeration,
Func <TItem, TItem, bool> equalityFunc,
Func <TItem, string> identifierRetrieverFunc,
Func <TItem, string> presentObjectDetailsFunc = null,
string missingItemType = null)
where TParent : class
where TItem : class
{
var object1 = comparison.Object1;
var object2 = comparison.Object2;
var list1 = getEnumeration(object1).ToList();
var list2 = getEnumeration(object2).ToList();
foreach (var entity1 in list1)
{
var entity2 = list2.FirstOrDefault(item => equalityFunc(item, entity1));
if (entity2 != null)
{
var childComparison = new Comparison <TItem>(entity1, entity2, comparison.Settings, comparison.Report, object1);
_objectComparer.Compare(childComparison);
}
else
{
var missingObjectType = missingItemType ?? _objectTypeResolver.TypeFor(entity1);
var presentObjectDetails = presentObjectDetailsFunc?.Invoke(entity1) ?? string.Empty;
comparison.Add(missingItem(object1, object2, entity1, null, missingObjectType, identifierRetrieverFunc(entity1), presentObjectDetails));
}
}
//all common entity have been added. Add missing entity from object1 base on object2
foreach (var entity2 in list2)
{
if (list1.Any(item => equalityFunc(item, entity2)))
{
continue;
}
var missingObjectType = missingItemType ?? _objectTypeResolver.TypeFor(entity2);
var presentObjectDetails = presentObjectDetailsFunc?.Invoke(entity2) ?? string.Empty;
comparison.Add(missingItem(object1, object2, null, entity2, missingObjectType, identifierRetrieverFunc(entity2), presentObjectDetails));
}
}
private static void addVersionDiffitem(IComparison <IBuildingBlockInfo> comparison, string buildingBlock1, string buildingBlock2)
{
comparison.Add(new PropertyValueDiffItem()
{
Object1 = comparison.Object1,
Object2 = comparison.Object2,
CommonAncestor = comparison.CommonAncestor,
PropertyName = AppConstants.Diff.Version,
FormattedValue1 = buildingBlock1,
FormattedValue2 = buildingBlock2,
Description = AppConstants.Diff.VersionDescription(buildingBlock1)
});
}
private void addMissingItem(IComparison <IEnumerable <UsedBuildingBlock> > comparison, UsedBuildingBlock buildingBlock1, UsedBuildingBlock buildingBlock2, PKSimBuildingBlockType buildingBlockType)
{
var missingObject = buildingBlock1 ?? buildingBlock2;
var missingItem = new MissingDiffItem
{
Object1 = buildingBlock1,
Object2 = buildingBlock2,
MissingObject1 = buildingBlock1,
MissingObject2 = buildingBlock2,
CommonAncestor = comparison.CommonAncestor,
MissingObjectName = missingObject.Name,
MissingObjectType = buildingBlockType.ToString()
};
comparison.Add(missingItem);
}
private void compareNeighbors(IComparison <INeighborhoodBase> comparison)
{
var firstNeigbor1Path = _entityPathResolver.PathFor(comparison.Object1.FirstNeighbor);
var secondNeigbor1Path = _entityPathResolver.PathFor(comparison.Object1.SecondNeighbor);
var firstNeigbor2Path = _entityPathResolver.PathFor(comparison.Object2.FirstNeighbor);
var secondNeigbor2Path = _entityPathResolver.PathFor(comparison.Object2.SecondNeighbor);
if (firstNeigbor1Path.Equals(firstNeigbor2Path) && secondNeigbor1Path.Equals(secondNeigbor2Path) ||
firstNeigbor1Path.Equals(secondNeigbor2Path) && secondNeigbor1Path.Equals(firstNeigbor2Path))
{
return;
}
comparison.Add(new PropertyValueDiffItem
{
CommonAncestor = comparison.Object1,
FormattedValue1 = Captions.Diff.ConnectionBetween(firstNeigbor1Path, secondNeigbor1Path),
FormattedValue2 = Captions.Diff.ConnectionBetween(firstNeigbor2Path, secondNeigbor2Path),
PropertyName = Captions.Diff.Connection,
Description = Captions.Diff.PropertyDiffers(Captions.Diff.Connection, Captions.Diff.ConnectionBetween(firstNeigbor1Path, secondNeigbor1Path), Captions.Diff.ConnectionBetween(firstNeigbor2Path, secondNeigbor2Path))
});
}
