C# SourceText.GetSubText方法代码示例

        public ChangedText(SourceText oldText, IEnumerable<TextChange> changes)
        {
            if (oldText == null)
            {
                throw new ArgumentNullException("text");
            }

            if (changes == null)
            {
                throw new ArgumentNullException("changes");
            }

            var segments = ArrayBuilder<SourceText>.GetInstance();
            var changeRanges = ArrayBuilder<TextChangeRange>.GetInstance();
            int position = 0;

            foreach (var change in changes)
            {
                // there can be no overlapping changes
                if (change.Span.Start < position)
                {
                    throw new InvalidOperationException("The changes must be ordered and not overlapping.");
                }

                // if we've skipped a range, add
                if (change.Span.Start > position)
                {
                    var subText = oldText.GetSubText(new TextSpan(position, change.Span.Start - position));
                    CompositeText.AddSegments(segments, subText);
                }

                if (!string.IsNullOrEmpty(change.NewText))
                {
                    var segment = SourceText.From(change.NewText);
                    CompositeText.AddSegments(segments, segment);
                }

                position = change.Span.End;

                changeRanges.Add(new TextChangeRange(change.Span, change.NewText != null ? change.NewText.Length : 0));
            }

            if (position < oldText.Length)
            {
                var subText = oldText.GetSubText(new TextSpan(position, oldText.Length - position));
                CompositeText.AddSegments(segments, subText);
            }

            this.oldText = oldText;
            this.newText = new CompositeText(segments.ToImmutableAndFree());
            this.changes = changeRanges.ToImmutableAndFree();
        }

        private List<TextChange> GetCommentChangesForDocument(IEnumerable<IEnumerable<TextChange>> partitionedChanges, string projectName, SourceText oldDocumentText, SourceText newDocumentText)
        {
            var commentChanges = new List<TextChange>();

            foreach (var changePartition in partitionedChanges)
            {
                var startPosition = changePartition.First().Span.Start;
                var endPosition = changePartition.Last().Span.End;

                var startLineStartPosition = oldDocumentText.Lines.GetLineFromPosition(startPosition).Start;
                var endLineEndPosition = oldDocumentText.Lines.GetLineFromPosition(endPosition).End;

                var oldText = oldDocumentText.GetSubText(TextSpan.FromBounds(startLineStartPosition, endLineEndPosition));
                var adjustedChanges = changePartition.Select(c => new TextChange(TextSpan.FromBounds(c.Span.Start - startLineStartPosition, c.Span.End - startLineStartPosition), c.NewText));
                var newText = oldText.WithChanges(adjustedChanges);

                var warningText = GetConflictCommentText(
                    string.Format(WorkspacesResources.UnmergedChangeFromProject, projectName),
                    TrimBlankLines(oldText),
                    TrimBlankLines(newText));

                if (warningText != null)
                {
                    commentChanges.Add(new TextChange(TextSpan.FromBounds(startLineStartPosition, startLineStartPosition), warningText));
                }
            }

            return commentChanges;
        }

        public async Task<IEnumerable<Range>> Classify(Document document, SourceText text)
        {
            var span = TextSpan.FromBounds(0, text.Length);

            IEnumerable<ClassifiedSpan> classifiedSpans = null;
            try
            {
                classifiedSpans = await Classifier.GetClassifiedSpansAsync(document, span);
            }
            catch (Exception ex)
            {
                Log.Exception(ex, "Exception during Classification of document: " + document.FilePath);
                return null;
            }

            var ranges = classifiedSpans.Select(classifiedSpan =>
                new Range
                {
                    ClassifiedSpan = classifiedSpan,
                    Text = text.GetSubText(classifiedSpan.TextSpan).ToString()
                });
            ranges = Merge(text, ranges);
            ranges = FilterByClassification(ranges);
            ranges = FillGaps(text, ranges);
            return ranges;
        }

        private static TextChange GetTextChange(SourceText text, TextSpan sourceSpan)
        {
            var subText = text.GetSubText(sourceSpan).ToString();

            int i = 2;
            for (; i < subText.Length; i++)
            {
                if (!char.IsWhiteSpace(subText[i]))
                {
                    break;
                }
            }

            return new TextChange(new TextSpan(sourceSpan.Start + 2, i - 2), " ");
        }

 public Range(string classification, TextSpan span, SourceText text)
     : this(classification, span, text.GetSubText(span).ToString())
 {
 }

        private ChangeList GetChangeList(IHierarchicalDifferenceCollection diff, DocumentId id, SourceText oldText, SourceText newText)
        {
            var spanChanges = new List<SpanChange>();
            foreach (var difference in diff)
            {
                var leftSpan = diff.LeftDecomposition.GetSpanInOriginal(difference.Left);
                var rightSpan = diff.RightDecomposition.GetSpanInOriginal(difference.Right);

                var leftText = oldText.GetSubText(leftSpan.ToTextSpan()).ToString();
                var rightText = newText.GetSubText(rightSpan.ToTextSpan()).ToString();

                var trackingSpan = _buffer.CurrentSnapshot.CreateTrackingSpan(leftSpan, SpanTrackingMode.EdgeInclusive);

                var isDeletion = difference.DifferenceType == DifferenceType.Remove;
                var displayText = isDeletion ? GetDisplayText(leftText) : GetDisplayText(rightText);

                var spanChange = new SpanChange(trackingSpan, _buffer, id, displayText, leftText, rightText, isDeletion, this, engine);

                spanChanges.Add(spanChange);
            }

            return new ChangeList(spanChanges.ToArray());
        }

		/// <inheritdoc />
		/// <remarks>
		///     If the <paramref name="position"/> is negative, the engine will
		///     update to: document.TextLength + (offset % document.TextLength+1)
		///     Otherwise it will update to: offset % document.TextLength+1
		/// </remarks>
		public void Update(SourceText sourceText, int position)
		{
			const int BUFFER_SIZE = 2000;
			
			if (currentEngine.Offset == position) {
				//positions match, nothing to be done
				return;
			} else if (currentEngine.Offset > position) {
				//moving backwards, so reset from previous saved location
				ResetEngineToPosition(sourceText, position);
			}

			// get the engine caught up
			int nextSave = (cachedEngines.Count == 0) ? BUFFER_SIZE : cachedEngines.Peek().Offset + BUFFER_SIZE;
			if (currentEngine.Offset + 1 == position) {
				char ch = sourceText[currentEngine.Offset];
				currentEngine.Push(ch);
				if (currentEngine.Offset == nextSave)
					cachedEngines.Push(currentEngine.Clone());
			} else {
				//bulk copy characters in case buffer is unmanaged 
				//(faster if we reduce managed/unmanaged transitions)
				while (currentEngine.Offset < position) {
					int endCut = currentEngine.Offset + BUFFER_SIZE;
					if (endCut > position)
						endCut = position;
					string buffer = sourceText.GetSubText(TextSpan.FromBounds(currentEngine.Offset, endCut)).ToString();
					foreach (char ch in buffer) {
						currentEngine.Push(ch);
						//ConsoleWrite ("pushing character '{0}'", ch);
						if (currentEngine.Offset == nextSave) {
							cachedEngines.Push(currentEngine.Clone());
							nextSave += BUFFER_SIZE;
						}
					}
				}
			}
		}

        private string TrimBlankLines(SourceText text)
        {
            int startLine, endLine;
            for (startLine = 0; startLine < text.Lines.Count; startLine++)
            {
                if (text.Lines[startLine].ToString().Any(c => !char.IsWhiteSpace(c)))
                {
                    break;
                }
            }

            for (endLine = text.Lines.Count - 1; endLine > startLine; endLine--)
            {
                if (text.Lines[endLine].ToString().Any(c => !char.IsWhiteSpace(c)))
                {
                    break;
                }
            }

            return startLine <= endLine
                ? text.GetSubText(TextSpan.FromBounds(text.Lines[startLine].Start, text.Lines[endLine].End)).ToString()
                : null;
        }

 private Range CreateRange(SourceText text, TextSpan span, string classification)
 {
     return new Range(classification, span, text.GetSubText(span).ToString());
 }