Example #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);
            }
        }
Example #2
0
        /*
         * 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
            DocumentLine ls = documentLineTree.GetByNumber(1);

            // but mark all other lines as deleted, and detach them from the other nodes
            for (DocumentLine 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();
            SimpleSegment       ds    = NewLineFinder.NextNewLine(document, 0);
            List <DocumentLine> lines = new List <DocumentLine>();
            int 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 (ILineTracker lineTracker in lineTrackers)
            {
                lineTracker.RebuildDocument();
            }
        }
Example #3
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());
        }
Example #4
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);
            }
        }