Code:
/ FXUpdate3074 / FXUpdate3074 / 1.1 / untmp / whidbey / QFE / ndp / fx / src / xsp / System / Web / Util / Wildcard.cs / 1 / 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.
Link Menu

This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- RealProxy.cs
- Codec.cs
- CodeParameterDeclarationExpression.cs
- TextEditorCopyPaste.cs
- EntityConnection.cs
- InstancePersistence.cs
- UserMapPath.cs
- Logging.cs
- ArgumentsParser.cs
- NativeMethods.cs
- UrlPath.cs
- UnsafeMethods.cs
- NegotiateStream.cs
- _HeaderInfo.cs
- PermissionRequestEvidence.cs
- HtmlShimManager.cs
- LinearQuaternionKeyFrame.cs
- SimpleLine.cs
- XamlTemplateSerializer.cs
- WindowShowOrOpenTracker.cs
- Types.cs
- EventlogProvider.cs
- QuestionEventArgs.cs
- DrawingContext.cs
- XmlIncludeAttribute.cs
- DataGridClipboardCellContent.cs
- NetDataContractSerializer.cs
- Model3DGroup.cs
- Attributes.cs
- ListViewGroupConverter.cs
- HttpCacheVary.cs
- _TransmitFileOverlappedAsyncResult.cs
- DataGridViewCellConverter.cs
- QueryComponents.cs
- DataTableReader.cs
- Hex.cs
- StubHelpers.cs
- PartitionedDataSource.cs
- ContentFilePart.cs
- RepeatButtonAutomationPeer.cs
- rsa.cs
- WebPartExportVerb.cs
- Parser.cs
- CmsInterop.cs
- BooleanToVisibilityConverter.cs
- IndexingContentUnit.cs
- TableColumn.cs
- HandledEventArgs.cs
- SecurityElement.cs
- Pair.cs
- HtmlInputControl.cs
- SignedPkcs7.cs
- TileModeValidation.cs
- SettingsBase.cs
- TextTreeTextBlock.cs
- FieldCollectionEditor.cs
- EntityCommandDefinition.cs
- ConfigurationManagerHelper.cs
- WorkflowMarkupSerializer.cs
- ExceptionHelpers.cs
- HierarchicalDataBoundControl.cs
- NavigateEvent.cs
- Baml2006ReaderSettings.cs
- MdiWindowListItemConverter.cs
- ListControlBoundActionList.cs
- GeneralTransform3DGroup.cs
- EndpointIdentityConverter.cs
- ComplexTypeEmitter.cs
- MenuAdapter.cs
- FrameworkContentElementAutomationPeer.cs
- UseAttributeSetsAction.cs
- ListSortDescriptionCollection.cs
- SamlSecurityToken.cs
- HandlerMappingMemo.cs
- PipeSecurity.cs
- DecoderBestFitFallback.cs
- StatusBar.cs
- ImageButton.cs
- ReflectionHelper.cs
- odbcmetadatacollectionnames.cs
- Geometry.cs
- ResponseStream.cs
- FormViewActionList.cs
- Message.cs
- Screen.cs
- EntityDataSourceValidationException.cs
- TypeResolvingOptions.cs
- X509AsymmetricSecurityKey.cs
- SchemaDeclBase.cs
- TransformerConfigurationWizardBase.cs
- DataGridViewRowContextMenuStripNeededEventArgs.cs
- VectorValueSerializer.cs
- WSSecurityOneDotOneSendSecurityHeader.cs
- WebZone.cs
- documentsequencetextview.cs
- MenuDesigner.cs
- AuthenticationSection.cs
- ComponentManagerBroker.cs
- Odbc32.cs
- LogArchiveSnapshot.cs