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)); } }