public bool TryLookupUri(Uri uri, HostNameComparisonMode hostNameComparisonMode, out TItem item) { BaseUriWithWildcard key = new BaseUriWithWildcard(uri, hostNameComparisonMode); if (TryCacheLookup(key, out item)) { return(item != null); } using (AsyncLock.TakeLock()) { // exact match failed, perform the full lookup (which will also // catch case-insensitive variations that aren't yet in our cache) bool dummy; SegmentHierarchyNode <TItem> node = FindDataNode( UriSegmenter.ToPath(key.BaseAddress, hostNameComparisonMode, includePortInComparison), out dummy); if (node != null) { item = node.Data; } // We want to cache both positive AND negative results AddToCache(key, item); return(item != null); } }
public bool IsRegistered(BaseUriWithWildcard key) { bool flag; SegmentHierarchyNode <TItem> node; string[] path = UriSegmenter <TItem> .ToPath(key.BaseAddress, key.HostNameComparisonMode, this.includePortInComparison); lock (this.ThisLock) { node = this.FindDataNode(path, out flag); } return((flag && (node != null)) && (node.Data != null)); }
public bool IsRegistered(BaseUriWithWildcard key) { Uri uri = key.BaseAddress; // don't need to normalize path since SegmentHierarchyNode is // already OrdinalIgnoreCase string[] paths = UriSegmenter.ToPath(uri, key.HostNameComparisonMode, includePortInComparison); bool exactMatch; SegmentHierarchyNode <TItem> node; using (AsyncLock.TakeLock()) { node = FindDataNode(paths, out exactMatch); } return(exactMatch && node != null && node.Data != null); }
private SegmentHierarchyNode <TItem> FindOrCreateNode(BaseUriWithWildcard baseUri) { Fx.Assert(baseUri != null, "FindOrCreateNode: baseUri is null"); string[] path = UriSegmenter.ToPath(baseUri.BaseAddress, baseUri.HostNameComparisonMode, _includePortInComparison); SegmentHierarchyNode <TItem> current = _root; for (int i = 0; i < path.Length; ++i) { if (!current.TryGetChild(path[i], out SegmentHierarchyNode <TItem> next)) { next = new SegmentHierarchyNode <TItem>(path[i], _useWeakReferences); current.SetChildNode(path[i], next); } current = next; } return(current); }
private SegmentHierarchyNode <TItem> FindOrCreateNode(BaseUriWithWildcard baseUri) { string[] strArray = UriSegmenter <TItem> .ToPath(baseUri.BaseAddress, baseUri.HostNameComparisonMode, this.includePortInComparison); SegmentHierarchyNode <TItem> root = this.root; for (int i = 0; i < strArray.Length; i++) { SegmentHierarchyNode <TItem> node2; if (!root.TryGetChild(strArray[i], out node2)) { node2 = new SegmentHierarchyNode <TItem>(strArray[i], this.useWeakReferences); root.SetChildNode(strArray[i], node2); } root = node2; } return(root); }
public void UnregisterUri(Uri uri, HostNameComparisonMode hostNameComparisonMode) { lock (this.ThisLock) { this.ClearCache(); string[] path = UriSegmenter <TItem> .ToPath(uri, hostNameComparisonMode, this.includePortInComparison); if (path.Length == 0) { this.root.RemoveData(); } else { this.root.RemovePath(path, 0); } this.count--; } }
public void UnregisterUri(Uri uri, HostNameComparisonMode hostNameComparisonMode) { using (AsyncLock.TakeLock()) { // Since every removed Uri could alter what Prefixes should have matched, we // should clear the cache of any existing results and start over ClearCache(); string[] path = UriSegmenter.ToPath(uri, hostNameComparisonMode, includePortInComparison); // Never remove the root if (path.Length == 0) { root.RemoveData(); } else { root.RemovePath(path, 0); } count--; } }
public bool TryLookupUri(Uri uri, HostNameComparisonMode hostNameComparisonMode, out TItem item) { BaseUriWithWildcard key = new BaseUriWithWildcard(uri, hostNameComparisonMode); if (this.TryCacheLookup(key, out item)) { return(((TItem)item) != null); } lock (this.ThisLock) { bool flag; SegmentHierarchyNode <TItem> node = this.FindDataNode(UriSegmenter <TItem> .ToPath(key.BaseAddress, hostNameComparisonMode, this.includePortInComparison), out flag); if (node != null) { item = node.Data; } this.AddToCache(key, item); return(((TItem)item) != null); } }