public bool MatchHeader(string headerName) { var header = headerName.ToLower(); if (PatternMatchUtils.SimpleMatch(Pattern, header)) { return(true); } return(false); }
/// <summary> /// Does the supplied <paramref name="datum"/> satisfy the criteria encapsulated by /// this instance? /// </summary> /// <param name="datum">The datum to be checked by this criteria instance.</param> /// <returns> /// True if the supplied <paramref name="datum"/> satisfies the criteria encapsulated /// by this instance; false if not or the supplied <paramref name="datum"/> is null. /// </returns> public bool IsSatisfied(object datum) { bool satisfied = false; MethodBase method = datum as MethodBase; if (method != null) { satisfied = PatternMatchUtils.SimpleMatch(pattern.ToLower(), method.Name.ToLower()); } return(satisfied); }
public bool MatchHeader(string headerName) { var header = headerName.ToLower(); foreach (var pattern in Patterns) { if (PatternMatchUtils.SimpleMatch(pattern, header)) { return(true); } } return(false); }
/// <summary> /// Return if the given object name matches one of the object names specified. /// </summary> /// <remarks> /// <p> /// The default implementation checks for "xxx*", "*xxx" and "*xxx*" matches, /// as well as direct equality. Can be overridden in subclasses. /// </p> /// </remarks> /// <param name="objectName">the object name to check</param> /// <returns>if the names match</returns> protected virtual bool IsObjectNameMatch(string objectName) { if (objectNames != null) { for (int i = 0; i < objectNames.Count; i++) { string mappedName = String.Copy((string)objectNames[i]); if (PatternMatchUtils.SimpleMatch(mappedName, objectName)) { return(true); } } } return(false); }
protected List <string> GetMatchingHeaderNames(string pattern, IDictionary <string, object> headers) { var matchingHeaderNames = new List <string>(); if (headers != null) { foreach (var header in headers) { if (PatternMatchUtils.SimpleMatch(pattern, header.Key)) { matchingHeaderNames.Add(header.Key); } } } return(matchingHeaderNames); }
public virtual IMessageBuilder FilterAndCopyHeadersIfAbsent(IDictionary <string, object> headersToCopy, params string[] headerPatternsToFilter) { IDictionary <string, object> headers = new Dictionary <string, object>(headersToCopy); if (headerPatternsToFilter?.Length > 0) { foreach (var entry in headersToCopy) { if (PatternMatchUtils.SimpleMatch(headerPatternsToFilter, entry.Key)) { headers.Remove(entry.Key); } } } return(CopyHeadersIfAbsent(headers)); }
/// <summary> /// Match a method against the given pattern. /// </summary> /// <param name="pattern">the pattern to match against.</param> /// <param name="method">the method to match.</param> /// <returns> /// <see lang="true"/> if the method matches the given pattern; otherwise <see lang="false"/>. /// </returns> /// <exception cref="System.ArgumentException"> /// If the supplied <paramref name="pattern"/> is invalid. /// </exception> public static bool MethodMatch(string pattern, MethodInfo method) { Match m = methodMatchRegex.Match(pattern); if (!m.Success) { throw new ArgumentException(String.Format("The pattern [{0}] is not well-formed.", pattern)); } // Check method name string methodNamePattern = m.Groups["methodName"].Value; if (!PatternMatchUtils.SimpleMatch(methodNamePattern, method.Name)) { return(false); } if (m.Groups["parameters"].Value.Length > 0) { // Check parameter types string parameters = m.Groups["parameterTypes"].Value; string[] paramTypes = (parameters.Length == 0) ? new string[0] : StringUtils.DelimitedListToStringArray(parameters, ","); ParameterInfo[] paramInfos = method.GetParameters(); // Verify parameter count if (paramTypes.Length != paramInfos.Length) { return(false); } // Match parameter types for (int i = 0; i < paramInfos.Length; i++) { if (paramInfos[i].ParameterType != TypeResolutionUtils.ResolveType(paramTypes[i])) { return(false); } } } return(true); }
private List <string> GetMatchingHeaderNames(string pattern, IDictionary <string, object> headers) { if (headers == null) { return(new List <string>()); } var matchingHeaderNames = new List <string>(); foreach (var key in headers.Keys) { if (PatternMatchUtils.SimpleMatch(pattern, key)) { matchingHeaderNames.Add(key); } } return(matchingHeaderNames); }
/// <summary> /// Match a method against the given pattern. /// </summary> /// <param name="pattern">the pattern to match against.</param> /// <param name="method">the method to match.</param> /// <returns> /// <see lang="true" /> if the method matches the given pattern; otherwise <see lang="false" />. /// </returns> /// <exception cref="System.ArgumentException"> /// If the supplied <paramref name="pattern" /> is invalid. /// </exception> public static bool MethodMatch(string pattern, MethodInfo method) { var m = _methodMatchRegex.Match(pattern); if (!m.Success) { throw new ArgumentException(String.Format("The pattern [{0}] is not well-formed.", pattern)); } // Check method name var methodNamePattern = m.Groups["methodName"].Value; if (!PatternMatchUtils.SimpleMatch(methodNamePattern, method.Name)) { return(false); } if (m.Groups["parameters"].Value.Length > 0) { // Check parameter types var parameters = m.Groups["parameterTypes"].Value; var paramTypes = (parameters.Length == 0) ? new string[0] : StringUtils.DelimitedListToStringArray(parameters, ","); var paramInfos = method.GetParameters(); // Verify parameter count if (paramTypes.Length != paramInfos.Length) { return(false); } // Match parameter types var result = !paramInfos.Where((t, i) => t.ParameterType != ResolveType(paramTypes[i])).Any(); return(result); } return(true); }
/// <summary> /// Does the supplied <paramref name="methodName"/> match the supplied <paramref name="mappedName"/>? /// </summary> /// <remarks> /// <p> /// The default implementation checks for "xxx*", "*xxx" and "*xxx*" matches, /// as well as direct equality. Can be overridden in subclasses. /// </p> /// </remarks> /// <param name="methodName"> /// The method name of the class. /// </param> /// <param name="mappedName"> /// The name in the descriptor. /// </param> /// <returns> /// <b>True</b> if the names match. /// </returns> protected virtual bool IsMatch(string methodName, string mappedName) { return(PatternMatchUtils.SimpleMatch(mappedName, methodName)); }
private void DoTest(string pattern, string str, bool shouldMatch) { Assert.Equal(shouldMatch, PatternMatchUtils.SimpleMatch(pattern, str)); }
/// <summary> /// Does the supplied type's <see cref="Type.FullName"/> match any of the <see cref="TypeNamePatterns"/>? /// </summary> /// <param name="type"> /// The candidate <see cref="System.Type"/>. /// </param> /// <returns> /// <see langword="true"/> if the <paramref name="type"/> matches any of the <see cref="TypeNamePatterns"/>. /// </returns> public bool Matches(Type type) { return(PatternMatchUtils.SimpleMatch(_typeNamePatterns, type.FullName)); }