File indexing completed on 2024-04-28 07:46:10

 /*
     SPDX-FileCopyrightText: 2010 Christoph Cullmann <cullmann@kde.org>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #ifndef KATE_TEXTBLOCK_H
 #define KATE_TEXTBLOCK_H
 
 #include "katetextline.h"
 
 #include <QList>
 #include <QSet>
 #include <QVarLengthArray>
 
 #include <ktexteditor/cursor.h>
 #include <ktexteditor_export.h>
 
 namespace KTextEditor
 {
 class View;
 }
 
 namespace Kate
 {
 class TextBuffer;
 class TextCursor;
 class TextRange;
 
 /**
  * Class representing a text block.
  * This is used to build up a Kate::TextBuffer.
  * This class should only be used by TextBuffer/Cursor/Range.
  */
 class TextBlock
 {
 public:
     /**
      * Construct an empty text block.
      * @param buffer parent text buffer
      * @param startLine start line of this block
      */
     TextBlock(TextBuffer *buffer, int startLine);
 
     /**
      * Destruct the text block
      */
     ~TextBlock();
 
     /**
      * Start line of this block.
      * @return start line of this block
      */
     int startLine() const
     {
         return m_startLine;
     }
 
     /**
      * Set start line of this block.
      * @param startLine new start line of this block
      */
     void setStartLine(int startLine);
 
     /**
      * Retrieve a text line.
      * @param line wanted line number
      * @return text line
      */
     TextLine line(int line) const;
 
     /**
      * Transfer all non text attributes for the given line from the given text line to the one in the block.
      * @param line line number to set attributes
      * @param textLine line reference to get attributes from
      */
     void setLineMetaData(int line, const TextLine &textLine);
 
     /**
      * Retrieve length for @p line.
      * @param line wanted line number
      * @return length of line
      */
     int lineLength(int line) const
     {
         Q_ASSERT(line >= startLine() && (line - startLine()) < lines());
         return m_lines[line - startLine()].length();
     }
 
     /**
      * Append a new line with given text.
      * @param textOfLine text of the line to append
      */
     void appendLine(const QString &textOfLine);
 
     /**
      * Clear the lines.
      */
     void clearLines();
 
     /**
      * Number of lines in this block.
      * @return number of lines
      */
     int lines() const
     {
         return static_cast<int>(m_lines.size());
     }
 
     /**
      * Retrieve text of block.
      * @param text for this block, lines separated by '\n'
      */
     void text(QString &text) const;
 
     /**
      * Wrap line at given cursor position.
      * @param position line/column as cursor where to wrap
      * @param fixStartLinesStartIndex start index to fix start lines, normally this is this block
      */
     void wrapLine(const KTextEditor::Cursor position, int fixStartLinesStartIndex);
 
     /**
      * Unwrap given line.
      * @param line line to unwrap
      * @param previousBlock previous block, if any, if we unwrap first line in block, we need to have this
      * @param fixStartLinesStartIndex start index to fix start lines, normally this is this block or the previous one
      */
     void unwrapLine(int line, TextBlock *previousBlock, int fixStartLinesStartIndex);
 
     /**
      * Insert text at given cursor position.
      * @param position position where to insert text
      * @param text text to insert
      */
     void insertText(const KTextEditor::Cursor position, const QString &text);
 
     /**
      * Remove text at given range.
      * @param range range of text to remove, must be on one line only.
      * @param removedText will be filled with removed text
      */
     void removeText(KTextEditor::Range range, QString &removedText);
 
     /**
      * Debug output, print whole block content with line numbers and line length
      * @param blockIndex index of this block in buffer
      */
     void debugPrint(int blockIndex) const;
 
     /**
      * Split given block. A new block will be created and all lines starting from the given index will
      * be moved to it, together with the cursors belonging to it.
      * @param fromLine line from which to split
      * @return new block containing the lines + cursors removed from this one
      */
     TextBlock *splitBlock(int fromLine);
 
     /**
      * Merge this block with given one, the given one must be a direct predecessor.
      * @param targetBlock block to merge with
      */
     void mergeBlock(TextBlock *targetBlock);
 
     /**
      * Delete the block content, delete all lines and delete all cursors not bound to ranges.
      * This is used in destructor of TextBuffer, for fast cleanup. Only stuff remaining afterwards are cursors which are
      * part of a range, TextBuffer will delete them itself...
      */
     void deleteBlockContent();
 
     /**
      * Clear the block content, delete all lines, move all cursors not bound to range to given block at 0,0.
      * This is used by clear() of TextBuffer.
      * @param targetBlock empty target block for cursors
      */
     void clearBlockContent(TextBlock *targetBlock);
 
     /**
      * Return all ranges in this block which might intersect the given line.
      * @param line                          line to check intersection
      * @param view                          only return ranges associated with given view
      * @param rangesWithAttributeOnly       ranges with attributes only?
      * @return list of possible candidate ranges
      */
     KTEXTEDITOR_EXPORT QList<TextRange *> rangesForLine(int line, KTextEditor::View *view, bool rangesWithAttributeOnly) const;
 
     KTEXTEDITOR_NO_EXPORT void rangesForLine(int line, KTextEditor::View *view, bool rangesWithAttributeOnly, QList<TextRange *> &outRanges) const;
 
     /**
      * Is the given range contained in this block?
      * @param range range to check for
      * @return contained in this blocks mapping?
      */
     bool containsRange(TextRange *range) const
     {
         return m_cachedLineForRanges.find(range) != m_cachedLineForRanges.end() || m_uncachedRanges.contains(range);
     }
 
     /**
      * Flag all modified text lines as saved on disk.
      */
     void markModifiedLinesAsSaved();
 
     /**
      * Insert cursor into this block.
      * @param cursor cursor to insert
      */
     void insertCursor(Kate::TextCursor *cursor)
     {
         m_cursors.insert(cursor);
     }
 
     /**
      * Remove cursor from this block.
      * @param cursor cursor to remove
      */
     void removeCursor(Kate::TextCursor *cursor)
     {
         m_cursors.remove(cursor);
     }
 
     /**
      * Update a range from this block.
      * Will move the range to right set, either cached for one-line ranges or not.
      * @param range range to update
      */
     void updateRange(TextRange *range);
 
     /**
      * Remove a range from this block.
      * @param range range to remove
      */
     void removeRange(TextRange *range);
 
     /**
      * Returns the size of this block i.e.,
      * the count of QChars it has + number of new lines
      */
     int blockSize() const
     {
         return m_blockSize + m_lines.size();
     }
 
 private:
     /**
      * Return all ranges in this block which might intersect the given line and only span one line.
      * For them an internal fast lookup cache is hold.
      * @param line line to check intersection
      * @return set of ranges
      */
     const QVarLengthArray<TextRange *, 6> *cachedRangesForLine(int line) const
     {
         line -= m_startLine;
         if (line >= 0 && (size_t)line < m_cachedRangesForLine.size()) {
             return &m_cachedRangesForLine[line];
         } else {
             return nullptr;
         }
     }
 
 private:
     /**
      * parent text buffer
      */
     TextBuffer *m_buffer;
 
     /**
      * Lines contained in this buffer.
      * We need no sharing, use STL.
      */
     std::vector<Kate::TextLine> m_lines;
 
     /**
      * Startline of this block
      */
     int m_startLine;
 
     /**
      * size of block i.e., number of QChars
      */
     int m_blockSize = 0;
 
     /**
      * Set of cursors for this block.
      * using QSet is better than unordered_set for perf reasons
      */
     QSet<TextCursor *> m_cursors;
 
     /**
      * Contains for each line-offset the ranges that were cached into it.
      * These ranges are fully contained by the line.
      */
     std::vector<QVarLengthArray<TextRange *, 6>> m_cachedRangesForLine;
 
     /**
      * Maps for each cached range the line into which the range was cached.
      */
     QHash<TextRange *, int> m_cachedLineForRanges;
 
     /**
      * This contains all the ranges that are not cached.
      */
     QVarLengthArray<TextRange *, 1> m_uncachedRanges;
 };
 
 }
 
 #endif