public static bool GatherAndValidateOverloads(Activity activity, out Dictionary<string, List<RuntimeArgument>> overloadGroups, out List<RuntimeArgument> requiredArgumentsNotInOverloadGroups, out OverloadGroupEquivalenceInfo equivalenceInfo, ref IList<ValidationError> validationErrors)
{
overloadGroups = null;
requiredArgumentsNotInOverloadGroups = null;
foreach (RuntimeArgument argument in activity.RuntimeArguments)
{
if (!argument.OverloadGroupNames.IsNullOrEmpty())
{
foreach (string str in argument.OverloadGroupNames)
{
if (overloadGroups == null)
{
overloadGroups = new Dictionary<string, List<RuntimeArgument>>();
}
List<RuntimeArgument> list = null;
if (!overloadGroups.TryGetValue(str, out list))
{
list = new List<RuntimeArgument>();
overloadGroups.Add(str, list);
}
list.Add(argument);
}
}
else if (argument.IsRequired)
{
if (requiredArgumentsNotInOverloadGroups == null)
{
requiredArgumentsNotInOverloadGroups = new List<RuntimeArgument>();
}
requiredArgumentsNotInOverloadGroups.Add(argument);
}
}
equivalenceInfo = GetOverloadGroupEquivalence(overloadGroups);
return ValidateOverloadGroupDefinitions(activity, equivalenceInfo, overloadGroups, ref validationErrors);
}
// This method checks if any of the overload groups are equivalent and/or are a subset/superset of another
// overload group. Returns true if there are not any errors.
static bool ValidateOverloadGroupDefinitions(Activity activity, OverloadGroupEquivalenceInfo equivalenceInfo, Dictionary <string, List <RuntimeArgument> > overloadGroups, ref IList <ValidationError> validationErrors)
{
Fx.Assert(equivalenceInfo != null, "equivalenceInfo should have been setup before calling this method");
bool noErrors = true;
if (!equivalenceInfo.EquivalentGroupsDictionary.IsNullOrEmpty())
{
Hashtable keysVisited = new Hashtable(equivalenceInfo.EquivalentGroupsDictionary.Count);
foreach (KeyValuePair <string, List <string> > entry in equivalenceInfo.EquivalentGroupsDictionary)
{
if (!keysVisited.Contains(entry.Key))
{
string[] equivalentGroups = new string[entry.Value.Count + 1];
equivalentGroups[0] = entry.Key;
entry.Value.CopyTo(equivalentGroups, 1);
IEnumerable <string> sortedList = equivalentGroups.OrderBy((s) => s, StringComparer.Ordinal);
ActivityUtilities.Add(ref validationErrors, new ValidationError(SR.OverloadGroupsAreEquivalent(sortedList.AsCommaSeparatedValues()), false, activity));
noErrors = false;
for (int i = 0; i < equivalentGroups.Length; i++)
{
keysVisited.Add(equivalentGroups[i], null);
}
}
}
}
else if (!equivalenceInfo.SupersetOfGroupsDictionary.IsNullOrEmpty())
{
foreach (KeyValuePair <string, List <string> > entry in equivalenceInfo.SupersetOfGroupsDictionary)
{
IList <string> sortedList = entry.Value.OrderBy((s) => s, StringComparer.Ordinal).ToList();
string[] subsetGroups = new string[sortedList.Count];
int index = 0;
// Select only subsets that have atleast one required argument in them.
// We ignore the subsets that have no required arguments in them.
foreach (string subsetGroup in sortedList)
{
if (overloadGroups[subsetGroup].Any <RuntimeArgument>((a) => a.IsRequired))
{
subsetGroups[index++] = subsetGroup;
}
}
// If there were any subsets with required arguments generate an error.
if (index > 0)
{
ActivityUtilities.Add(ref validationErrors, new ValidationError(SR.OverloadGroupHasSubsets(entry.Key, subsetGroups.AsCommaSeparatedValues()), false, activity));
noErrors = false;
}
}
}
return(noErrors);
}
private static bool ValidateOverloadGroupDefinitions(Activity activity, OverloadGroupEquivalenceInfo equivalenceInfo, Dictionary <string, List <RuntimeArgument> > overloadGroups, ref IList <ValidationError> validationErrors)
{
bool flag = true;
if (!equivalenceInfo.EquivalentGroupsDictionary.IsNullOrEmpty())
{
Hashtable hashtable = new Hashtable(equivalenceInfo.EquivalentGroupsDictionary.Count);
foreach (KeyValuePair <string, List <string> > pair in equivalenceInfo.EquivalentGroupsDictionary)
{
if (!hashtable.Contains(pair.Key))
{
string[] array = new string[pair.Value.Count + 1];
array[0] = pair.Key;
pair.Value.CopyTo(array, 1);
IEnumerable <string> c = array.OrderBy <string, string>(s => s, StringComparer.Ordinal);
ActivityUtilities.Add <ValidationError>(ref validationErrors, new ValidationError(System.Activities.SR.OverloadGroupsAreEquivalent(c.AsCommaSeparatedValues()), false, activity));
flag = false;
for (int i = 0; i < array.Length; i++)
{
hashtable.Add(array[i], null);
}
}
}
return(flag);
}
if (!equivalenceInfo.SupersetOfGroupsDictionary.IsNullOrEmpty())
{
foreach (KeyValuePair <string, List <string> > pair2 in equivalenceInfo.SupersetOfGroupsDictionary)
{
IList <string> list = pair2.Value.OrderBy <string, string>(s => s, StringComparer.Ordinal).ToList <string>();
string[] strArray2 = new string[list.Count];
int num2 = 0;
foreach (string str in list)
{
if (overloadGroups[str].Any <RuntimeArgument>(a => a.IsRequired))
{
strArray2[num2++] = str;
}
}
if (num2 > 0)
{
ActivityUtilities.Add <ValidationError>(ref validationErrors, new ValidationError(System.Activities.SR.OverloadGroupHasSubsets(pair2.Key, strArray2.AsCommaSeparatedValues()), false, activity));
flag = false;
}
}
}
return(flag);
}
static OverloadGroupEquivalenceInfo GetOverloadGroupEquivalence(Dictionary <string, List <RuntimeArgument> > groupDefinitions)
{
OverloadGroupEquivalenceInfo overloadGroupsInfo = new OverloadGroupEquivalenceInfo();
if (!groupDefinitions.IsNullOrEmpty())
{
string[] groupNames = new string[groupDefinitions.Count];
groupDefinitions.Keys.CopyTo(groupNames, 0);
for (int i = 0; i < groupNames.Length; i++)
{
string group1 = groupNames[i];
HashSet <RuntimeArgument> group1Args = new HashSet <RuntimeArgument>(groupDefinitions[group1]);
for (int j = i + 1; j < groupNames.Length; j++)
{
string group2 = groupNames[j];
HashSet <RuntimeArgument> group2Args = new HashSet <RuntimeArgument>(groupDefinitions[group2]);
if (group1Args.IsProperSupersetOf(group2Args))
{
overloadGroupsInfo.SetAsSuperset(group1, group2);
}
else if (group1Args.IsProperSubsetOf(group2Args))
{
overloadGroupsInfo.SetAsSuperset(group2, group1);
}
else if (group1Args.SetEquals(group2Args))
{
overloadGroupsInfo.SetAsEquivalent(group1, group2);
}
else if (group1Args.Overlaps(group2Args))
{
overloadGroupsInfo.SetAsOverlapping(group1, group2);
}
else // the groups are disjoint.
{
overloadGroupsInfo.SetAsDisjoint(group1, group2);
}
}
}
}
return(overloadGroupsInfo);
}
private static OverloadGroupEquivalenceInfo GetOverloadGroupEquivalence(Dictionary <string, List <RuntimeArgument> > groupDefinitions)
{
OverloadGroupEquivalenceInfo info = new OverloadGroupEquivalenceInfo();
if (!groupDefinitions.IsNullOrEmpty())
{
string[] array = new string[groupDefinitions.Count];
groupDefinitions.Keys.CopyTo(array, 0);
for (int i = 0; i < array.Length; i++)
{
string str = array[i];
HashSet <RuntimeArgument> set = new HashSet <RuntimeArgument>(groupDefinitions[str]);
for (int j = i + 1; j < array.Length; j++)
{
string str2 = array[j];
HashSet <RuntimeArgument> other = new HashSet <RuntimeArgument>(groupDefinitions[str2]);
if (set.IsProperSupersetOf(other))
{
info.SetAsSuperset(str, str2);
}
else if (set.IsProperSubsetOf(other))
{
info.SetAsSuperset(str2, str);
}
else if (set.SetEquals(other))
{
info.SetAsEquivalent(str, str2);
}
else if (set.Overlaps(other))
{
info.SetAsOverlapping(str, str2);
}
else
{
info.SetAsDisjoint(str, str2);
}
}
}
}
return(info);
}
private static OverloadGroupEquivalenceInfo GetOverloadGroupEquivalence(Dictionary<string, List<RuntimeArgument>> groupDefinitions)
{
OverloadGroupEquivalenceInfo info = new OverloadGroupEquivalenceInfo();
if (!groupDefinitions.IsNullOrEmpty())
{
string[] array = new string[groupDefinitions.Count];
groupDefinitions.Keys.CopyTo(array, 0);
for (int i = 0; i < array.Length; i++)
{
string str = array[i];
HashSet<RuntimeArgument> set = new HashSet<RuntimeArgument>(groupDefinitions[str]);
for (int j = i + 1; j < array.Length; j++)
{
string str2 = array[j];
HashSet<RuntimeArgument> other = new HashSet<RuntimeArgument>(groupDefinitions[str2]);
if (set.IsProperSupersetOf(other))
{
info.SetAsSuperset(str, str2);
}
else if (set.IsProperSubsetOf(other))
{
info.SetAsSuperset(str2, str);
}
else if (set.SetEquals(other))
{
info.SetAsEquivalent(str, str2);
}
else if (set.Overlaps(other))
{
info.SetAsOverlapping(str, str2);
}
else
{
info.SetAsDisjoint(str, str2);
}
}
}
}
return info;
}
public static void ValidateArguments(Activity activity, OverloadGroupEquivalenceInfo equivalenceInfo, Dictionary <string, List <RuntimeArgument> > overloadGroups, List <RuntimeArgument> requiredArgumentsNotInOverloadGroups, IDictionary <string, object> inputs, ref IList <ValidationError> validationErrors)
{
if (!requiredArgumentsNotInOverloadGroups.IsNullOrEmpty())
{
// 1. Check if there are any Required arguments (outside overload groups) that were not specified.
foreach (RuntimeArgument argument in requiredArgumentsNotInOverloadGroups)
{
if (CheckIfArgumentIsNotBound(argument, inputs))
{
ActivityUtilities.Add(ref validationErrors, new ValidationError(SR.RequiredArgumentValueNotSupplied(argument.Name), false, argument.Name, activity));
}
}
}
if (!overloadGroups.IsNullOrEmpty())
{
//1. Check to see if any of the overload groups are configured.
// An overload group is considered to be completely configured if all it's required arguments
// are non-null. If an overload group does not have any required arguments then the group is
// considered configured if any of the optional arguments are configured.
Dictionary <string, bool> configurationResults = new Dictionary <string, bool>();
string configuredGroupName = string.Empty;
int configuredCount = 0;
int overloadGroupsWithNoRequiredArgs = 0;
foreach (KeyValuePair <string, List <RuntimeArgument> > entry in overloadGroups)
{
string groupName = entry.Key;
configurationResults.Add(groupName, false);
IEnumerable <RuntimeArgument> requiredArguments = entry.Value.Where((a) => a.IsRequired);
if (requiredArguments.Count() > 0)
{
if (requiredArguments.All(localArgument => CheckIfArgumentIsBound(localArgument, inputs)))
{
configurationResults[groupName] = true;
configuredGroupName = groupName;
configuredCount++;
}
}
else
{
overloadGroupsWithNoRequiredArgs++;
IEnumerable <RuntimeArgument> optionalArguments = entry.Value.Where((a) => !a.IsRequired);
if (optionalArguments.Any(localArgument => CheckIfArgumentIsBound(localArgument, inputs)))
{
configurationResults[groupName] = true;
configuredGroupName = groupName;
configuredCount++;
}
}
}
//2. It's an error if none of the groups are configured unless there
// is atleast one overload group with no required arguments in it.
if (configuredCount == 0)
{
if (overloadGroupsWithNoRequiredArgs == 0)
{
ActivityUtilities.Add(ref validationErrors, new ValidationError(SR.NoOverloadGroupsAreConfigured, false, activity));
}
}
//3. If only one overload group was configured, ensure none of the disjoint/overlapping groups have any
// required or optional activity arguments set.
else if (configuredCount == 1)
{
HashSet <RuntimeArgument> configuredOverloadSet = new HashSet <RuntimeArgument>(overloadGroups[configuredGroupName]);
Predicate <RuntimeArgument> checkIfArgumentIsBound = new Predicate <RuntimeArgument>(localArgument => CheckIfArgumentIsBound(localArgument, inputs));
List <string> disjointGroups = null;
if (!equivalenceInfo.DisjointGroupsDictionary.IsNullOrEmpty())
{
equivalenceInfo.DisjointGroupsDictionary.TryGetValue(configuredGroupName, out disjointGroups);
}
List <string> overlappingGroups = null;
if (!equivalenceInfo.OverlappingGroupsDictionary.IsNullOrEmpty())
{
equivalenceInfo.OverlappingGroupsDictionary.TryGetValue(configuredGroupName, out overlappingGroups);
}
// Iterate over the groups that may not be completely configured.
foreach (string groupName in configurationResults.Keys.Where((k) => configurationResults[k] == false))
{
// Check if the partially configured group name is in the disjoint groups list.
// If so, find all configured arguments.
if (disjointGroups != null && disjointGroups.Contains(groupName))
{
foreach (RuntimeArgument configuredArgument in overloadGroups[groupName].FindAll(checkIfArgumentIsBound))
{
ActivityUtilities.Add(ref validationErrors, new ValidationError(SR.ExtraOverloadGroupPropertiesConfigured(configuredGroupName,
configuredArgument.Name, groupName), false, activity));
}
}
else if (overlappingGroups != null && overlappingGroups.Contains(groupName))
{
// Find all arguments of the Overlapping group that are not in the configuredOverloadSet.
HashSet <RuntimeArgument> overloadGroupSet = new HashSet <RuntimeArgument>(overloadGroups[groupName]);
IEnumerable <RuntimeArgument> intersectSet = overloadGroupSet.Intersect(configuredOverloadSet);
List <RuntimeArgument> exceptList = overloadGroupSet.Except(intersectSet).ToList();
foreach (RuntimeArgument configuredArgument in exceptList.FindAll(checkIfArgumentIsBound))
{
ActivityUtilities.Add(ref validationErrors, new ValidationError(SR.ExtraOverloadGroupPropertiesConfigured(configuredGroupName,
configuredArgument.Name, groupName), false, activity));
}
}
}
}
//4. If more than one overload group is configured, generate an error.
else
{
IEnumerable <string> configuredGroups = configurationResults.Keys.Where((k) => configurationResults[k]).OrderBy((k) => k, StringComparer.Ordinal);
ActivityUtilities.Add(ref validationErrors, new ValidationError(SR.MultipleOverloadGroupsConfigured(configuredGroups.AsCommaSeparatedValues()), false, activity));
}
}
}
public static bool GatherAndValidateOverloads(Activity activity, out Dictionary <string, List <RuntimeArgument> > overloadGroups, out List <RuntimeArgument> requiredArgumentsNotInOverloadGroups, out OverloadGroupEquivalenceInfo equivalenceInfo, ref IList <ValidationError> validationErrors)
{
overloadGroups = null;
requiredArgumentsNotInOverloadGroups = null;
IEnumerable <RuntimeArgument> runtimeArguments = activity.RuntimeArguments;
foreach (RuntimeArgument runtimeArgument in runtimeArguments)
{
if (!runtimeArgument.OverloadGroupNames.IsNullOrEmpty())
{
foreach (string groupName in runtimeArgument.OverloadGroupNames)
{
if (overloadGroups == null)
{
overloadGroups = new Dictionary <string, List <RuntimeArgument> >();
}
List <RuntimeArgument> arguments = null;
if (!overloadGroups.TryGetValue(groupName, out arguments))
{
arguments = new List <RuntimeArgument>();
overloadGroups.Add(groupName, arguments);
}
arguments.Add(runtimeArgument);
}
}
else
{
if (runtimeArgument.IsRequired)
{
if (requiredArgumentsNotInOverloadGroups == null)
{
requiredArgumentsNotInOverloadGroups = new List <RuntimeArgument>();
}
requiredArgumentsNotInOverloadGroups.Add(runtimeArgument);
}
}
}
equivalenceInfo = GetOverloadGroupEquivalence(overloadGroups);
return(ValidateOverloadGroupDefinitions(activity, equivalenceInfo, overloadGroups, ref validationErrors));
}
static OverloadGroupEquivalenceInfo GetOverloadGroupEquivalence(Dictionary<string, List<RuntimeArgument>> groupDefinitions)
{
OverloadGroupEquivalenceInfo overloadGroupsInfo = new OverloadGroupEquivalenceInfo();
if (!groupDefinitions.IsNullOrEmpty())
{
string[] groupNames = new string[groupDefinitions.Count];
groupDefinitions.Keys.CopyTo(groupNames, 0);
for (int i = 0; i < groupNames.Length; i++)
{
string group1 = groupNames[i];
HashSet<RuntimeArgument> group1Args = new HashSet<RuntimeArgument>(groupDefinitions[group1]);
for (int j = i + 1; j < groupNames.Length; j++)
{
string group2 = groupNames[j];
HashSet<RuntimeArgument> group2Args = new HashSet<RuntimeArgument>(groupDefinitions[group2]);
if (group1Args.IsProperSupersetOf(group2Args))
{
overloadGroupsInfo.SetAsSuperset(group1, group2);
}
else if (group1Args.IsProperSubsetOf(group2Args))
{
overloadGroupsInfo.SetAsSuperset(group2, group1);
}
else if (group1Args.SetEquals(group2Args))
{
overloadGroupsInfo.SetAsEquivalent(group1, group2);
}
else if (group1Args.Overlaps(group2Args))
{
overloadGroupsInfo.SetAsOverlapping(group1, group2);
}
else // the groups are disjoint.
{
overloadGroupsInfo.SetAsDisjoint(group1, group2);
}
}
}
}
return overloadGroupsInfo;
}
// This method checks if any of the overload groups are equivalent and/or are a subset/superset of another
// overload group. Returns true if there are not any errors.
static bool ValidateOverloadGroupDefinitions(Activity activity, OverloadGroupEquivalenceInfo equivalenceInfo, Dictionary<string, List<RuntimeArgument>> overloadGroups, ref IList<ValidationError> validationErrors)
{
Fx.Assert(equivalenceInfo != null, "equivalenceInfo should have been setup before calling this method");
bool noErrors = true;
if (!equivalenceInfo.EquivalentGroupsDictionary.IsNullOrEmpty())
{
Hashtable keysVisited = new Hashtable(equivalenceInfo.EquivalentGroupsDictionary.Count);
foreach (KeyValuePair<string, List<string>> entry in equivalenceInfo.EquivalentGroupsDictionary)
{
if (!keysVisited.Contains(entry.Key))
{
string[] equivalentGroups = new string[entry.Value.Count + 1];
equivalentGroups[0] = entry.Key;
entry.Value.CopyTo(equivalentGroups, 1);
IEnumerable<string> sortedList = equivalentGroups.OrderBy((s) => s, StringComparer.Ordinal);
ActivityUtilities.Add(ref validationErrors, new ValidationError(SR.OverloadGroupsAreEquivalent(sortedList.AsCommaSeparatedValues()), false, activity));
noErrors = false;
for (int i = 0; i < equivalentGroups.Length; i++)
{
keysVisited.Add(equivalentGroups[i], null);
}
}
}
}
else if (!equivalenceInfo.SupersetOfGroupsDictionary.IsNullOrEmpty())
{
foreach (KeyValuePair<string, List<string>> entry in equivalenceInfo.SupersetOfGroupsDictionary)
{
IList<string> sortedList = entry.Value.OrderBy((s) => s, StringComparer.Ordinal).ToList();
string[] subsetGroups = new string[sortedList.Count];
int index = 0;
// Select only subsets that have atleast one required argument in them.
// We ignore the subsets that have no required arguments in them.
foreach (string subsetGroup in sortedList)
{
if (overloadGroups[subsetGroup].Any<RuntimeArgument>((a) => a.IsRequired))
{
subsetGroups[index++] = subsetGroup;
}
}
// If there were any subsets with required arguments generate an error.
if (index > 0)
{
ActivityUtilities.Add(ref validationErrors, new ValidationError(SR.OverloadGroupHasSubsets(entry.Key, subsetGroups.AsCommaSeparatedValues()), false, activity));
noErrors = false;
}
}
}
return noErrors;
}
public static void ValidateArguments(Activity activity, OverloadGroupEquivalenceInfo equivalenceInfo, Dictionary<string, List<RuntimeArgument>> overloadGroups, List<RuntimeArgument> requiredArgumentsNotInOverloadGroups, IDictionary<string, object> inputs, ref IList<ValidationError> validationErrors)
{
if (!requiredArgumentsNotInOverloadGroups.IsNullOrEmpty())
{
// 1. Check if there are any Required arguments (outside overload groups) that were not specified.
foreach (RuntimeArgument argument in requiredArgumentsNotInOverloadGroups)
{
if (CheckIfArgumentIsNotBound(argument, inputs))
{
ActivityUtilities.Add(ref validationErrors, new ValidationError(SR.RequiredArgumentValueNotSupplied(argument.Name), false, argument.Name, activity));
}
}
}
if (!overloadGroups.IsNullOrEmpty())
{
//1. Check to see if any of the overload groups are configured.
// An overload group is considered to be completely configured if all it's required arguments
// are non-null. If an overload group does not have any required arguments then the group is
// considered configured if any of the optional arguments are configured.
Dictionary<string, bool> configurationResults = new Dictionary<string, bool>();
string configuredGroupName = string.Empty;
int configuredCount = 0;
int overloadGroupsWithNoRequiredArgs = 0;
foreach (KeyValuePair<string, List<RuntimeArgument>> entry in overloadGroups)
{
string groupName = entry.Key;
configurationResults.Add(groupName, false);
IEnumerable<RuntimeArgument> requiredArguments = entry.Value.Where((a) => a.IsRequired);
if (requiredArguments.Count() > 0)
{
if (requiredArguments.All(localArgument => CheckIfArgumentIsBound(localArgument, inputs)))
{
configurationResults[groupName] = true;
configuredGroupName = groupName;
configuredCount++;
}
}
else
{
overloadGroupsWithNoRequiredArgs++;
IEnumerable<RuntimeArgument> optionalArguments = entry.Value.Where((a) => !a.IsRequired);
if (optionalArguments.Any(localArgument => CheckIfArgumentIsBound(localArgument, inputs)))
{
configurationResults[groupName] = true;
configuredGroupName = groupName;
configuredCount++;
}
}
}
//2. It's an error if none of the groups are configured unless there
// is atleast one overload group with no required arguments in it.
if (configuredCount == 0)
{
if (overloadGroupsWithNoRequiredArgs == 0)
{
ActivityUtilities.Add(ref validationErrors, new ValidationError(SR.NoOverloadGroupsAreConfigured, false, activity));
}
}
//3. If only one overload group was configured, ensure none of the disjoint/overlapping groups have any
// required or optional activity arguments set.
else if (configuredCount == 1)
{
HashSet<RuntimeArgument> configuredOverloadSet = new HashSet<RuntimeArgument>(overloadGroups[configuredGroupName]);
Predicate<RuntimeArgument> checkIfArgumentIsBound = new Predicate<RuntimeArgument>(localArgument => CheckIfArgumentIsBound(localArgument, inputs));
List<string> disjointGroups = null;
if (!equivalenceInfo.DisjointGroupsDictionary.IsNullOrEmpty())
{
equivalenceInfo.DisjointGroupsDictionary.TryGetValue(configuredGroupName, out disjointGroups);
}
List<string> overlappingGroups = null;
if (!equivalenceInfo.OverlappingGroupsDictionary.IsNullOrEmpty())
{
equivalenceInfo.OverlappingGroupsDictionary.TryGetValue(configuredGroupName, out overlappingGroups);
}
// Iterate over the groups that may not be completely configured.
foreach (string groupName in configurationResults.Keys.Where((k) => configurationResults[k] == false))
{
// Check if the partially configured group name is in the disjoint groups list.
// If so, find all configured arguments.
if (disjointGroups != null && disjointGroups.Contains(groupName))
{
foreach (RuntimeArgument configuredArgument in overloadGroups[groupName].FindAll(checkIfArgumentIsBound))
{
ActivityUtilities.Add(ref validationErrors, new ValidationError(SR.ExtraOverloadGroupPropertiesConfigured(configuredGroupName,
configuredArgument.Name, groupName), false, activity));
}
}
else if (overlappingGroups != null && overlappingGroups.Contains(groupName))
{
// Find all arguments of the Overlapping group that are not in the configuredOverloadSet.
HashSet<RuntimeArgument> overloadGroupSet = new HashSet<RuntimeArgument>(overloadGroups[groupName]);
IEnumerable<RuntimeArgument> intersectSet = overloadGroupSet.Intersect(configuredOverloadSet);
List<RuntimeArgument> exceptList = overloadGroupSet.Except(intersectSet).ToList();
foreach (RuntimeArgument configuredArgument in exceptList.FindAll(checkIfArgumentIsBound))
{
ActivityUtilities.Add(ref validationErrors, new ValidationError(SR.ExtraOverloadGroupPropertiesConfigured(configuredGroupName,
configuredArgument.Name, groupName), false, activity));
}
}
}
}
//4. If more than one overload group is configured, generate an error.
else
{
IEnumerable<string> configuredGroups = configurationResults.Keys.Where((k) => configurationResults[k]).OrderBy((k) => k, StringComparer.Ordinal);
ActivityUtilities.Add(ref validationErrors, new ValidationError(SR.MultipleOverloadGroupsConfigured(configuredGroups.AsCommaSeparatedValues()), false, activity));
}
}
}
public static bool GatherAndValidateOverloads(Activity activity, out Dictionary<string, List<RuntimeArgument>> overloadGroups, out List<RuntimeArgument> requiredArgumentsNotInOverloadGroups, out OverloadGroupEquivalenceInfo equivalenceInfo, ref IList<ValidationError> validationErrors)
{
overloadGroups = null;
requiredArgumentsNotInOverloadGroups = null;
IEnumerable<RuntimeArgument> runtimeArguments = activity.RuntimeArguments;
foreach (RuntimeArgument runtimeArgument in runtimeArguments)
{
if (!runtimeArgument.OverloadGroupNames.IsNullOrEmpty())
{
foreach (string groupName in runtimeArgument.OverloadGroupNames)
{
if (overloadGroups == null)
{
overloadGroups = new Dictionary<string, List<RuntimeArgument>>();
}
List<RuntimeArgument> arguments = null;
if (!overloadGroups.TryGetValue(groupName, out arguments))
{
arguments = new List<RuntimeArgument>();
overloadGroups.Add(groupName, arguments);
}
arguments.Add(runtimeArgument);
}
}
else
{
if (runtimeArgument.IsRequired)
{
if (requiredArgumentsNotInOverloadGroups == null)
{
requiredArgumentsNotInOverloadGroups = new List<RuntimeArgument>();
}
requiredArgumentsNotInOverloadGroups.Add(runtimeArgument);
}
}
}
equivalenceInfo = GetOverloadGroupEquivalence(overloadGroups);
return ValidateOverloadGroupDefinitions(activity, equivalenceInfo, overloadGroups, ref validationErrors);
}
private static bool ValidateOverloadGroupDefinitions(Activity activity, OverloadGroupEquivalenceInfo equivalenceInfo, Dictionary<string, List<RuntimeArgument>> overloadGroups, ref IList<ValidationError> validationErrors)
{
bool flag = true;
if (!equivalenceInfo.EquivalentGroupsDictionary.IsNullOrEmpty())
{
Hashtable hashtable = new Hashtable(equivalenceInfo.EquivalentGroupsDictionary.Count);
foreach (KeyValuePair<string, List<string>> pair in equivalenceInfo.EquivalentGroupsDictionary)
{
if (!hashtable.Contains(pair.Key))
{
string[] array = new string[pair.Value.Count + 1];
array[0] = pair.Key;
pair.Value.CopyTo(array, 1);
IEnumerable<string> c = array.OrderBy<string, string>(s => s, StringComparer.Ordinal);
ActivityUtilities.Add<ValidationError>(ref validationErrors, new ValidationError(System.Activities.SR.OverloadGroupsAreEquivalent(c.AsCommaSeparatedValues()), false, activity));
flag = false;
for (int i = 0; i < array.Length; i++)
{
hashtable.Add(array[i], null);
}
}
}
return flag;
}
if (!equivalenceInfo.SupersetOfGroupsDictionary.IsNullOrEmpty())
{
foreach (KeyValuePair<string, List<string>> pair2 in equivalenceInfo.SupersetOfGroupsDictionary)
{
IList<string> list = pair2.Value.OrderBy<string, string>(s => s, StringComparer.Ordinal).ToList<string>();
string[] strArray2 = new string[list.Count];
int num2 = 0;
foreach (string str in list)
{
if (overloadGroups[str].Any<RuntimeArgument>(a => a.IsRequired))
{
strArray2[num2++] = str;
}
}
if (num2 > 0)
{
ActivityUtilities.Add<ValidationError>(ref validationErrors, new ValidationError(System.Activities.SR.OverloadGroupHasSubsets(pair2.Key, strArray2.AsCommaSeparatedValues()), false, activity));
flag = false;
}
}
}
return flag;
}
public static void ValidateArguments(Activity activity, OverloadGroupEquivalenceInfo equivalenceInfo, Dictionary<string, List<RuntimeArgument>> overloadGroups, List<RuntimeArgument> requiredArgumentsNotInOverloadGroups, IDictionary<string, object> inputs, ref IList<ValidationError> validationErrors)
{
Func<RuntimeArgument, bool> func3 = null;
Func<RuntimeArgument, bool> func4 = null;
Predicate<RuntimeArgument> predicate2 = null;
if (!requiredArgumentsNotInOverloadGroups.IsNullOrEmpty())
{
foreach (RuntimeArgument argument in requiredArgumentsNotInOverloadGroups)
{
if (CheckIfArgumentIsNotBound(argument, inputs))
{
ActivityUtilities.Add<ValidationError>(ref validationErrors, new ValidationError(System.Activities.SR.RequiredArgumentValueNotSupplied(argument.Name), false, argument.Name, activity));
}
}
}
if (!overloadGroups.IsNullOrEmpty())
{
Func<string, bool> func = null;
Func<string, bool> func2 = null;
Dictionary<string, bool> configurationResults = new Dictionary<string, bool>();
string key = string.Empty;
int num = 0;
int num2 = 0;
foreach (KeyValuePair<string, List<RuntimeArgument>> pair in overloadGroups)
{
string str2 = pair.Key;
configurationResults.Add(str2, false);
IEnumerable<RuntimeArgument> source = from a in pair.Value
where a.IsRequired
select a;
if (source.Count<RuntimeArgument>() > 0)
{
if (func3 == null)
{
func3 = localArgument => CheckIfArgumentIsBound(localArgument, inputs);
}
if (source.All<RuntimeArgument>(func3))
{
configurationResults[str2] = true;
key = str2;
num++;
}
}
else
{
num2++;
if (func4 == null)
{
func4 = localArgument => CheckIfArgumentIsBound(localArgument, inputs);
}
if ((from a in pair.Value
where !a.IsRequired
select a).Any<RuntimeArgument>(func4))
{
configurationResults[str2] = true;
key = str2;
num++;
}
}
}
switch (num)
{
case 0:
if (num2 == 0)
{
ActivityUtilities.Add<ValidationError>(ref validationErrors, new ValidationError(System.Activities.SR.NoOverloadGroupsAreConfigured, false, activity));
return;
}
return;
case 1:
{
HashSet<RuntimeArgument> second = new HashSet<RuntimeArgument>(overloadGroups[key]);
if (predicate2 == null)
{
predicate2 = localArgument => CheckIfArgumentIsBound(localArgument, inputs);
}
Predicate<RuntimeArgument> match = predicate2;
List<string> list = null;
if (!equivalenceInfo.DisjointGroupsDictionary.IsNullOrEmpty())
{
equivalenceInfo.DisjointGroupsDictionary.TryGetValue(key, out list);
}
List<string> list2 = null;
if (!equivalenceInfo.OverlappingGroupsDictionary.IsNullOrEmpty())
{
equivalenceInfo.OverlappingGroupsDictionary.TryGetValue(key, out list2);
}
if (func == null)
{
func = k => !configurationResults[k];
}
foreach (string str3 in configurationResults.Keys.Where<string>(func))
{
if ((list != null) && list.Contains(str3))
{
foreach (RuntimeArgument argument2 in overloadGroups[str3].FindAll(match))
{
ActivityUtilities.Add<ValidationError>(ref validationErrors, new ValidationError(System.Activities.SR.ExtraOverloadGroupPropertiesConfigured(key, argument2.Name, str3), false, activity));
}
}
else if ((list2 != null) && list2.Contains(str3))
{
HashSet<RuntimeArgument> first = new HashSet<RuntimeArgument>(overloadGroups[str3]);
IEnumerable<RuntimeArgument> enumerable3 = first.Intersect<RuntimeArgument>(second);
foreach (RuntimeArgument argument3 in first.Except<RuntimeArgument>(enumerable3).ToList<RuntimeArgument>().FindAll(match))
{
ActivityUtilities.Add<ValidationError>(ref validationErrors, new ValidationError(System.Activities.SR.ExtraOverloadGroupPropertiesConfigured(key, argument3.Name, str3), false, activity));
}
}
}
return;
}
}
if (func2 == null)
{
func2 = k => configurationResults[k];
}
IEnumerable<string> c = configurationResults.Keys.Where<string>(func2).OrderBy<string, string>(k => k, StringComparer.Ordinal);
ActivityUtilities.Add<ValidationError>(ref validationErrors, new ValidationError(System.Activities.SR.MultipleOverloadGroupsConfigured(c.AsCommaSeparatedValues()), false, activity));
}
}
public static bool GatherAndValidateOverloads(Activity activity, out Dictionary <string, List <RuntimeArgument> > overloadGroups, out List <RuntimeArgument> requiredArgumentsNotInOverloadGroups, out OverloadGroupEquivalenceInfo equivalenceInfo, ref IList <ValidationError> validationErrors)
{
overloadGroups = null;
requiredArgumentsNotInOverloadGroups = null;
foreach (RuntimeArgument argument in activity.RuntimeArguments)
{
if (!argument.OverloadGroupNames.IsNullOrEmpty())
{
foreach (string str in argument.OverloadGroupNames)
{
if (overloadGroups == null)
{
overloadGroups = new Dictionary <string, List <RuntimeArgument> >();
}
List <RuntimeArgument> list = null;
if (!overloadGroups.TryGetValue(str, out list))
{
list = new List <RuntimeArgument>();
overloadGroups.Add(str, list);
}
list.Add(argument);
}
}
else if (argument.IsRequired)
{
if (requiredArgumentsNotInOverloadGroups == null)
{
requiredArgumentsNotInOverloadGroups = new List <RuntimeArgument>();
}
requiredArgumentsNotInOverloadGroups.Add(argument);
}
}
equivalenceInfo = GetOverloadGroupEquivalence(overloadGroups);
return(ValidateOverloadGroupDefinitions(activity, equivalenceInfo, overloadGroups, ref validationErrors));
}
public static void ValidateArguments(Activity activity, OverloadGroupEquivalenceInfo equivalenceInfo, Dictionary <string, List <RuntimeArgument> > overloadGroups, List <RuntimeArgument> requiredArgumentsNotInOverloadGroups, IDictionary <string, object> inputs, ref IList <ValidationError> validationErrors)
{
Func <RuntimeArgument, bool> func3 = null;
Func <RuntimeArgument, bool> func4 = null;
Predicate <RuntimeArgument> predicate2 = null;
if (!requiredArgumentsNotInOverloadGroups.IsNullOrEmpty())
{
foreach (RuntimeArgument argument in requiredArgumentsNotInOverloadGroups)
{
if (CheckIfArgumentIsNotBound(argument, inputs))
{
ActivityUtilities.Add <ValidationError>(ref validationErrors, new ValidationError(System.Activities.SR.RequiredArgumentValueNotSupplied(argument.Name), false, argument.Name, activity));
}
}
}
if (!overloadGroups.IsNullOrEmpty())
{
Func <string, bool> func = null;
Func <string, bool> func2 = null;
Dictionary <string, bool> configurationResults = new Dictionary <string, bool>();
string key = string.Empty;
int num = 0;
int num2 = 0;
foreach (KeyValuePair <string, List <RuntimeArgument> > pair in overloadGroups)
{
string str2 = pair.Key;
configurationResults.Add(str2, false);
IEnumerable <RuntimeArgument> source = from a in pair.Value
where a.IsRequired
select a;
if (source.Count <RuntimeArgument>() > 0)
{
if (func3 == null)
{
func3 = localArgument => CheckIfArgumentIsBound(localArgument, inputs);
}
if (source.All <RuntimeArgument>(func3))
{
configurationResults[str2] = true;
key = str2;
num++;
}
}
else
{
num2++;
if (func4 == null)
{
func4 = localArgument => CheckIfArgumentIsBound(localArgument, inputs);
}
if ((from a in pair.Value
where !a.IsRequired
select a).Any <RuntimeArgument>(func4))
{
configurationResults[str2] = true;
key = str2;
num++;
}
}
}
switch (num)
{
case 0:
if (num2 == 0)
{
ActivityUtilities.Add <ValidationError>(ref validationErrors, new ValidationError(System.Activities.SR.NoOverloadGroupsAreConfigured, false, activity));
return;
}
return;
case 1:
{
HashSet <RuntimeArgument> second = new HashSet <RuntimeArgument>(overloadGroups[key]);
if (predicate2 == null)
{
predicate2 = localArgument => CheckIfArgumentIsBound(localArgument, inputs);
}
Predicate <RuntimeArgument> match = predicate2;
List <string> list = null;
if (!equivalenceInfo.DisjointGroupsDictionary.IsNullOrEmpty())
{
equivalenceInfo.DisjointGroupsDictionary.TryGetValue(key, out list);
}
List <string> list2 = null;
if (!equivalenceInfo.OverlappingGroupsDictionary.IsNullOrEmpty())
{
equivalenceInfo.OverlappingGroupsDictionary.TryGetValue(key, out list2);
}
if (func == null)
{
func = k => !configurationResults[k];
}
foreach (string str3 in configurationResults.Keys.Where <string>(func))
{
if ((list != null) && list.Contains(str3))
{
foreach (RuntimeArgument argument2 in overloadGroups[str3].FindAll(match))
{
ActivityUtilities.Add <ValidationError>(ref validationErrors, new ValidationError(System.Activities.SR.ExtraOverloadGroupPropertiesConfigured(key, argument2.Name, str3), false, activity));
}
}
else if ((list2 != null) && list2.Contains(str3))
{
HashSet <RuntimeArgument> first = new HashSet <RuntimeArgument>(overloadGroups[str3]);
IEnumerable <RuntimeArgument> enumerable3 = first.Intersect <RuntimeArgument>(second);
foreach (RuntimeArgument argument3 in first.Except <RuntimeArgument>(enumerable3).ToList <RuntimeArgument>().FindAll(match))
{
ActivityUtilities.Add <ValidationError>(ref validationErrors, new ValidationError(System.Activities.SR.ExtraOverloadGroupPropertiesConfigured(key, argument3.Name, str3), false, activity));
}
}
}
return;
}
}
if (func2 == null)
{
func2 = k => configurationResults[k];
}
IEnumerable <string> c = configurationResults.Keys.Where <string>(func2).OrderBy <string, string>(k => k, StringComparer.Ordinal);
ActivityUtilities.Add <ValidationError>(ref validationErrors, new ValidationError(System.Activities.SR.MultipleOverloadGroupsConfigured(c.AsCommaSeparatedValues()), false, activity));
}
}
