Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / xsp / System / Web / Util / Wildcard.cs / 1305376 / Wildcard.cs
//------------------------------------------------------------------------------ //// Copyright (c) Microsoft Corporation. All rights reserved. // //----------------------------------------------------------------------------- /* * Wildcard * * wildcard wrappers for Regex * * (1) Wildcard does straight string wildcarding with no path separator awareness * (2) WildcardUrl recognizes that forward / slashes are special and can't match * or ? * (3) WildcardDos recognizes that backward \ and : are special and can't match * or ? * * Copyright (c) 1999, Microsoft Corporation */ namespace System.Web.Util { using System.Runtime.Serialization.Formatters; using System.Text.RegularExpressions; /* * Wildcard * * Wildcard patterns have three metacharacters: * * A ? is equivalent to . * A * is equivalent to .* * A , is equivalent to | * * Note that by each alternative is surrounded by \A...\z to anchor * at the edges of the string. */ internal class Wildcard { #if NOT_USED internal /*public*/ Wildcard(String pattern) : this (pattern, false) { } #endif internal /*public*/ Wildcard(String pattern, bool caseInsensitive) { _pattern = pattern; _caseInsensitive = caseInsensitive; } internal String _pattern; internal bool _caseInsensitive; internal Regex _regex; protected static Regex metaRegex = new Regex("[\\+\\{\\\\\\[\\|\\(\\)\\.\\^\\$]"); protected static Regex questRegex = new Regex("\\?"); protected static Regex starRegex = new Regex("\\*"); protected static Regex commaRegex = new Regex(","); protected static Regex slashRegex = new Regex("(?=/)"); protected static Regex backslashRegex = new Regex("(?=[\\\\:])"); /* * IsMatch returns true if the input is an exact match for the * wildcard pattern. */ internal /*public*/ bool IsMatch(String input) { EnsureRegex(); bool result = _regex.IsMatch(input); return result; } #if DONT_COMPILE internal /*public*/ String Pattern { get { return _pattern; } } #endif /* * Builds the matching regex when needed */ protected void EnsureRegex() { // threadsafe without protection because of gc if (_regex != null) return; _regex = RegexFromWildcard(_pattern, _caseInsensitive); } /* * Basic wildcard -> Regex conversion, no slashes */ protected virtual Regex RegexFromWildcard(String pattern, bool caseInsensitive) { RegexOptions options = RegexOptions.None; // match right-to-left (for speed) if the pattern starts with a * if (pattern.Length > 0 && pattern[0] == '*') options = RegexOptions.RightToLeft | RegexOptions.Singleline; else options = RegexOptions.Singleline; // case insensitivity if (caseInsensitive) options |= RegexOptions.IgnoreCase | RegexOptions.CultureInvariant; // Remove regex metacharacters pattern = metaRegex.Replace(pattern, "\\$0"); // Replace wildcard metacharacters with regex codes pattern = questRegex.Replace(pattern, "."); pattern = starRegex.Replace(pattern, ".*"); pattern = commaRegex.Replace(pattern, "\\z|\\A"); // anchor the pattern at beginning and end, and return the regex return new Regex("\\A" + pattern + "\\z", options); } } abstract internal class WildcardPath : Wildcard { #if NOT_USED internal /*public*/ WildcardPath(String pattern) : base(pattern) { } private Regex[][] _dirs; #endif internal /*public*/ WildcardPath(String pattern, bool caseInsensitive) : base(pattern, caseInsensitive) { } private Regex _suffix; /* * IsSuffix returns true if a suffix of the input is an exact * match for the wildcard pattern. */ internal /*public*/ bool IsSuffix(String input) { EnsureSuffix(); return _suffix.IsMatch(input); } #if NOT_USED /* * AllowPrefix returns true if the input is an exact match for * a prefix-directory of the wildcard pattern (i.e., if it * is possible to match the wildcard pattern by adding * more subdirectories or a filename at the end of the path). */ internal /*public*/ bool AllowPrefix(String prefix) { String[] dirs = SplitDirs(prefix); EnsureDirs(); for (int i = 0; i < _dirs.Length; i++) { // pattern is shorter than prefix: reject if (_dirs[i].Length < dirs.Length) goto NextAlt; for (int j = 0; j < dirs.Length; j++) { // the jth directory doesn't match; path is not a prefix if (!_dirs[i][j].IsMatch(dirs[j])) goto NextAlt; } // one alternative passed: we pass. return true; NextAlt: ; } return false; } /* * Builds the matching regex array when needed */ protected void EnsureDirs() { // threadsafe without protection because of gc if (_dirs != null) return; _dirs = DirsFromWildcard(_pattern); } #endif /* * Builds the matching regex when needed */ protected void EnsureSuffix() { // threadsafe without protection because of gc if (_suffix != null) return; _suffix = SuffixFromWildcard(_pattern, _caseInsensitive); } /* * Specialize for forward-slash and backward-slash cases */ protected abstract Regex SuffixFromWildcard(String pattern, bool caseInsensitive); protected abstract Regex[][] DirsFromWildcard(String pattern); protected abstract String[] SplitDirs(String input); } /* * WildcardUrl * * The twist is that * and ? cannot match forward slashes, * and we can do an exact suffix match that starts after * any /, and we can also do a prefix prune. */ internal class WildcardUrl : WildcardPath { #if NOT_USED internal /*public*/ WildcardUrl(String pattern) : base(pattern) { } #endif internal /*public*/ WildcardUrl(String pattern, bool caseInsensitive) : base(pattern, caseInsensitive) { } protected override String[] SplitDirs(String input) { return slashRegex.Split(input); } protected override Regex RegexFromWildcard(String pattern, bool caseInsensitive) { RegexOptions options; // match right-to-left (for speed) if the pattern starts with a * if (pattern.Length > 0 && pattern[0] == '*') options = RegexOptions.RightToLeft; else options = RegexOptions.None; // case insensitivity if (caseInsensitive) options |= RegexOptions.IgnoreCase | RegexOptions.CultureInvariant; // Remove regex metacharacters pattern = metaRegex.Replace(pattern, "\\$0"); // Replace wildcard metacharacters with regex codes pattern = questRegex.Replace(pattern, "[^/]"); pattern = starRegex.Replace(pattern, "[^/]*"); pattern = commaRegex.Replace(pattern, "\\z|\\A"); // anchor the pattern at beginning and end, and return the regex return new Regex("\\A" + pattern + "\\z", options); } protected override Regex SuffixFromWildcard(String pattern, bool caseInsensitive) { RegexOptions options; // match right-to-left (for speed) options = RegexOptions.RightToLeft; // case insensitivity if (caseInsensitive) options |= RegexOptions.IgnoreCase | RegexOptions.CultureInvariant; // Remove regex metacharacters pattern = metaRegex.Replace(pattern, "\\$0"); // Replace wildcard metacharacters with regex codes pattern = questRegex.Replace(pattern, "[^/]"); pattern = starRegex.Replace(pattern, "[^/]*"); pattern = commaRegex.Replace(pattern, "\\z|(?:\\A|(?<=/))"); // anchor the pattern at beginning and end, and return the regex return new Regex("(?:\\A|(?<=/))" + pattern + "\\z", options); } protected override Regex[][] DirsFromWildcard(String pattern) { String[] alts = commaRegex.Split(pattern); Regex[][] dirs = new Regex[alts.Length][]; for (int i = 0; i < alts.Length; i++) { String[] dirpats = slashRegex.Split(alts[i]); Regex[] dirregex = new Regex[dirpats.Length]; if (alts.Length == 1 && dirpats.Length == 1) { // common case: no commas, no slashes: dir regex is same as top regex. EnsureRegex(); dirregex[0] = _regex; } else { for (int j = 0; j < dirpats.Length; j++) { dirregex[j] = RegexFromWildcard(dirpats[j], _caseInsensitive); } } dirs[i] = dirregex; } return dirs; } } } // File provided for Reference Use Only by Microsoft Corporation (c) 2007. //------------------------------------------------------------------------------ //// Copyright (c) Microsoft Corporation. All rights reserved. // //----------------------------------------------------------------------------- /* * Wildcard * * wildcard wrappers for Regex * * (1) Wildcard does straight string wildcarding with no path separator awareness * (2) WildcardUrl recognizes that forward / slashes are special and can't match * or ? * (3) WildcardDos recognizes that backward \ and : are special and can't match * or ? * * Copyright (c) 1999, Microsoft Corporation */ namespace System.Web.Util { using System.Runtime.Serialization.Formatters; using System.Text.RegularExpressions; /* * Wildcard * * Wildcard patterns have three metacharacters: * * A ? is equivalent to . * A * is equivalent to .* * A , is equivalent to | * * Note that by each alternative is surrounded by \A...\z to anchor * at the edges of the string. */ internal class Wildcard { #if NOT_USED internal /*public*/ Wildcard(String pattern) : this (pattern, false) { } #endif internal /*public*/ Wildcard(String pattern, bool caseInsensitive) { _pattern = pattern; _caseInsensitive = caseInsensitive; } internal String _pattern; internal bool _caseInsensitive; internal Regex _regex; protected static Regex metaRegex = new Regex("[\\+\\{\\\\\\[\\|\\(\\)\\.\\^\\$]"); protected static Regex questRegex = new Regex("\\?"); protected static Regex starRegex = new Regex("\\*"); protected static Regex commaRegex = new Regex(","); protected static Regex slashRegex = new Regex("(?=/)"); protected static Regex backslashRegex = new Regex("(?=[\\\\:])"); /* * IsMatch returns true if the input is an exact match for the * wildcard pattern. */ internal /*public*/ bool IsMatch(String input) { EnsureRegex(); bool result = _regex.IsMatch(input); return result; } #if DONT_COMPILE internal /*public*/ String Pattern { get { return _pattern; } } #endif /* * Builds the matching regex when needed */ protected void EnsureRegex() { // threadsafe without protection because of gc if (_regex != null) return; _regex = RegexFromWildcard(_pattern, _caseInsensitive); } /* * Basic wildcard -> Regex conversion, no slashes */ protected virtual Regex RegexFromWildcard(String pattern, bool caseInsensitive) { RegexOptions options = RegexOptions.None; // match right-to-left (for speed) if the pattern starts with a * if (pattern.Length > 0 && pattern[0] == '*') options = RegexOptions.RightToLeft | RegexOptions.Singleline; else options = RegexOptions.Singleline; // case insensitivity if (caseInsensitive) options |= RegexOptions.IgnoreCase | RegexOptions.CultureInvariant; // Remove regex metacharacters pattern = metaRegex.Replace(pattern, "\\$0"); // Replace wildcard metacharacters with regex codes pattern = questRegex.Replace(pattern, "."); pattern = starRegex.Replace(pattern, ".*"); pattern = commaRegex.Replace(pattern, "\\z|\\A"); // anchor the pattern at beginning and end, and return the regex return new Regex("\\A" + pattern + "\\z", options); } } abstract internal class WildcardPath : Wildcard { #if NOT_USED internal /*public*/ WildcardPath(String pattern) : base(pattern) { } private Regex[][] _dirs; #endif internal /*public*/ WildcardPath(String pattern, bool caseInsensitive) : base(pattern, caseInsensitive) { } private Regex _suffix; /* * IsSuffix returns true if a suffix of the input is an exact * match for the wildcard pattern. */ internal /*public*/ bool IsSuffix(String input) { EnsureSuffix(); return _suffix.IsMatch(input); } #if NOT_USED /* * AllowPrefix returns true if the input is an exact match for * a prefix-directory of the wildcard pattern (i.e., if it * is possible to match the wildcard pattern by adding * more subdirectories or a filename at the end of the path). */ internal /*public*/ bool AllowPrefix(String prefix) { String[] dirs = SplitDirs(prefix); EnsureDirs(); for (int i = 0; i < _dirs.Length; i++) { // pattern is shorter than prefix: reject if (_dirs[i].Length < dirs.Length) goto NextAlt; for (int j = 0; j < dirs.Length; j++) { // the jth directory doesn't match; path is not a prefix if (!_dirs[i][j].IsMatch(dirs[j])) goto NextAlt; } // one alternative passed: we pass. return true; NextAlt: ; } return false; } /* * Builds the matching regex array when needed */ protected void EnsureDirs() { // threadsafe without protection because of gc if (_dirs != null) return; _dirs = DirsFromWildcard(_pattern); } #endif /* * Builds the matching regex when needed */ protected void EnsureSuffix() { // threadsafe without protection because of gc if (_suffix != null) return; _suffix = SuffixFromWildcard(_pattern, _caseInsensitive); } /* * Specialize for forward-slash and backward-slash cases */ protected abstract Regex SuffixFromWildcard(String pattern, bool caseInsensitive); protected abstract Regex[][] DirsFromWildcard(String pattern); protected abstract String[] SplitDirs(String input); } /* * WildcardUrl * * The twist is that * and ? cannot match forward slashes, * and we can do an exact suffix match that starts after * any /, and we can also do a prefix prune. */ internal class WildcardUrl : WildcardPath { #if NOT_USED internal /*public*/ WildcardUrl(String pattern) : base(pattern) { } #endif internal /*public*/ WildcardUrl(String pattern, bool caseInsensitive) : base(pattern, caseInsensitive) { } protected override String[] SplitDirs(String input) { return slashRegex.Split(input); } protected override Regex RegexFromWildcard(String pattern, bool caseInsensitive) { RegexOptions options; // match right-to-left (for speed) if the pattern starts with a * if (pattern.Length > 0 && pattern[0] == '*') options = RegexOptions.RightToLeft; else options = RegexOptions.None; // case insensitivity if (caseInsensitive) options |= RegexOptions.IgnoreCase | RegexOptions.CultureInvariant; // Remove regex metacharacters pattern = metaRegex.Replace(pattern, "\\$0"); // Replace wildcard metacharacters with regex codes pattern = questRegex.Replace(pattern, "[^/]"); pattern = starRegex.Replace(pattern, "[^/]*"); pattern = commaRegex.Replace(pattern, "\\z|\\A"); // anchor the pattern at beginning and end, and return the regex return new Regex("\\A" + pattern + "\\z", options); } protected override Regex SuffixFromWildcard(String pattern, bool caseInsensitive) { RegexOptions options; // match right-to-left (for speed) options = RegexOptions.RightToLeft; // case insensitivity if (caseInsensitive) options |= RegexOptions.IgnoreCase | RegexOptions.CultureInvariant; // Remove regex metacharacters pattern = metaRegex.Replace(pattern, "\\$0"); // Replace wildcard metacharacters with regex codes pattern = questRegex.Replace(pattern, "[^/]"); pattern = starRegex.Replace(pattern, "[^/]*"); pattern = commaRegex.Replace(pattern, "\\z|(?:\\A|(?<=/))"); // anchor the pattern at beginning and end, and return the regex return new Regex("(?:\\A|(?<=/))" + pattern + "\\z", options); } protected override Regex[][] DirsFromWildcard(String pattern) { String[] alts = commaRegex.Split(pattern); Regex[][] dirs = new Regex[alts.Length][]; for (int i = 0; i < alts.Length; i++) { String[] dirpats = slashRegex.Split(alts[i]); Regex[] dirregex = new Regex[dirpats.Length]; if (alts.Length == 1 && dirpats.Length == 1) { // common case: no commas, no slashes: dir regex is same as top regex. EnsureRegex(); dirregex[0] = _regex; } else { for (int j = 0; j < dirpats.Length; j++) { dirregex[j] = RegexFromWildcard(dirpats[j], _caseInsensitive); } } dirs[i] = dirregex; } return dirs; } } } // File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- QuaternionIndependentAnimationStorage.cs
- SpecialTypeDataContract.cs
- StringAttributeCollection.cs
- DBPropSet.cs
- SoapFault.cs
- TaskExceptionHolder.cs
- TextDecorationCollection.cs
- ArgumentNullException.cs
- EntityDataSourceDesigner.cs
- JsonReaderWriterFactory.cs
- LinqDataSourceUpdateEventArgs.cs
- Color.cs
- ActiveXMessageFormatter.cs
- PropertyItem.cs
- ReadWriteSpinLock.cs
- DateTimeParse.cs
- PageCatalogPartDesigner.cs
- DataRelation.cs
- JsonDataContract.cs
- WebBrowser.cs
- EventMappingSettingsCollection.cs
- _DomainName.cs
- Subset.cs
- XmlBinaryReader.cs
- SqlCommandBuilder.cs
- WindowsListViewSubItem.cs
- DataGridViewRowEventArgs.cs
- TextSimpleMarkerProperties.cs
- DynamicValueConverter.cs
- BuildProvider.cs
- ResourceContainer.cs
- ViewSimplifier.cs
- _UriSyntax.cs
- TraceData.cs
- ShadowGlyph.cs
- ExtendedPropertyCollection.cs
- ValidatorCollection.cs
- DataSourceHelper.cs
- Canvas.cs
- AuthorizationPolicyTypeElement.cs
- RegistryConfigurationProvider.cs
- WindowInteropHelper.cs
- WebControlsSection.cs
- StringDictionaryCodeDomSerializer.cs
- Help.cs
- BinaryParser.cs
- TypeResolvingOptions.cs
- WsdlInspector.cs
- SelectionBorderGlyph.cs
- FileRecordSequenceHelper.cs
- ConfigXmlCDataSection.cs
- coordinatorfactory.cs
- XmlUnspecifiedAttribute.cs
- ToolStripItemImageRenderEventArgs.cs
- regiisutil.cs
- ResourceAttributes.cs
- DoubleAnimationClockResource.cs
- FixedPageProcessor.cs
- StorageEndPropertyMapping.cs
- Errors.cs
- keycontainerpermission.cs
- AnnotationResourceCollection.cs
- SettingsPropertyValue.cs
- MediaElement.cs
- CommonDialog.cs
- MessageQueueConverter.cs
- CharEnumerator.cs
- ResourceExpressionBuilder.cs
- NamedServiceModelExtensionCollectionElement.cs
- XmlnsDictionary.cs
- IdentityModelStringsVersion1.cs
- Control.cs
- ClientUtils.cs
- HandleInitializationContext.cs
- TraceFilter.cs
- CollectionConverter.cs
- XmlElement.cs
- BrowserCapabilitiesFactory35.cs
- ActiveDocumentEvent.cs
- TypedLocationWrapper.cs
- CopyOfAction.cs
- ArrayElementGridEntry.cs
- PermissionToken.cs
- HGlobalSafeHandle.cs
- CultureTable.cs
- MDIClient.cs
- ValueChangedEventManager.cs
- ControlBuilder.cs
- HtmlControlPersistable.cs
- InputManager.cs
- coordinatorscratchpad.cs
- SizeAnimationBase.cs
- ToolStripDropDownClosingEventArgs.cs
- Solver.cs
- ErrorsHelper.cs
- TableRowGroup.cs
- WebPartConnectionsCancelVerb.cs
- TextParentUndoUnit.cs
- DataGridViewCellValidatingEventArgs.cs
- XmlSchemaValidationException.cs