Java BreakIterator.DONE屬性代碼示例

private Vector testLastAndPrevious(BreakIterator bi, String text) {
    int p = bi.last();
    int lastP = p;
    Vector<String> result = new Vector<String>();

    if (p != text.length())
        errln("last() returned " + p + " instead of " + text.length());
    while (p != BreakIterator.DONE) {
        p = bi.previous();
        if (p != BreakIterator.DONE) {
            if (p >= lastP)
                errln("previous() failed to move backward: previous() on position "
                                + lastP + " yielded " + p);

            result.insertElementAt(text.substring(p, lastP), 0);
        }
        else {
            if (lastP != 0)
                errln("previous() returned DONE prematurely: offset was "
                                + lastP + " instead of 0");
        }
        lastP = p;
    }
    return result;
}
 

@Override
public String[] split(String text) {
    boundary.setText(text);
    ArrayList<String> words = new ArrayList<>();
    int start = boundary.first();
    int end = boundary.next();

    while (end != BreakIterator.DONE) {
        String word = text.substring(start, end).trim();
        if (!word.isEmpty()) {
            words.add(word);
        }
        start = end;
        end = boundary.next();
    }

    String[] array = new String[words.size()];
    for (int i = 0; i < array.length; i++) {
        array[i] = words.get(i);
    }

    return array;
}
 

@Override
public String[] split(String text) {
    boundary.setText(text);
    ArrayList<String> sentences = new ArrayList<>();
    int start = boundary.first();
    for (int end = boundary.next();
            end != BreakIterator.DONE;
            start = end, end = boundary.next()) {
        sentences.add(text.substring(start, end).trim());
    }

    String[] array = new String[sentences.size()];
    for (int i = 0; i < array.length; i++) {
        array[i] = sentences.get(i);
    }

    return array;
}
 

@Override
protected boolean incrementWord() {
  int start = wordBreaker.current();
  if (start == BreakIterator.DONE) {
    return false; // BreakIterator exhausted
  }

  // find the next set of boundaries, skipping over non-tokens
  int end = wordBreaker.next();
  while (end != BreakIterator.DONE &&
         !Character.isLetterOrDigit(Character.codePointAt(buffer, sentenceStart + start, sentenceEnd))) {
    start = end;
    end = wordBreaker.next();
  }

  if (end == BreakIterator.DONE) {
    return false; // BreakIterator exhausted
  }

  clearAttributes();
  termAtt.copyBuffer(buffer, sentenceStart + start, end - start);
  offsetAtt.setOffset(correctOffset(offset + sentenceStart + start), correctOffset(offset + sentenceStart + end));
  return true;
}
 

/**
 * Needed to unify forward and backward searching.
 * The method assumes that s is the text assigned to words.
 */
private int findWordLimit(int index, BreakIterator words, boolean direction,
                                 String s) {
    // Fix for 4256660 and 4256661.
    // Words iterator is different from character and sentence iterators
    // in that end of one word is not necessarily start of another word.
    // Please see java.text.BreakIterator JavaDoc. The code below is
    // based on nextWordStartAfter example from BreakIterator.java.
    int last = (direction == NEXT) ? words.following(index)
                                   : words.preceding(index);
    int current = (direction == NEXT) ? words.next()
                                      : words.previous();
    while (current != BreakIterator.DONE) {
        for (int p = Math.min(last, current); p < Math.max(last, current); p++) {
            if (Character.isLetter(s.charAt(p))) {
                return last;
            }
        }
        last = current;
        current = (direction == NEXT) ? words.next()
                                      : words.previous();
    }
    return BreakIterator.DONE;
}
 

