/// <summary> /// Creates a ReadOnlyRegionHandle for the given buffer and span. /// </summary> /// <param name="version"> /// The <see cref="TextVersion"/> with which this read only region is associated. /// </param> /// <param name="span"> /// The span of interest. /// </param> /// <param name="trackingMode"> /// Specifies the tracking behavior of the read only region. /// </param> /// <param name="edgeInsertionMode"> /// Specifies if insertions should be allowed at the edges /// </param> /// <remarks> /// Don't call this constructor with invalid parameters. It doesn't verify all of them. /// </remarks> internal ReadOnlyRegion(TextVersion version, Span span, SpanTrackingMode trackingMode, EdgeInsertionMode edgeInsertionMode, DynamicReadOnlyRegionQuery callback) { _edgeInsertionMode = edgeInsertionMode; // TODO: change to simple forward tracking text span _trackingSpan = new ForwardFidelityTrackingSpan(version, span, trackingMode); QueryCallback = callback; }
internal ReadOnlySpan(ITextVersion version, IReadOnlyRegion readOnlyRegion) : base(version, readOnlyRegion.Span.GetSpan(version), readOnlyRegion.Span.TrackingMode) { _startEdgeInsertionMode = readOnlyRegion.EdgeInsertionMode; _endEdgeInsertionMode = readOnlyRegion.EdgeInsertionMode; }
internal ReadOnlySpan(ITextVersion version, Span span, SpanTrackingMode trackingMode, EdgeInsertionMode startEdgeInsertionMode, EdgeInsertionMode endEdgeInsertionMode) : base(version, span, trackingMode) { _startEdgeInsertionMode = startEdgeInsertionMode; _endEdgeInsertionMode = endEdgeInsertionMode; }
public IReadOnlyRegion CreateDynamicReadOnlyRegion(Span span, SpanTrackingMode trackingMode, EdgeInsertionMode edgeInsertionMode, DynamicReadOnlyRegionQuery callback) { ReadOnlyRegion readOnlyRegion = new ReadOnlyRegion(this.baseBuffer.CurrentVersion, span, trackingMode, edgeInsertionMode, callback); readOnlyRegionsToAdd.Add(readOnlyRegion); this.aggregateStart = Math.Min(this.aggregateStart, span.Start); this.aggregateEnd = Math.Max(this.aggregateEnd, span.End); return(readOnlyRegion); }
public IReadOnlyRegion CreateReadOnlyRegion(Span span, SpanTrackingMode trackingMode, EdgeInsertionMode edgeInsertionMode) { return(CreateDynamicReadOnlyRegion(span, trackingMode, edgeInsertionMode, callback: null)); }
private static IList <ReadOnlySpan> NormalizeSpans(TextVersion version, IEnumerable <IReadOnlyRegion> regions) { List <IReadOnlyRegion> sorted = new List <IReadOnlyRegion>(regions.Where(region => region.QueryCallback == null)); if (sorted.Count == 0) { return(new FrugalList <ReadOnlySpan>()); } else if (sorted.Count == 1) { return(new FrugalList <ReadOnlySpan>() { new ReadOnlySpan(version, sorted[0]) }); } else { sorted.Sort((s1, s2) => s1.Span.GetSpan(version).Start.CompareTo(s2.Span.GetSpan(version).Start)); List <ReadOnlySpan> normalized = new List <ReadOnlySpan>(sorted.Count); int oldStart = sorted[0].Span.GetSpan(version).Start; int oldEnd = sorted[0].Span.GetSpan(version).End; EdgeInsertionMode oldStartEdgeInsertionMode = sorted[0].EdgeInsertionMode; EdgeInsertionMode oldEndEdgeInsertionMode = sorted[0].EdgeInsertionMode; SpanTrackingMode oldSpanTrackingMode = sorted[0].Span.TrackingMode; for (int i = 1; (i < sorted.Count); ++i) { int newStart = sorted[i].Span.GetSpan(version).Start; int newEnd = sorted[i].Span.GetSpan(version).End; // Since the new span's start occurs after the old span's end, we can just add the old span directly. if (oldEnd < newStart) { normalized.Add(new ReadOnlySpan(version, new Span(oldStart, oldEnd - oldStart), oldSpanTrackingMode, oldStartEdgeInsertionMode, oldEndEdgeInsertionMode)); oldStart = newStart; oldEnd = newEnd; oldStartEdgeInsertionMode = sorted[i].EdgeInsertionMode; oldEndEdgeInsertionMode = sorted[i].EdgeInsertionMode; oldSpanTrackingMode = sorted[i].Span.TrackingMode; } else { // The two read only regions start at the same position if (newStart == oldStart) { // If one read only region denies edge insertions, combined they do as well if (sorted[i].EdgeInsertionMode == EdgeInsertionMode.Deny) { oldStartEdgeInsertionMode = EdgeInsertionMode.Deny; } // This is tricky. We want one span that will be inclusive tracking, and one that won't. if (oldSpanTrackingMode != sorted[i].Span.TrackingMode) { // Since the read only regions cover the same exact span, the combined one will be edge inclusive tracking if (oldEnd == newEnd) { oldSpanTrackingMode = SpanTrackingMode.EdgeInclusive; } else if (oldEnd < newEnd) { // Since the old span and new span don't have the same span tracking mode and don't end in the same position, we need to create a new span that is edge inclusive // and deny inserts between it and the next span. normalized.Add(new ReadOnlySpan(version, new Span(oldStart, oldEnd - oldStart), SpanTrackingMode.EdgeInclusive, oldStartEdgeInsertionMode, EdgeInsertionMode.Deny)); oldStart = oldEnd; // Explicitly use the old end here since we want these spans to be adjacent oldEnd = newEnd; oldStartEdgeInsertionMode = sorted[i].EdgeInsertionMode; oldEndEdgeInsertionMode = sorted[i].EdgeInsertionMode; oldSpanTrackingMode = sorted[i].Span.TrackingMode; } else { // Since the new span ends first, create a span that is edge inclusive tracking that ends at the the new span's end. normalized.Add(new ReadOnlySpan(version, new Span(newStart, newEnd - newStart), SpanTrackingMode.EdgeInclusive, oldStartEdgeInsertionMode, EdgeInsertionMode.Deny)); oldStart = newEnd; // Explicitly use the new end here since we want these spans to be adjacent } } } if (oldEnd < newEnd) { // If the tracking modes are different then we need to create a new span // with the old tracking mode, and start a new span with the new span tracking mode. // Also, if the old end and the new start are identical and both edge insertion mode's // are allow, then we need to create a new span. if (((oldEnd == newStart) && ((oldEndEdgeInsertionMode == EdgeInsertionMode.Allow) && (sorted[i].EdgeInsertionMode == EdgeInsertionMode.Allow))) || (oldSpanTrackingMode != sorted[i].Span.TrackingMode)) { normalized.Add(new ReadOnlySpan(version, new Span(oldStart, oldEnd - oldStart), oldSpanTrackingMode, oldStartEdgeInsertionMode, oldEndEdgeInsertionMode)); oldStart = oldEnd; // Explicitly use the old end here since we want these spans to be adjacent. oldEnd = newEnd; // If we are splitting up the spans because of a change in tracking mode, then explicitly deny inserting between them if (oldSpanTrackingMode != sorted[i].Span.TrackingMode) { oldStartEdgeInsertionMode = EdgeInsertionMode.Deny; // Explicitly use deny here since we don't want to allow insertions between these spans } else { oldStartEdgeInsertionMode = EdgeInsertionMode.Allow; } oldEndEdgeInsertionMode = sorted[i].EdgeInsertionMode; oldSpanTrackingMode = sorted[i].Span.TrackingMode; } else { oldEnd = newEnd; oldEndEdgeInsertionMode = sorted[i].EdgeInsertionMode; } } else if (oldEnd == newEnd) { if (sorted[i].EdgeInsertionMode == EdgeInsertionMode.Deny) { oldEndEdgeInsertionMode = EdgeInsertionMode.Deny; } if (oldSpanTrackingMode != sorted[i].Span.TrackingMode) { normalized.Add(new ReadOnlySpan(version, new Span(oldStart, oldEnd - oldStart), oldSpanTrackingMode, oldStartEdgeInsertionMode, oldEndEdgeInsertionMode)); oldStart = newEnd; oldEnd = newEnd; oldStartEdgeInsertionMode = sorted[i].EdgeInsertionMode; oldEndEdgeInsertionMode = sorted[i].EdgeInsertionMode; oldSpanTrackingMode = sorted[i].Span.TrackingMode; } } } } normalized.Add(new ReadOnlySpan(version, new Span(oldStart, oldEnd - oldStart), oldSpanTrackingMode, oldStartEdgeInsertionMode, oldEndEdgeInsertionMode)); return(normalized); } }