private static bool AreAllDifferencesAllowed([NotNull] IRow row1, int tableIndex1,
[NotNull] HashSet <string> set1,
[NotNull] IRow row2, int tableIndex2,
[NotNull] HashSet <string> set2,
[NotNull]
AllowedDifferenceCondition condition)
{
HashSet <string> nonEmptySet1 = set1.Count == 0 ? _nullStringSet : set1;
HashSet <string> nonEmptySet2 = set2.Count == 0 ? _nullStringSet : set2;
return(nonEmptySet1.All(v1 => nonEmptySet2.All(
v2 => condition.IsFulfilled(row1, tableIndex1, v1,
row2, tableIndex2, v2))));
}
public FieldInfo(
[NotNull] string fieldName,
[CanBeNull] string multiValueSeparator = null,
[CanBeNull] IValueTransformation valueTransformation = null,
[CanBeNull] AllowedDifferenceCondition allowedDifferenceCondition = null)
{
Assert.ArgumentNotNullOrEmpty(fieldName, nameof(fieldName));
FieldName = fieldName;
_valueTransformation = valueTransformation;
_allowedDifferenceCondition = allowedDifferenceCondition;
MultiValueSeparator = multiValueSeparator == null
? null
: multiValueSeparator.Length == 0
? null
: multiValueSeparator;
}
private static IDictionary <string, IValueTransformation> ParseFieldOptions(
[CanBeNull] IEnumerable <string> fieldOptions, bool caseSensitive,
[NotNull] out IDictionary <string, AllowedDifferenceCondition>
allowedDifferenceConditions)
{
allowedDifferenceConditions = new Dictionary <string, AllowedDifferenceCondition>(
StringComparer.OrdinalIgnoreCase);
if (fieldOptions == null)
{
return(new Dictionary <string, IValueTransformation>());
}
const char fieldSeparator = ':';
var transformations = new Dictionary <string, ChainedValueTransformation>(
StringComparer.OrdinalIgnoreCase);
foreach (string fieldOption in fieldOptions)
{
if (StringUtils.IsNullOrEmptyOrBlank(fieldOption))
{
// ignore empty options
continue;
}
int separatorIndex = fieldOption.IndexOf(fieldSeparator);
if (separatorIndex <= 0 || separatorIndex >= fieldOption.Length - 1)
{
throw CreateInvalidFieldOptionException(fieldOption);
}
string fieldName = fieldOption.Substring(0, separatorIndex).Trim();
string option = fieldOption.Substring(separatorIndex + 1).Trim();
if (StringUtils.IsNullOrEmptyOrBlank(fieldName))
{
throw CreateInvalidFieldOptionException(fieldOption);
}
if (StringUtils.IsNullOrEmptyOrBlank(option))
{
throw CreateInvalidFieldOptionException(fieldOption);
}
if (option.StartsWith(_allowedDifferenceConditionPrefix,
StringComparison.OrdinalIgnoreCase))
{
AllowedDifferenceCondition allowedDifferenceCondition =
CreateAllowedDifferenceCondition(option, fieldName, caseSensitive);
if (allowedDifferenceCondition != null)
{
if (allowedDifferenceConditions.ContainsKey(fieldName))
{
throw new InvalidConfigurationException(
"Only one 'allowedDifferenceCondition' is supported per field");
}
allowedDifferenceConditions.Add(fieldName, allowedDifferenceCondition);
}
}
else
{
ChainedValueTransformation chainedValueTransformation;
if (!transformations.TryGetValue(fieldName, out chainedValueTransformation))
{
chainedValueTransformation = new ChainedValueTransformation();
transformations.Add(fieldName, chainedValueTransformation);
}
chainedValueTransformation.Add(
CreateValueTransformation(option, fieldName, caseSensitive));
}
}
return(transformations.ToDictionary
<KeyValuePair <string, ChainedValueTransformation>, string, IValueTransformation>
(pair => pair.Key,
pair => pair.Value,
StringComparer.OrdinalIgnoreCase));
}