void TestPrintAt_2() {
    iter = BreakIterator.getWordInstance(Locale.US);

    int[][] index = {
        {2, 9, 10, 15, 17},
        {1, 9, 10, 13, 16, 18, 20},
        {4, 9, 10, 13, 16, 18, 20},
        {6, 7, 10, 11, 15},
    };

    for (int i = 0; i < given.length; i++) {
        iter.setText(given[i]);

        // Check preceding(0)'s return value - should equals BreakIterator.DONE.
        if (iter.preceding(0) != BreakIterator.DONE) {
             errln("Word break failure: printAt_2() expected:-1(BreakIterator.DONE), got:" +
                   iter.preceding(0));
        }

        for (int j = 0; j < index[i].length; j++) {
            start = iter.preceding(index[i][j]);
            end = iter.next();

            if (!expected[i][j].equals(given[i].substring(start, end))) {
                errln("Word break failure: printAt_2() expected:<" +
                      expected[i][j] + ">, got:<" +
                      given[i].substring(start, end) +
                      "> start=" + start + "  end=" + end);
            }
        }

        // Check next()'s return value - should equals BreakIterator.DONE.
        end = iter.last();
        start = iter.next();
        if (start != BreakIterator.DONE) {
             errln("Word break failure: printAt_2() expected:-1(BreakIterator.DONE), got:" + start);
        }
    }
}
 

/**
 * Returns the Segment at <code>index</code> representing either
 * the paragraph or sentence as identified by <code>part</code>, or
 * null if a valid paragraph/sentence can't be found. The offset
 * will point to the start of the word/sentence in the array, and
 * the modelOffset will point to the location of the word/sentence
 * in the model.
 */
private IndexedSegment getSegmentAt(int part, int index)
    throws BadLocationException {

    IndexedSegment seg = getParagraphElementText(index);
    if (seg == null) {
        return null;
    }
    BreakIterator iterator;
    switch (part) {
    case AccessibleText.WORD:
        iterator = BreakIterator.getWordInstance(getLocale());
        break;
    case AccessibleText.SENTENCE:
        iterator = BreakIterator.getSentenceInstance(getLocale());
        break;
    default:
        return null;
    }
    seg.first();
    iterator.setText(seg);
    int end = iterator.following(index - seg.modelOffset + seg.offset);
    if (end == BreakIterator.DONE) {
        return null;
    }
    if (end > seg.offset + seg.count) {
        return null;
    }
    int begin = iterator.previous();
    if (begin == BreakIterator.DONE ||
        begin >= seg.offset + seg.count) {
        return null;
    }
    seg.modelOffset = seg.modelOffset + begin - seg.offset;
    seg.offset = begin;
    seg.count = end - begin;
    return seg;
}
 

@Override
public boolean onDoubleTap(MotionEvent e) {

    int x = (int) e.getX();
    int y = (int) e.getY();

    // find the position
    int offset = getOffsetForPosition(x, y);

    // select word
    BreakIterator iterator = BreakIterator.getWordInstance();
    iterator.setText(getText().toString());

    // start and end are the word boundaries;
    int start;
    if (iterator.isBoundary(offset)) {
        start = offset;
    } else {
        start = iterator.preceding(offset);
    }
    int end = iterator.following(offset);

    // handle tapping at the very beginning or end.
    if (end == BreakIterator.DONE) {
        end = start;
        start = iterator.preceding(offset);
        if (start == BreakIterator.DONE) start = end;
    }

    setSelection(start, end);

    return super.onDoubleTap(e);
}
 

/**
 * Determines the minimum span for this view along an axis.
 *
 * <p>This implementation returns the longest non-breakable area within
 * the view as a minimum span for {@code View.X_AXIS}.</p>
 *
 * @param axis  may be either {@code View.X_AXIS} or {@code View.Y_AXIS}
 * @return      the minimum span the view can be rendered into
 * @throws IllegalArgumentException if the {@code axis} parameter is invalid
 * @see         javax.swing.text.View#getMinimumSpan
 */
@Override
public float getMinimumSpan(int axis) {
    switch (axis) {
        case View.X_AXIS:
            if (minimumSpan < 0) {
                minimumSpan = 0;
                int p0 = getStartOffset();
                int p1 = getEndOffset();
                while (p1 > p0) {
                    int breakSpot = getBreakSpot(p0, p1);
                    if (breakSpot == BreakIterator.DONE) {
                        // the rest of the view is non-breakable
                        breakSpot = p0;
                    }
                    minimumSpan = Math.max(minimumSpan,
                            getPartialSpan(breakSpot, p1));
                    // Note: getBreakSpot returns the *last* breakspot
                    p1 = breakSpot - 1;
                }
            }
            return minimumSpan;
        case View.Y_AXIS:
            return super.getMinimumSpan(axis);
        default:
            throw new IllegalArgumentException("Invalid axis: " + axis);
    }
}
 

