Package org.eclipse.jface.text

## Class AbstractLineTracker

- java.lang.Object
- - org.eclipse.jface.text.AbstractLineTracker

All Implemented Interfaces:
  `ILineTracker`, `ILineTrackerExtension`

Direct Known Subclasses:
  `ConfigurableLineTracker`, `DefaultLineTracker`

    public abstract class AbstractLineTracker
    extends Object
    implements ILineTracker, ILineTrackerExtension

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.

### Nested Class Summary

Nested Classes
`static class` `AbstractLineTracker.DelimiterInfo` Combines the information of the occurrence of a line delimiter.
`protected static class` `AbstractLineTracker.Request` Representation of replace and set requests.

### Constructor Summary

Constructors
`protected` `AbstractLineTracker()` Creates a new line tracker.

### Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
`protected void` `checkRewriteSession()` Checks the presence of a rewrite session and flushes it.
`int` `computeNumberOfLines​(String text)` Computes the number of lines in the given text.
`protected void` `flushRewriteSession()` Flushes the active rewrite session.
`String` `getLineDelimiter​(int line)` Returns the line delimiter of the specified line.
`IRegion` `getLineInformation​(int line)` Returns a line description of the given line.
`IRegion` `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.
`protected boolean` `hasActiveRewriteSession()` Tells whether there's an active rewrite session.
`protected abstract AbstractLineTracker.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.
`void` `startRewriteSession​(DocumentRewriteSession session)` Tells the line tracker that a rewrite session started.
`void` `stopRewriteSession​(DocumentRewriteSession session, String text)` Tells the line tracker that the rewrite session has finished.

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

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

### Methods inherited from interface org.eclipse.jface.text.ILineTracker

`getLegalLineDelimiters`

### Constructor Detail

#### AbstractLineTracker

    protected AbstractLineTracker()

Creates a new line tracker.

### Method Detail

#### computeNumberOfLines

    public 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

#### getLineDelimiter

    public 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

#### getLineInformation

    public IRegion 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

#### getLineInformationOfOffset

    public IRegion 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

#### getLineLength

    public 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 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

#### getLineOffset

    public 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

#### getNumberOfLines

    public 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 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

#### set

    public 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

#### replace

    public 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 abstract AbstractLineTracker.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`

#### startRewriteSession

    public final void startRewriteSession​(DocumentRewriteSession session)

Description copied from interface: `ILineTrackerExtension`
Tells the line tracker that a rewrite session started. A rewrite session is a sequence of replace operations that form a semantic unit. The line tracker is allowed to use that information for internal optimization.

Specified by:
  `startRewriteSession` in interface `ILineTrackerExtension`
Parameters:
  `session` - the rewrite session

#### stopRewriteSession

    public final void stopRewriteSession​(DocumentRewriteSession session,
                                         String text)

Description copied from interface: `ILineTrackerExtension`
Tells the line tracker that the rewrite session has finished. This method is only called when `startRewriteSession` has been called before. The text resulting from the rewrite session is passed to the line tracker.

Specified by:
  `stopRewriteSession` in interface `ILineTrackerExtension`
Parameters:
  `session` - the rewrite session
  `text` - the text with which to re-initialize the line tracker

#### hasActiveRewriteSession

    protected final boolean hasActiveRewriteSession()

Tells whether there's an active rewrite session.

Returns:
  `true` if there is an active rewrite session, `false` otherwise
Since:
  3.1

#### flushRewriteSession

    protected final void flushRewriteSession()
                                      throws BadLocationException

Flushes the active rewrite session.

Throws:
  `BadLocationException` - in case the recorded requests cannot be processed correctly
Since:
  3.1

#### checkRewriteSession

    protected final void checkRewriteSession()
                                      throws BadLocationException

Checks the presence of a rewrite session and flushes it.

Throws:
  `BadLocationException` - in case flushing does not succeed
Since:
  3.1