Package org.eclipse.lemminx.commons

## Class TreeLineTracker

- java.lang.Object
- - org.eclipse.lemminx.commons.TreeLineTracker

All Implemented Interfaces:
  `ILineTracker`

    public class TreeLineTracker
    extends Object
    implements ILineTracker

Abstract implementation of `ILineTracker`. It lets the definition of line delimiters to subclasses. Assuming that '\n' is the only line delimiter, this abstract implementation defines the following line scheme:

- "" -> [0,0]
- "a" -> [0,1]
- "\n" -> [0,1], [1,0]
- "a\n" -> [0,2], [2,0]
- "a\nb" -> [0,2], [2,1]
- "a\nbc\n" -> [0,2], [2,3], [5,0]

This class must be subclassed.

Performance: The query operations perform in O(log n) where n is the number of lines in the document. The modification operations roughly perform in O(l * log n) where n is the number of lines in the document and l is the sum of the number of removed, added or modified lines.

Since:
  3.2

### Field Summary

Fields
`static String[]` `DELIMITERS` The predefined delimiters of this tracker

### Constructor Summary

Constructors
`protected` `TreeLineTracker()` Creates a new line tracker.
`` `TreeLineTracker​(org.eclipse.lemminx.commons.ListLineTracker tracker)` Package visible constructor for creating a tree tracker from a list tracker.

### Method Summary

All Methods Instance Methods Concrete Methods
`int` `computeNumberOfLines​(String text)` Computes the number of lines in the given text.
`String` `getLineDelimiter​(int line)` Returns the line delimiter of the specified line.
`org.eclipse.lemminx.commons.Line` `getLineInformation​(int line)` Returns a line description of the given line.
`org.eclipse.lemminx.commons.Line` `getLineInformationOfOffset​(int offset)` Returns a line description of the line at the given offset.
`int` `getLineLength​(int line)` Returns length of the specified line including the line's delimiter.
`int` `getLineNumberOfOffset​(int offset)` Returns the line number the character at the given offset belongs to.
`int` `getLineOffset​(int line)` Returns the position of the first character of the specified line.
`int` `getNumberOfLines()` Returns the number of lines.
`int` `getNumberOfLines​(int offset, int length)` Returns the number of lines which are occupied by a given text range.
`int` `getOffsetAt​(org.eclipse.lsp4j.Position position)`
`org.eclipse.lsp4j.Position` `getPositionAt​(int offset)`
`protected org.eclipse.lemminx.commons.ListLineTracker.DelimiterInfo` `nextDelimiterInfo​(String text, int offset)` Returns the information about the first delimiter found in the given text starting at the given offset.
`void` `replace​(int offset, int length, String text)` Informs the line tracker about the specified change in the tracked text.
`void` `set​(String text)` Sets the tracked text to the specified text.
`String` `toString()`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

### Field Detail

#### DELIMITERS

    public static final String[] DELIMITERS

The predefined delimiters of this tracker

### Constructor Detail

#### TreeLineTracker

    protected TreeLineTracker()

Creates a new line tracker.

#### TreeLineTracker

    public TreeLineTracker​(org.eclipse.lemminx.commons.ListLineTracker tracker)

Package visible constructor for creating a tree tracker from a list tracker.

Parameters:
  `tracker` - the list line tracker

### Method Detail

#### replace

    public final void replace​(int offset,
                              int length,
                              String text)
                       throws BadLocationException

Description copied from interface: `ILineTracker`
Informs the line tracker about the specified change in the tracked text.

Specified by:
  `replace` in interface `ILineTracker`
Parameters:
  `offset` - the offset of the replaced text
  `length` - the length of the replaced text
  `text` - the substitution text
Throws:
  `BadLocationException` - if specified range is unknown to this tracker

#### nextDelimiterInfo

    protected org.eclipse.lemminx.commons.ListLineTracker.DelimiterInfo nextDelimiterInfo​(String text,
                                                                                          int offset)

Returns the information about the first delimiter found in the given text starting at the given offset.

Parameters:
  `text` - the text to be searched
  `offset` - the offset in the given text
Returns:
  the information of the first found delimiter or `null`

#### getLineDelimiter

    public final String getLineDelimiter​(int line)
                                  throws BadLocationException

Description copied from interface: `ILineTracker`
Returns the line delimiter of the specified line. Returns `null` if the line is not closed with a line delimiter.

Specified by:
  `getLineDelimiter` in interface `ILineTracker`
