Eclipse Platform Release 3.7

## 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
`protected 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
`protected` `AbstractLineTracker()` Creates a new line tracker.

Method Summary
`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

Eclipse Platform Release 3.7

Guidelines for using Eclipse APIs.

Copyright (c) Eclipse contributors and others 2000, 2011. All rights reserved.