src/com/ibm/icu/impl/UnicodeCharacterIterator.java - external/github.com/unicode-org/icu - Git at Google

 /*
  *******************************************************************************
  * Copyright (C) 1996-2000, International Business Machines Corporation and    *
  * others. All Rights Reserved.                                                *
  *******************************************************************************
  *
  * $Source: /xsrl/Nsvn/icu/icu4j/src/com/ibm/icu/impl/Attic/UnicodeCharacterIterator.java,v $
  * $Date: 2002/08/07 17:55:03 $
  * $Revision: 1.2 $
  *
  *******************************************************************************
  */
 package com.ibm.icu.impl;

 import com.ibm.icu.text.Replaceable;
 import com.ibm.icu.text.ReplaceableString;
 import com.ibm.icu.text.UTF16;
 import java.text.CharacterIterator;

 /**
  * Internal class that iterates through a com.ibm.text.Replacable text object
  * to return either Unicode characters.
  * @author synwee
  * @version release 2.1, February 2002
  */
 public final class UnicodeCharacterIterator implements CharacterIterator
 {
 	// public data members -----------------------------------------------------

 	/**
 	 * Indicator that we have reached the ends of the UTF16 text when returning
 	 * 16 bit character.
 	 */
 	public static final int DONE = 0xFFFF;
 	/**
 	 * Indicator that we have reached the ends of the UTF16 text when returning
 	 * codepoints.
 	 */
 	public static final int DONE_CODEPOINT = -1;

 	// public constructor ------------------------------------------------------

 	/**
 	 * Public constructor.
 	 * By default the iteration range will be from 0 to the end of the text.
 	 * @param replacable text which the iterator will be based on
 	 */
 	public UnicodeCharacterIterator(Replaceable replaceable)
 	{
 		m_replaceable_  = replaceable;
 		m_index_        = 0;
 		m_start_        = 0;
 		m_limit_        = replaceable.length();
 	}

 	/**
 	 * Public constructor
 	 * By default the iteration range will be from 0 to the end of the text.
 	 * @param str text which the iterator will be based on
 	 */
 	public UnicodeCharacterIterator(String str)
 	{
 		m_replaceable_  = new ReplaceableString(str);
 		m_index_        = 0;
 		m_start_        = 0;
 		m_limit_        = m_replaceable_.length();
 	}

 	/**
      * Constructs an iterator over the given range of the given string.
      * @param  text  text to be iterated over
      * @param  start offset of the first character to iterate
      * @param  limit offset of the character following the last character to
      * 					iterate
      */
     public UnicodeCharacterIterator(String str, int start, int limit)
     {
     	m_replaceable_  = new ReplaceableString(str);
 		m_start_        = start;
 		m_limit_        = limit;
 		m_index_        = m_start_;
     }

     /**
      * Constructs an iterator over the given range of the given replaceable
      * string.
      * @param  text  text to be iterated over
      * @param  start offset of the first character to iterate
      * @param  limit offset of the character following the last character to
      * 					iterate
      */
     public UnicodeCharacterIterator(Replaceable replaceable, int start, int limit)
     {
     	m_replaceable_  = replaceable;
 		m_start_        = start;
 		m_limit_        = limit;
 		m_index_        = m_start_;
     }

 	// public methods ----------------------------------------------------------

 	/**
      * Creates a copy of this iterator.
      * Cloning will not duplicate a new Replaceable object.
      * @return copy of this iterator
      */
     public Object clone()
     {
         try {
             return super.clone();
         }
         catch (CloneNotSupportedException e) {
             throw new InternalError(
             "Cloning by the super class java.text.CharacterIterator is not " +
             "supported");
         }
     }

 	/**
      * Returns the current UTF16 character.
      * @return current UTF16 character
      */
     public char current()
     {
         if (m_index_ >= m_start_ && m_index_ < m_limit_) {
             return m_replaceable_.charAt(m_index_);
         }
         return DONE;
     }

     /**
      * Returns the current codepoint
      * @return current codepoint
      */
     public int currentCodePoint()
     {
         if (m_index_ >= m_start_ && m_index_ < m_limit_) {
             return m_replaceable_.char32At(m_index_);
         }
         return DONE_CODEPOINT;
     }

     /**
      * Gets the first UTF16 character in text.
      * @return the first UTF16 in text.
      */
     public char first()
     {
         m_index_ = m_start_;
         return current();
     }

     /**
      * Returns the start of the text to iterate.
      * @return by default this method will return 0, unless a range for
      * iteration had been specified during construction.
      */
     public int getBeginIndex()
     {
         return m_start_;
     }

     /**
      * Returns the limit offset of the text to iterate
      * @return by default this method returns the length of the text, unless a
      * range for iteration had been specified during construction.
      */
     public int getEndIndex()
     {
         return m_limit_;
     }

     /**
      * Gets the current index in text.
      * @return current index in text.
      */
     public int getIndex()
     {
         return m_index_;
     }

     /**
      * Gets the last UTF16 iterateable character from the text and shifts the
      * index to the end of the text accordingly.
      * @return the last UTF16 iterateable character
      */
     public char last()
     {
         if (m_limit_ != m_start_) {
             m_index_ = m_limit_ - 1;
             return m_replaceable_.charAt(m_index_);
         }
 		m_index_ = m_limit_;
         return DONE;
     }

 	/**
      * Returns next UTF16 character and increments the iterator's index by 1.
 	 * If the resulting index is greater or equal to the iteration limit, the
 	 * index is reset to the text iteration limit and a value of DONE_CODEPOINT is
 	 * returned.
 	 * @return next UTF16 character in text or DONE if the new index is off the
 	 *         end of the text iteration limit.
      */
     public char next()
     {
         if (m_index_ < m_limit_) {
         	char result = m_replaceable_.charAt(m_index_);
             m_index_ ++;
             return result;
         }
         return DONE;
     }

 	/**
 	 * Returns next codepoint after current index and increments the iterator's
 	 * index by a number depending on the returned codepoint.
 	 * This assumes the text is stored as 16-bit code units
      * with surrogate pairs intermixed. If the index of a leading or trailing
      * code unit of a surrogate pair is given, return the code point after the
      * surrogate pair.
 	 * If the resulting index is greater or equal to the text iterateable limit,
 	 * the current index is reset to the text iterateable limit and a value of
 	 * DONE_CODEPOINT is returned.
 	 * @return next codepoint in text or DONE_CODEPOINT if the new index is off the
 	 *         end of the text iterateable limit.
 	 */
 	public int nextCodePoint()
 	{
         if (m_index_ < m_limit_) {
             char ch = m_replaceable_.charAt(m_index_);
             m_index_ ++;
             if (ch >= UTF16.LEAD_SURROGATE_MIN_VALUE &&
                 ch <= UTF16.LEAD_SURROGATE_MAX_VALUE &&
                 m_index_ < m_limit_) {
                 char trail = m_replaceable_.charAt(m_index_);
                 if (trail >= UTF16.TRAIL_SURROGATE_MIN_VALUE &&
                     trail <= UTF16.TRAIL_SURROGATE_MAX_VALUE) {
                     m_index_ ++;
                     return UCharacterProperty.getRawSupplementary(ch,
                                                                   trail);
                 }
             }
             return ch;
         }
         return DONE_CODEPOINT;
 	}

     /**
      * Returns previous UTF16 character and decrements the iterator's index by
      * 1.
 	 * If the resulting index is less than the text iterateable limit, the
 	 * index is reset to the start of the text iteration and a value of
 	 * DONE_CODEPOINT is returned.
 	 * @return next UTF16 character in text or DONE if the new index is off the
 	 *         start of the text iteration range.
      */
     public char previous()
     {
         if (m_index_ > m_start_) {
             m_index_ --;
             return m_replaceable_.charAt(m_index_);
         }
         return DONE;
     }

     /**
      * Returns previous codepoint before current index and decrements the
      * iterator's index by a number depending on the returned codepoint.
 	 * This assumes the text is stored as 16-bit code units
      * with surrogate pairs intermixed. If the index of a leading or trailing
      * code unit of a surrogate pair is given, return the code point before the
      * surrogate pair.
 	 * If the resulting index is less than the text iterateable range, the
 	 * current index is reset to the start of the range and a value of
 	 * DONE_CODEPOINT is returned.
 	 * @return previous codepoint in text or DONE_CODEPOINT if the new index is
 	 *         off the start of the text iteration range.
      */
     public int previousCodePoint()
     {
         if (m_index_ > m_start_) {
             m_index_ --;
             char ch = m_replaceable_.charAt(m_index_);
             if (ch >= UTF16.TRAIL_SURROGATE_MIN_VALUE &&
                 ch <= UTF16.TRAIL_SURROGATE_MAX_VALUE &&
                 m_index_ > m_start_) {
                 m_index_ --;
                 char lead = m_replaceable_.charAt(m_index_);
                 if (lead >= UTF16.LEAD_SURROGATE_MIN_VALUE &&
                     lead <= UTF16.LEAD_SURROGATE_MAX_VALUE) {
                     return UCharacterProperty.getRawSupplementary(lead,ch);
                 }
             }
             return ch;
         }
         return DONE_CODEPOINT;
     }

 	/**
 	 * <p>Sets the index to the specified index in the text and returns that
 	 * single UTF16 character at index.
 	 * This assumes the text is stored as 16-bit code units.</p>
 	 * @param index the index within the text.
 	 * @exception IllegalArgumentException is thrown if an invalid index is
 	 *            supplied. i.e. index is out of bounds.
 	 * @return the character at the specified index or DONE if the specified
 	 *         index is equal to the limit of the text iteration range.
 	 */
 	public char setIndex(int index)
 	{
 		if (index < m_start_ || index > m_limit_) {
 			throw new IllegalArgumentException("Index index out of bounds");
 		}
 		m_index_ = index;
 		return current();
 	}

 	// private data members ----------------------------------------------------

 	/**
 	 * Replacable object
 	 */
 	private Replaceable m_replaceable_;
 	/**
 	 * Current index
 	 */
 	private int m_index_;
 	/**
 	 * Start offset of iterateable range, by default this is 0
 	 */
 	private int m_start_;
 	/**
 	 * Limit offset of iterateable range, by default this is the length of the
 	 * string
 	 */
 	private int m_limit_;
 }
	/*
	*******************************************************************************
	* Copyright (C) 1996-2000, International Business Machines Corporation and *
	* others. All Rights Reserved. *
	*******************************************************************************
	*
	* $Source: /xsrl/Nsvn/icu/icu4j/src/com/ibm/icu/impl/Attic/UnicodeCharacterIterator.java,v $
	* $Date: 2002/08/07 17:55:03 $
	* $Revision: 1.2 $
	*
	*******************************************************************************
	*/
	package com.ibm.icu.impl;

	import com.ibm.icu.text.Replaceable;
	import com.ibm.icu.text.ReplaceableString;
	import com.ibm.icu.text.UTF16;
	import java.text.CharacterIterator;

	/**
	* Internal class that iterates through a com.ibm.text.Replacable text object
	* to return either Unicode characters.
	* @author synwee
	* @version release 2.1, February 2002
	*/
	public final class UnicodeCharacterIterator implements CharacterIterator
	{
	// public data members -----------------------------------------------------

	/**
	* Indicator that we have reached the ends of the UTF16 text when returning
	* 16 bit character.
	*/
	public static final int DONE = 0xFFFF;
	/**
	* Indicator that we have reached the ends of the UTF16 text when returning
	* codepoints.
	*/
	public static final int DONE_CODEPOINT = -1;

	// public constructor ------------------------------------------------------

	/**
	* Public constructor.
	* By default the iteration range will be from 0 to the end of the text.
	* @param replacable text which the iterator will be based on
	*/
	public UnicodeCharacterIterator(Replaceable replaceable)
	{
	m_replaceable_ = replaceable;
	m_index_ = 0;
	m_start_ = 0;
	m_limit_ = replaceable.length();
	}

	/**
	* Public constructor
	* By default the iteration range will be from 0 to the end of the text.
	* @param str text which the iterator will be based on
	*/
	public UnicodeCharacterIterator(String str)
	{
	m_replaceable_ = new ReplaceableString(str);
	m_index_ = 0;
	m_start_ = 0;
	m_limit_ = m_replaceable_.length();
	}

	/**
	* Constructs an iterator over the given range of the given string.
	* @param text text to be iterated over
	* @param start offset of the first character to iterate
	* @param limit offset of the character following the last character to
	* iterate
	*/
	public UnicodeCharacterIterator(String str, int start, int limit)
	{
	m_replaceable_ = new ReplaceableString(str);
	m_start_ = start;
	m_limit_ = limit;
	m_index_ = m_start_;
	}

	/**
	* Constructs an iterator over the given range of the given replaceable
	* string.
	* @param text text to be iterated over
	* @param start offset of the first character to iterate
	* @param limit offset of the character following the last character to
	* iterate
	*/
	public UnicodeCharacterIterator(Replaceable replaceable, int start, int limit)
	{
	m_replaceable_ = replaceable;
	m_start_ = start;
	m_limit_ = limit;
	m_index_ = m_start_;
	}

	// public methods ----------------------------------------------------------

	/**
	* Creates a copy of this iterator.
	* Cloning will not duplicate a new Replaceable object.
	* @return copy of this iterator
	*/
	public Object clone()
	{
	try {
	return super.clone();
	}
	catch (CloneNotSupportedException e) {
	throw new InternalError(
	"Cloning by the super class java.text.CharacterIterator is not " +
	"supported");
	}
	}

	/**
	* Returns the current UTF16 character.
	* @return current UTF16 character
	*/
	public char current()
	{
	if (m_index_ >= m_start_ && m_index_ < m_limit_) {
	return m_replaceable_.charAt(m_index_);
	}
	return DONE;
	}

	/**
	* Returns the current codepoint
	* @return current codepoint
	*/
	public int currentCodePoint()
	{
	if (m_index_ >= m_start_ && m_index_ < m_limit_) {
	return m_replaceable_.char32At(m_index_);
	}
	return DONE_CODEPOINT;
	}

	/**
	* Gets the first UTF16 character in text.
	* @return the first UTF16 in text.
	*/
	public char first()
	{
	m_index_ = m_start_;
	return current();
	}

	/**
	* Returns the start of the text to iterate.
	* @return by default this method will return 0, unless a range for
	* iteration had been specified during construction.
	*/
	public int getBeginIndex()
	{
	return m_start_;
	}

	/**
	* Returns the limit offset of the text to iterate
	* @return by default this method returns the length of the text, unless a
	* range for iteration had been specified during construction.
	*/
	public int getEndIndex()
	{
	return m_limit_;
	}

	/**
	* Gets the current index in text.
	* @return current index in text.
	*/
	public int getIndex()
	{
	return m_index_;
	}

	/**
	* Gets the last UTF16 iterateable character from the text and shifts the
	* index to the end of the text accordingly.
	* @return the last UTF16 iterateable character
	*/
	public char last()
	{
	if (m_limit_ != m_start_) {
	m_index_ = m_limit_ - 1;
	return m_replaceable_.charAt(m_index_);
	}
	m_index_ = m_limit_;
	return DONE;
	}

	/**
	* Returns next UTF16 character and increments the iterator's index by 1.
	* If the resulting index is greater or equal to the iteration limit, the
	* index is reset to the text iteration limit and a value of DONE_CODEPOINT is
	* returned.
	* @return next UTF16 character in text or DONE if the new index is off the
	* end of the text iteration limit.
	*/
	public char next()
	{
	if (m_index_ < m_limit_) {
	char result = m_replaceable_.charAt(m_index_);
	m_index_ ++;
	return result;
	}
	return DONE;
	}

	/**
	* Returns next codepoint after current index and increments the iterator's
	* index by a number depending on the returned codepoint.
	* This assumes the text is stored as 16-bit code units
	* with surrogate pairs intermixed. If the index of a leading or trailing
	* code unit of a surrogate pair is given, return the code point after the
	* surrogate pair.
	* If the resulting index is greater or equal to the text iterateable limit,
	* the current index is reset to the text iterateable limit and a value of
	* DONE_CODEPOINT is returned.
	* @return next codepoint in text or DONE_CODEPOINT if the new index is off the
	* end of the text iterateable limit.
	*/
	public int nextCodePoint()
	{
	if (m_index_ < m_limit_) {
	char ch = m_replaceable_.charAt(m_index_);
	m_index_ ++;
	if (ch >= UTF16.LEAD_SURROGATE_MIN_VALUE &&
	ch <= UTF16.LEAD_SURROGATE_MAX_VALUE &&
	m_index_ < m_limit_) {
	char trail = m_replaceable_.charAt(m_index_);
	if (trail >= UTF16.TRAIL_SURROGATE_MIN_VALUE &&
	trail <= UTF16.TRAIL_SURROGATE_MAX_VALUE) {
	m_index_ ++;
	return UCharacterProperty.getRawSupplementary(ch,
	trail);
	}
	}
	return ch;
	}
	return DONE_CODEPOINT;
	}

	/**
	* Returns previous UTF16 character and decrements the iterator's index by
	* 1.
	* If the resulting index is less than the text iterateable limit, the
	* index is reset to the start of the text iteration and a value of
	* DONE_CODEPOINT is returned.
	* @return next UTF16 character in text or DONE if the new index is off the
	* start of the text iteration range.
	*/
	public char previous()
	{
	if (m_index_ > m_start_) {
	m_index_ --;
	return m_replaceable_.charAt(m_index_);
	}
	return DONE;
	}

	/**
	* Returns previous codepoint before current index and decrements the
	* iterator's index by a number depending on the returned codepoint.
	* This assumes the text is stored as 16-bit code units
	* with surrogate pairs intermixed. If the index of a leading or trailing
	* code unit of a surrogate pair is given, return the code point before the
	* surrogate pair.
	* If the resulting index is less than the text iterateable range, the
	* current index is reset to the start of the range and a value of
	* DONE_CODEPOINT is returned.
	* @return previous codepoint in text or DONE_CODEPOINT if the new index is
	* off the start of the text iteration range.
	*/
	public int previousCodePoint()
	{
	if (m_index_ > m_start_) {
	m_index_ --;
	char ch = m_replaceable_.charAt(m_index_);
	if (ch >= UTF16.TRAIL_SURROGATE_MIN_VALUE &&
	ch <= UTF16.TRAIL_SURROGATE_MAX_VALUE &&
	m_index_ > m_start_) {
	m_index_ --;
	char lead = m_replaceable_.charAt(m_index_);
	if (lead >= UTF16.LEAD_SURROGATE_MIN_VALUE &&
	lead <= UTF16.LEAD_SURROGATE_MAX_VALUE) {
	return UCharacterProperty.getRawSupplementary(lead,ch);
	}
	}
	return ch;
	}
	return DONE_CODEPOINT;
	}

	/**
	* <p>Sets the index to the specified index in the text and returns that
	* single UTF16 character at index.
	* This assumes the text is stored as 16-bit code units.</p>
	* @param index the index within the text.
	* @exception IllegalArgumentException is thrown if an invalid index is
	* supplied. i.e. index is out of bounds.
	* @return the character at the specified index or DONE if the specified
	* index is equal to the limit of the text iteration range.
	*/
	public char setIndex(int index)
	{
	if (index < m_start_ \|\| index > m_limit_) {
	throw new IllegalArgumentException("Index index out of bounds");
	}
	m_index_ = index;
	return current();
	}

	// private data members ----------------------------------------------------

	/**
	* Replacable object
	*/
	private Replaceable m_replaceable_;
	/**
	* Current index
	*/
	private int m_index_;
	/**
	* Start offset of iterateable range, by default this is 0
	*/
	private int m_start_;
	/**
	* Limit offset of iterateable range, by default this is the length of the
	* string
	*/
	private int m_limit_;
	}