Google Git
Sign in
skia / external / github.com / unicode-org / icu / refs/tags/icu4j-cldr-26-d04 / . / eclipse-build / plugins.template / com.ibm.icu.base / src / com / ibm / icu / text / Bidi.java
blob: fddd92fb23f883398e2dd77d0b1c080c69c4595d [file] [log] [blame]
/*
*******************************************************************************
* Copyright (C) 2001-2012, International Business Machines
* Corporation and others. All Rights Reserved.
*******************************************************************************
*/
/* FOOD FOR THOUGHT: currently the reordering modes are a mixture of
* algorithm for direct BiDi, algorithm for inverse Bidi and the bizarre
* concept of RUNS_ONLY which is a double operation.
* It could be advantageous to divide this into 3 concepts:
* a) Operation: direct / inverse / RUNS_ONLY
* b) Direct algorithm: default / NUMBERS_SPECIAL / GROUP_NUMBERS_WITH_L
* c) Inverse algorithm: default / INVERSE_LIKE_DIRECT / NUMBERS_SPECIAL
* This would allow combinations not possible today like RUNS_ONLY with
* NUMBERS_SPECIAL.
* Also allow to set INSERT_MARKS for the direct step of RUNS_ONLY and
* REMOVE_CONTROLS for the inverse step.
* Not all combinations would be supported, and probably not all do make sense.
* This would need to document which ones are supported and what are the
* fallbacks for unsupported combinations.
*/
//TODO: make sample program do something simple but real and complete
package com.ibm.icu.text;
import java.text.AttributedCharacterIterator;
/**
*
* <h2>Bidi algorithm for ICU</h2>
*
* This is an implementation of the Unicode Bidirectional algorithm. The
* algorithm is defined in the <a
* href="http://www.unicode.org/unicode/reports/tr9/">Unicode Standard Annex #9</a>,
* version 13, also described in The Unicode Standard, Version 4.0 .
* <p>
*
* Note: Libraries that perform a bidirectional algorithm and reorder strings
* accordingly are sometimes called "Storage Layout Engines". ICU's Bidi and
* shaping (ArabicShaping) classes can be used at the core of such "Storage
* Layout Engines".
*
* <h3>General remarks about the API:</h3>
*
* The &quot;limit&quot; of a sequence of characters is the position just after
* their last character, i.e., one more than that position.
* <p>
*
* Some of the API methods provide access to &quot;runs&quot;. Such a
* &quot;run&quot; is defined as a sequence of characters that are at the same
* embedding level after performing the Bidi algorithm.
* <p>
*
* <h3>Basic concept: paragraph</h3>
* A piece of text can be divided into several paragraphs by characters
* with the Bidi class <code>Block Separator</code>. For handling of
* paragraphs, see:
* <ul>
* <li>{@link #countParagraphs}
* <li>{@link #getParaLevel}
* <li>{@link #getParagraph}
* <li>{@link #getParagraphByIndex}
* </ul>
*
* <h3>Basic concept: text direction</h3>
* The direction of a piece of text may be:
* <ul>
* <li>{@link #LTR}
* <li>{@link #RTL}
* <li>{@link #MIXED}
* </ul>
*
* <h3>Basic concept: levels</h3>
*
* Levels in this API represent embedding levels according to the Unicode
* Bidirectional Algorithm.
* Their low-order bit (even/odd value) indicates the visual direction.<p>
*
* Levels can be abstract values when used for the
* <code>paraLevel</code> and <code>embeddingLevels</code>
* arguments of <code>setPara()</code>; there:
* <ul>
* <li>the high-order bit of an <code>embeddingLevels[]</code>
* value indicates whether the using application is
* specifying the level of a character to <i>override</i> whatever the
* Bidi implementation would resolve it to.</li>
* <li><code>paraLevel</code> can be set to the
* pseudo-level values <code>LEVEL_DEFAULT_LTR</code>
* and <code>LEVEL_DEFAULT_RTL</code>.</li>
* </ul>
*
* <p>The related constants are not real, valid level values.
* <code>DEFAULT_XXX</code> can be used to specify
* a default for the paragraph level for
* when the <code>setPara()</code> method
* shall determine it but there is no
* strongly typed character in the input.<p>
*
* Note that the value for <code>LEVEL_DEFAULT_LTR</code> is even
* and the one for <code>LEVEL_DEFAULT_RTL</code> is odd,
* just like with normal LTR and RTL level values -
* these special values are designed that way. Also, the implementation
* assumes that MAX_EXPLICIT_LEVEL is odd.
*
* <ul><b>See Also:</b>
* <li>{@link #LEVEL_DEFAULT_LTR}
* <li>{@link #LEVEL_DEFAULT_RTL}
* <li>{@link #LEVEL_OVERRIDE}
* <li>{@link #MAX_EXPLICIT_LEVEL}
* <li>{@link #setPara}
* </ul>
*
* <h3>Basic concept: Reordering Mode</h3>
* Reordering mode values indicate which variant of the Bidi algorithm to
* use.
*
* <ul><b>See Also:</b>
* <li>{@link #setReorderingMode}
* <li>{@link #REORDER_DEFAULT}
* <li>{@link #REORDER_NUMBERS_SPECIAL}
* <li>{@link #REORDER_GROUP_NUMBERS_WITH_R}
* <li>{@link #REORDER_RUNS_ONLY}
* <li>{@link #REORDER_INVERSE_NUMBERS_AS_L}
* <li>{@link #REORDER_INVERSE_LIKE_DIRECT}
* <li>{@link #REORDER_INVERSE_FOR_NUMBERS_SPECIAL}
* </ul>
*
* <h3>Basic concept: Reordering Options</h3>
* Reordering options can be applied during Bidi text transformations.
* <ul><b>See Also:</b>
* <li>{@link #setReorderingOptions}
* <li>{@link #OPTION_DEFAULT}
* <li>{@link #OPTION_INSERT_MARKS}
* <li>{@link #OPTION_REMOVE_CONTROLS}
* <li>{@link #OPTION_STREAMING}
* </ul>
*
*
* @author Simon Montagu, Matitiahu Allouche (ported from C code written by Markus W. Scherer)
* @stable ICU 3.8
*
*
* <h4> Sample code for the ICU Bidi API </h4>
*
* <h5>Rendering a paragraph with the ICU Bidi API</h5>
*
* This is (hypothetical) sample code that illustrates how the ICU Bidi API
* could be used to render a paragraph of text. Rendering code depends highly on
* the graphics system, therefore this sample code must make a lot of
* assumptions, which may or may not match any existing graphics system's
* properties.
*
* <p>
* The basic assumptions are:
* </p>
* <ul>
* <li>Rendering is done from left to right on a horizontal line.</li>
* <li>A run of single-style, unidirectional text can be rendered at once.
* </li>
* <li>Such a run of text is passed to the graphics system with characters
* (code units) in logical order.</li>
* <li>The line-breaking algorithm is very complicated and Locale-dependent -
* and therefore its implementation omitted from this sample code.</li>
* </ul>
*
* <pre>
*
* package com.ibm.icu.dev.test.bidi;
*
* import com.ibm.icu.text.Bidi;
* import com.ibm.icu.text.BidiRun;
*
* public class Sample {
*
* static final int styleNormal = 0;
* static final int styleSelected = 1;
* static final int styleBold = 2;
* static final int styleItalics = 4;
* static final int styleSuper=8;
* static final int styleSub = 16;
*
* static class StyleRun {
* int limit;
* int style;
*
* public StyleRun(int limit, int style) {
* this.limit = limit;
* this.style = style;
* }
* }
*
* static class Bounds {
* int start;
* int limit;
*
* public Bounds(int start, int limit) {
* this.start = start;
* this.limit = limit;
* }
* }
*
* static int getTextWidth(String text, int start, int limit,
* StyleRun[] styleRuns, int styleRunCount) {
* // simplistic way to compute the width
* return limit - start;
* }
*
* // set limit and StyleRun limit for a line
* // from text[start] and from styleRuns[styleRunStart]
* // using Bidi.getLogicalRun(...)
* // returns line width
* static int getLineBreak(String text, Bounds line, Bidi para,
* StyleRun styleRuns[], Bounds styleRun) {
* // dummy return
* return 0;
* }
*
* // render runs on a line sequentially, always from left to right
*
* // prepare rendering a new line
* static void startLine(byte textDirection, int lineWidth) {
* System.out.println();
* }
*
* // render a run of text and advance to the right by the run width
* // the text[start..limit-1] is always in logical order
* static void renderRun(String text, int start, int limit,
* byte textDirection, int style) {
* }
*
* // We could compute a cross-product
* // from the style runs with the directional runs
* // and then reorder it.
* // Instead, here we iterate over each run type
* // and render the intersections -
* // with shortcuts in simple (and common) cases.
* // renderParagraph() is the main function.
*
* // render a directional run with
* // (possibly) multiple style runs intersecting with it
* static void renderDirectionalRun(String text, int start, int limit,
* byte direction, StyleRun styleRuns[],
* int styleRunCount) {
* int i;
*
* // iterate over style runs
* if (direction == Bidi.LTR) {
* int styleLimit;
* for (i = 0; i < styleRunCount; ++i) {
* styleLimit = styleRuns[i].limit;
* if (start < styleLimit) {
* if (styleLimit > limit) {
* styleLimit = limit;
* }
* renderRun(text, start, styleLimit,
* direction, styleRuns[i].style);
* if (styleLimit == limit) {
* break;
* }
* start = styleLimit;
* }
* }
* } else {
* int styleStart;
*
* for (i = styleRunCount-1; i >= 0; --i) {
* if (i > 0) {
* styleStart = styleRuns[i-1].limit;
* } else {
* styleStart = 0;
* }
* if (limit >= styleStart) {
* if (styleStart < start) {
* styleStart = start;
* }
* renderRun(text, styleStart, limit, direction,
* styleRuns[i].style);
* if (styleStart == start) {
* break;
* }
* limit = styleStart;
* }
* }
* }
* }
*
* // the line object represents text[start..limit-1]
* static void renderLine(Bidi line, String text, int start, int limit,
* StyleRun styleRuns[], int styleRunCount) {
* byte direction = line.getDirection();
* if (direction != Bidi.MIXED) {
* // unidirectional
* if (styleRunCount <= 1) {
* renderRun(text, start, limit, direction, styleRuns[0].style);
* } else {
* renderDirectionalRun(text, start, limit, direction,
* styleRuns, styleRunCount);
* }
* } else {
* // mixed-directional
* int count, i;
* BidiRun run;
*
* try {
* count = line.countRuns();
* } catch (IllegalStateException e) {
* e.printStackTrace();
* return;
* }
* if (styleRunCount <= 1) {
* int style = styleRuns[0].style;
*
* // iterate over directional runs
* for (i = 0; i < count; ++i) {
* run = line.getVisualRun(i);
* renderRun(text, run.getStart(), run.getLimit(),
* run.getDirection(), style);
* }
* } else {
* // iterate over both directional and style runs
* for (i = 0; i < count; ++i) {
* run = line.getVisualRun(i);
* renderDirectionalRun(text, run.getStart(),
* run.getLimit(), run.getDirection(),
* styleRuns, styleRunCount);
* }
* }
* }
* }
*
* static void renderParagraph(String text, byte textDirection,
* StyleRun styleRuns[], int styleRunCount,
* int lineWidth) {
* int length = text.length();
* Bidi para = new Bidi();
* try {
* para.setPara(text,
* textDirection != 0 ? Bidi.LEVEL_DEFAULT_RTL
* : Bidi.LEVEL_DEFAULT_LTR,
* null);
* } catch (Exception e) {
* e.printStackTrace();
* return;
* }
* byte paraLevel = (byte)(1 & para.getParaLevel());
* StyleRun styleRun = new StyleRun(length, styleNormal);
*
* if (styleRuns == null || styleRunCount <= 0) {
* styleRuns = new StyleRun[1];
* styleRunCount = 1;
* styleRuns[0] = styleRun;
* }
* // assume styleRuns[styleRunCount-1].limit>=length
*
* int width = getTextWidth(text, 0, length, styleRuns, styleRunCount);
* if (width <= lineWidth) {
* // everything fits onto one line
*
* // prepare rendering a new line from either left or right
* startLine(paraLevel, width);
*
* renderLine(para, text, 0, length, styleRuns, styleRunCount);
* } else {
* // we need to render several lines
* Bidi line = new Bidi(length, 0);
* int start = 0, limit;
* int styleRunStart = 0, styleRunLimit;
*
* for (;;) {
* limit = length;
* styleRunLimit = styleRunCount;
* width = getLineBreak(text, new Bounds(start, limit),
* para, styleRuns,
* new Bounds(styleRunStart, styleRunLimit));
* try {
* line = para.setLine(start, limit);
* } catch (Exception e) {
* e.printStackTrace();
* return;
* }
* // prepare rendering a new line
* // from either left or right
* startLine(paraLevel, width);
*
* if (styleRunStart > 0) {
* int newRunCount = styleRuns.length - styleRunStart;
* StyleRun[] newRuns = new StyleRun[newRunCount];
* System.arraycopy(styleRuns, styleRunStart, newRuns, 0,
* newRunCount);
* renderLine(line, text, start, limit, newRuns,
* styleRunLimit - styleRunStart);
* } else {
* renderLine(line, text, start, limit, styleRuns,
* styleRunLimit - styleRunStart);
* }
* if (limit == length) {
* break;
* }
* start = limit;
* styleRunStart = styleRunLimit - 1;
* if (start >= styleRuns[styleRunStart].limit) {
* ++styleRunStart;
* }
* }
* }
* }
*
* public static void main(String[] args)
* {
* renderParagraph("Some Latin text...", Bidi.LTR, null, 0, 80);
* renderParagraph("Some Hebrew text...", Bidi.RTL, null, 0, 60);
* }
* }
*
* </pre>
*/
public class Bidi {
private java.text.Bidi bidi;
private Bidi(java.text.Bidi delegate) {
this.bidi = delegate;
}
/** Paragraph level setting<p>
*
* Constant indicating that the base direction depends on the first strong
* directional character in the text according to the Unicode Bidirectional
* Algorithm. If no strong directional character is present,
* then set the paragraph level to 0 (left-to-right).<p>
*
* If this value is used in conjunction with reordering modes
* <code>REORDER_INVERSE_LIKE_DIRECT</code> or
* <code>REORDER_INVERSE_FOR_NUMBERS_SPECIAL</code>, the text to reorder
* is assumed to be visual LTR, and the text after reordering is required
* to be the corresponding logical string with appropriate contextual
* direction. The direction of the result string will be RTL if either
* the righmost or leftmost strong character of the source text is RTL
* or Arabic Letter, the direction will be LTR otherwise.<p>
*
* If reordering option <code>OPTION_INSERT_MARKS</code> is set, an RLM may
* be added at the beginning of the result string to ensure round trip
* (that the result string, when reordered back to visual, will produce
* the original source text).
* @see #REORDER_INVERSE_LIKE_DIRECT
* @see #REORDER_INVERSE_FOR_NUMBERS_SPECIAL
* @stable ICU 3.8
*/
public static final byte LEVEL_DEFAULT_LTR = (byte)0x7e;
/** Paragraph level setting<p>
*
* Constant indicating that the base direction depends on the first strong
* directional character in the text according to the Unicode Bidirectional
* Algorithm. If no strong directional character is present,
* then set the paragraph level to 1 (right-to-left).<p>
*
* If this value is used in conjunction with reordering modes
* <code>REORDER_INVERSE_LIKE_DIRECT</code> or
* <code>REORDER_INVERSE_FOR_NUMBERS_SPECIAL</code>, the text to reorder
* is assumed to be visual LTR, and the text after reordering is required
* to be the corresponding logical string with appropriate contextual
* direction. The direction of the result string will be RTL if either
* the righmost or leftmost strong character of the source text is RTL
* or Arabic Letter, or if the text contains no strong character;
* the direction will be LTR otherwise.<p>
*
* If reordering option <code>OPTION_INSERT_MARKS</code> is set, an RLM may
* be added at the beginning of the result string to ensure round trip
* (that the result string, when reordered back to visual, will produce
* the original source text).
* @see #REORDER_INVERSE_LIKE_DIRECT
* @see #REORDER_INVERSE_FOR_NUMBERS_SPECIAL
* @stable ICU 3.8
*/
public static final byte LEVEL_DEFAULT_RTL = (byte)0x7f;
/**
* Maximum explicit embedding level.
* (The maximum resolved level can be up to <code>MAX_EXPLICIT_LEVEL+1</code>).
* @stable ICU 3.8
*/
public static final byte MAX_EXPLICIT_LEVEL = 61;
/**
* Bit flag for level input.
* Overrides directional properties.
* @stable ICU 3.8
*/
public static final byte LEVEL_OVERRIDE = (byte)0x80;
/**
* Special value which can be returned by the mapping methods when a
* logical index has no corresponding visual index or vice-versa. This may
* happen for the logical-to-visual mapping of a Bidi control when option
* <code>OPTION_REMOVE_CONTROLS</code> is
* specified. This can also happen for the visual-to-logical mapping of a
* Bidi mark (LRM or RLM) inserted by option
* <code>OPTION_INSERT_MARKS</code>.
* @see #getVisualIndex
* @see #getVisualMap
* @see #getLogicalIndex
* @see #getLogicalMap
* @see #OPTION_INSERT_MARKS
* @see #OPTION_REMOVE_CONTROLS
* @stable ICU 3.8
*/
public static final int MAP_NOWHERE = -1;
/**
* All left-to-right text.
* @stable ICU 3.8
*/
public static final byte LTR = 0;
/**
* All right-to-left text.
* @stable ICU 3.8
*/
public static final byte RTL = 1;
/**
* Mixed-directional text.
* @stable ICU 3.8
*/
public static final byte MIXED = 2;
/**
* option bit for writeReordered():
* keep combining characters after their base characters in RTL runs
*
* @see #writeReordered
* @stable ICU 3.8
*/
public static final short KEEP_BASE_COMBINING = 1;
/**
* option bit for writeReordered():
* replace characters with the "mirrored" property in RTL runs
* by their mirror-image mappings
*
* @see #writeReordered
* @stable ICU 3.8
*/
public static final short DO_MIRRORING = 2;
/**
* option bit for writeReordered():
* surround the run with LRMs if necessary;
* this is part of the approximate "inverse Bidi" algorithm
*
* <p>This option does not imply corresponding adjustment of the index
* mappings.</p>
*
* @see #setInverse
* @see #writeReordered
* @stable ICU 3.8
*/
public static final short INSERT_LRM_FOR_NUMERIC = 4;
/**
* option bit for writeReordered():
* remove Bidi control characters
* (this does not affect INSERT_LRM_FOR_NUMERIC)
*
* <p>This option does not imply corresponding adjustment of the index
* mappings.</p>
*
* @see #writeReordered
* @see #INSERT_LRM_FOR_NUMERIC
* @stable ICU 3.8
*/
public static final short REMOVE_BIDI_CONTROLS = 8;
/**
* option bit for writeReordered():
* write the output in reverse order
*
* <p>This has the same effect as calling <code>writeReordered()</code>
* first without this option, and then calling
* <code>writeReverse()</code> without mirroring.
* Doing this in the same step is faster and avoids a temporary buffer.
* An example for using this option is output to a character terminal that
* is designed for RTL scripts and stores text in reverse order.</p>
*
* @see #writeReordered
* @stable ICU 3.8
*/
public static final short OUTPUT_REVERSE = 16;
/** Reordering mode: Regular Logical to Visual Bidi algorithm according to Unicode.
* @see #setReorderingMode
* @stable ICU 3.8
*/
public static final short REORDER_DEFAULT = 0;
/** Reordering mode: Logical to Visual algorithm which handles numbers in
* a way which mimicks the behavior of Windows XP.
* @see #setReorderingMode
* @stable ICU 3.8
*/
public static final short REORDER_NUMBERS_SPECIAL = 1;
/** Reordering mode: Logical to Visual algorithm grouping numbers with
* adjacent R characters (reversible algorithm).
* @see #setReorderingMode
* @stable ICU 3.8
*/
public static final short REORDER_GROUP_NUMBERS_WITH_R = 2;
/** Reordering mode: Reorder runs only to transform a Logical LTR string
* to the logical RTL string with the same display, or vice-versa.<br>
* If this mode is set together with option
* <code>OPTION_INSERT_MARKS</code>, some Bidi controls in the source
* text may be removed and other controls may be added to produce the
* minimum combination which has the required display.
* @see #OPTION_INSERT_MARKS
* @see #setReorderingMode
* @stable ICU 3.8
*/
public static final short REORDER_RUNS_ONLY = 3;
/** Reordering mode: Visual to Logical algorithm which handles numbers
* like L (same algorithm as selected by <code>setInverse(true)</code>.
* @see #setInverse
* @see #setReorderingMode
* @stable ICU 3.8
*/
public static final short REORDER_INVERSE_NUMBERS_AS_L = 4;
/** Reordering mode: Visual to Logical algorithm equivalent to the regular
* Logical to Visual algorithm.
* @see #setReorderingMode
* @stable ICU 3.8
*/
public static final short REORDER_INVERSE_LIKE_DIRECT = 5;
/** Reordering mode: Inverse Bidi (Visual to Logical) algorithm for the
* <code>REORDER_NUMBERS_SPECIAL</code> Bidi algorithm.
* @see #setReorderingMode
* @stable ICU 3.8
*/
public static final short REORDER_INVERSE_FOR_NUMBERS_SPECIAL = 6;
/**
* Option value for <code>setReorderingOptions</code>:
* disable all the options which can be set with this method
* @see #setReorderingOptions
* @stable ICU 3.8
*/
public static final int OPTION_DEFAULT = 0;
/**
* Option bit for <code>setReorderingOptions</code>:
* insert Bidi marks (LRM or RLM) when needed to ensure correct result of
* a reordering to a Logical order
*
* <p>This option must be set or reset before calling
* <code>setPara</code>.</p>
*
* <p>This option is significant only with reordering modes which generate
* a result with Logical order, specifically.</p>
* <ul>
* <li><code>REORDER_RUNS_ONLY</code></li>
* <li><code>REORDER_INVERSE_NUMBERS_AS_L</code></li>
* <li><code>REORDER_INVERSE_LIKE_DIRECT</code></li>
* <li><code>REORDER_INVERSE_FOR_NUMBERS_SPECIAL</code></li>
* </ul>
*
* <p>If this option is set in conjunction with reordering mode
* <code>REORDER_INVERSE_NUMBERS_AS_L</code> or with calling
* <code>setInverse(true)</code>, it implies option
* <code>INSERT_LRM_FOR_NUMERIC</code> in calls to method
* <code>writeReordered()</code>.</p>
*
* <p>For other reordering modes, a minimum number of LRM or RLM characters
* will be added to the source text after reordering it so as to ensure
* round trip, i.e. when applying the inverse reordering mode on the
* resulting logical text with removal of Bidi marks
* (option <code>OPTION_REMOVE_CONTROLS</code> set before calling
* <code>setPara()</code> or option
* <code>REMOVE_BIDI_CONTROLS</code> in
* <code>writeReordered</code>), the result will be identical to the
* source text in the first transformation.
*
* <p>This option will be ignored if specified together with option
* <code>OPTION_REMOVE_CONTROLS</code>. It inhibits option
* <code>REMOVE_BIDI_CONTROLS</code> in calls to method
* <code>writeReordered()</code> and it implies option
* <code>INSERT_LRM_FOR_NUMERIC</code> in calls to method
* <code>writeReordered()</code> if the reordering mode is
* <code>REORDER_INVERSE_NUMBERS_AS_L</code>.</p>
*
* @see #setReorderingMode
* @see #setReorderingOptions
* @see #INSERT_LRM_FOR_NUMERIC
* @see #REMOVE_BIDI_CONTROLS
* @see #OPTION_REMOVE_CONTROLS
* @see #REORDER_RUNS_ONLY
* @see #REORDER_INVERSE_NUMBERS_AS_L
* @see #REORDER_INVERSE_LIKE_DIRECT
* @see #REORDER_INVERSE_FOR_NUMBERS_SPECIAL
* @stable ICU 3.8
*/
public static final int OPTION_INSERT_MARKS = 1;
/**
* Option bit for <code>setReorderingOptions</code>:
* remove Bidi control characters
*
* <p>This option must be set or reset before calling
* <code>setPara</code>.</p>
*
* <p>This option nullifies option
* <code>OPTION_INSERT_MARKS</code>. It inhibits option
* <code>INSERT_LRM_FOR_NUMERIC</code> in calls to method
* <code>writeReordered()</code> and it implies option
* <code>REMOVE_BIDI_CONTROLS</code> in calls to that method.</p>
*
* @see #setReorderingMode
* @see #setReorderingOptions
* @see #OPTION_INSERT_MARKS
* @see #INSERT_LRM_FOR_NUMERIC
* @see #REMOVE_BIDI_CONTROLS
* @stable ICU 3.8
*/
public static final int OPTION_REMOVE_CONTROLS = 2;
/**
* Option bit for <code>setReorderingOptions</code>:
* process the output as part of a stream to be continued
*
* <p>This option must be set or reset before calling
* <code>setPara</code>.</p>
*
* <p>This option specifies that the caller is interested in processing
* large text object in parts. The results of the successive calls are
* expected to be concatenated by the caller. Only the call for the last
* part will have this option bit off.</p>
*
* <p>When this option bit is on, <code>setPara()</code> may process
* less than the full source text in order to truncate the text at a
* meaningful boundary. The caller should call
* <code>getProcessedLength()</code> immediately after calling
* <code>setPara()</code> in order to determine how much of the source
* text has been processed. Source text beyond that length should be
* resubmitted in following calls to <code>setPara</code>. The
* processed length may be less than the length of the source text if a
* character preceding the last character of the source text constitutes a
* reasonable boundary (like a block separator) for text to be continued.<br>
* If the last character of the source text constitutes a reasonable
* boundary, the whole text will be processed at once.<br>
* If nowhere in the source text there exists
* such a reasonable boundary, the processed length will be zero.<br>
* The caller should check for such an occurrence and do one of the following:
* <ul><li>submit a larger amount of text with a better chance to include
* a reasonable boundary.</li>
* <li>resubmit the same text after turning off option
* <code>OPTION_STREAMING</code>.</li></ul>
* In all cases, this option should be turned off before processing the last
* part of the text.</p>
*
* <p>When the <code>OPTION_STREAMING</code> option is used, it is
* recommended to call <code>orderParagraphsLTR(true)</code> before calling
* <code>setPara()</code> so that later paragraphs may be concatenated to
* previous paragraphs on the right.
* </p>
*
* @see #setReorderingMode
* @see #setReorderingOptions
* @see #getProcessedLength
* @stable ICU 3.8
*/
public static final int OPTION_STREAMING = 4;
/**
* Value returned by <code>BidiClassifier</code> when there is no need to
* override the standard Bidi class for a given code point.
* @see BidiClassifier
* @stable ICU 3.8
*/
public static final int CLASS_DEFAULT = 19; //UCharacterDirection.CHAR_DIRECTION_COUNT;
// /**
// * Allocate a <code>Bidi</code> object.
// * Such an object is initially empty. It is assigned
// * the Bidi properties of a piece of text containing one or more paragraphs
// * by <code>setPara()</code>
// * or the Bidi properties of a line within a paragraph by
// * <code>setLine()</code>.<p>
// * This object can be reused.<p>
// * <code>setPara()</code> and <code>setLine()</code> will allocate
// * additional memory for internal structures as necessary.
// *
// * @stable ICU 3.8
// */
// public Bidi()
// {
// throw new UnsupportedOperationException("Constructor not supported by com.ibm.icu.base");
// }
// /**
// * Allocate a <code>Bidi</code> object with preallocated memory
// * for internal structures.
// * This method provides a <code>Bidi</code> object like the default constructor
// * but it also preallocates memory for internal structures
// * according to the sizings supplied by the caller.<p>
// * The preallocation can be limited to some of the internal memory
// * by setting some values to 0 here. That means that if, e.g.,
// * <code>maxRunCount</code> cannot be reasonably predetermined and should not
// * be set to <code>maxLength</code> (the only failproof value) to avoid
// * wasting memory, then <code>maxRunCount</code> could be set to 0 here
// * and the internal structures that are associated with it will be allocated
// * on demand, just like with the default constructor.
// *
// * @param maxLength is the maximum text or line length that internal memory
// * will be preallocated for. An attempt to associate this object with a
// * longer text will fail, unless this value is 0, which leaves the allocation
// * up to the implementation.
// *
// * @param maxRunCount is the maximum anticipated number of same-level runs
// * that internal memory will be preallocated for. An attempt to access
// * visual runs on an object that was not preallocated for as many runs
// * as the text was actually resolved to will fail,
// * unless this value is 0, which leaves the allocation up to the implementation.<br><br>
// * The number of runs depends on the actual text and maybe anywhere between
// * 1 and <code>maxLength</code>. It is typically small.
// *
// * @throws IllegalArgumentException if maxLength or maxRunCount is less than 0
// * @stable ICU 3.8
// */
// public Bidi(int maxLength, int maxRunCount)
// {
// throw new UnsupportedOperationException("Constructor not supported by com.ibm.icu.base");
// }
// /**
// * Modify the operation of the Bidi algorithm such that it
// * approximates an "inverse Bidi" algorithm. This method
// * must be called before <code>setPara()</code>.
// *
// * <p>The normal operation of the Bidi algorithm as described
// * in the Unicode Technical Report is to take text stored in logical
// * (keyboard, typing) order and to determine the reordering of it for visual
// * rendering.
// * Some legacy systems store text in visual order, and for operations
// * with standard, Unicode-based algorithms, the text needs to be transformed
// * to logical order. This is effectively the inverse algorithm of the
// * described Bidi algorithm. Note that there is no standard algorithm for
// * this "inverse Bidi" and that the current implementation provides only an
// * approximation of "inverse Bidi".</p>
// *
// * <p>With <code>isInversed</code> set to <code>true</code>,
// * this method changes the behavior of some of the subsequent methods
// * in a way that they can be used for the inverse Bidi algorithm.
// * Specifically, runs of text with numeric characters will be treated in a
// * special way and may need to be surrounded with LRM characters when they are
// * written in reordered sequence.</p>
// *
// * <p>Output runs should be retrieved using <code>getVisualRun()</code>.
// * Since the actual input for "inverse Bidi" is visually ordered text and
// * <code>getVisualRun()</code> gets the reordered runs, these are actually
// * the runs of the logically ordered output.</p>
// *
// * <p>Calling this method with argument <code>isInverse</code> set to
// * <code>true</code> is equivalent to calling <code>setReorderingMode</code>
// * with argument <code>reorderingMode</code>
// * set to <code>REORDER_INVERSE_NUMBERS_AS_L</code>.<br>
// * Calling this method with argument <code>isInverse</code> set to
// * <code>false</code> is equivalent to calling <code>setReorderingMode</code>
// * with argument <code>reorderingMode</code>
// * set to <code>REORDER_DEFAULT</code>.
// *
// * @param isInverse specifies "forward" or "inverse" Bidi operation.
// *
// * @see #setPara
// * @see #writeReordered
// * @see #setReorderingMode
// * @see #REORDER_INVERSE_NUMBERS_AS_L
// * @see #REORDER_DEFAULT
// * @stable ICU 3.8
// */
// public void setInverse(boolean isInverse) {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
// /**
// * Is this <code>Bidi</code> object set to perform the inverse Bidi
// * algorithm?
// * <p>Note: calling this method after setting the reordering mode with
// * <code>setReorderingMode</code> will return <code>true</code> if the
// * reordering mode was set to
// * <code>REORDER_INVERSE_NUMBERS_AS_L<code>, <code>false</code>
// * for all other values.</p>
// *
// * @return <code>true</code> if the <code>Bidi</code> object is set to
// * perform the inverse Bidi algorithm by handling numbers as L.
// *
// * @see #setInverse
// * @see #setReorderingMode
// * @see #REORDER_INVERSE_NUMBERS_AS_L
// * @stable ICU 3.8
// */
// public boolean isInverse() {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
// /**
// * Modify the operation of the Bidi algorithm such that it implements some
// * variant to the basic Bidi algorithm or approximates an "inverse Bidi"
// * algorithm, depending on different values of the "reordering mode".
// * This method must be called before <code>setPara()</code>, and stays in
// * effect until called again with a different argument.
// *
// * <p>The normal operation of the Bidi algorithm as described in the Unicode
// * Standard Annex #9 is to take text stored in logical (keyboard, typing)
// * order and to determine how to reorder it for visual rendering.</p>
// *
// * <p>With the reordering mode set to a value other than
// * <code>REORDER_DEFAULT</code>, this method changes the behavior of some of
// * the subsequent methods in a way such that they implement an inverse Bidi
// * algorithm or some other algorithm variants.</p>
// *
// * <p>Some legacy systems store text in visual order, and for operations
// * with standard, Unicode-based algorithms, the text needs to be transformed
// * into logical order. This is effectively the inverse algorithm of the
// * described Bidi algorithm. Note that there is no standard algorithm for
// * this "inverse Bidi", so a number of variants are implemented here.</p>
// *
// * <p>In other cases, it may be desirable to emulate some variant of the
// * Logical to Visual algorithm (e.g. one used in MS Windows), or perform a
// * Logical to Logical transformation.</p>
// *
// * <ul>
// * <li>When the Reordering Mode is set to
// * <code>REORDER_DEFAULT</code>,
// * the standard Bidi Logical to Visual algorithm is applied.</li>
// *
// * <li>When the reordering mode is set to
// * <code>REORDER_NUMBERS_SPECIAL</code>,
// * the algorithm used to perform Bidi transformations when calling
// * <code>setPara</code> should approximate the algorithm used in Microsoft
// * Windows XP rather than strictly conform to the Unicode Bidi algorithm.
// * <br>
// * The differences between the basic algorithm and the algorithm addressed
// * by this option are as follows:
// * <ul>
// * <li>Within text at an even embedding level, the sequence "123AB"
// * (where AB represent R or AL letters) is transformed to "123BA" by the
// * Unicode algorithm and to "BA123" by the Windows algorithm.</li>
// *
// * <li>Arabic-Indic numbers (AN) are handled by the Windows algorithm just
// * like regular numbers (EN).</li>
// * </ul></li>
// *
// * <li>When the reordering mode is set to
// * <code>REORDER_GROUP_NUMBERS_WITH_R</code>,
// * numbers located between LTR text and RTL text are associated with the RTL
// * text. For instance, an LTR paragraph with content "abc 123 DEF" (where
// * upper case letters represent RTL characters) will be transformed to
// * "abc FED 123" (and not "abc 123 FED"), "DEF 123 abc" will be transformed
// * to "123 FED abc" and "123 FED abc" will be transformed to "DEF 123 abc".
// * This makes the algorithm reversible and makes it useful when round trip
// * (from visual to logical and back to visual) must be achieved without
// * adding LRM characters. However, this is a variation from the standard
// * Unicode Bidi algorithm.<br>
// * The source text should not contain Bidi control characters other than LRM
// * or RLM.</li>
// *
// * <li>When the reordering mode is set to
// * <code>REORDER_RUNS_ONLY</code>,
// * a "Logical to Logical" transformation must be performed:
// * <ul>
// * <li>If the default text level of the source text (argument
// * <code>paraLevel</code> in <code>setPara</code>) is even, the source text
// * will be handled as LTR logical text and will be transformed to the RTL
// * logical text which has the same LTR visual display.</li>
// * <li>If the default level of the source text is odd, the source text
// * will be handled as RTL logical text and will be transformed to the
// * LTR logical text which has the same LTR visual display.</li>
// * </ul>
// * This mode may be needed when logical text which is basically Arabic or
// * Hebrew, with possible included numbers or phrases in English, has to be
// * displayed as if it had an even embedding level (this can happen if the
// * displaying application treats all text as if it was basically LTR).
// * <br>
// * This mode may also be needed in the reverse case, when logical text which
// * is basically English, with possible included phrases in Arabic or Hebrew,
// * has to be displayed as if it had an odd embedding level.
// * <br>
// * Both cases could be handled by adding LRE or RLE at the head of the
// * text, if the display subsystem supports these formatting controls. If it
// * does not, the problem may be handled by transforming the source text in
// * this mode before displaying it, so that it will be displayed properly.
// * <br>
// * The source text should not contain Bidi control characters other than LRM
// * or RLM.</li>
// *
// * <li>When the reordering mode is set to
// * <code>REORDER_INVERSE_NUMBERS_AS_L</code>, an "inverse Bidi"
// * algorithm is applied.
// * Runs of text with numeric characters will be treated like LTR letters and
// * may need to be surrounded with LRM characters when they are written in
// * reordered sequence (the option <code>INSERT_LRM_FOR_NUMERIC</code> can
// * be used with method <code>writeReordered</code> to this end. This mode
// * is equivalent to calling <code>setInverse()</code> with
// * argument <code>isInverse</code> set to <code>true</code>.</li>
// *
// * <li>When the reordering mode is set to
// * <code>REORDER_INVERSE_LIKE_DIRECT</code>, the "direct" Logical to
// * Visual Bidi algorithm is used as an approximation of an "inverse Bidi"
// * algorithm. This mode is similar to mode
// * <code>REORDER_INVERSE_NUMBERS_AS_L</code> but is closer to the
// * regular Bidi algorithm.
// * <br>
// * For example, an LTR paragraph with the content "FED 123 456 CBA" (where
// * upper case represents RTL characters) will be transformed to
// * "ABC 456 123 DEF", as opposed to "DEF 123 456 ABC"
// * with mode <code>REORDER_INVERSE_NUMBERS_AS_L</code>.<br>
// * When used in conjunction with option
// * <code>OPTION_INSERT_MARKS</code>, this mode generally
// * adds Bidi marks to the output significantly more sparingly than mode
// * <code>REORDER_INVERSE_NUMBERS_AS_L</code>.<br> with option
// * <code>INSERT_LRM_FOR_NUMERIC</code> in calls to
// * <code>writeReordered</code>.</li>
// *
// * <li>When the reordering mode is set to
// * <code>REORDER_INVERSE_FOR_NUMBERS_SPECIAL</code>, the Logical to Visual
// * Bidi algorithm used in Windows XP is used as an approximation of an "inverse
// * Bidi" algorithm.
// * <br>
// * For example, an LTR paragraph with the content "abc FED123" (where
// * upper case represents RTL characters) will be transformed to
// * "abc 123DEF.</li>
// * </ul>
// *
// * <p>In all the reordering modes specifying an "inverse Bidi" algorithm
// * (i.e. those with a name starting with <code>REORDER_INVERSE</code>),
// * output runs should be retrieved using <code>getVisualRun()</code>, and
// * the output text with <code>writeReordered()</code>. The caller should
// * keep in mind that in "inverse Bidi" modes the input is actually visually
// * ordered text and reordered output returned by <code>getVisualRun()</code>
// * or <code>writeReordered()</code> are actually runs or character string
// * of logically ordered output.<br>
// * For all the "inverse Bidi" modes, the source text should not contain
// * Bidi control characters other than LRM or RLM.</p>
// *
// * <p>Note that option <code>OUTPUT_REVERSE</code> of
// * <code>writeReordered</code> has no useful meaning and should not be used
// * in conjunction with any value of the reordering mode specifying "inverse
// * Bidi" or with value <code>REORDER_RUNS_ONLY</code>.
// *
// * @param reorderingMode specifies the required variant of the Bidi
// * algorithm.
// *
// * @see #setInverse
// * @see #setPara
// * @see #writeReordered
// * @see #INSERT_LRM_FOR_NUMERIC
// * @see #OUTPUT_REVERSE
// * @see #REORDER_DEFAULT
// * @see #REORDER_NUMBERS_SPECIAL
// * @see #REORDER_GROUP_NUMBERS_WITH_R
// * @see #REORDER_RUNS_ONLY
// * @see #REORDER_INVERSE_NUMBERS_AS_L
// * @see #REORDER_INVERSE_LIKE_DIRECT
// * @see #REORDER_INVERSE_FOR_NUMBERS_SPECIAL
// * @stable ICU 3.8
// */
// public void setReorderingMode(int reorderingMode) {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
// /**
// * What is the requested reordering mode for a given Bidi object?
// *
// * @return the current reordering mode of the Bidi object
// *
// * @see #setReorderingMode
// * @stable ICU 3.8
// */
// public int getReorderingMode() {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
// /**
// * Specify which of the reordering options should be applied during Bidi
// * transformations.
// *
// * @param options A combination of zero or more of the following
// * reordering options:
// * <code>OPTION_DEFAULT</code>, <code>OPTION_INSERT_MARKS</code>,
// * <code>OPTION_REMOVE_CONTROLS</code>, <code>OPTION_STREAMING</code>.
// *
// * @see #getReorderingOptions
// * @see #OPTION_DEFAULT
// * @see #OPTION_INSERT_MARKS
// * @see #OPTION_REMOVE_CONTROLS
// * @see #OPTION_STREAMING
// * @stable ICU 3.8
// */
// public void setReorderingOptions(int options) {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
// /**
// * What are the reordering options applied to a given Bidi object?
// *
// * @return the current reordering options of the Bidi object
// *
// * @see #setReorderingOptions
// * @stable ICU 3.8
// */
// public int getReorderingOptions() {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
// /**
// * Perform the Unicode Bidi algorithm. It is defined in the
// * <a href="http://www.unicode.org/unicode/reports/tr9/">Unicode Standard Annex #9</a>,
// * version 13,
// * also described in The Unicode Standard, Version 4.0 .<p>
// *
// * This method takes a piece of plain text containing one or more paragraphs,
// * with or without externally specified embedding levels from <i>styled</i>
// * text and computes the left-right-directionality of each character.<p>
// *
// * If the entire text is all of the same directionality, then
// * the method may not perform all the steps described by the algorithm,
// * i.e., some levels may not be the same as if all steps were performed.
// * This is not relevant for unidirectional text.<br>
// * For example, in pure LTR text with numbers the numbers would get
// * a resolved level of 2 higher than the surrounding text according to
// * the algorithm. This implementation may set all resolved levels to
// * the same value in such a case.<p>
// *
// * The text can be composed of multiple paragraphs. Occurrence of a block
// * separator in the text terminates a paragraph, and whatever comes next starts
// * a new paragraph. The exception to this rule is when a Carriage Return (CR)
// * is followed by a Line Feed (LF). Both CR and LF are block separators, but
// * in that case, the pair of characters is considered as terminating the
// * preceding paragraph, and a new paragraph will be started by a character
// * coming after the LF.
// *
// * Although the text is passed here as a <code>String</code>, it is
// * stored internally as an array of characters. Therefore the
// * documentation will refer to indexes of the characters in the text.
// *
// * @param text contains the text that the Bidi algorithm will be performed
// * on. This text can be retrieved with <code>getText()</code> or
// * <code>getTextAsString</code>.<br>
// *
// * @param paraLevel specifies the default level for the text;
// * it is typically 0 (LTR) or 1 (RTL).
// * If the method shall determine the paragraph level from the text,
// * then <code>paraLevel</code> can be set to
// * either <code>LEVEL_DEFAULT_LTR</code>
// * or <code>LEVEL_DEFAULT_RTL</code>; if the text contains multiple
// * paragraphs, the paragraph level shall be determined separately for
// * each paragraph; if a paragraph does not include any strongly typed
// * character, then the desired default is used (0 for LTR or 1 for RTL).
// * Any other value between 0 and <code>MAX_EXPLICIT_LEVEL</code>
// * is also valid, with odd levels indicating RTL.
// *
// * @param embeddingLevels (in) may be used to preset the embedding and override levels,
// * ignoring characters like LRE and PDF in the text.
// * A level overrides the directional property of its corresponding
// * (same index) character if the level has the
// * <code>LEVEL_OVERRIDE</code> bit set.<br><br>
// * Except for that bit, it must be
// * <code>paraLevel<=embeddingLevels[]<=MAX_EXPLICIT_LEVEL</code>,
// * with one exception: a level of zero may be specified for a
// * paragraph separator even if <code>paraLevel&gt;0</code> when multiple
// * paragraphs are submitted in the same call to <code>setPara()</code>.<br><br>
// * <strong>Caution: </strong>A reference to this array, not a copy
// * of the levels, will be stored in the <code>Bidi</code> object;
// * the <code>embeddingLevels</code>
// * should not be modified to avoid unexpected results on subsequent
// * Bidi operations. However, the <code>setPara()</code> and
// * <code>setLine()</code> methods may modify some or all of the
// * levels.<br><br>
// * <strong>Note:</strong> the <code>embeddingLevels</code> array must
// * have one entry for each character in <code>text</code>.
// *
// * @throws IllegalArgumentException if the values in embeddingLevels are
// * not within the allowed range
// *
// * @see #LEVEL_DEFAULT_LTR
// * @see #LEVEL_DEFAULT_RTL
// * @see #LEVEL_OVERRIDE
// * @see #MAX_EXPLICIT_LEVEL
// * @stable ICU 3.8
// */
// public void setPara(String text, byte paraLevel, byte[] embeddingLevels)
// {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
// /**
// * Perform the Unicode Bidi algorithm. It is defined in the
// * <a href="http://www.unicode.org/unicode/reports/tr9/">Unicode Standard Annex #9</a>,
// * version 13,
// * also described in The Unicode Standard, Version 4.0 .<p>
// *
// * This method takes a piece of plain text containing one or more paragraphs,
// * with or without externally specified embedding levels from <i>styled</i>
// * text and computes the left-right-directionality of each character.<p>
// *
// * If the entire text is all of the same directionality, then
// * the method may not perform all the steps described by the algorithm,
// * i.e., some levels may not be the same as if all steps were performed.
// * This is not relevant for unidirectional text.<br>
// * For example, in pure LTR text with numbers the numbers would get
// * a resolved level of 2 higher than the surrounding text according to
// * the algorithm. This implementation may set all resolved levels to
// * the same value in such a case.<p>
// *
// * The text can be composed of multiple paragraphs. Occurrence of a block
// * separator in the text terminates a paragraph, and whatever comes next starts
// * a new paragraph. The exception to this rule is when a Carriage Return (CR)
// * is followed by a Line Feed (LF). Both CR and LF are block separators, but
// * in that case, the pair of characters is considered as terminating the
// * preceding paragraph, and a new paragraph will be started by a character
// * coming after the LF.
// *
// * The text is stored internally as an array of characters. Therefore the
// * documentation will refer to indexes of the characters in the text.
// *
// * @param chars contains the text that the Bidi algorithm will be performed
// * on. This text can be retrieved with <code>getText()</code> or
// * <code>getTextAsString</code>.<br>
// *
// * @param paraLevel specifies the default level for the text;
// * it is typically 0 (LTR) or 1 (RTL).
// * If the method shall determine the paragraph level from the text,
// * then <code>paraLevel</code> can be set to
// * either <code>LEVEL_DEFAULT_LTR</code>
// * or <code>LEVEL_DEFAULT_RTL</code>; if the text contains multiple
// * paragraphs, the paragraph level shall be determined separately for
// * each paragraph; if a paragraph does not include any strongly typed
// * character, then the desired default is used (0 for LTR or 1 for RTL).
// * Any other value between 0 and <code>MAX_EXPLICIT_LEVEL</code>
// * is also valid, with odd levels indicating RTL.
// *
// * @param embeddingLevels (in) may be used to preset the embedding and
// * override levels, ignoring characters like LRE and PDF in the text.
// * A level overrides the directional property of its corresponding
// * (same index) character if the level has the
// * <code>LEVEL_OVERRIDE</code> bit set.<br><br>
// * Except for that bit, it must be
// * <code>paraLevel<=embeddingLevels[]<=MAX_EXPLICIT_LEVEL</code>,
// * with one exception: a level of zero may be specified for a
// * paragraph separator even if <code>paraLevel&gt;0</code> when multiple
// * paragraphs are submitted in the same call to <code>setPara()</code>.<br><br>
// * <strong>Caution: </strong>A reference to this array, not a copy
// * of the levels, will be stored in the <code>Bidi</code> object;
// * the <code>embeddingLevels</code>
// * should not be modified to avoid unexpected results on subsequent
// * Bidi operations. However, the <code>setPara()</code> and
// * <code>setLine()</code> methods may modify some or all of the
// * levels.<br><br>
// * <strong>Note:</strong> the <code>embeddingLevels</code> array must
// * have one entry for each character in <code>text</code>.
// *
// * @throws IllegalArgumentException if the values in embeddingLevels are
// * not within the allowed range
// *
// * @see #LEVEL_DEFAULT_LTR
// * @see #LEVEL_DEFAULT_RTL
// * @see #LEVEL_OVERRIDE
// * @see #MAX_EXPLICIT_LEVEL
// * @stable ICU 3.8
// */
// public void setPara(char[] chars, byte paraLevel, byte[] embeddingLevels)
// {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
// /**
// * Perform the Unicode Bidi algorithm on a given paragraph, as defined in the
// * <a href="http://www.unicode.org/unicode/reports/tr9/">Unicode Standard Annex #9</a>,
// * version 13,
// * also described in The Unicode Standard, Version 4.0 .<p>
// *
// * This method takes a paragraph of text and computes the
// * left-right-directionality of each character. The text should not
// * contain any Unicode block separators.<p>
// *
// * The RUN_DIRECTION attribute in the text, if present, determines the base
// * direction (left-to-right or right-to-left). If not present, the base
// * direction is computed using the Unicode Bidirectional Algorithm,
// * defaulting to left-to-right if there are no strong directional characters
// * in the text. This attribute, if present, must be applied to all the text
// * in the paragraph.<p>
// *
// * The BIDI_EMBEDDING attribute in the text, if present, represents
// * embedding level information. Negative values from -1 to -62 indicate
// * overrides at the absolute value of the level. Positive values from 1 to
// * 62 indicate embeddings. Where values are zero or not defined, the base
// * embedding level as determined by the base direction is assumed.<p>
// *
// * The NUMERIC_SHAPING attribute in the text, if present, converts European
// * digits to other decimal digits before running the bidi algorithm. This
// * attribute, if present, must be applied to all the text in the paragraph.
// *
// * If the entire text is all of the same directionality, then
// * the method may not perform all the steps described by the algorithm,
// * i.e., some levels may not be the same as if all steps were performed.
// * This is not relevant for unidirectional text.<br>
// * For example, in pure LTR text with numbers the numbers would get
// * a resolved level of 2 higher than the surrounding text according to
// * the algorithm. This implementation may set all resolved levels to
// * the same value in such a case.<p>
// *
// * @param paragraph a paragraph of text with optional character and
// * paragraph attribute information
// * @stable ICU 3.8
// */
// public void setPara(AttributedCharacterIterator paragraph)
// {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
// /**
// * Specify whether block separators must be allocated level zero,
// * so that successive paragraphs will progress from left to right.
// * This method must be called before <code>setPara()</code>.
// * Paragraph separators (B) may appear in the text. Setting them to level zero
// * means that all paragraph separators (including one possibly appearing
// * in the last text position) are kept in the reordered text after the text
// * that they follow in the source text.
// * When this feature is not enabled, a paragraph separator at the last
// * position of the text before reordering will go to the first position
// * of the reordered text when the paragraph level is odd.
// *
// * @param ordarParaLTR specifies whether paragraph separators (B) must
// * receive level 0, so that successive paragraphs progress from left to right.
// *
// * @see #setPara
// * @stable ICU 3.8
// */
// public void orderParagraphsLTR(boolean ordarParaLTR) {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
// /**
// * Is this <code>Bidi</code> object set to allocate level 0 to block
// * separators so that successive paragraphs progress from left to right?
// *
// * @return <code>true</code> if the <code>Bidi</code> object is set to
// * allocate level 0 to block separators.
// *
// * @stable ICU 3.8
// */
// public boolean isOrderParagraphsLTR() {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
// /**
// * Get the directionality of the text.
// *
// * @return a value of <code>LTR</code>, <code>RTL</code> or <code>MIXED</code>
// * that indicates if the entire text
// * represented by this object is unidirectional,
// * and which direction, or if it is mixed-directional.
// *
// * @throws IllegalStateException if this call is not preceded by a successful
// * call to <code>setPara</code> or <code>setLine</code>
// *
// * @see #LTR
// * @see #RTL
// * @see #MIXED
// * @stable ICU 3.8
// */
// public byte getDirection()
// {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
// /**
// * Get the text.
// *
// * @return A <code>String</code> containing the text that the
// * <code>Bidi</code> object was created for.
// *
// * @throws IllegalStateException if this call is not preceded by a successful
// * call to <code>setPara</code> or <code>setLine</code>
// *
// * @see #setPara
// * @see #setLine
// * @stable ICU 3.8
// */
// public String getTextAsString()
// {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
// /**
// * Get the text.
// *
// * @return A <code>char</code> array containing the text that the
// * <code>Bidi</code> object was created for.
// *
// * @throws IllegalStateException if this call is not preceded by a successful
// * call to <code>setPara</code> or <code>setLine</code>
// *
// * @see #setPara
// * @see #setLine
// * @stable ICU 3.8
// */
// public char[] getText()
// {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
/**
* Get the length of the text.
*
* @return The length of the text that the <code>Bidi</code> object was
* created for.
*
* @throws IllegalStateException if this call is not preceded by a successful
* call to <code>setPara</code> or <code>setLine</code>
* @stable ICU 3.8
*/
public int getLength()
{
return bidi.getLength();
}
// /**
// * Get the length of the source text processed by the last call to
// * <code>setPara()</code>. This length may be different from the length of
// * the source text if option <code>OPTION_STREAMING</code> has been
// * set.
// * <br>
// * Note that whenever the length of the text affects the execution or the
// * result of a method, it is the processed length which must be considered,
// * except for <code>setPara</code> (which receives unprocessed source text)
// * and <code>getLength</code> (which returns the original length of the
// * source text).<br>
// * In particular, the processed length is the one to consider in the
// * following cases:
// * <ul>
// * <li>maximum value of the <code>limit</code> argument of
// * <code>setLine</code></li>
// * <li>maximum value of the <code>charIndex</code> argument of
// * <code>getParagraph</code></li>
// * <li>maximum value of the <code>charIndex</code> argument of
// * <code>getLevelAt</code></li>
// * <li>number of elements in the array returned by <code>getLevels</code>
// * </li>
// * <li>maximum value of the <code>logicalStart</code> argument of
// * <code>getLogicalRun</code></li>
// * <li>maximum value of the <code>logicalIndex</code> argument of
// * <code>getVisualIndex</code></li>
// * <li>number of elements returned by <code>getLogicalMap</code></li>
// * <li>length of text processed by <code>writeReordered</code></li>
// * </ul>
// *
// * @return The length of the part of the source text processed by
// * the last call to <code>setPara</code>.
// *
// * @throws IllegalStateException if this call is not preceded by a successful
// * call to <code>setPara</code> or <code>setLine</code>
// *
// * @see #setPara
// * @see #OPTION_STREAMING
// * @stable ICU 3.8
// */
// public int getProcessedLength() {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
// /**
// * Get the length of the reordered text resulting from the last call to
// * <code>setPara()</code>. This length may be different from the length
// * of the source text if option <code>OPTION_INSERT_MARKS</code>
// * or option <code>OPTION_REMOVE_CONTROLS</code> has been set.
// * <br>
// * This resulting length is the one to consider in the following cases:
// * <ul>
// * <li>maximum value of the <code>visualIndex</code> argument of
// * <code>getLogicalIndex</code></li>
// * <li>number of elements returned by <code>getVisualMap</code></li>
// * </ul>
// * Note that this length stays identical to the source text length if
// * Bidi marks are inserted or removed using option bits of
// * <code>writeReordered</code>, or if option
// * <code>REORDER_INVERSE_NUMBERS_AS_L</code> has been set.
// *
// * @return The length of the reordered text resulting from
// * the last call to <code>setPara</code>.
// *
// * @throws IllegalStateException if this call is not preceded by a successful
// * call to <code>setPara</code> or <code>setLine</code>
// *
// * @see #setPara
// * @see #OPTION_INSERT_MARKS
// * @see #OPTION_REMOVE_CONTROLS
// * @see #REORDER_INVERSE_NUMBERS_AS_L
// * @stable ICU 3.8
// */
// public int getResultLength() {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
/* paragraphs API methods ------------------------------------------------- */
// /**
// * Get the paragraph level of the text.
// *
// * @return The paragraph level. If there are multiple paragraphs, their
// * level may vary if the required paraLevel is LEVEL_DEFAULT_LTR or
// * LEVEL_DEFAULT_RTL. In that case, the level of the first paragraph
// * is returned.
// *
// * @throws IllegalStateException if this call is not preceded by a successful
// * call to <code>setPara</code> or <code>setLine</code>
// *
// * @see #LEVEL_DEFAULT_LTR
// * @see #LEVEL_DEFAULT_RTL
// * @see #getParagraph
// * @see #getParagraphByIndex
// * @stable ICU 3.8
// */
// public byte getParaLevel()
// {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
// /**
// * Get the number of paragraphs.
// *
// * @return The number of paragraphs.
// *
// * @throws IllegalStateException if this call is not preceded by a successful
// * call to <code>setPara</code> or <code>setLine</code>
// * @stable ICU 3.8
// */
// public int countParagraphs()
// {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
// /**
// * Get a paragraph, given the index of this paragraph.
// *
// * This method returns information about a paragraph.<p>
// *
// * @param paraIndex is the number of the paragraph, in the
// * range <code>[0..countParagraphs()-1]</code>.
// *
// * @return a BidiRun object with the details of the paragraph:<br>
// * <code>start</code> will receive the index of the first character
// * of the paragraph in the text.<br>
// * <code>limit</code> will receive the limit of the paragraph.<br>
// * <code>embeddingLevel</code> will receive the level of the paragraph.
// *
// * @throws IllegalStateException if this call is not preceded by a successful
// * call to <code>setPara</code> or <code>setLine</code>
// * @throws IllegalArgumentException if paraIndex is not in the range
// * <code>[0..countParagraphs()-1]</code>
// *
// * @see com.ibm.icu.text.BidiRun
// * @stable ICU 3.8
// */
// public BidiRun getParagraphByIndex(int paraIndex)
// {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
// /**
// * Get a paragraph, given a position within the text.
// * This method returns information about a paragraph.<br>
// * Note: if the paragraph index is known, it is more efficient to
// * retrieve the paragraph information using getParagraphByIndex().<p>
// *
// * @param charIndex is the index of a character within the text, in the
// * range <code>[0..getProcessedLength()-1]</code>.
// *
// * @return a BidiRun object with the details of the paragraph:<br>
// * <code>start</code> will receive the index of the first character
// * of the paragraph in the text.<br>
// * <code>limit</code> will receive the limit of the paragraph.<br>
// * <code>embeddingLevel</code> will receive the level of the paragraph.
// *
// * @throws IllegalStateException if this call is not preceded by a successful
// * call to <code>setPara</code> or <code>setLine</code>
// * @throws IllegalArgumentException if charIndex is not within the legal range
// *
// * @see com.ibm.icu.text.BidiRun
// * @see #getParagraphByIndex
// * @see #getProcessedLength
// * @stable ICU 3.8
// */
// public BidiRun getParagraph(int charIndex)
// {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
// /**
// * Get the index of a paragraph, given a position within the text.<p>
// *
// * @param charIndex is the index of a character within the text, in the
// * range <code>[0..getProcessedLength()-1]</code>.
// *
// * @return The index of the paragraph containing the specified position,
// * starting from 0.
// *
// * @throws IllegalStateException if this call is not preceded by a successful
// * call to <code>setPara</code> or <code>setLine</code>
// * @throws IllegalArgumentException if charIndex is not within the legal range
// *
// * @see com.ibm.icu.text.BidiRun
// * @see #getProcessedLength
// * @stable ICU 3.8
// */
// public int getParagraphIndex(int charIndex)
// {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
// /**
// * Set a custom Bidi classifier used by the UBA implementation for Bidi
// * class determination.
// *
// * @param classifier A new custom classifier. This can be null.
// *
// * @see #getCustomClassifier
// * @stable ICU 3.8
// */
// public void setCustomClassifier(BidiClassifier classifier) {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
// /**
// * Gets the current custom class classifier used for Bidi class
// * determination.
// *
// * @return An instance of class <code>BidiClassifier</code>
// *
// * @see #setCustomClassifier
// * @stable ICU 3.8
// */
// public BidiClassifier getCustomClassifier() {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
// /**
// * Retrieves the Bidi class for a given code point.
// * <p>If a <code>BidiClassifier</code> is defined and returns a value
// * other than <code>CLASS_DEFAULT</code>, that value is used; otherwise
// * the default class determination mechanism is invoked.</p>
// *
// * @param c The code point to get a Bidi class for.
// *
// * @return The Bidi class for the character <code>c</code> that is in effect
// * for this <code>Bidi</code> instance.
// *
// * @see BidiClassifier
// * @stable ICU 3.8
// */
// public int getCustomizedClass(int c) {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
// /**
// * <code>setLine()</code> returns a <code>Bidi</code> object to
// * contain the reordering information, especially the resolved levels,
// * for all the characters in a line of text. This line of text is
// * specified by referring to a <code>Bidi</code> object representing
// * this information for a piece of text containing one or more paragraphs,
// * and by specifying a range of indexes in this text.<p>
// * In the new line object, the indexes will range from 0 to <code>limit-start-1</code>.<p>
// *
// * This is used after calling <code>setPara()</code>
// * for a piece of text, and after line-breaking on that text.
// * It is not necessary if each paragraph is treated as a single line.<p>
// *
// * After line-breaking, rules (L1) and (L2) for the treatment of
// * trailing WS and for reordering are performed on
// * a <code>Bidi</code> object that represents a line.<p>
// *
// * <strong>Important: </strong>the line <code>Bidi</code> object may
// * reference data within the global text <code>Bidi</code> object.
// * You should not alter the content of the global text object until
// * you are finished using the line object.
// *
// * @param start is the line's first index into the text.
// *
// * @param limit is just behind the line's last index into the text
// * (its last index +1).
// *
// * @return a <code>Bidi</code> object that will now represent a line of the text.
// *
// * @throws IllegalStateException if this call is not preceded by a successful
// * call to <code>setPara</code>
// * @throws IllegalArgumentException if start and limit are not in the range
// * <code>0&lt;=start&lt;limit&lt;=getProcessedLength()</code>,
// * or if the specified line crosses a paragraph boundary
// *
// * @see #setPara
// * @see #getProcessedLength
// * @stable ICU 3.8
// */
// public Bidi setLine(int start, int limit)
// {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
/**
* Get the level for one character.
*
* @param charIndex the index of a character.
*
* @return The level for the character at <code>charIndex</code>.
*
* @throws IllegalStateException if this call is not preceded by a successful
* call to <code>setPara</code> or <code>setLine</code>
* @throws IllegalArgumentException if charIndex is not in the range
* <code>0&lt;=charIndex&lt;getProcessedLength()</code>
*
* @see #getProcessedLength
* @stable ICU 3.8
*/
public byte getLevelAt(int charIndex)
{
return (byte)bidi.getLevelAt(charIndex);
}
// /**
// * Get an array of levels for each character.<p>
// *
// * Note that this method may allocate memory under some
// * circumstances, unlike <code>getLevelAt()</code>.
// *
// * @return The levels array for the text,
// * or <code>null</code> if an error occurs.
// *
// * @throws IllegalStateException if this call is not preceded by a successful
// * call to <code>setPara</code> or <code>setLine</code>
// * @stable ICU 3.8
// */
// public byte[] getLevels()
// {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
// /**
// * Get a logical run.
// * This method returns information about a run and is used
// * to retrieve runs in logical order.<p>
// * This is especially useful for line-breaking on a paragraph.
// *
// * @param logicalPosition is a logical position within the source text.
// *
// * @return a BidiRun object filled with <code>start</code> containing
// * the first character of the run, <code>limit</code> containing
// * the limit of the run, and <code>embeddingLevel</code> containing
// * the level of the run.
// *
// * @throws IllegalStateException if this call is not preceded by a successful
// * call to <code>setPara</code> or <code>setLine</code>
// * @throws IllegalArgumentException if logicalPosition is not in the range
// * <code>0&lt;=logicalPosition&lt;getProcessedLength()</code>
// *
// * @see com.ibm.icu.text.BidiRun
// * @see com.ibm.icu.text.BidiRun#getStart()
// * @see com.ibm.icu.text.BidiRun#getLimit()
// * @see com.ibm.icu.text.BidiRun#getEmbeddingLevel()
// *
// * @stable ICU 3.8
// */
// public BidiRun getLogicalRun(int logicalPosition)
// {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
// /**
// * Get the number of runs.
// * This method may invoke the actual reordering on the
// * <code>Bidi</code> object, after <code>setPara()</code>
// * may have resolved only the levels of the text. Therefore,
// * <code>countRuns()</code> may have to allocate memory,
// * and may throw an exception if it fails to do so.
// *
// * @return The number of runs.
// *
// * @throws IllegalStateException if this call is not preceded by a successful
// * call to <code>setPara</code> or <code>setLine</code>
// * @stable ICU 3.8
// */
// public int countRuns()
// {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
// /**
// *
// * Get a <code>BidiRun</code> object according to its index. BidiRun methods
// * may be used to retrieve the run's logical start, length and level,
// * which can be even for an LTR run or odd for an RTL run.
// * In an RTL run, the character at the logical start is
// * visually on the right of the displayed run.
// * The length is the number of characters in the run.<p>
// * <code>countRuns()</code> is normally called
// * before the runs are retrieved.
// *
// * <p>
// * Example:
// * <pre>
// * Bidi bidi = new Bidi();
// * String text = "abc 123 DEFG xyz";
// * bidi.setPara(text, Bidi.RTL, null);
// * int i, count=bidi.countRuns(), logicalStart, visualIndex=0, length;
// * BidiRun run;
// * for (i = 0; i &lt; count; ++i) {
// * run = bidi.getVisualRun(i);
// * logicalStart = run.getStart();
// * length = run.getLength();
// * if (Bidi.LTR == run.getEmbeddingLevel()) {
// * do { // LTR
// * show_char(text.charAt(logicalStart++), visualIndex++);
// * } while (--length &gt; 0);
// * } else {
// * logicalStart += length; // logicalLimit
// * do { // RTL
// * show_char(text.charAt(--logicalStart), visualIndex++);
// * } while (--length &gt; 0);
// * }
// * }
// * </pre>
// * <p>
// * Note that in right-to-left runs, code like this places
// * second surrogates before first ones (which is generally a bad idea)
// * and combining characters before base characters.
// * <p>
// * Use of <code>{@link #writeReordered}</code>, optionally with the
// * <code>{@link #KEEP_BASE_COMBINING}</code> option, can be considered in
// * order to avoid these issues.
// *
// * @param runIndex is the number of the run in visual order, in the
// * range <code>[0..countRuns()-1]</code>.
// *
// * @return a BidiRun object containing the details of the run. The
// * directionality of the run is
// * <code>LTR==0</code> or <code>RTL==1</code>,
// * never <code>MIXED</code>.
// *
// * @throws IllegalStateException if this call is not preceded by a successful
// * call to <code>setPara</code> or <code>setLine</code>
// * @throws IllegalArgumentException if <code>runIndex</code> is not in
// * the range <code>0&lt;=runIndex&lt;countRuns()</code>
// *
// * @see #countRuns()
// * @see com.ibm.icu.text.BidiRun
// * @see com.ibm.icu.text.BidiRun#getStart()
// * @see com.ibm.icu.text.BidiRun#getLength()
// * @see com.ibm.icu.text.BidiRun#getEmbeddingLevel()
// * @stable ICU 3.8
// */
// public BidiRun getVisualRun(int runIndex)
// {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
// /**
// * Get the visual position from a logical text position.
// * If such a mapping is used many times on the same
// * <code>Bidi</code> object, then calling
// * <code>getLogicalMap()</code> is more efficient.
// * <p>
// * The value returned may be <code>MAP_NOWHERE</code> if there is no
// * visual position because the corresponding text character is a Bidi
// * control removed from output by the option
// * <code>OPTION_REMOVE_CONTROLS</code>.
// * <p>
// * When the visual output is altered by using options of
// * <code>writeReordered()</code> such as <code>INSERT_LRM_FOR_NUMERIC</code>,
// * <code>KEEP_BASE_COMBINING</code>, <code>OUTPUT_REVERSE</code>,
// * <code>REMOVE_BIDI_CONTROLS</code>, the visual position returned may not
// * be correct. It is advised to use, when possible, reordering options
// * such as {@link #OPTION_INSERT_MARKS} and {@link #OPTION_REMOVE_CONTROLS}.
// * <p>
// * Note that in right-to-left runs, this mapping places
// * second surrogates before first ones (which is generally a bad idea)
// * and combining characters before base characters.
// * Use of <code>{@link #writeReordered}</code>, optionally with the
// * <code>{@link #KEEP_BASE_COMBINING}</code> option can be considered instead
// * of using the mapping, in order to avoid these issues.
// *
// * @param logicalIndex is the index of a character in the text.
// *
// * @return The visual position of this character.
// *
// * @throws IllegalStateException if this call is not preceded by a successful
// * call to <code>setPara</code> or <code>setLine</code>
// * @throws IllegalArgumentException if <code>logicalIndex</code> is not in
// * the range <code>0&lt;=logicalIndex&lt;getProcessedLength()</code>
// *
// * @see #getLogicalMap
// * @see #getLogicalIndex
// * @see #getProcessedLength
// * @see #MAP_NOWHERE
// * @see #OPTION_REMOVE_CONTROLS
// * @see #writeReordered
// * @stable ICU 3.8
// */
// public int getVisualIndex(int logicalIndex)
// {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
// /**
// * Get the logical text position from a visual position.
// * If such a mapping is used many times on the same
// * <code>Bidi</code> object, then calling
// * <code>getVisualMap()</code> is more efficient.
// * <p>
// * The value returned may be <code>MAP_NOWHERE</code> if there is no
// * logical position because the corresponding text character is a Bidi
// * mark inserted in the output by option
// * <code>OPTION_INSERT_MARKS</code>.
// * <p>
// * This is the inverse method to <code>getVisualIndex()</code>.
// * <p>
// * When the visual output is altered by using options of
// * <code>writeReordered()</code> such as <code>INSERT_LRM_FOR_NUMERIC</code>,
// * <code>KEEP_BASE_COMBINING</code>, <code>OUTPUT_REVERSE</code>,
// * <code>REMOVE_BIDI_CONTROLS</code>, the logical position returned may not
// * be correct. It is advised to use, when possible, reordering options
// * such as {@link #OPTION_INSERT_MARKS} and {@link #OPTION_REMOVE_CONTROLS}.
// *
// * @param visualIndex is the visual position of a character.
// *
// * @return The index of this character in the text.
// *
// * @throws IllegalStateException if this call is not preceded by a successful
// * call to <code>setPara</code> or <code>setLine</code>
// * @throws IllegalArgumentException if <code>visualIndex</code> is not in
// * the range <code>0&lt;=visualIndex&lt;getResultLength()</code>
// *
// * @see #getVisualMap
// * @see #getVisualIndex
// * @see #getResultLength
// * @see #MAP_NOWHERE
// * @see #OPTION_INSERT_MARKS
// * @see #writeReordered
// * @stable ICU 3.8
// */
// public int getLogicalIndex(int visualIndex)
// {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
// /**
// * Get a logical-to-visual index map (array) for the characters in the
// * <code>Bidi</code> (paragraph or line) object.
// * <p>
// * Some values in the map may be <code>MAP_NOWHERE</code> if the
// * corresponding text characters are Bidi controls removed from the visual
// * output by the option <code>OPTION_REMOVE_CONTROLS</code>.
// * <p>
// * When the visual output is altered by using options of
// * <code>writeReordered()</code> such as <code>INSERT_LRM_FOR_NUMERIC</code>,
// * <code>KEEP_BASE_COMBINING</code>, <code>OUTPUT_REVERSE</code>,
// * <code>REMOVE_BIDI_CONTROLS</code>, the visual positions returned may not
// * be correct. It is advised to use, when possible, reordering options
// * such as {@link #OPTION_INSERT_MARKS} and {@link #OPTION_REMOVE_CONTROLS}.
// * <p>
// * Note that in right-to-left runs, this mapping places
// * second surrogates before first ones (which is generally a bad idea)
// * and combining characters before base characters.
// * Use of <code>{@link #writeReordered}</code>, optionally with the
// * <code>{@link #KEEP_BASE_COMBINING}</code> option can be considered instead
// * of using the mapping, in order to avoid these issues.
// *
// * @return an array of <code>getProcessedLength()</code>
// * indexes which will reflect the reordering of the characters.<br><br>
// * The index map will result in
// * <code>indexMap[logicalIndex]==visualIndex</code>, where
// * <code>indexMap</code> represents the returned array.
// *
// * @throws IllegalStateException if this call is not preceded by a successful
// * call to <code>setPara</code> or <code>setLine</code>
// *
// * @see #getVisualMap
// * @see #getVisualIndex
// * @see #getProcessedLength
// * @see #MAP_NOWHERE
// * @see #OPTION_REMOVE_CONTROLS
// * @see #writeReordered
// * @stable ICU 3.8
// */
// public int[] getLogicalMap()
// {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
// /**
// * Get a visual-to-logical index map (array) for the characters in the
// * <code>Bidi</code> (paragraph or line) object.
// * <p>
// * Some values in the map may be <code>MAP_NOWHERE</code> if the
// * corresponding text characters are Bidi marks inserted in the visual
// * output by the option <code>OPTION_INSERT_MARKS</code>.
// * <p>
// * When the visual output is altered by using options of
// * <code>writeReordered()</code> such as <code>INSERT_LRM_FOR_NUMERIC</code>,
// * <code>KEEP_BASE_COMBINING</code>, <code>OUTPUT_REVERSE</code>,
// * <code>REMOVE_BIDI_CONTROLS</code>, the logical positions returned may not
// * be correct. It is advised to use, when possible, reordering options
// * such as {@link #OPTION_INSERT_MARKS} and {@link #OPTION_REMOVE_CONTROLS}.
// *
// * @return an array of <code>getResultLength()</code>
// * indexes which will reflect the reordering of the characters.<br><br>
// * The index map will result in
// * <code>indexMap[visualIndex]==logicalIndex</code>, where
// * <code>indexMap</code> represents the returned array.
// *
// * @throws IllegalStateException if this call is not preceded by a successful
// * call to <code>setPara</code> or <code>setLine</code>
// *
// * @see #getLogicalMap
// * @see #getLogicalIndex
// * @see #getResultLength
// * @see #MAP_NOWHERE
// * @see #OPTION_INSERT_MARKS
// * @see #writeReordered
// * @stable ICU 3.8
// */
// public int[] getVisualMap()
// {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
// /**
// * This is a convenience method that does not use a <code>Bidi</code> object.
// * It is intended to be used for when an application has determined the levels
// * of objects (character sequences) and just needs to have them reordered (L2).
// * This is equivalent to using <code>getLogicalMap()</code> on a
// * <code>Bidi</code> object.
// *
// * @param levels is an array of levels that have been determined by
// * the application.
// *
// * @return an array of <code>levels.length</code>
// * indexes which will reflect the reordering of the characters.<p>
// * The index map will result in
// * <code>indexMap[logicalIndex]==visualIndex</code>, where
// * <code>indexMap</code> represents the returned array.
// *
// * @stable ICU 3.8
// */
// public static int[] reorderLogical(byte[] levels)
// {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
// /**
// * This is a convenience method that does not use a <code>Bidi</code> object.
// * It is intended to be used for when an application has determined the levels
// * of objects (character sequences) and just needs to have them reordered (L2).
// * This is equivalent to using <code>getVisualMap()</code> on a
// * <code>Bidi</code> object.
// *
// * @param levels is an array of levels that have been determined by
// * the application.
// *
// * @return an array of <code>levels.length</code>
// * indexes which will reflect the reordering of the characters.<p>
// * The index map will result in
// * <code>indexMap[visualIndex]==logicalIndex</code>, where
// * <code>indexMap</code> represents the returned array.
// *
// * @stable ICU 3.8
// */
// public static int[] reorderVisual(byte[] levels)
// {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
// /**
// * Invert an index map.
// * The index mapping of the argument map is inverted and returned as
// * an array of indexes that we will call the inverse map.
// *
// * @param srcMap is an array whose elements define the original mapping
// * from a source array to a destination array.
// * Some elements of the source array may have no mapping in the
// * destination array. In that case, their value will be
// * the special value <code>MAP_NOWHERE</code>.
// * All elements must be >=0 or equal to <code>MAP_NOWHERE</code>.
// * Some elements in the source map may have a value greater than the
// * srcMap.length if the destination array has more elements than the
// * source array.
// * There must be no duplicate indexes (two or more elements with the
// * same value except <code>MAP_NOWHERE</code>).
// *
// * @return an array representing the inverse map.
// * This array has a number of elements equal to 1 + the highest
// * value in <code>srcMap</code>.
// * For elements of the result array which have no matching elements
// * in the source array, the corresponding elements in the inverse
// * map will receive a value equal to <code>MAP_NOWHERE</code>.
// * If element with index i in <code>srcMap</code> has a value k different
// * from <code>MAP_NOWHERE</code>, this means that element i of
// * the source array maps to element k in the destination array.
// * The inverse map will have value i in its k-th element.
// * For all elements of the destination array which do not map to
// * an element in the source array, the corresponding element in the
// * inverse map will have a value equal to <code>MAP_NOWHERE</code>.
// *
// * @see #MAP_NOWHERE
// * @stable ICU 3.8
// */
// public static int[] invertMap(int[] srcMap)
// {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
/*
* Fields and methods for compatibility with java.text.bidi (Sun implementation)
*/
/**
* Constant indicating base direction is left-to-right.
* @stable ICU 3.8
*/
public static final int DIRECTION_LEFT_TO_RIGHT = LTR;
/**
* Constant indicating base direction is right-to-left.
* @stable ICU 3.8
*/
public static final int DIRECTION_RIGHT_TO_LEFT = RTL;
/**
* Constant indicating that the base direction depends on the first strong
* directional character in the text according to the Unicode Bidirectional
* Algorithm. If no strong directional character is present, the base
* direction is left-to-right.
* @stable ICU 3.8
*/
public static final int DIRECTION_DEFAULT_LEFT_TO_RIGHT = LEVEL_DEFAULT_LTR;
/**
* Constant indicating that the base direction depends on the first strong
* directional character in the text according to the Unicode Bidirectional
* Algorithm. If no strong directional character is present, the base
* direction is right-to-left.
* @stable ICU 3.8
*/
public static final int DIRECTION_DEFAULT_RIGHT_TO_LEFT = LEVEL_DEFAULT_RTL;
/**
* Create Bidi from the given paragraph of text and base direction.
*
* @param paragraph a paragraph of text
* @param flags a collection of flags that control the algorithm. The
* algorithm understands the flags DIRECTION_LEFT_TO_RIGHT,
* DIRECTION_RIGHT_TO_LEFT, DIRECTION_DEFAULT_LEFT_TO_RIGHT, and
* DIRECTION_DEFAULT_RIGHT_TO_LEFT. Other values are reserved.
* @see #DIRECTION_LEFT_TO_RIGHT
* @see #DIRECTION_RIGHT_TO_LEFT
* @see #DIRECTION_DEFAULT_LEFT_TO_RIGHT
* @see #DIRECTION_DEFAULT_RIGHT_TO_LEFT
* @stable ICU 3.8
*/
public Bidi(String paragraph, int flags)
{
// Note: ICU and Oracle JDK are using the
// same DIRECTION_* flags definitions.
this(new java.text.Bidi(paragraph, flags));
}
/**
* Create Bidi from the given paragraph of text.<p>
*
* The RUN_DIRECTION attribute in the text, if present, determines the base
* direction (left-to-right or right-to-left). If not present, the base
* direction is computed using the Unicode Bidirectional Algorithm,
* defaulting to left-to-right if there are no strong directional characters
* in the text. This attribute, if present, must be applied to all the text
* in the paragraph.<p>
*
* The BIDI_EMBEDDING attribute in the text, if present, represents
* embedding level information. Negative values from -1 to -62 indicate
* overrides at the absolute value of the level. Positive values from 1 to
* 62 indicate embeddings. Where values are zero or not defined, the base
* embedding level as determined by the base direction is assumed.<p>
*
* The NUMERIC_SHAPING attribute in the text, if present, converts European
* digits to other decimal digits before running the bidi algorithm. This
* attribute, if present, must be applied to all the text in the paragraph.<p>
*
* Note: this constructor calls setPara() internally.
*
* @param paragraph a paragraph of text with optional character and
* paragraph attribute information
* @stable ICU 3.8
*/
public Bidi(AttributedCharacterIterator paragraph)
{
// ICU does not define its own attributes and just
// use java.awt.font.TextAttribute. Thus, no mappings
// are necessary.
this(new java.text.Bidi(paragraph));
}
/**
* Create Bidi from the given text, embedding, and direction information.
* The embeddings array may be null. If present, the values represent
* embedding level information. Negative values from -1 to -61 indicate
* overrides at the absolute value of the level. Positive values from 1 to
* 61 indicate embeddings. Where values are zero, the base embedding level
* as determined by the base direction is assumed.<p>
*
* Note: this constructor calls setPara() internally.
*
* @param text an array containing the paragraph of text to process.
* @param textStart the index into the text array of the start of the
* paragraph.
* @param embeddings an array containing embedding values for each character
* in the paragraph. This can be null, in which case it is assumed
* that there is no external embedding information.
* @param embStart the index into the embedding array of the start of the
* paragraph.
* @param paragraphLength the length of the paragraph in the text and
* embeddings arrays.
* @param flags a collection of flags that control the algorithm. The
* algorithm understands the flags DIRECTION_LEFT_TO_RIGHT,
* DIRECTION_RIGHT_TO_LEFT, DIRECTION_DEFAULT_LEFT_TO_RIGHT, and
* DIRECTION_DEFAULT_RIGHT_TO_LEFT. Other values are reserved.
*
* @throws IllegalArgumentException if the values in embeddings are
* not within the allowed range
*
* @see #DIRECTION_LEFT_TO_RIGHT
* @see #DIRECTION_RIGHT_TO_LEFT
* @see #DIRECTION_DEFAULT_LEFT_TO_RIGHT
* @see #DIRECTION_DEFAULT_RIGHT_TO_LEFT
* @stable ICU 3.8
*/
public Bidi(char[] text,
int textStart,
byte[] embeddings,
int embStart,
int paragraphLength,
int flags)
{
// Note: ICU and Oracle JDK are using the
// same DIRECTION_* flags definitions.
this(new java.text.Bidi(text, textStart, embeddings, embStart, paragraphLength, flags));
}
/**
* Create a Bidi object representing the bidi information on a line of text
* within the paragraph represented by the current Bidi. This call is not
* required if the entire paragraph fits on one line.
*
* @param lineStart the offset from the start of the paragraph to the start
* of the line.
* @param lineLimit the offset from the start of the paragraph to the limit
* of the line.
*
* @throws IllegalStateException if this call is not preceded by a successful
* call to <code>setPara</code>
* @throws IllegalArgumentException if lineStart and lineLimit are not in the range
* <code>0&lt;=lineStart&lt;lineLimit&lt;=getProcessedLength()</code>,
* or if the specified line crosses a paragraph boundary
* @stable ICU 3.8
*/
public Bidi createLineBidi(int lineStart, int lineLimit)
{
return new Bidi(bidi.createLineBidi(lineStart, lineLimit));
}
/**
* Return true if the line is not left-to-right or right-to-left. This means
* it either has mixed runs of left-to-right and right-to-left text, or the
* base direction differs from the direction of the only run of text.
*
* @return true if the line is not left-to-right or right-to-left.
*
* @throws IllegalStateException if this call is not preceded by a successful
* call to <code>setPara</code>
* @stable ICU 3.8
*/
public boolean isMixed()
{
return bidi.isMixed();
}
/**
* Return true if the line is all left-to-right text and the base direction
* is left-to-right.
*
* @return true if the line is all left-to-right text and the base direction
* is left-to-right.
*
* @throws IllegalStateException if this call is not preceded by a successful
* call to <code>setPara</code>
* @stable ICU 3.8
*/
public boolean isLeftToRight()
{
return bidi.isLeftToRight();
}
/**
* Return true if the line is all right-to-left text, and the base direction
* is right-to-left
*
* @return true if the line is all right-to-left text, and the base
* direction is right-to-left
*
* @throws IllegalStateException if this call is not preceded by a successful
* call to <code>setPara</code>
* @stable ICU 3.8
*/
public boolean isRightToLeft()
{
return bidi.isRightToLeft();
}
/**
* Return true if the base direction is left-to-right
*
* @return true if the base direction is left-to-right
*
* @throws IllegalStateException if this call is not preceded by a successful
* call to <code>setPara</code> or <code>setLine</code>
*
* @stable ICU 3.8
*/
public boolean baseIsLeftToRight()
{
return bidi.baseIsLeftToRight();
}
/**
* Return the base level (0 if left-to-right, 1 if right-to-left).
*
* @return the base level
*
* @throws IllegalStateException if this call is not preceded by a successful
* call to <code>setPara</code> or <code>setLine</code>
*
* @stable ICU 3.8
*/
public int getBaseLevel()
{
return bidi.getBaseLevel();
}
/**
* Return the number of level runs.
*
* @return the number of level runs
*
* @throws IllegalStateException if this call is not preceded by a successful
* call to <code>setPara</code> or <code>setLine</code>
*
* @stable ICU 3.8
*/
public int getRunCount()
{
return bidi.getRunCount();
}
/**
* Return the level of the nth logical run in this line.
*
* @param run the index of the run, between 0 and <code>countRuns()-1</code>
*
* @return the level of the run
*
* @throws IllegalStateException if this call is not preceded by a successful
* call to <code>setPara</code> or <code>setLine</code>
* @throws IllegalArgumentException if <code>run</code> is not in
* the range <code>0&lt;=run&lt;countRuns()</code>
* @stable ICU 3.8
*/
public int getRunLevel(int run)
{
return bidi.getRunLevel(run);
}
/**
* Return the index of the character at the start of the nth logical run in
* this line, as an offset from the start of the line.
*
* @param run the index of the run, between 0 and <code>countRuns()</code>
*
* @return the start of the run
*
* @throws IllegalStateException if this call is not preceded by a successful
* call to <code>setPara</code> or <code>setLine</code>
* @throws IllegalArgumentException if <code>run</code> is not in
* the range <code>0&lt;=run&lt;countRuns()</code>
* @stable ICU 3.8
*/
public int getRunStart(int run)
{
return bidi.getRunStart(run);
}
/**
* Return the index of the character past the end of the nth logical run in
* this line, as an offset from the start of the line. For example, this
* will return the length of the line for the last run on the line.
*
* @param run the index of the run, between 0 and <code>countRuns()</code>
*
* @return the limit of the run
*
* @throws IllegalStateException if this call is not preceded by a successful
* call to <code>setPara</code> or <code>setLine</code>
* @throws IllegalArgumentException if <code>run</code> is not in
* the range <code>0&lt;=run&lt;countRuns()</code>
* @stable ICU 3.8
*/
public int getRunLimit(int run)
{
return bidi.getRunLimit(run);
}
/**
* Return true if the specified text requires bidi analysis. If this returns
* false, the text will display left-to-right. Clients can then avoid
* constructing a Bidi object. Text in the Arabic Presentation Forms area of
* Unicode is presumed to already be shaped and ordered for display, and so
* will not cause this method to return true.
*
* @param text the text containing the characters to test
* @param start the start of the range of characters to test
* @param limit the limit of the range of characters to test
*
* @return true if the range of characters requires bidi analysis
*
* @stable ICU 3.8
*/
public static boolean requiresBidi(char[] text,
int start,
int limit)
{
return java.text.Bidi.requiresBidi(text, start, limit);
}
/**
* Reorder the objects in the array into visual order based on their levels.
* This is a utility method to use when you have a collection of objects
* representing runs of text in logical order, each run containing text at a
* single level. The elements at <code>index</code> from
* <code>objectStart</code> up to <code>objectStart + count</code> in the
* objects array will be reordered into visual order assuming
* each run of text has the level indicated by the corresponding element in
* the levels array (at <code>index - objectStart + levelStart</code>).
*
* @param levels an array representing the bidi level of each object
* @param levelStart the start position in the levels array
* @param objects the array of objects to be reordered into visual order
* @param objectStart the start position in the objects array
* @param count the number of objects to reorder
* @stable ICU 3.8
*/
public static void reorderVisually(byte[] levels,
int levelStart,
Object[] objects,
int objectStart,
int count)
{
java.text.Bidi.reorderVisually(levels, levelStart, objects, objectStart, count);
}
// /**
// * Take a <code>Bidi</code> object containing the reordering
// * information for a piece of text (one or more paragraphs) set by
// * <code>setPara()</code> or for a line of text set by <code>setLine()</code>
// * and return a string containing the reordered text.
// *
// * <p>The text may have been aliased (only a reference was stored
// * without copying the contents), thus it must not have been modified
// * since the <code>setPara()</code> call.</p>
// *
// * This method preserves the integrity of characters with multiple
// * code units and (optionally) combining characters.
// * Characters in RTL runs can be replaced by mirror-image characters
// * in the returned string. Note that "real" mirroring has to be done in a
// * rendering engine by glyph selection and that for many "mirrored"
// * characters there are no Unicode characters as mirror-image equivalents.
// * There are also options to insert or remove Bidi control
// * characters; see the descriptions of the return value and the
// * <code>options</code> parameter, and of the option bit flags.
// *
// * @param options A bit set of options for the reordering that control
// * how the reordered text is written.
// * The options include mirroring the characters on a code
// * point basis and inserting LRM characters, which is used
// * especially for transforming visually stored text
// * to logically stored text (although this is still an
// * imperfect implementation of an "inverse Bidi" algorithm
// * because it uses the "forward Bidi" algorithm at its core).
// * The available options are:
// * <code>DO_MIRRORING</code>,
// * <code>INSERT_LRM_FOR_NUMERIC</code>,
// * <code>KEEP_BASE_COMBINING</code>,
// * <code>OUTPUT_REVERSE</code>,
// * <code>REMOVE_BIDI_CONTROLS</code>,
// * <code>STREAMING</code>
// *
// * @return The reordered text.
// * If the <code>INSERT_LRM_FOR_NUMERIC</code> option is set, then
// * the length of the returned string could be as large as
// * <code>getLength()+2*countRuns()</code>.<br>
// * If the <code>REMOVE_BIDI_CONTROLS</code> option is set, then the
// * length of the returned string may be less than
// * <code>getLength()</code>.<br>
// * If none of these options is set, then the length of the returned
// * string will be exactly <code>getProcessedLength()</code>.
// *
// * @throws IllegalStateException if this call is not preceded by a successful
// * call to <code>setPara</code> or <code>setLine</code>
// *
// * @see #DO_MIRRORING
// * @see #INSERT_LRM_FOR_NUMERIC
// * @see #KEEP_BASE_COMBINING
// * @see #OUTPUT_REVERSE
// * @see #REMOVE_BIDI_CONTROLS
// * @see #OPTION_STREAMING
// * @see #getProcessedLength
// * @stable ICU 3.8
// */
// public String writeReordered(int options)
// {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
// /**
// * Reverse a Right-To-Left run of Unicode text.
// *
// * This method preserves the integrity of characters with multiple
// * code units and (optionally) combining characters.
// * Characters can be replaced by mirror-image characters
// * in the destination buffer. Note that "real" mirroring has
// * to be done in a rendering engine by glyph selection
// * and that for many "mirrored" characters there are no
// * Unicode characters as mirror-image equivalents.
// * There are also options to insert or remove Bidi control
// * characters.
// *
// * This method is the implementation for reversing RTL runs as part
// * of <code>writeReordered()</code>. For detailed descriptions
// * of the parameters, see there.
// * Since no Bidi controls are inserted here, the output string length
// * will never exceed <code>src.length()</code>.
// *
// * @see #writeReordered
// *
// * @param src The RTL run text.
// *
// * @param options A bit set of options for the reordering that control
// * how the reordered text is written.
// * See the <code>options</code> parameter in <code>writeReordered()</code>.
// *
// * @return The reordered text.
// * If the <code>REMOVE_BIDI_CONTROLS</code> option
// * is set, then the length of the returned string may be less than
// * <code>src.length()</code>. If this option is not set,
// * then the length of the returned string will be exactly
// * <code>src.length()</code>.
// *
// * @throws IllegalArgumentException if <code>src</code> is null.
// * @stable ICU 3.8
// */
// public static String writeReverse(String src, int options)
// {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
// /**
// * Get the base direction of the text provided according to the Unicode
// * Bidirectional Algorithm. The base direction is derived from the first
// * character in the string with bidirectional character type L, R, or AL.
// * If the first such character has type L, LTR is returned. If the first
// * such character has type R or AL, RTL is returned. If the string does
// * not contain any character of these types, then NEUTRAL is returned.
// * This is a lightweight function for use when only the base direction is
// * needed and no further bidi processing of the text is needed.
// * @param paragraph the text whose paragraph level direction is needed.
// * @return LTR, RTL, NEUTRAL
// * @see #LTR
// * @see #RTL
// * @see #NEUTRAL
// * @draft ICU 4.6
// * @provisional This API might change or be removed in a future release.
// */
// public static byte getBaseDirection(CharSequence paragraph) {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
// /**
// * Set the context before a call to setPara().<p>
// *
// * setPara() computes the left-right directionality for a given piece
// * of text which is supplied as one of its arguments. Sometimes this piece
// * of text (the "main text") should be considered in context, because text
// * appearing before ("prologue") and/or after ("epilogue") the main text
// * may affect the result of this computation.<p>
// *
// * This function specifies the prologue and/or the epilogue for the next
// * call to setPara(). If successive calls to setPara()
// * all need specification of a context, setContext() must be called
// * before each call to setPara(). In other words, a context is not
// * "remembered" after the following successful call to setPara().<p>
// *
// * If a call to setPara() specifies DEFAULT_LTR or
// * DEFAULT_RTL as paraLevel and is preceded by a call to
// * setContext() which specifies a prologue, the paragraph level will
// * be computed taking in consideration the text in the prologue.<p>
// *
// * When setPara() is called without a previous call to
// * setContext, the main text is handled as if preceded and followed
// * by strong directional characters at the current paragraph level.
// * Calling setContext() with specification of a prologue will change
// * this behavior by handling the main text as if preceded by the last
// * strong character appearing in the prologue, if any.
// * Calling setContext() with specification of an epilogue will change
// * the behavior of setPara() by handling the main text as if followed
// * by the first strong character or digit appearing in the epilogue, if any.<p>
// *
// * Note 1: if <code>setContext</code> is called repeatedly without
// * calling <code>setPara</code>, the earlier calls have no effect,
// * only the last call will be remembered for the next call to
// * <code>setPara</code>.<p>
// *
// * Note 2: calling <code>setContext(null, null)</code>
// * cancels any previous setting of non-empty prologue or epilogue.
// * The next call to <code>setPara()</code> will process no
// * prologue or epilogue.<p>
// *
// * Note 3: users must be aware that even after setting the context
// * before a call to setPara() to perform e.g. a logical to visual
// * transformation, the resulting string may not be identical to what it
// * would have been if all the text, including prologue and epilogue, had
// * been processed together.<br>
// * Example (upper case letters represent RTL characters):<br>
// * &nbsp;&nbsp;prologue = "<code>abc DE</code>"<br>
// * &nbsp;&nbsp;epilogue = none<br>
// * &nbsp;&nbsp;main text = "<code>FGH xyz</code>"<br>
// * &nbsp;&nbsp;paraLevel = LTR<br>
// * &nbsp;&nbsp;display without prologue = "<code>HGF xyz</code>"
// * ("HGF" is adjacent to "xyz")<br>
// * &nbsp;&nbsp;display with prologue = "<code>abc HGFED xyz</code>"
// * ("HGF" is not adjacent to "xyz")<br>
// *
// * @param prologue is the text which precedes the text that
// * will be specified in a coming call to setPara().
// * If there is no prologue to consider,
// * this parameter can be <code>null</code>.
// *
// * @param epilogue is the text which follows the text that
// * will be specified in a coming call to setPara().
// * If there is no epilogue to consider,
// * this parameter can be <code>null</code>.
// *
// * @see #setPara
// * @draft ICU 4.8
// * @provisional This API might change or be removed in a future release.
// */
// public void setContext(String prologue, String epilogue) {
// throw new UnsupportedOperationException("Method not supported by com.ibm.icu.base");
// }
}