public static Dictionary<String, String> SplitByKey(this String source, String keyRegexPattern, Boolean overwrite) { if (source.IsNullOrEmpty() || keyRegexPattern.IsNullOrEmpty()) throw new ArgumentNullException("source"); Dictionary<String, String> results = new Dictionary<string, string>(); Match match = null; Match lastMatch = null; while ((match = Regex.Match(source, keyRegexPattern)).Success) { if (lastMatch != null) { Boolean flag = results.ContainsKey(lastMatch.Value); if (flag && overwrite) { results[lastMatch.Value] = source.Substring(0, match.Index); } else if (flag == false) { results.Add(lastMatch.Value, source.Substring(0, match.Index)); } } lastMatch = match; source = source.Substring(match.Index + match.Length); } if (lastMatch != null) { Boolean flag = results.ContainsKey(lastMatch.Value); if (flag && overwrite) { results[lastMatch.Value] = source.Substring(0, match.Index); } else if (flag == false) { results.Add(lastMatch.Value, source.Substring(0)); } } if (!results.IsNullOrEmpty()) return results; else return null; }
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; }
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; }
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 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)); } }