/**
 * Set the iterator to analyze a new piece of text.  This function resets
 * the current iteration position to the beginning of the text.
 * @param newText An iterator over the text to analyze.
 */
@Override
public void setText(CharacterIterator newText) {
    // Test iterator to see if we need to wrap it in a SafeCharIterator.
    // The correct behavior for CharacterIterators is to allow the
    // position to be set to the endpoint of the iterator.  Many
    // CharacterIterators do not uphold this, so this is a workaround
    // to permit them to use this class.
    int end = newText.getEndIndex();
    boolean goodIterator;
    try {
        newText.setIndex(end);  // some buggy iterators throw an exception here
        goodIterator = newText.getIndex() == end;
    }
    catch(IllegalArgumentException e) {
        goodIterator = false;
    }

    if (goodIterator) {
        text = newText;
    }
    else {
        text = new SafeCharIterator(newText);
    }
    text.first();

    cachedLastKnownBreak = BreakIterator.DONE;
}
 

/**
 * Sets the iterator to refer to the first boundary position following
 * the specified position.
 * @offset The position from which to begin searching for a break position.
 * @return The position of the first break after the current position.
 */
@Override
public int following(int offset) {

    CharacterIterator text = getText();
    checkOffset(offset, text);

    // Set our internal iteration position (temporarily)
    // to the position passed in.  If this is the _beginning_ position,
    // then we can just use next() to get our return value
    text.setIndex(offset);
    if (offset == text.getBeginIndex()) {
        cachedLastKnownBreak = handleNext();
        return cachedLastKnownBreak;
    }

    // otherwise, we have to sync up first.  Use handlePrevious() to back
    // us up to a known break position before the specified position (if
    // we can determine that the specified position is a break position,
    // we don't back up at all).  This may or may not be the last break
    // position at or before our starting position.  Advance forward
    // from here until we've passed the starting position.  The position
    // we stop on will be the first break position after the specified one.
    int result = cachedLastKnownBreak;
    if (result >= offset || result <= BreakIterator.DONE) {
        result = handlePrevious();
    } else {
        //it might be better to check if handlePrevious() give us closer
        //safe value but handlePrevious() is slow too
        //So, this has to be done carefully
        text.setIndex(result);
    }
    while (result != BreakIterator.DONE && result <= offset) {
        result = handleNext();
    }
    cachedLastKnownBreak = result;
    return result;
}
 

/**
 * 
 * @param toWrap
 *            The string on which the line wrapping process should be done
 * @param maxLength
 *            The maximum length per line
 * @return The StringBuffer with the wrapped lines
 */
public static String wrapText(final String toWrap, final int maxLength)
{
	if (maxLength == 0) throw new IllegalArgumentException("maxLength must not be 0");

	StringBuffer ret = new StringBuffer();
	BreakIterator boundary = BreakIterator.getLineInstance();
	boundary.setText(toWrap);
	int realEnd = BreakIterator.DONE;
	int start = boundary.first();
	int end = boundary.next();

	int lineLength = 0;

	while (end != BreakIterator.DONE)
	{
		int charCount = end - start - 1;

		if (charCount > maxLength)
		{
			realEnd = end;
			end = start + maxLength;
		}
		String word = toWrap.substring(start, end);
		lineLength = lineLength + word.length();
		if (lineLength >= maxLength)
		{
			ret.append("\n");
			lineLength = word.length();
		}
		ret.append(word);
		if (realEnd == BreakIterator.DONE)
		{
			start = end;
			end = boundary.next();
		}
		else
		{
			start = end;
			end = realEnd;
			realEnd = BreakIterator.DONE;
		}
	}
	return ret.toString();
}
 

