/// <summary>
/// Normalizes all new lines in <paramref name="input"/> to be <paramref name="newLine"/>.
/// </summary>
public static string NormalizeNewLines(string input, string newLine)
{
if (input == null)
{
return(null);
}
if (!IsNewLine(newLine))
{
throw new ArgumentException("newLine must be one of the known newline sequences");
}
var ds = NewLineFinder.NextNewLine(input, 0);
if (ds == SimpleSegment.Invalid) // text does not contain any new lines
{
return(input);
}
var b = new StringBuilder(input.Length);
var lastEndOffset = 0;
do
{
b.Append(input, lastEndOffset, ds.Offset - lastEndOffset);
b.Append(newLine);
lastEndOffset = ds.EndOffset;
ds = NewLineFinder.NextNewLine(input, lastEndOffset);
} while (ds != SimpleSegment.Invalid);
// remaining string (after last newline)
b.Append(input, lastEndOffset, input.Length - lastEndOffset);
return(b.ToString());
}
/// <summary>
/// Finds the next new line character starting at offset.
/// </summary>
/// <param name="text">The text source to search in.</param>
/// <param name="offset">The starting offset for the search.</param>
/// <param name="newLineType">The string representing the new line that was found, or null if no new line was found.</param>
/// <returns>The position of the first new line starting at or after <paramref name="offset"/>,
/// or -1 if no new line was found.</returns>
public static int FindNextNewLine(ITextSource text, int offset, out string newLineType)
{
if (text == null)
{
throw new ArgumentNullException(nameof(text));
}
if (offset < 0 || offset > text.TextLength)
{
throw new ArgumentOutOfRangeException(nameof(offset), offset, "offset is outside of text source");
}
var s = NewLineFinder.NextNewLine(text, offset);
if (s == SimpleSegment.Invalid)
{
newLineType = null;
return(-1);
}
if (s.Length == 2)
{
newLineType = "\r\n";
}
else if (text.GetCharAt(s.Offset) == '\n')
{
newLineType = "\n";
}
else
{
newLineType = "\r";
}
return(s.Offset);
}
/*
* HashSet<DocumentLine> deletedLines = new HashSet<DocumentLine>();
* readonly HashSet<DocumentLine> changedLines = new HashSet<DocumentLine>();
* HashSet<DocumentLine> deletedOrChangedLines = new HashSet<DocumentLine>();
*
* /// <summary>
* /// Gets the list of lines deleted since the last RetrieveChangedLines() call.
* /// The returned list is unsorted.
* /// </summary>
* public ICollection<DocumentLine> RetrieveDeletedLines()
* {
* var r = deletedLines;
* deletedLines = new HashSet<DocumentLine>();
* return r;
* }
*
* /// <summary>
* /// Gets the list of lines changed since the last RetrieveChangedLines() call.
* /// The returned list is sorted by line number and does not contain deleted lines.
* /// </summary>
* public List<DocumentLine> RetrieveChangedLines()
* {
* var list = (from line in changedLines
* where !line.IsDeleted
* let number = line.LineNumber
* orderby number
* select line).ToList();
* changedLines.Clear();
* return list;
* }
*
* /// <summary>
* /// Gets the list of lines changed since the last RetrieveDeletedOrChangedLines() call.
* /// The returned list is not sorted.
* /// </summary>
* public ICollection<DocumentLine> RetrieveDeletedOrChangedLines()
* {
* var r = deletedOrChangedLines;
* deletedOrChangedLines = new HashSet<DocumentLine>();
* return r;
* }
*/
#endregion
#region Rebuild
public void Rebuild()
{
// keep the first document line
var ls = _documentLineTree.GetByNumber(1);
// but mark all other lines as deleted, and detach them from the other nodes
for (var line = ls.NextLine; line != null; line = line.NextLine)
{
line.IsDeleted = true;
line.Parent = line.Left = line.Right = null;
}
// Reset the first line to detach it from the deleted lines
ls.ResetLine();
var ds = NewLineFinder.NextNewLine(_document, 0);
var lines = new List <DocumentLine>();
var lastDelimiterEnd = 0;
while (ds != SimpleSegment.Invalid)
{
ls.TotalLength = ds.Offset + ds.Length - lastDelimiterEnd;
ls.DelimiterLength = ds.Length;
lastDelimiterEnd = ds.Offset + ds.Length;
lines.Add(ls);
ls = new DocumentLine(_document);
ds = NewLineFinder.NextNewLine(_document, lastDelimiterEnd);
}
ls.TotalLength = _document.TextLength - lastDelimiterEnd;
lines.Add(ls);
_documentLineTree.RebuildTree(lines);
foreach (var lineTracker in _lineTrackers)
{
lineTracker.RebuildDocument();
}
}
public void Insert(int offset, ITextSource text)
{
var line = _documentLineTree.GetByOffset(offset);
var lineOffset = line.Offset;
Debug.Assert(offset <= lineOffset + line.TotalLength);
if (offset > lineOffset + line.Length)
{
Debug.Assert(line.DelimiterLength == 2);
// we are inserting in the middle of a delimiter
// shorten line
SetLineLength(line, line.TotalLength - 1);
// add new line
line = InsertLineAfter(line, 1);
line = SetLineLength(line, 1);
}
var ds = NewLineFinder.NextNewLine(text, 0);
if (ds == SimpleSegment.Invalid)
{
// no newline is being inserted, all text is inserted in a single line
//line.InsertedLinePart(offset - line.Offset, text.Length);
SetLineLength(line, line.TotalLength + text.TextLength);
return;
}
//DocumentLine firstLine = line;
//firstLine.InsertedLinePart(offset - firstLine.Offset, ds.Offset);
var lastDelimiterEnd = 0;
while (ds != SimpleSegment.Invalid)
{
// split line segment at line delimiter
var lineBreakOffset = offset + ds.Offset + ds.Length;
lineOffset = line.Offset;
var lengthAfterInsertionPos = lineOffset + line.TotalLength - (offset + lastDelimiterEnd);
line = SetLineLength(line, lineBreakOffset - lineOffset);
var newLine = InsertLineAfter(line, lengthAfterInsertionPos);
newLine = SetLineLength(newLine, lengthAfterInsertionPos);
line = newLine;
lastDelimiterEnd = ds.Offset + ds.Length;
ds = NewLineFinder.NextNewLine(text, lastDelimiterEnd);
}
//firstLine.SplitTo(line);
// insert rest after last delimiter
if (lastDelimiterEnd != text.TextLength)
{
//line.InsertedLinePart(0, text.Length - lastDelimiterEnd);
SetLineLength(line, line.TotalLength + text.TextLength - lastDelimiterEnd);
}
}