Logo
Distributed Genetic Programming Framework
print print

File org.jfree.util.LineBreakIterator.java

Here you can find all the information about the file org.jfree.util.LineBreakIterator.java. You may explore it here or download it onto your local disk.
/* ========================================================================
 * JCommon : a free general purpose class library for the Java(tm) platform
 * ========================================================================
 *
 * (C) Copyright 2000-2005, by Object Refinery Limited and Contributors.
 * 
 * Project Info:  http://www.jfree.org/jcommon/index.html
 *
 * This library is free software; you can redistribute it and/or modify it 
 * under the terms of the GNU Lesser General Public License as published by 
 * the Free Software Foundation; either version 2.1 of the License, or 
 * (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful, but 
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 
 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public 
 * License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, 
 * USA.  
 *
 * [Java is a trademark or registered trademark of Sun Microsystems, Inc. 
 * in the United States and other countries.]
 *
 * ----------------------
 * LineBreakIterator.java
 * ----------------------
 * (C)opyright 2003, by Thomas Morgner and Contributors.
 *
 * Original Author:  Thomas Morgner;
 * Contributor(s):   David Gilbert (for Object Refinery Limited);
 *
 * $Id: LineBreakIterator.java,v 1.4 2005/11/03 09:55:26 mungady Exp $
 *
 * Changes
 * -------
 * 13-03-2003 : Initial version
 */

package org.jfree.util;

import java.util.Iterator;

/**
 * An iterator that breaks text into lines.
 * The result is equal to BufferedReader.readLine().
 *
 * @author Thomas Morgner
 */

public class LineBreakIterator implements Iterator
{
  /** A useful constant. */
  public static final int DONE = -1;

  /** Storage for the text. */
  private char[] text;

  /** The current position. */
  private int position;

  /**
   * Default constructor.
   */

  public LineBreakIterator()
  {
    setText("");
  }

  /**
   * Creates a new line break iterator.
   *
   * @param text the text to be broken up.
   */

  public LineBreakIterator(final String text)
  {
    setText(text);
  }

  /**
   * Returns the position of the next break.
   *
   * @return A position.
   */

  public synchronized int nextPosition()
  {
    if (this.text == null)
    {
      return DONE;
    }
    if (this.position == DONE)
    {
      return DONE;
    }

    // recognize \n, \r, \r\n

    final int nChars = this.text.length;
    int nextChar = this.position;

    for (;;)
    {
      if (nextChar >= nChars)
      {
        /* End of text reached */
        this.position = DONE;
        return DONE;
      }

      boolean eol = false;
      char c = 0;
      int i;

      // search the next line break, either \n or \r
      for (i = nextChar; i < nChars; i++)
      {
        c = this.text[i];
        if ((c == '\n') || (c == '\r'))
        {
          eol = true;
          break;
        }
      }

      nextChar = i;
      if (eol)
      {
        nextChar++;
        if (c == '\r')
        {
          if ((nextChar < nChars) && (this.text[nextChar] == '\n'))
          {
            nextChar++;
          }
        }
        this.position = nextChar;
        return (this.position);
      }
    }
  }

  /**
   * Same like next(), but returns the End-Of-Text as
   * if there was a linebreak added (Reader.readLine() compatible)
   *
   * @return The next position.
   */

  public int nextWithEnd()
  {
    final int pos = this.position;
    if (pos == DONE)
    {
      return DONE;
    }
    if (pos == this.text.length)
    {
      this.position = DONE;
      return DONE;
    }
    final int retval = nextPosition();
    if (retval == DONE)
    {
      return this.text.length;
    }
    return retval;
  }

  /**
   * Returns the text to be broken up.
   *
   * @return The text.
   */

  public String getText()
  {
    return new String(this.text);
  }

  /**
   * Sets the text to be broken up.
   *
   * @param text  the text.
   */

  public void setText(final String text)
  {
    this.position = 0;
    this.text = text.toCharArray();
  }

  /**
   * Returns <tt>true</tt> if the iteration has more elements. (In other
   * words, returns <tt>true</tt> if <tt>next</tt> would return an element
   * rather than throwing an exception.)
   *
   * @return <tt>true</tt> if the iterator has more elements.
   */

  public boolean hasNext()
  {
    return (this.position != DONE);
  }

  /**
   * Returns the next element in the iteration.
   *
   * @return the next element in the iteration.
   */

  public Object next()
  {
    if (this.position == DONE)
    {
      // allready at the end ...
      return null;
    }

    final int lastFound = this.position;
    int pos = nextWithEnd();
    if (pos == DONE)
    {
      // the end of the text has been reached ...
      return new String(this.text, lastFound, this.text.length - lastFound);
    }

    // step one char back
    if (pos > 0)
    {
      final int end = lastFound;
      for (; ((pos) > end) && ((this.text[pos - 1] == '\n') || this.text[pos - 1] == '\r'); pos--)
      {
        // search the end of the current linebreak sequence ..
      }
    }
    //System.out.println ("text: " + new String (text));
    //System.out.println ("pos: " + pos + " lastFound: " + lastFound);
    return new String(this.text, lastFound, pos - lastFound);
  }

  /**
   *
   * Removes from the underlying collection the last element returned by the
   * iterator (optional operation).  This method can be called only once per
   * call to <tt>next</tt>.  The behavior of an iterator is unspecified if
   * the underlying collection is modified while the iteration is in
   * progress in any way other than by calling this method.
   *
   * @exception UnsupportedOperationException if the <tt>remove</tt>
   *    operation is not supported by this Iterator.
   * @exception IllegalStateException if the <tt>next</tt> method has not
   *    yet been called, or the <tt>remove</tt> method has already
   *    been called after the last call to the <tt>next</tt>
   *    method.
   */

  public void remove()
  {
      throw new UnsupportedOperationException("This iterator is read-only.");
  }
}

File Information:

file name:LineBreakIterator.java
package:org.jfree.util
qualified name:org.jfree.util.LineBreakIterator.java
file type:Java Source File
download location:download http://dgpf.sourceforge.net/source/org/jfree/util/LineBreakIterator.java
size:6.469 KB (6625 B)
uploaded: 2015-07-22 04:11:10 GMT+0000
last update: 2006-09-26 10:30:36 GMT+0000
last access: 2018-01-24 01:38:18 GMT+0000

statistics online since 2006-01-02.   RSS Feed
Contact us by sending an email to tweise@gmx.de to receive further information, to report errors, or to join our project.
All content on this site (http://dgpf.sourceforge.net/) is LGPL-licensed.
http://dgpf.sourceforge.net/scripts/source/source.php last modified at 2015-07-22 04:10:53 GMT+0000 served at 2018-01-24 01:38:18 GMT+0000.
Valid CSS Valid XHTML 1.1
Valid RSS SourceForge.net Logo