/** Asserts that two breakiterators break the text the same way */
private static void assertSameBreaks(CharacterIterator one, CharacterIterator two, BreakIterator expected, BreakIterator actual) {
    expected.setText(one);
    actual.setText(two);

    assertEquals(expected.current(), actual.current());

    // next()
    int v = expected.current();
    while (v != BreakIterator.DONE) {
        assertEquals(v = expected.next(), actual.next());
        assertEquals(expected.current(), actual.current());
    }

    // first()
    assertEquals(expected.first(), actual.first());
    assertEquals(expected.current(), actual.current());
    // last()
    assertEquals(expected.last(), actual.last());
    assertEquals(expected.current(), actual.current());

    // previous()
    v = expected.current();
    while (v != BreakIterator.DONE) {
        assertEquals(v = expected.previous(), actual.previous());
        assertEquals(expected.current(), actual.current());
    }

    // following()
    for (int i = one.getBeginIndex(); i <= one.getEndIndex(); i++) {
        expected.first();
        actual.first();
        assertEquals(expected.following(i), actual.following(i));
        assertEquals(expected.current(), actual.current());
    }

    // preceding()
    for (int i = one.getBeginIndex(); i <= one.getEndIndex(); i++) {
        expected.last();
        actual.last();
        assertEquals(expected.preceding(i), actual.preceding(i));
        assertEquals(expected.current(), actual.current());
    }
}
 

static void formatText(PrintWriter writer, String target, int initialLength) {
  BreakIterator boundary = BreakIterator.getLineInstance();
  boundary.setText(target);
  int start = boundary.first();
  int end = boundary.next();
  int lineLength = initialLength;

  while (end != BreakIterator.DONE) {
    // Look at the end and only accept whitespace breaks
    char endChar = target.charAt(end - 1);
    while (!Character.isWhitespace(endChar)) {
      int lastEnd = end;
      end = boundary.next();
      if (end == BreakIterator.DONE) {
        // give up. We are at the end of the string
        end = lastEnd;
        break;
      }
      endChar = target.charAt(end - 1);
    }
    int wordEnd = end;
    if (endChar == '\n') {
      // trim off the \n since println will do it for us
      wordEnd--;
      if (wordEnd > 0 && target.charAt(wordEnd - 1) == '\r') {
        wordEnd--;
      }
    } else if (endChar == '\t') {
      // figure tabs use 8 characters
      lineLength += 7;
    }
    String word = target.substring(start, wordEnd);
    lineLength += word.length();
    writer.print(word);
    if (endChar == '\n' || endChar == '\r') {
      // force end of line
      writer.println();
      writer.print("  ");
      lineLength = 2;
    }
    start = end;
    end = boundary.next();
  }
  if (lineLength != 0) {
    writer.println();
  }
}
 

private void _display(String caption, String text, String messageType) {
    captionLabel.setText(caption);

    BreakIterator iter = BreakIterator.getWordInstance();
    if (text != null) {
        iter.setText(text);
        int start = iter.first(), end;
        int nLines = 0;

        do {
            end = iter.next();

            if (end == BreakIterator.DONE ||
                text.substring(start, end).length() >= 50)
            {
                lineLabels[nLines].setText(text.substring(start, end == BreakIterator.DONE ?
                                                          iter.last() : end));
                textPanel.add(lineLabels[nLines++]);
                start = end;
            }
            if (nLines == BALLOON_WORD_LINE_MAX_COUNT) {
                if (end != BreakIterator.DONE) {
                    lineLabels[nLines - 1].setText(
                        new String(lineLabels[nLines - 1].getText() + " ..."));
                }
                break;
            }
        } while (end != BreakIterator.DONE);


        textPanel.setLayout(new GridLayout(nLines, 1));
    }

    if ("ERROR".equals(messageType)) {
        iconImage = errorImage;
    } else if ("WARNING".equals(messageType)) {
        iconImage = warnImage;
    } else if ("INFO".equals(messageType)) {
        iconImage = infoImage;
    } else {
        iconImage = null;
    }

    if (iconImage != null) {
        Dimension tpSize = textPanel.getSize();
        iconCanvas.setSize(BALLOON_ICON_WIDTH, (BALLOON_ICON_HEIGHT > tpSize.height ?
                                                BALLOON_ICON_HEIGHT : tpSize.height));
        iconCanvas.validate();
    }

    SunToolkit.executeOnEventHandlerThread(target, new Runnable() {
            public void run() {
                if (liveArguments.isDisposed()) {
                    return;
                }
                Point parLoc = getParent().getLocationOnScreen();
                Dimension parSize = getParent().getSize();
                show(new Point(parLoc.x + parSize.width/2, parLoc.y + parSize.height/2),
                     BALLOON_TRAY_ICON_INDENT);
                if (iconImage != null) {
                    iconCanvas.updateImage(iconImage); // call it after the show(..) above
                }
            }
        });
}