internal IDisposable CreateBlock(string blockName) { // Unit tests case if (_performanceMarkerBlockProviders == null || _performanceMarkerBlockProviders.Count == 0) { return(new Block()); } // Optimize for the most common case if (_performanceMarkerBlockProviders.Count == 1) { IDisposable block = _performanceMarkerBlockProviders[0].Value?.CreateBlock(blockName); if (block != null) { return(block); } } var providedBlocks = new FrugalList <IDisposable>(); for (int i = 0; i < _performanceMarkerBlockProviders.Count; i++) { providedBlocks.Add(_performanceMarkerBlockProviders[i].Value?.CreateBlock(blockName)); } return(new Block(providedBlocks)); }
private static void SplitMapDownToFirstMatchNoTrack(FrugalList <SnapshotSpan> unmappedSpans, Predicate <ITextBuffer> match, IList <SnapshotSpan> mappedSpans, bool mapByContentType) { ITextSnapshot matchingSnapshot = null; while (unmappedSpans.Count > 0) { SnapshotSpan span = unmappedSpans[unmappedSpans.Count - 1]; unmappedSpans.RemoveAt(unmappedSpans.Count - 1); if (span.Snapshot == matchingSnapshot) { mappedSpans.Add(span); } else if (match(span.Snapshot.TextBuffer)) { mappedSpans.Add(span); matchingSnapshot = span.Snapshot; } else { IProjectionSnapshot spanSnapshotAsProjection = span.Snapshot as IProjectionSnapshot; if (spanSnapshotAsProjection != null && (!mapByContentType || span.Snapshot.TextBuffer.ContentType.IsOfType("projection"))) { unmappedSpans.AddRange(spanSnapshotAsProjection.MapToSourceSnapshots(span)); } } } }
public static void MapUpToSnapshotNoTrack(ITextSnapshot targetSnapshot, SnapshotSpan anchor, IList <SnapshotSpan> mappedSpans) { if (anchor.Snapshot == targetSnapshot) { mappedSpans.Add(anchor); } else { IProjectionSnapshot targetAsProjection = targetSnapshot as IProjectionSnapshot; if (targetAsProjection != null) { var sourceSnapshots = targetAsProjection.SourceSnapshots; for (int s = 0; s < sourceSnapshots.Count; ++s) { FrugalList <SnapshotSpan> downSpans = new FrugalList <SnapshotSpan>(); MapUpToSnapshotNoTrack(sourceSnapshots[s], anchor, downSpans); for (int ds = 0; ds < downSpans.Count; ++ds) { var upSpans = targetAsProjection.MapFromSourceSnapshot(downSpans[ds]); for (int us = 0; us < upSpans.Count; ++us) { mappedSpans.Add(new SnapshotSpan(targetSnapshot, upSpans[us])); } } } } } }
public NormalizedSnapshotSpanCollection GetSpans(ITextSnapshot targetSnapshot) { if (targetSnapshot == null) { throw new ArgumentNullException("targetSnapshot"); } if (_unmappable) { return(NormalizedSnapshotSpanCollection.Empty); } NormalizedSnapshotSpanCollection results = this.GetSpans(targetSnapshot.TextBuffer); if ((results.Count > 0) && (results[0].Snapshot != targetSnapshot)) { FrugalList <SnapshotSpan> translatedSpans = new FrugalList <SnapshotSpan>(); foreach (SnapshotSpan s in results) { translatedSpans.Add(s.TranslateTo(targetSnapshot, _trackingMode)); } results = new NormalizedSnapshotSpanCollection(translatedSpans); } return(results); }
internal static NormalizedSnapshotSpanCollection MapDownToBufferNoTrack(SnapshotSpan sourceSpan, ITextBuffer targetBuffer, bool mapByContentType = false) { FrugalList <SnapshotSpan> mappedSpans = new FrugalList <SnapshotSpan>(); MapDownToFirstMatchNoTrack(sourceSpan, (ITextBuffer b) => { return(b == targetBuffer); }, mappedSpans, mapByContentType); return(new NormalizedSnapshotSpanCollection(mappedSpans)); }
private void MapUpToBufferNoTrack(Predicate <ITextBuffer> match, FrugalList <SnapshotSpan> mappedSpans) { ITextSnapshot targetSnapshot = MappingHelper.FindCorrespondingSnapshot(_root, match); if (targetSnapshot != null) { //Map _anchor up to targetSnapshot (they should be concurrent snapshots) MapUpToSnapshotNoTrack(targetSnapshot, mappedSpans); } }
internal static void MapDownToBufferNoTrack(SnapshotSpan sourceSpan, ITextBuffer targetBuffer, IList <SnapshotSpan> mappedSpans, bool mapByContentType = false) { // Most of the time, the sourceSpan will map to the targetBuffer as a single span, rather than being split. // Since this method is called a lot, we'll assume first that we'll get a single span and don't need to // allocate a stack to keep track of unmapped spans. If that fails we'll fall back on the more expensive approach. // Scroll around for a while and this saves a bunch of allocations. SnapshotSpan mappedSpan = sourceSpan; while (true) { if (mappedSpan.Snapshot.TextBuffer == targetBuffer) { mappedSpans.Add(mappedSpan); return; } else { IProjectionSnapshot mappedSpanProjectionSnapshot = mappedSpan.Snapshot as IProjectionSnapshot; if (mappedSpanProjectionSnapshot != null && (!mapByContentType || mappedSpanProjectionSnapshot.ContentType.IsOfType("projection"))) { var mappedDownSpans = mappedSpanProjectionSnapshot.MapToSourceSnapshots(mappedSpan); if (mappedDownSpans.Count == 1) { mappedSpan = mappedDownSpans[0]; continue; } else if (mappedDownSpans.Count == 0) { return; } else { // the projection mapping resulted in more than one span FrugalList <SnapshotSpan> unmappedSpans = new FrugalList <SnapshotSpan>(mappedDownSpans); SplitMapDownToBufferNoTrack(unmappedSpans, targetBuffer, mappedSpans, mapByContentType); return; } } else { // either it's a projection buffer we can't look through, or it's // an ordinary buffer that didn't match return; } } } }
public NormalizedSnapshotSpanCollection GetSpans(Predicate <ITextBuffer> match) { if (_unmappable) { return(NormalizedSnapshotSpanCollection.Empty); } //Try mapping down first. FrugalList <SnapshotSpan> mappedSpans = new FrugalList <SnapshotSpan>(); MappingHelper.MapDownToFirstMatchNoTrack(_anchor, match, mappedSpans); if (mappedSpans.Count == 0) { //Unable to map down ... try mapping up. this.MapUpToBufferNoTrack(match, mappedSpans); } return(new NormalizedSnapshotSpanCollection(mappedSpans)); }
private static void SplitMapDownToBufferNoTrack(FrugalList <SnapshotSpan> unmappedSpans, ITextBuffer targetBuffer, IList <SnapshotSpan> mappedSpans, bool mapByContentType) { while (unmappedSpans.Count > 0) { SnapshotSpan span = unmappedSpans[unmappedSpans.Count - 1]; unmappedSpans.RemoveAt(unmappedSpans.Count - 1); if (span.Snapshot.TextBuffer == targetBuffer) { mappedSpans.Add(span); } else { IProjectionSnapshot spanSnapshotAsProjection = span.Snapshot as IProjectionSnapshot; if (spanSnapshotAsProjection != null && (!mapByContentType || span.Snapshot.TextBuffer.ContentType.IsOfType("projection"))) { unmappedSpans.AddRange(spanSnapshotAsProjection.MapToSourceSnapshots(span)); } } } }
public NormalizedSnapshotSpanCollection GetSpans(ITextBuffer targetBuffer) { if (targetBuffer == null) { throw new ArgumentNullException("targetBuffer"); } if (_unmappable) { return(NormalizedSnapshotSpanCollection.Empty); } if (targetBuffer.Properties.ContainsProperty("IdentityMapping")) { // text buffer properties uses the hybrid dictionary, which requires TWO lookups to determine that // a key is not present. Since this test usually fails, do it the hard way (the second lookup shows up // in scrolling profiles). ITextBuffer doppelganger = (ITextBuffer)targetBuffer.Properties["IdentityMapping"]; if (doppelganger == _anchor.Snapshot.TextBuffer) { // We are mapping up from a doppelganger buffer; the coordinates will be the same. We // just need to figure out the right snapshot. ITextSnapshot targetSnapshot = MappingHelper.FindCorrespondingSnapshot(_root, targetBuffer); return(new NormalizedSnapshotSpanCollection(new SnapshotSpan(targetSnapshot, _anchor.Span))); } } //Try mapping down first. FrugalList <SnapshotSpan> mappedSpans = new FrugalList <SnapshotSpan>(); MappingHelper.MapDownToBufferNoTrack(_anchor, targetBuffer, mappedSpans); if (mappedSpans.Count == 0) { //Unable to map down ... try mapping up. this.MapUpToBufferNoTrack(targetBuffer, mappedSpans); } return(new NormalizedSnapshotSpanCollection(mappedSpans)); }
public Block(FrugalList <IDisposable> markers) { _markers = markers; }
public FrugalEnumerator(FrugalList <T> list) { this.list = list; this.position = -1; }
/// <summary> /// For unit testing. /// </summary> public GuardedOperations(params IExtensionErrorHandler[] extensionErrorHandler) { _errorHandlers = new FrugalList <IExtensionErrorHandler>(extensionErrorHandler); _perfTrackers = new FrugalList <IExtensionPerformanceTracker>(); }
private void MapUpToSnapshotNoTrack(ITextSnapshot targetSnapshot, FrugalList <SnapshotSpan> mappedSpans) { MappingSpanSnapshot.MapUpToSnapshotNoTrack(targetSnapshot, _anchor, mappedSpans); }
/// <summary> /// For unit testing. /// </summary> public GuardedOperations(IExtensionErrorHandler extensionErrorHandler) { _errorHandlers = new List <IExtensionErrorHandler>(); _errorHandlers.Add(extensionErrorHandler); _perfTrackers = new FrugalList <IExtensionPerformanceTracker>(); }