Beispiel #1
0
        /// <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("text");
            }
            if (offset < 0 || offset > text.TextLength)
            {
                throw new ArgumentOutOfRangeException("offset", offset, "offset is outside of text source");
            }
            SimpleSegment s = NewLineFinder.NextNewLine(text, offset);

            if (s == SimpleSegment.Invalid)
            {
                newLineType = null;
                return(-1);
            }
            else
            {
                if (s.Length == 2)
                {
                    newLineType = "\r\n";
                }
                else if (text.GetCharAt(s.Offset) == '\n')
                {
                    newLineType = "\n";
                }
                else
                {
                    newLineType = "\r";
                }
                return(s.Offset);
            }
        }
Beispiel #2
0
        /// <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");
            }
            SimpleSegment ds = NewLineFinder.NextNewLine(input, 0);

            if (ds == SimpleSegment.Invalid) // text does not contain any new lines
            {
                return(input);
            }
            StringBuilder b             = new StringBuilder(input.Length);
            int           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());
        }
Beispiel #3
0
        public void Insert(int offset, ITextSource text)
        {
            DocumentLine line       = documentLineTree.GetByOffset(offset);
            int          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);
            }

            SimpleSegment 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);
            int lastDelimiterEnd = 0;

            while (ds != SimpleSegment.Invalid)
            {
                // split line segment at line delimiter
                int lineBreakOffset = offset + ds.Offset + ds.Length;
                lineOffset = line.Offset;
                int lengthAfterInsertionPos = lineOffset + line.TotalLength - (offset + lastDelimiterEnd);
                line = SetLineLength(line, lineBreakOffset - lineOffset);
                DocumentLine 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);
            }
        }