Parameters:
  `line` - the line whose line delimiter is queried
Returns:
  the line's delimiter or `null` if line does not have a delimiter
Throws:
  `BadLocationException` - if the line number is invalid in this tracker's line structure

#### computeNumberOfLines

    public final int computeNumberOfLines​(String text)

Description copied from interface: `ILineTracker`
Computes the number of lines in the given text.

Specified by:
  `computeNumberOfLines` in interface `ILineTracker`
Parameters:
  `text` - the text whose number of lines should be computed
Returns:
  the number of lines in the given text

#### getNumberOfLines

    public final int getNumberOfLines()

Description copied from interface: `ILineTracker`
Returns the number of lines.

Note that a document always has at least one line.

Specified by:
  `getNumberOfLines` in interface `ILineTracker`
Returns:
  the number of lines in this tracker's line structure

#### getNumberOfLines

    public final int getNumberOfLines​(int offset,
                                      int length)
                               throws BadLocationException

Description copied from interface: `ILineTracker`
Returns the number of lines which are occupied by a given text range.

Specified by:
  `getNumberOfLines` in interface `ILineTracker`
Parameters:
  `offset` - the offset of the specified text range
  `length` - the length of the specified text range
Returns:
  the number of lines occupied by the specified range
Throws:
  `BadLocationException` - if specified range is unknown to this tracker

#### getLineOffset

    public final int getLineOffset​(int line)
                            throws BadLocationException

Description copied from interface: `ILineTracker`
Returns the position of the first character of the specified line.

Specified by:
  `getLineOffset` in interface `ILineTracker`
Parameters:
  `line` - the line of interest
Returns:
  offset of the first character of the line
Throws:
  `BadLocationException` - if the line is unknown to this tracker

#### getLineLength

    public final int getLineLength​(int line)
                            throws BadLocationException

Description copied from interface: `ILineTracker`
Returns length of the specified line including the line's delimiter.

Specified by:
  `getLineLength` in interface `ILineTracker`
Parameters:
  `line` - the line of interest
Returns:
  the length of the line
Throws:
  `BadLocationException` - if line is unknown to this tracker

#### getLineNumberOfOffset

    public final int getLineNumberOfOffset​(int offset)
                                    throws BadLocationException

Description copied from interface: `ILineTracker`
Returns the line number the character at the given offset belongs to.

Specified by:
  `getLineNumberOfOffset` in interface `ILineTracker`
Parameters:
  `offset` - the offset whose line number to be determined
Returns:
  the number of the line the offset is on
Throws:
  `BadLocationException` - if the offset is invalid in this tracker

#### getPositionAt

    public final org.eclipse.lsp4j.Position getPositionAt​(int offset)
                                                   throws BadLocationException

Specified by:
  `getPositionAt` in interface `ILineTracker`
Throws:
  `BadLocationException`

#### getOffsetAt

    public int getOffsetAt​(org.eclipse.lsp4j.Position position)
                    throws BadLocationException

Specified by:
  `getOffsetAt` in interface `ILineTracker`
Throws:
  `BadLocationException`

#### getLineInformationOfOffset

    public final org.eclipse.lemminx.commons.Line getLineInformationOfOffset​(int offset)
                                                                      throws BadLocationException

Description copied from interface: `ILineTracker`
Returns a line description of the line at the given offset. The description contains the start offset and the length of the line excluding the line's delimiter.

Specified by:
  `getLineInformationOfOffset` in interface `ILineTracker`
Parameters:
  `offset` - the offset whose line should be described
Returns:
  a region describing the line
Throws:
  `BadLocationException` - if offset is invalid in this tracker

#### getLineInformation

    public final org.eclipse.lemminx.commons.Line getLineInformation​(int line)
                                                              throws BadLocationException

Description copied from interface: `ILineTracker`
Returns a line description of the given line. The description contains the start offset and the length of the line excluding the line's delimiter.

Specified by:
  `getLineInformation` in interface `ILineTracker`
Parameters:
  `line` - the line that should be described
Returns:
  a region describing the line
Throws:
  `BadLocationException` - if line is unknown to this tracker

#### set

    public final void set​(String text)

Description copied from interface: `ILineTracker`
Sets the tracked text to the specified text.

Specified by:
  `set` in interface `ILineTracker`
Parameters:
  `text` - the new tracked text

#### toString

    public String toString()

Overrides:
  `toString` in class `Object`