PlaneText.scala

// PlaneText.scala
// Copyright (c) 2015 J. M. Spivey

/** An extension of Text that keeps track of the division of the
  * text into lines. */
class PlaneText(init: Int) extends Text() {
  /* For present purposes, we count each newline character as part of the
   * line it terminates, so that every line has non-zero length.  Let's
   * also imagine that a special terminator character is added to the end of
   * the text, so that the very last line also has non-zero length.  For an
   * ordinary text file that ends in a newline, this last line will be empty
   * and be counted as having length 1, and the editor will count the
   * file as having one more line than there are newline characters. */
  private var nlines = 1
  private var linelen = new Array[Int](init)
  linelen(0) = 1

  /* For efficiency, we keep track of the beginning of the most recent line
   * that was accessed.  This will help a lot if accesses are clustered.
   * The invariant is linestart = sum linelen[0..curline) */
  private var curline = 0
  private var linestart = 0

  def this() { this(1000) }

  /** Return the number of lines, including the fictitious last line. */
  def numLines: Int = nlines

  /** Return the length of a line in the file */
  def getLineLength(n: Int): Int = linelen(n)

  /** Find the line number corresponding to a character index. */
  def getRow(pos: Int): Int = {
    findPos(pos); curline
  }

  /** Find the column number of a character index in its line. */
  def getColumn(pos: Int): Int = {
    findPos(pos); pos - linestart
  }

  // Augment the mutator methods of Text to maintain the line map

  override def clear() {
    super.clear()
    nlines = 1
    linelen(0) = 1
    curline = 0
    linestart = 0
  }

  override def insert(pos: Int, ch: Char) {
    super.insert(pos, ch)
    findPos(pos)
    if (ch != '\n')
      linelen(curline) += 1
    else
      mapLines()
  }

  override def insert(pos: Int, s: String) {
    super.insert(pos, s)
    mapLines()
  }

  override def insertRange(pos: Int, t: Text, start: Int, nchars: Int) {
    super.insertRange(pos, t, start, nchars)
    mapLines()
  }

  override def insertFile(pos: Int, in: java.io.Reader) {
    try {
      super.insertFile(pos, in)
    } finally {
      // Even if an IOException is thrown, we still update the line map
      mapLines()
    }
  }

  override def deleteChar(pos: Int) {
    val ch = charAt(pos)
    super.deleteChar(pos)
    findPos(pos)
    if (ch != '\n')
      linelen(curline) -= 1
    else
      mapLines()
  }

  override def deleteRange(start: Int, len: Int) {
    super.deleteRange(start, len)

    findPos(start)
    if (start + len < linestart + linelen(curline))
      linelen(curline) -= len
    else
      mapLines()
  }

  /** Return the editing position closest to the specified coordinates */
  def getPos(row: Int, col: Int): Int = {
    val r = Math.min(Math.max(row, 0), nlines - 1)
    findLine(r)
    val c = Math.min(Math.max(col, 0), linelen(curline) - 1)
    linestart + c
  }

  /** Fetch the text of line n, without the trailing newline */
  def fetchLine(n: Int, buf: Text) {
    findLine(n)
    getRange(linestart, linelen(n) - 1, buf)
  }

  /** Refresh the line map by scanning the whole file.
    * This is always a last resort if we choose not to update the
    * line map in a faster way. */
  private def mapLines() {
    nlines = 0
    var c = 0

    for (i <- 0 until length) {
      c += 1
      if (charAt(i) == '\n') {
        lineRoom()
        linelen(nlines) = c
        nlines += 1; c = 0
      }
    }

    lineRoom()
    linelen(nlines) = c + 1
    nlines += 1

    // Reset the cache
    curline = 0; linestart = 0
  }

  /** Set curline to a specified line number. */
  private def findLine(n: Int) {
    assert(n >= 0 && n < nlines)

    // Move forwards if necessary
    while (n > curline) {
      linestart += linelen(curline)
      curline += 1
    }

    // Move backwards if necessary
    while (n < curline) {
      curline -= 1
      linestart -= linelen(curline)
    }
  }

  /** Set current line so that it contains a specified character index. */
  private def findPos(j: Int) {
    assert(j >= 0 && j <= length)

    // Move forwards if necessary
    while (j >= linestart + linelen(curline)) {
      linestart += linelen(curline)
      curline += 1
    }

    // Move backwards if necessary
    while (j < linestart) {
      curline -= 1
      linestart -= linelen(curline)
    }

    assert(linestart <= j && j < linestart + linelen(curline))
  }

  /** Find room for one more line */
  private def lineRoom() {
    if (nlines >= linelen.length) {
      val newlen = new Array[Int](2 * linelen.length)
      Array.copy(linelen, 0, newlen, 0, nlines)
      linelen = newlen
    }
  }
}