~repos /gdx-studio

/*
 * 02/24/2004
 *
 * DocumentReader.java - A reader for javax.swing.text.Document
 * objects.
 *
 * This library is distributed under a modified BSD license.  See the included
 * RSyntaxTextArea.License.txt file for details.
 */
package org.fife.io;

import java.io.Reader;
import javax.swing.text.BadLocationException;
import javax.swing.text.Document;
import javax.swing.text.Segment;


/**
 * A <code>Reader</code> for <code>javax.swing.text.Document</code> objects.
 *
 * @author Robert Futrell
 * @version 1.0
 */
public class DocumentReader extends Reader {

  /**
   * The stream's position in the document.
   */
  private long position;

  /**
   * A remembered position in the document.
   */
  private long mark;

  /**
   * The document we're working on.
   */
  private Document document;

  /**
   * Used for fast character access.
   */
  private Segment segment;


  /**
   * Constructor.
   *
   * @param document The document we're 'reading'.
   */
  public DocumentReader(Document document) {
    position = 0;
    mark = -1;
    this.document = document;
    this.segment = new Segment();
  }


  /**
   * This currently does nothing...
   */
  @Override
  public void close() {
  }


  /**
   * Marks the present position in the stream.  Subsequent calls to
   * <code>reset()</code> will reposition the stream to this point.
   *
   * @param readAheadLimit Ignored.
   */
  @Override
  public void mark(int readAheadLimit) {
    mark = position;
  }


  /**
   * Tells whether this reader supports the <code>mark</code> operation.
   * This always returns <code>true</code> for <code>DocumentReader</code>.
   */
  @Override
  public boolean markSupported() {
    return true;
  }


  /**
   * Reads the single character at the current position in the document.
   */
  @Override
  public int read() {
    if(position>=document.getLength()) {
      return -1;      // Read past end of document.
    }
    try {
      document.getText((int)position,1, segment);
      position++;
      return segment.array[segment.offset];
    } catch (BadLocationException ble) {
      /* Should never happen?? */
      ble.printStackTrace();
      return -1;
    }
  }


  /**
   * Read <code>array.length</code> characters from the beginning
   * of the document into <code>array</code>.
   *
   * @param array The array to read characters into.
   * @return The number of characters read.
   */
  @Override
  public int read(char array[]) {
    return read(array, 0, array.length);
  }


  /**
   * Reads characters into a portion of an array.
   *
   * @param cbuf The destination buffer.
   * @param off Offset at which to start storing characters.
   * @param len Maximum number of characters to read.
   * @return The number of characters read, or <code>-1</code> if the
   *         end of the stream (document) has been reached.
   */
  @Override
  public int read(char cbuf[], int off, int len) {
    int k;
    if(position>=document.getLength()) {
      return -1;      // Read past end of document.
    }
    k = len;
    if((position+k)>=document.getLength())
      k = document.getLength() - (int)position;
    if(off + k >= cbuf.length)
      k = cbuf.length - off;
    try {
      document.getText((int)position, k, segment);
      position += k;
      System.arraycopy(segment.array,segment.offset,
              cbuf,off,
              k);
      return k;
    } catch (BadLocationException ble) {
      /* Should never happen ? */
      return -1;
    }
  }


  /**
   * Tells whether this reader is ready to be read without
   * blocking for input.  <code>DocumentReader</code> will
   * always return true.
   *
   * @return <code>true</code> if the next read operation will
   *         return without blocking.
   */
  @Override
  public boolean ready() {
    return true;
  }


  /**
   * Resets the stream.  If the stream has been marked, then attempt to
   * reposition it at the mark.  If the stream has not been marked, then
   * move it to the beginning of the document.
   */
  @Override
  public void reset() {
    if(mark==-1) {
      position = 0;
    }
    else {
      position = mark;
      mark = -1;
    }
  }


  /**
   * Skips characters.  This will not 'skip' past the end of the document.
   *
   * @param n The number of characters to skip.
   * @return The number of characters actually skipped.
   */
  @Override
  public long skip(long n) {
    if (position+n<=document.getLength()) {
      position += n;
      return n;
    }
    long temp = position;
    position = document.getLength();
    return document.getLength() - temp;
  }


  /**
   * Move to the specified position in the document.  If <code>pos</code>
   * is greater than the document's length, the stream's position is moved
   * to the end of the document.
   *
   * @param pos The position in the document to move to.
   */
  public void seek(long pos) {
    position = Math.min(pos, document.getLength());
  }


}