src/com/ibm/richtext/textformat/MTextIterator.java - external/github.com/unicode-org/icu - Git at Google

 /*
  * (C) Copyright IBM Corp. 1998-2004.  All Rights Reserved.
  *
  * The program is provided "as is" without any warranty express or
  * implied, including the warranty of non-infringement and the implied
  * warranties of merchantibility and fitness for a particular purpose.
  * IBM will not be liable for any damages suffered by you as a result
  * of using the Program. In no event will IBM be liable for any
  * special, indirect or consequential damages or lost profits even if
  * IBM has been advised of the possibility of their occurrence. IBM
  * will not be liable for any third party claims against you.
  */
 // Requires Java2
 package com.ibm.richtext.textformat;

 import com.ibm.richtext.styledtext.MConstText;
 import java.text.CharacterIterator;

 import com.ibm.richtext.textlayout.attributes.AttributeMap;

 ///*JDK12IMPORTS
 import java.text.AttributedCharacterIterator;
 import java.util.Map;
 import java.util.Set;
 //JDK12IMPORTS*/

 /*JDK11IMPORTS
 import com.ibm.richtext.textlayout.attributes.AttributedCharacterIterator;
 import com.ibm.richtext.textlayout.attributes.AttributedCharacterIterator.Attribute;
 import com.ibm.richtext.textlayout.attributes.Map;
 JDK11IMPORTS*/

 /**
  * An AttributedCharacterIterator over an MConstText.
  */
 public final class MTextIterator implements AttributedCharacterIterator,
                                             Cloneable {

     static final String COPYRIGHT =
                 "(C) Copyright IBM Corp. 1998-1999 - All Rights Reserved";
     // memory leak, since this cache is never flushed

     private static class Matcher {

         boolean matches(Map lhs, Map rhs, Object query) {

             Object lhsVal = lhs.get(query);
             Object rhsVal = rhs.get(query);

             if (lhsVal == null) {
                 return rhsVal == null;
             }
             else {
                 return lhsVal.equals(rhsVal);
             }
         }
     }

     private static final Matcher ATTR_MATCHER = new Matcher();

     // Not quite optimal.  Could have a matcher that would decompose
     // a set once for repeated queries.  Of course that would require
     // allocation...
 ///*JDK12IMPORTS
     private static final Matcher SET_MATCHER = new Matcher() {

         boolean matches(Map lhs, Map rhs, Object query) {

             // Not using Iterator to simplify 1.1 port.
             Object[] elements = ((Set)query).toArray();
             for (int i=0; i < elements.length; i++) {
                 if (!super.matches(lhs, rhs, elements[i])) {
                     return false;
                 }
             }
             return true;
         }
     };
 //JDK12IMPORTS*/

     private final class StyleCache {

         private int fRunStart = 0;
         private int fRunLimit = -1;
         private int fRangeStart;
         private int fRangeLimit;
         private AttributeMap fStyle;

         StyleCache(MConstText text, int start, int limit) {
             fText = text;
             fRangeStart = start;
             fRangeLimit = limit;
             update(start);
         }

         private void update(int pos) {
             if (pos < fRunStart || pos >= fRunLimit) {
                 AttributeMap style = AttributeMap.EMPTY_ATTRIBUTE_MAP;
                 if (pos < fRangeStart) {
                     fRunLimit = fRangeStart;
                     fRunStart = Integer.MIN_VALUE;
                 }
                 else if (pos > fRangeLimit) {
                     fRunStart = fRangeLimit;
                     fRunLimit = Integer.MAX_VALUE;
                 }
                 else {
                     fRunStart = Math.max(fRangeStart, fText.characterStyleStart(pos));
                     fRunStart = Math.max(fRunStart, fText.paragraphStart(pos));

                     fRunLimit = Math.min(fRangeLimit, fText.characterStyleLimit(pos));
                     fRunLimit = Math.min(fRunLimit, fText.paragraphLimit(pos));
                     if (fRunStart < fRunLimit) {
                         style = fText.paragraphStyleAt(pos);
                         style = style.addAttributes(fText.characterStyleAt(pos));
                     }
                 }
                 fStyle = fFontResolver.applyFont(style);
             }
         }

         int getRunStart(int pos) {
             update(pos);
             return fRunStart;
         }

         int getRunLimit(int pos) {
             update(pos);
             return fRunLimit;
         }

         Map getStyle(int pos) {
             update(pos);
             return fStyle;
         }
     }

     private MConstText fText;
     private CharacterIterator fCharIter;
     private FontResolver fFontResolver;

     private StyleCache fStyleCache;

     /**
      * Create an MTextIterator over the range [start, limit).
      */
     public MTextIterator(MConstText text,
                          FontResolver resolver,
                          int start,
                          int limit) {

         fText = text;
         fFontResolver = resolver;
         fCharIter = text.createCharacterIterator(start, limit);

         fStyleCache = new StyleCache(text, start, limit);
     }

     /**
      * Sets the position to getBeginIndex() and returns the character at that
      * position.
      * @return the first character in the text, or DONE if the text is empty
      * @see #getBeginIndex
      */
     public char first() {
         return fCharIter.first();
     }

     /**
      * Sets the position to getEndIndex()-1 (getEndIndex() if the text is empty)
      * and returns the character at that position.
      * @return the last character in the text, or DONE if the text is empty
      * @see #getEndIndex
      */
     public char last() {
         return fCharIter.last();
     }

     /**
      * Gets the character at the current position (as returned by getIndex()).
      * @return the character at the current position or DONE if the current
      * position is off the end of the text.
      * @see #getIndex
      */
     public char current() {
         return fCharIter.current();
     }

     /**
      * Increments the iterator's index by one and returns the character
      * at the new index.  If the resulting index is greater or equal
      * to getEndIndex(), the current index is reset to getEndIndex() and
      * a value of DONE is returned.
      * @return the character at the new position or DONE if the new
      * position is off the end of the text range.
      */
     public char next() {
         return fCharIter.next();
     }

     /**
      * Decrements the iterator's index by one and returns the character
      * at the new index. If the current index is getBeginIndex(), the index
      * remains at getBeginIndex() and a value of DONE is returned.
      * @return the character at the new position or DONE if the current
      * position is equal to getBeginIndex().
      */
     public char previous() {
         return fCharIter.previous();
     }

     /**
      * Sets the position to the specified position in the text and returns that
      * character.
      * @param position the position within the text.  Valid values range from
      * getBeginIndex() to getEndIndex().  An IllegalArgumentException is thrown
      * if an invalid value is supplied.
      * @return the character at the specified position or DONE if the specified position is equal to getEndIndex()
      */
     public char setIndex(int position) {
         return fCharIter.setIndex(position);
     }

     /**
      * Returns the start index of the text.
      * @return the index at which the text begins.
      */
     public int getBeginIndex() {
         return fCharIter.getBeginIndex();
     }

     /**
      * Returns the end index of the text.  This index is the index of the first
      * character following the end of the text.
      * @return the index after the last character in the text
      */
     public int getEndIndex() {
         return fCharIter.getEndIndex();
     }

     /**
      * Returns the current index.
      * @return the current index.
      */
     public int getIndex() {
         return fCharIter.getIndex();
     }

     /**
      * Returns the index of the first character of the run
      * with respect to all attributes containing the current character.
      */
     public int getRunStart() {
         return fStyleCache.getRunStart(fCharIter.getIndex());
     }

     /**
      * Returns the index of the first character of the run
      * with respect to the given attribute containing the current character.
      */
     public int getRunStart(Object attribute) {

         return getRunStart(attribute, ATTR_MATCHER);
     }

     /**
      * Returns the index of the first character of the run
      * with respect to the given attribute containing the current character.
      */
 ///*JDK12IMPORTS
     public int getRunStart(Attribute attribute) {

         return getRunStart(attribute, ATTR_MATCHER);
     }
 //JDK12IMPORTS*/

     /**
      * Returns the index of the first character of the run
      * with respect to the given attributes containing the current character.
      */
 ///*JDK12IMPORTS
     public int getRunStart(Set attributes) {

         return getRunStart(attributes, SET_MATCHER);
     }
 //JDK12IMPORTS*/

     private int getRunStart(Object query, Matcher matcher) {

         int runStart = getRunStart();
         int rangeStart = getBeginIndex();
         Map initialStyle = getAttributes();

         while (runStart > rangeStart) {
             AttributeMap style = fText.characterStyleAt(runStart-1);
             if (!matcher.matches(initialStyle, style, query)) {
                 return runStart;
             }
             runStart = fText.characterStyleStart(runStart-1);
         }
         return rangeStart;
     }

     /**
      * Returns the index of the first character following the run
      * with respect to all attributes containing the current character.
      */
     public int getRunLimit() {
         return fStyleCache.getRunLimit(fCharIter.getIndex());
     }

     /**
      * Returns the index of the first character following the run
      * with respect to the given attribute containing the current character.
      */
     public int getRunLimit(Object attribute) {

         return getRunLimit(attribute, ATTR_MATCHER);
     }

     /**
      * Returns the index of the first character following the run
      * with respect to the given attribute containing the current character.
      */
 ///*JDK12IMPORTS
     public int getRunLimit(Attribute attribute) {

         return getRunLimit(attribute, ATTR_MATCHER);
     }
 //JDK12IMPORTS*/

     /**
      * Returns the index of the first character following the run
      * with respect to the given attributes containing the current character.
      */
 ///*JDK12IMPORTS
     public int getRunLimit(Set attributes) {

         return getRunLimit(attributes, SET_MATCHER);
     }
 //JDK12IMPORTS*/

     private int getRunLimit(Object query, Matcher matcher) {

         int runLimit = getRunLimit();
         int rangeLimit = getEndIndex();
         Map initialStyle = getAttributes();

         while (runLimit < rangeLimit) {
             AttributeMap style = fText.characterStyleAt(runLimit);
             if (!matcher.matches(initialStyle, style, query)) {
                 return runLimit;
             }
             runLimit = fText.characterStyleLimit(runLimit);
         }
         return rangeLimit;
     }

     /**
      * Returns a map with the attributes defined on the current
      * character.
      */
     public Map getAttributes() {
         return fStyleCache.getStyle(fCharIter.getIndex());
     }

     /**
      * Returns the value of the named attribute for the current character.
      * Returns null if the attribute is not defined.
      * @param attribute the key of the attribute whose value is requested.
      */
     public Object getAttribute(Object attribute) {
         return getAttributes().get(attribute);
     }

     /**
      * Returns the value of the named attribute for the current character.
      * Returns null if the attribute is not defined.
      * @param attribute the key of the attribute whose value is requested.
      */
     public Object getAttribute(Attribute attribute) {
         return getAttributes().get(attribute);
     }

     /**
      * Returns the keys of all attributes defined on the
      * iterator's text range. The set is empty if no
      * attributes are defined.
      */
 ///*JDK12IMPORTS
     public Set getAllAttributeKeys() {
         throw new Error("Implement this method!");
     }
 //JDK12IMPORTS*/

     public Object clone() {
         return new MTextIterator(fText,
                                  fFontResolver,
                                  getBeginIndex(),
                                  getEndIndex());
     }
 }
	/*
	* (C) Copyright IBM Corp. 1998-2004. All Rights Reserved.
	*
	* The program is provided "as is" without any warranty express or
	* implied, including the warranty of non-infringement and the implied
	* warranties of merchantibility and fitness for a particular purpose.
	* IBM will not be liable for any damages suffered by you as a result
	* of using the Program. In no event will IBM be liable for any
	* special, indirect or consequential damages or lost profits even if
	* IBM has been advised of the possibility of their occurrence. IBM
	* will not be liable for any third party claims against you.
	*/
	// Requires Java2
	package com.ibm.richtext.textformat;

	import com.ibm.richtext.styledtext.MConstText;
	import java.text.CharacterIterator;

	import com.ibm.richtext.textlayout.attributes.AttributeMap;

	///*JDK12IMPORTS
	import java.text.AttributedCharacterIterator;
	import java.util.Map;
	import java.util.Set;
	//JDK12IMPORTS*/

	/*JDK11IMPORTS
	import com.ibm.richtext.textlayout.attributes.AttributedCharacterIterator;
	import com.ibm.richtext.textlayout.attributes.AttributedCharacterIterator.Attribute;
	import com.ibm.richtext.textlayout.attributes.Map;
	JDK11IMPORTS*/

	/**
	* An AttributedCharacterIterator over an MConstText.
	*/
	public final class MTextIterator implements AttributedCharacterIterator,
	Cloneable {

	static final String COPYRIGHT =
	"(C) Copyright IBM Corp. 1998-1999 - All Rights Reserved";
	// memory leak, since this cache is never flushed

	private static class Matcher {

	boolean matches(Map lhs, Map rhs, Object query) {

	Object lhsVal = lhs.get(query);
	Object rhsVal = rhs.get(query);

	if (lhsVal == null) {
	return rhsVal == null;
	}
	else {
	return lhsVal.equals(rhsVal);
	}
	}
	}

	private static final Matcher ATTR_MATCHER = new Matcher();

	// Not quite optimal. Could have a matcher that would decompose
	// a set once for repeated queries. Of course that would require
	// allocation...
	///*JDK12IMPORTS
	private static final Matcher SET_MATCHER = new Matcher() {

	boolean matches(Map lhs, Map rhs, Object query) {

	// Not using Iterator to simplify 1.1 port.
	Object[] elements = ((Set)query).toArray();
	for (int i=0; i < elements.length; i++) {
	if (!super.matches(lhs, rhs, elements[i])) {
	return false;
	}
	}
	return true;
	}
	};
	//JDK12IMPORTS*/

	private final class StyleCache {

	private int fRunStart = 0;
	private int fRunLimit = -1;
	private int fRangeStart;
	private int fRangeLimit;
	private AttributeMap fStyle;

	StyleCache(MConstText text, int start, int limit) {
	fText = text;
	fRangeStart = start;
	fRangeLimit = limit;
	update(start);
	}

	private void update(int pos) {
	if (pos < fRunStart \|\| pos >= fRunLimit) {
	AttributeMap style = AttributeMap.EMPTY_ATTRIBUTE_MAP;
	if (pos < fRangeStart) {
	fRunLimit = fRangeStart;
	fRunStart = Integer.MIN_VALUE;
	}
	else if (pos > fRangeLimit) {
	fRunStart = fRangeLimit;
	fRunLimit = Integer.MAX_VALUE;
	}
	else {
	fRunStart = Math.max(fRangeStart, fText.characterStyleStart(pos));
	fRunStart = Math.max(fRunStart, fText.paragraphStart(pos));

	fRunLimit = Math.min(fRangeLimit, fText.characterStyleLimit(pos));
	fRunLimit = Math.min(fRunLimit, fText.paragraphLimit(pos));
	if (fRunStart < fRunLimit) {
	style = fText.paragraphStyleAt(pos);
	style = style.addAttributes(fText.characterStyleAt(pos));
	}
	}
	fStyle = fFontResolver.applyFont(style);
	}
	}

	int getRunStart(int pos) {
	update(pos);
	return fRunStart;
	}

	int getRunLimit(int pos) {
	update(pos);
	return fRunLimit;
	}

	Map getStyle(int pos) {
	update(pos);
	return fStyle;
	}
	}

	private MConstText fText;
	private CharacterIterator fCharIter;
	private FontResolver fFontResolver;

	private StyleCache fStyleCache;

	/**
	* Create an MTextIterator over the range [start, limit).
	*/
	public MTextIterator(MConstText text,
	FontResolver resolver,
	int start,
	int limit) {

	fText = text;
	fFontResolver = resolver;
	fCharIter = text.createCharacterIterator(start, limit);

	fStyleCache = new StyleCache(text, start, limit);
	}

	/**
	* Sets the position to getBeginIndex() and returns the character at that
	* position.
	* @return the first character in the text, or DONE if the text is empty
	* @see #getBeginIndex
	*/
	public char first() {
	return fCharIter.first();
	}

	/**
	* Sets the position to getEndIndex()-1 (getEndIndex() if the text is empty)
	* and returns the character at that position.
	* @return the last character in the text, or DONE if the text is empty
	* @see #getEndIndex
	*/
	public char last() {
	return fCharIter.last();
	}

	/**
	* Gets the character at the current position (as returned by getIndex()).
	* @return the character at the current position or DONE if the current
	* position is off the end of the text.
	* @see #getIndex
	*/
	public char current() {
	return fCharIter.current();
	}

	/**
	* Increments the iterator's index by one and returns the character
	* at the new index. If the resulting index is greater or equal
	* to getEndIndex(), the current index is reset to getEndIndex() and
	* a value of DONE is returned.
	* @return the character at the new position or DONE if the new
	* position is off the end of the text range.
	*/
	public char next() {
	return fCharIter.next();
	}

	/**
	* Decrements the iterator's index by one and returns the character
	* at the new index. If the current index is getBeginIndex(), the index
	* remains at getBeginIndex() and a value of DONE is returned.
	* @return the character at the new position or DONE if the current
	* position is equal to getBeginIndex().
	*/
	public char previous() {
	return fCharIter.previous();
	}

	/**
	* Sets the position to the specified position in the text and returns that
	* character.
	* @param position the position within the text. Valid values range from
	* getBeginIndex() to getEndIndex(). An IllegalArgumentException is thrown
	* if an invalid value is supplied.
	* @return the character at the specified position or DONE if the specified position is equal to getEndIndex()
	*/
	public char setIndex(int position) {
	return fCharIter.setIndex(position);
	}

	/**
	* Returns the start index of the text.
	* @return the index at which the text begins.
	*/
	public int getBeginIndex() {
	return fCharIter.getBeginIndex();
	}

	/**
	* Returns the end index of the text. This index is the index of the first
	* character following the end of the text.
	* @return the index after the last character in the text
	*/
	public int getEndIndex() {
	return fCharIter.getEndIndex();
	}

	/**
	* Returns the current index.
	* @return the current index.
	*/
	public int getIndex() {
	return fCharIter.getIndex();
	}

	/**
	* Returns the index of the first character of the run
	* with respect to all attributes containing the current character.
	*/
	public int getRunStart() {
	return fStyleCache.getRunStart(fCharIter.getIndex());
	}

	/**
	* Returns the index of the first character of the run
	* with respect to the given attribute containing the current character.
	*/
	public int getRunStart(Object attribute) {

	return getRunStart(attribute, ATTR_MATCHER);
	}

	/**
	* Returns the index of the first character of the run
	* with respect to the given attribute containing the current character.
	*/
	///*JDK12IMPORTS
	public int getRunStart(Attribute attribute) {

	return getRunStart(attribute, ATTR_MATCHER);
	}
	//JDK12IMPORTS*/

	/**
	* Returns the index of the first character of the run
	* with respect to the given attributes containing the current character.
	*/
	///*JDK12IMPORTS
	public int getRunStart(Set attributes) {

	return getRunStart(attributes, SET_MATCHER);
	}
	//JDK12IMPORTS*/

	private int getRunStart(Object query, Matcher matcher) {

	int runStart = getRunStart();
	int rangeStart = getBeginIndex();
	Map initialStyle = getAttributes();

	while (runStart > rangeStart) {
	AttributeMap style = fText.characterStyleAt(runStart-1);
	if (!matcher.matches(initialStyle, style, query)) {
	return runStart;
	}
	runStart = fText.characterStyleStart(runStart-1);
	}
	return rangeStart;
	}

	/**
	* Returns the index of the first character following the run
	* with respect to all attributes containing the current character.
	*/
	public int getRunLimit() {
	return fStyleCache.getRunLimit(fCharIter.getIndex());
	}

	/**
	* Returns the index of the first character following the run
	* with respect to the given attribute containing the current character.
	*/
	public int getRunLimit(Object attribute) {

	return getRunLimit(attribute, ATTR_MATCHER);
	}

	/**
	* Returns the index of the first character following the run
	* with respect to the given attribute containing the current character.
	*/
	///*JDK12IMPORTS
	public int getRunLimit(Attribute attribute) {

	return getRunLimit(attribute, ATTR_MATCHER);
	}
	//JDK12IMPORTS*/

	/**
	* Returns the index of the first character following the run
	* with respect to the given attributes containing the current character.
	*/
	///*JDK12IMPORTS
	public int getRunLimit(Set attributes) {

	return getRunLimit(attributes, SET_MATCHER);
	}
	//JDK12IMPORTS*/

	private int getRunLimit(Object query, Matcher matcher) {

	int runLimit = getRunLimit();
	int rangeLimit = getEndIndex();
	Map initialStyle = getAttributes();

	while (runLimit < rangeLimit) {
	AttributeMap style = fText.characterStyleAt(runLimit);
	if (!matcher.matches(initialStyle, style, query)) {
	return runLimit;
	}
	runLimit = fText.characterStyleLimit(runLimit);
	}
	return rangeLimit;
	}

	/**
	* Returns a map with the attributes defined on the current
	* character.
	*/
	public Map getAttributes() {
	return fStyleCache.getStyle(fCharIter.getIndex());
	}

	/**
	* Returns the value of the named attribute for the current character.
	* Returns null if the attribute is not defined.
	* @param attribute the key of the attribute whose value is requested.
	*/
	public Object getAttribute(Object attribute) {
	return getAttributes().get(attribute);
	}

	/**
	* Returns the value of the named attribute for the current character.
	* Returns null if the attribute is not defined.
	* @param attribute the key of the attribute whose value is requested.
	*/
	public Object getAttribute(Attribute attribute) {
	return getAttributes().get(attribute);
	}

	/**
	* Returns the keys of all attributes defined on the
	* iterator's text range. The set is empty if no
	* attributes are defined.
	*/
	///*JDK12IMPORTS
	public Set getAllAttributeKeys() {
	throw new Error("Implement this method!");
	}
	//JDK12IMPORTS*/

	public Object clone() {
	return new MTextIterator(fText,
	fFontResolver,
	getBeginIndex(),
	getEndIndex());
	}
	}