private static IEnumerable <IEnumerable <TextChangeRange> > GetMultipleVersionTextChanges(
ITextImageVersion oldVersion, ITextImageVersion newVersion, bool forward)
{
for (var version = oldVersion; version != newVersion; version = version.Next)
{
yield return(version.Changes.Select(forward ? s_forwardTextChangeRange : s_backwardTextChangeRange));
}
}
public VersionedSpan TranslateTo(ITextImageVersion other, SpanTrackingMode mode)
{
if (other == null)
{
throw new ArgumentNullException(nameof(other));
}
return(new VersionedSpan(other, other.TrackTo(this, mode)));
}
private CachingTextImage(StringRebuilder builder, ITextImageVersion version)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
this.Builder = builder;
this.Version = version;
}
public static int TrackPositionBackwardInTime(PointTrackingMode trackingMode,
int currentPosition,
ITextImageVersion currentVersion,
ITextImageVersion targetVersion)
{
if (trackingMode < PointTrackingMode.Positive || trackingMode > PointTrackingMode.Negative)
{
throw new ArgumentOutOfRangeException("trackingMode");
}
if (currentVersion == null)
{
throw new ArgumentNullException("currentVersion");
}
if (targetVersion == null)
{
throw new ArgumentNullException("targetVersion");
}
if (targetVersion.Identifier != currentVersion.Identifier)
{
throw new ArgumentException("currentVersion and targetVersion must be from the same ITextImage");
}
if (targetVersion.VersionNumber > currentVersion.VersionNumber)
{
throw new ArgumentOutOfRangeException("targetVersion");
}
if (currentPosition < 0 || currentPosition > currentVersion.Length)
{
throw new ArgumentOutOfRangeException("currentPosition");
}
// track backwards in time
INormalizedTextChangeCollection[] textChangesStack = new INormalizedTextChangeCollection[currentVersion.VersionNumber - targetVersion.VersionNumber];
int top = 0;
{
ITextImageVersion roverVersion = targetVersion;
while (roverVersion != currentVersion)
{
textChangesStack[top++] = roverVersion.Changes;
roverVersion = roverVersion.Next;
}
}
while (top > 0)
{
currentPosition = TrackPositionBackwardInTime(trackingMode,
currentPosition,
textChangesStack[--top]);
}
return(currentPosition);
}
private TextChangeRange GetChangeRanges(ITextImageVersion oldVersion, ITextImageVersion newVersion, bool forward)
{
TextChangeRange?range = null;
var iterator = GetMultipleVersionTextChanges(oldVersion, newVersion, forward);
foreach (var changes in forward ? iterator : iterator.Reverse())
{
range = range.Accumulate(changes);
}
Contract.Requires(range.HasValue);
return(range.Value);
}
private static TextChangeRange GetChangeRanges(ITextImageVersion oldVersion, ITextImageVersion newVersion, bool forward)
{
TextChangeRange?range = null;
var iterator = GetMultipleVersionTextChanges(oldVersion, newVersion, forward);
foreach (var changes in forward ? iterator : iterator.Reverse())
{
range = range.Accumulate(changes);
}
RoslynDebug.Assert(range.HasValue);
return(range.Value);
}
public VersionedSpan(ITextImageVersion version, Span span)
{
if (version == null)
{
throw new ArgumentNullException(nameof(version));
}
if (span.End > version.Length)
{
throw new ArgumentOutOfRangeException(nameof(span));
}
this.Version = version;
this.Span = span;
}
public VersionedPosition(ITextImageVersion version, int position)
{
if (version == null)
{
throw new ArgumentNullException(nameof(version));
}
if ((position < 0) || (position > version.Length))
{
throw new ArgumentOutOfRangeException(nameof(position));
}
this.Version = version;
this.Position = position;
}
public static int TrackPositionForwardInTime(PointTrackingMode trackingMode,
int currentPosition,
ITextImageVersion currentVersion,
ITextImageVersion targetVersion)
{
if (trackingMode < PointTrackingMode.Positive || trackingMode > PointTrackingMode.Negative)
{
throw new ArgumentOutOfRangeException("trackingMode");
}
if (currentVersion == null)
{
throw new ArgumentNullException("currentVersion");
}
if (targetVersion == null)
{
throw new ArgumentNullException("targetVersion");
}
if (targetVersion.Identifier != currentVersion.Identifier)
{
throw new ArgumentException("currentVersion and targetVersion must be from the same ITextImage");
}
if (targetVersion.VersionNumber < currentVersion.VersionNumber)
{
throw new ArgumentOutOfRangeException("targetVersion");
}
if (currentPosition < 0 || currentPosition > currentVersion.Length)
{
throw new ArgumentOutOfRangeException("currentPosition");
}
// track forward in time
while (currentVersion != targetVersion)
{
currentPosition = TrackPositionForwardInTime(trackingMode,
currentPosition,
currentVersion.Changes);
currentVersion = currentVersion.Next;
}
Debug.Assert(currentPosition >= 0 && currentPosition <= currentVersion.Length);
return(currentPosition);
}
internal void SetChanges(INormalizedTextChangeCollection changes, ITextImageVersion next)
{
Next = next;
Changes = changes;
}
public TextImage(ITextImageVersion version, StringOperand sourceOperand)
{
Version = version;
_sourceOperand = sourceOperand;
}
public TextImage(TextBuffer textBuffer, ITextSource textSource, ITextImageVersion version)
{
TextBuffer = textBuffer ?? throw new ArgumentNullException(nameof(textBuffer));
this.textSource = textSource ?? throw new ArgumentNullException(nameof(textSource));
Version = version ?? throw new ArgumentNullException(nameof(version));
}
public static ITextImage Create(StringRebuilder builder, ITextImageVersion version)
{
return(new CachingTextImage(builder, version));
}
public static Span TrackSpanBackwardInTime(SpanTrackingMode trackingMode, Span span, ITextImageVersion currentVersion, ITextImageVersion targetVersion)
{
if (trackingMode < SpanTrackingMode.EdgeExclusive || trackingMode > SpanTrackingMode.Custom)
{
throw new ArgumentOutOfRangeException("trackingMode");
}
if (currentVersion == null)
{
throw new ArgumentNullException("currentVersion");
}
if (targetVersion == null)
{
throw new ArgumentNullException("targetVersion");
}
if (targetVersion.Identifier != currentVersion.Identifier)
{
throw new ArgumentException("currentVersion and targetVersion must be from the same ITextImage");
}
if (span.End > currentVersion.Length)
{
throw new ArgumentOutOfRangeException("span");
}
if (targetVersion.VersionNumber > currentVersion.VersionNumber)
{
throw new ArgumentOutOfRangeException("targetVersion");
}
int resultStart =
TrackPositionBackwardInTime
((trackingMode == SpanTrackingMode.EdgeExclusive || trackingMode == SpanTrackingMode.EdgePositive)
? PointTrackingMode.Positive
: PointTrackingMode.Negative,
span.Start, currentVersion, targetVersion);
int resultEnd =
TrackPositionBackwardInTime
((trackingMode == SpanTrackingMode.EdgeExclusive || trackingMode == SpanTrackingMode.EdgeNegative)
? PointTrackingMode.Negative
: PointTrackingMode.Positive,
span.End, currentVersion, targetVersion);
return(Span.FromBounds(resultStart, System.Math.Max(resultStart, resultEnd)));
}
