Google Git
Sign in
android / platform / prebuilts / runtime / eb5522cb40cf9baf036f3efa6140870048a0576a / . / mainline / i18n / sdk / sdk_library / system / i18n.module.public.api_stub_sources / android / icu / text / Bidi.java
blob: 34d2a04bdd733e8f3504bfd47d6d26666f9b78ce [file] [log] [blame]
/* GENERATED SOURCE. DO NOT MODIFY. */
// ? 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
*******************************************************************************
* Copyright (C) 2001-2016, 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 android.icu.text;
import android.icu.lang.UCharacter;
import android.icu.lang.UProperty;
/**
*
* <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>.
* <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.
*
* <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}
* <li>{@link #NEUTRAL}
* </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.
*
* <p>Note: The numeric values of the related constants will not change:
* They are tied to the use of 7-bit byte values (plus the override bit)
* and of the byte data type in this API.
*
* <p><b>See Also:</b>
* <ul>
* <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.
*
* <b>See Also:</b>
* <ul>
* <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.
*
* <b>See Also:</b>
* <ul>
* <li>{@link #setReorderingOptions}
* <li>{@link #OPTION_DEFAULT}
* <li>{@link #OPTION_INSERT_MARKS}
* <li>{@link #OPTION_REMOVE_CONTROLS}
* <li>{@link #OPTION_STREAMING}
* </ul>
*
* <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:
*
* <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 android.icu.dev.test.bidi;
*
* import android.icu.text.Bidi;
* import android.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 &lt; styleRunCount; ++i) {
* styleLimit = styleRuns[i].limit;
* if (start &lt; styleLimit) {
* if (styleLimit &gt; 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 &gt;= 0; --i) {
* if (i &gt; 0) {
* styleStart = styleRuns[i-1].limit;
* } else {
* styleStart = 0;
* }
* if (limit &gt;= styleStart) {
* if (styleStart &lt; 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 &lt;= 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 &lt;= 1) {
* int style = styleRuns[0].style;
*
* // iterate over directional runs
* for (i = 0; i &lt; 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 &lt; 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 &amp; para.getParaLevel());
* StyleRun styleRun = new StyleRun(length, styleNormal);
*
* if (styleRuns == null || styleRunCount &lt;= 0) {
* styleRuns = new StyleRun[1];
* styleRunCount = 1;
* styleRuns[0] = styleRun;
* }
* // assume styleRuns[styleRunCount-1].limit&gt;=length
*
* int width = getTextWidth(text, 0, length, styleRuns, styleRunCount);
* if (width &lt;= 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 &gt; 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 &gt;= 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>
*
* @author Simon Montagu, Matitiahu Allouche (ported from C code written by Markus W. Scherer)
*/
@SuppressWarnings({"unchecked", "deprecation", "all"})
public class Bidi {
/**
* 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.
*/
public Bidi() { throw new RuntimeException("Stub!"); }
/**
* 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 java.lang.IllegalArgumentException if maxLength or maxRunCount is less than 0
*/
public Bidi(int maxLength, int maxRunCount) { throw new RuntimeException("Stub!"); }
/**
* 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
*/
public Bidi(java.lang.String paragraph, int flags) { throw new RuntimeException("Stub!"); }
/**
* 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 indicate overrides at the absolute value of the level.
* Positive values indicate embeddings. (See {@link #MAX_EXPLICIT_LEVEL}.)
* 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
*/
public Bidi(java.text.AttributedCharacterIterator paragraph) { throw new RuntimeException("Stub!"); }
/**
* Create Bidi from the given text, embedding, and direction information.
*
* <p>The embeddings array may be null. If present, the values represent
* embedding level information.
* Negative values indicate overrides at the absolute value of the level.
* Positive values indicate embeddings. (See {@link #MAX_EXPLICIT_LEVEL}.)
* Where values are zero, the base embedding level
* as determined by the base direction is assumed,
* except for paragraph separators which remain at 0 to prevent reordering of paragraphs.</p>
*
* <p>Note: This constructor calls setPara() internally,
* after converting the java.text.Bidi-style embeddings with negative overrides
* into ICU-style embeddings with bit fields for {@link #LEVEL_OVERRIDE} and the level.
*
* @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 java.lang.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
*/
public Bidi(char[] text, int textStart, byte[] embeddings, int embStart, int paragraphLength, int flags) { throw new RuntimeException("Stub!"); }
/**
* 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>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>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>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
*/
public void setInverse(boolean isInverse) { throw new RuntimeException("Stub!"); }
/**
* 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.
*
* @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
*/
public boolean isInverse() { throw new RuntimeException("Stub!"); }
/**
* 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>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>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>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.
*
* <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>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
*/
public void setReorderingMode(int reorderingMode) { throw new RuntimeException("Stub!"); }
/**
* What is the requested reordering mode for a given Bidi object?
*
* @return the current reordering mode of the Bidi object
*
* @see #setReorderingMode
*/
public int getReorderingMode() { throw new RuntimeException("Stub!"); }
/**
* 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
*/
public void setReorderingOptions(int options) { throw new RuntimeException("Stub!"); }
/**
* What are the reordering options applied to a given Bidi object?
*
* @return the current reordering options of the Bidi object
*
* @see #setReorderingOptions
*/
public int getReorderingOptions() { throw new RuntimeException("Stub!"); }
/**
* 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
*/
public static byte getBaseDirection(java.lang.CharSequence paragraph) { throw new RuntimeException("Stub!"); }
/**
* 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
*/
public void setContext(java.lang.String prologue, java.lang.String epilogue) { throw new RuntimeException("Stub!"); }
/**
* Perform the Unicode Bidi algorithm. It is defined in the
* <a href="http://www.unicode.org/reports/tr9/">Unicode Standard Annex #9</a>.
*
* <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>
*
* <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>
*
* <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.
*
* <p>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>
* Aside from that bit, it must be
* <code>paraLevel&lt;=embeddingLevels[]&lt;=MAX_EXPLICIT_LEVEL</code>,
* except that level 0 is always allowed.
* Level 0 for a paragraph separator prevents reordering of paragraphs;
* this only works reliably if <code>LEVEL_OVERRIDE</code>
* is also set for paragraph separators.
* Level 0 for other characters is treated as a wildcard
* and is lifted up to the resolved level of the surrounding paragraph.<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 java.lang.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
*/
public void setPara(java.lang.String text, byte paraLevel, byte[] embeddingLevels) { throw new RuntimeException("Stub!"); }
/**
* Perform the Unicode Bidi algorithm. It is defined in the
* <a href="http://www.unicode.org/reports/tr9/">Unicode Standard Annex #9</a>.
*
* <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>
*
* <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>
*
* <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.
*
* <p>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>
* Aside from that bit, it must be
* <code>paraLevel&lt;=embeddingLevels[]&lt;=MAX_EXPLICIT_LEVEL</code>,
* except that level 0 is always allowed.
* Level 0 for a paragraph separator prevents reordering of paragraphs;
* this only works reliably if <code>LEVEL_OVERRIDE</code>
* is also set for paragraph separators.
* Level 0 for other characters is treated as a wildcard
* and is lifted up to the resolved level of the surrounding paragraph.<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 java.lang.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
*/
public void setPara(char[] chars, byte paraLevel, byte[] embeddingLevels) { throw new RuntimeException("Stub!"); }
/**
* 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 indicate overrides at the absolute value of the level.
* Positive values indicate embeddings. (See {@link #MAX_EXPLICIT_LEVEL}.)
* 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
*/
public void setPara(java.text.AttributedCharacterIterator paragraph) { throw new RuntimeException("Stub!"); }
/**
* 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
*/
public void orderParagraphsLTR(boolean ordarParaLTR) { throw new RuntimeException("Stub!"); }
/**
* 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.
*/
public boolean isOrderParagraphsLTR() { throw new RuntimeException("Stub!"); }
/**
* 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 java.lang.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
*/
public byte getDirection() { throw new RuntimeException("Stub!"); }
/**
* Get the text.
*
* @return A <code>String</code> containing the text that the
* <code>Bidi</code> object was created for.
*
* @throws java.lang.IllegalStateException if this call is not preceded by a successful
* call to <code>setPara</code> or <code>setLine</code>
*
* @see #setPara
* @see #setLine
*/
public java.lang.String getTextAsString() { throw new RuntimeException("Stub!"); }
/**
* Get the text.
*
* @return A <code>char</code> array containing the text that the
* <code>Bidi</code> object was created for.
*
* @throws java.lang.IllegalStateException if this call is not preceded by a successful
* call to <code>setPara</code> or <code>setLine</code>
*
* @see #setPara
* @see #setLine
*/
public char[] getText() { throw new RuntimeException("Stub!"); }
/**
* Get the length of the text.
*
* @return The length of the text that the <code>Bidi</code> object was
* created for.
*
* @throws java.lang.IllegalStateException if this call is not preceded by a successful
* call to <code>setPara</code> or <code>setLine</code>
*/
public int getLength() { throw new RuntimeException("Stub!"); }
/**
* 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 java.lang.IllegalStateException if this call is not preceded by a successful
* call to <code>setPara</code> or <code>setLine</code>
*
* @see #setPara
* @see #OPTION_STREAMING
*/
public int getProcessedLength() { throw new RuntimeException("Stub!"); }
/**
* 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 java.lang.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
*/
public int getResultLength() { throw new RuntimeException("Stub!"); }
/**
* 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 java.lang.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
*/
public byte getParaLevel() { throw new RuntimeException("Stub!"); }
/**
* Get the number of paragraphs.
*
* @return The number of paragraphs.
*
* @throws java.lang.IllegalStateException if this call is not preceded by a successful
* call to <code>setPara</code> or <code>setLine</code>
*/
public int countParagraphs() { throw new RuntimeException("Stub!"); }
/**
* 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 java.lang.IllegalStateException if this call is not preceded by a successful
* call to <code>setPara</code> or <code>setLine</code>
* @throws java.lang.IllegalArgumentException if paraIndex is not in the range
* <code>[0..countParagraphs()-1]</code>
*
* @see android.icu.text.BidiRun
*/
public android.icu.text.BidiRun getParagraphByIndex(int paraIndex) { throw new RuntimeException("Stub!"); }
/**
* 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 java.lang.IllegalStateException if this call is not preceded by a successful
* call to <code>setPara</code> or <code>setLine</code>
* @throws java.lang.IllegalArgumentException if charIndex is not within the legal range
*
* @see android.icu.text.BidiRun
* @see #getParagraphByIndex
* @see #getProcessedLength
*/
public android.icu.text.BidiRun getParagraph(int charIndex) { throw new RuntimeException("Stub!"); }
/**
* 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 java.lang.IllegalStateException if this call is not preceded by a successful
* call to <code>setPara</code> or <code>setLine</code>
* @throws java.lang.IllegalArgumentException if charIndex is not within the legal range
*
* @see android.icu.text.BidiRun
* @see #getProcessedLength
*/
public int getParagraphIndex(int charIndex) { throw new RuntimeException("Stub!"); }
/**
* 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
*/
public void setCustomClassifier(android.icu.text.BidiClassifier classifier) { throw new RuntimeException("Stub!"); }
/**
* Gets the current custom class classifier used for Bidi class
* determination.
*
* @return An instance of class <code>BidiClassifier</code>
*
* @see #setCustomClassifier
*/
public android.icu.text.BidiClassifier getCustomClassifier() { throw new RuntimeException("Stub!"); }
/**
* Retrieves the Bidi class for a given code point.
* <p>If a <code>BidiClassifier</code> is defined and returns a value
* other than <code>UCharacter.getIntPropertyMaxValue(UProperty.BIDI_CLASS)+1</code>,
* that value is used; otherwise the default class determination mechanism is invoked.
*
* @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 android.icu.text.BidiClassifier
*/
public int getCustomizedClass(int c) { throw new RuntimeException("Stub!"); }
/**
* <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 java.lang.IllegalStateException if this call is not preceded by a successful
* call to <code>setPara</code>
* @throws java.lang.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
*/
public android.icu.text.Bidi setLine(int start, int limit) { throw new RuntimeException("Stub!"); }
/**
* Get the level for one character.
*
* @param charIndex the index of a character.
*
* @return The level for the character at <code>charIndex</code>.
*
* @throws java.lang.IllegalStateException if this call is not preceded by a successful
* call to <code>setPara</code> or <code>setLine</code>
* @throws java.lang.IllegalArgumentException if charIndex is not in the range
* <code>0&lt;=charIndex&lt;getProcessedLength()</code>
*
* @see #getProcessedLength
*/
public byte getLevelAt(int charIndex) { throw new RuntimeException("Stub!"); }
/**
* 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 java.lang.IllegalStateException if this call is not preceded by a successful
* call to <code>setPara</code> or <code>setLine</code>
*/
public byte[] getLevels() { throw new RuntimeException("Stub!"); }
/**
* 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 java.lang.IllegalStateException if this call is not preceded by a successful
* call to <code>setPara</code> or <code>setLine</code>
* @throws java.lang.IllegalArgumentException if logicalPosition is not in the range
* <code>0&lt;=logicalPosition&lt;getProcessedLength()</code>
*
* @see android.icu.text.BidiRun
* @see android.icu.text.BidiRun#getStart()
* @see android.icu.text.BidiRun#getLimit()
* @see android.icu.text.BidiRun#getEmbeddingLevel()
*/
public android.icu.text.BidiRun getLogicalRun(int logicalPosition) { throw new RuntimeException("Stub!"); }
/**
* 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 java.lang.IllegalStateException if this call is not preceded by a successful
* call to <code>setPara</code> or <code>setLine</code>
*/
public int countRuns() { throw new RuntimeException("Stub!"); }
/**
*
* 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 java.lang.IllegalStateException if this call is not preceded by a successful
* call to <code>setPara</code> or <code>setLine</code>
* @throws java.lang.IllegalArgumentException if <code>runIndex</code> is not in
* the range <code>0&lt;=runIndex&lt;countRuns()</code>
*
* @see #countRuns()
* @see android.icu.text.BidiRun
* @see android.icu.text.BidiRun#getStart()
* @see android.icu.text.BidiRun#getLength()
* @see android.icu.text.BidiRun#getEmbeddingLevel()
*/
public android.icu.text.BidiRun getVisualRun(int runIndex) { throw new RuntimeException("Stub!"); }
/**
* 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 java.lang.IllegalStateException if this call is not preceded by a successful
* call to <code>setPara</code> or <code>setLine</code>
* @throws java.lang.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
*/
public int getVisualIndex(int logicalIndex) { throw new RuntimeException("Stub!"); }
/**
* 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 java.lang.IllegalStateException if this call is not preceded by a successful
* call to <code>setPara</code> or <code>setLine</code>
* @throws java.lang.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
*/
public int getLogicalIndex(int visualIndex) { throw new RuntimeException("Stub!"); }
/**
* 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 java.lang.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
*/
public int[] getLogicalMap() { throw new RuntimeException("Stub!"); }
/**
* 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 java.lang.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
*/
public int[] getVisualMap() { throw new RuntimeException("Stub!"); }
/**
* 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.
*/
public static int[] reorderLogical(byte[] levels) { throw new RuntimeException("Stub!"); }
/**
* 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.
*/
public static int[] reorderVisual(byte[] levels) { throw new RuntimeException("Stub!"); }
/**
* 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 &gt;=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
*/
public static int[] invertMap(int[] srcMap) { throw new RuntimeException("Stub!"); }
/**
* 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 java.lang.IllegalStateException if this call is not preceded by a successful
* call to <code>setPara</code>
* @throws java.lang.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
*/
public android.icu.text.Bidi createLineBidi(int lineStart, int lineLimit) { throw new RuntimeException("Stub!"); }
/**
* 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 java.lang.IllegalStateException if this call is not preceded by a successful
* call to <code>setPara</code>
*/
public boolean isMixed() { throw new RuntimeException("Stub!"); }
/**
* 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 java.lang.IllegalStateException if this call is not preceded by a successful
* call to <code>setPara</code>
*/
public boolean isLeftToRight() { throw new RuntimeException("Stub!"); }
/**
* 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 java.lang.IllegalStateException if this call is not preceded by a successful
* call to <code>setPara</code>
*/
public boolean isRightToLeft() { throw new RuntimeException("Stub!"); }
/**
* Return true if the base direction is left-to-right
*
* @return true if the base direction is left-to-right
*
* @throws java.lang.IllegalStateException if this call is not preceded by a successful
* call to <code>setPara</code> or <code>setLine</code>
*/
public boolean baseIsLeftToRight() { throw new RuntimeException("Stub!"); }
/**
* Return the base level (0 if left-to-right, 1 if right-to-left).
*
* @return the base level
*
* @throws java.lang.IllegalStateException if this call is not preceded by a successful
* call to <code>setPara</code> or <code>setLine</code>
*/
public int getBaseLevel() { throw new RuntimeException("Stub!"); }
/**
* Return the number of level runs.
*
* @return the number of level runs
*
* @throws java.lang.IllegalStateException if this call is not preceded by a successful
* call to <code>setPara</code> or <code>setLine</code>
*/
public int getRunCount() { throw new RuntimeException("Stub!"); }
/**
* 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 java.lang.IllegalStateException if this call is not preceded by a successful
* call to <code>setPara</code> or <code>setLine</code>
* @throws java.lang.IllegalArgumentException if <code>run</code> is not in
* the range <code>0&lt;=run&lt;countRuns()</code>
*/
public int getRunLevel(int run) { throw new RuntimeException("Stub!"); }
/**
* 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 java.lang.IllegalStateException if this call is not preceded by a successful
* call to <code>setPara</code> or <code>setLine</code>
* @throws java.lang.IllegalArgumentException if <code>run</code> is not in
* the range <code>0&lt;=run&lt;countRuns()</code>
*/
public int getRunStart(int run) { throw new RuntimeException("Stub!"); }
/**
* 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 java.lang.IllegalStateException if this call is not preceded by a successful
* call to <code>setPara</code> or <code>setLine</code>
* @throws java.lang.IllegalArgumentException if <code>run</code> is not in
* the range <code>0&lt;=run&lt;countRuns()</code>
*/
public int getRunLimit(int run) { throw new RuntimeException("Stub!"); }
/**
* 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
*/
public static boolean requiresBidi(char[] text, int start, int limit) { throw new RuntimeException("Stub!"); }
/**
* 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
*/
public static void reorderVisually(byte[] levels, int levelStart, java.lang.Object[] objects, int objectStart, int count) { throw new RuntimeException("Stub!"); }
/**
* 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.
*
* 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 java.lang.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
*/
public java.lang.String writeReordered(int options) { throw new RuntimeException("Stub!"); }
/**
* 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 java.lang.IllegalArgumentException if <code>src</code> is null.
*/
public static java.lang.String writeReverse(java.lang.String src, int options) { throw new RuntimeException("Stub!"); }
/**
* 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.
*/
public static final int DIRECTION_DEFAULT_LEFT_TO_RIGHT = 126; // 0x7e
/**
* 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.
*/
public static final int DIRECTION_DEFAULT_RIGHT_TO_LEFT = 127; // 0x7f
/**
* Constant indicating base direction is left-to-right.
*/
public static final int DIRECTION_LEFT_TO_RIGHT = 0; // 0x0
/**
* Constant indicating base direction is right-to-left.
*/
public static final int DIRECTION_RIGHT_TO_LEFT = 1; // 0x1
/**
* option bit for writeReordered():
* replace characters with the "mirrored" property in RTL runs
* by their mirror-image mappings
*
* @see #writeReordered
*/
public static final short DO_MIRRORING = 2; // 0x2
/**
* 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.
*
* @see #setInverse
* @see #writeReordered
*/
public static final short INSERT_LRM_FOR_NUMERIC = 4; // 0x4
/**
* option bit for writeReordered():
* keep combining characters after their base characters in RTL runs
*
* @see #writeReordered
*/
public static final short KEEP_BASE_COMBINING = 1; // 0x1
/** 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 rightmost 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
*/
public static final byte LEVEL_DEFAULT_LTR = 126; // 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 rightmost 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
*/
public static final byte LEVEL_DEFAULT_RTL = 127; // 0x7f
/**
* Bit flag for level input.
* Overrides directional properties.
*/
public static final byte LEVEL_OVERRIDE = -128; // 0xffffff80
/**
* Left-to-right text.
* <ul>
* <li>As return value for <code>getDirection()</code>, it means
* that the source string contains no right-to-left characters, or
* that the source string is empty and the paragraph level is even.
* <li>As return value for <code>getBaseDirection()</code>, it
* means that the first strong character of the source string has
* a left-to-right direction.
* </ul>
*/
public static final byte LTR = 0; // 0x0
/**
* 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
*/
public static final int MAP_NOWHERE = -1; // 0xffffffff
/**
* Maximum explicit embedding level.
* Same as the max_depth value in the
* <a href="http://www.unicode.org/reports/tr9/#BD2">Unicode Bidirectional Algorithm</a>.
* (The maximum resolved level can be up to <code>MAX_EXPLICIT_LEVEL+1</code>).
*/
public static final byte MAX_EXPLICIT_LEVEL = 125; // 0x7d
/**
* Mixed-directional text.
* <p>As return value for <code>getDirection()</code>, it means
* that the source string contains both left-to-right and
* right-to-left characters.
*/
public static final byte MIXED = 2; // 0x2
/**
* No strongly directional text.
* <p>As return value for <code>getBaseDirection()</code>, it means
* that the source string is missing or empty, or contains neither
* left-to-right nor right-to-left characters.
*/
public static final byte NEUTRAL = 3; // 0x3
/**
* Option value for <code>setReorderingOptions</code>:
* disable all the options which can be set with this method
* @see #setReorderingOptions
*/
public static final int OPTION_DEFAULT = 0; // 0x0
/**
* 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>This option is significant only with reordering modes which generate
* a result with Logical order, specifically.
* <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>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>.
*
* @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
*/
public static final int OPTION_INSERT_MARKS = 1; // 0x1
/**
* Option bit for <code>setReorderingOptions</code>:
* remove Bidi control characters
*
* <p>This option must be set or reset before calling
* <code>setPara</code>.
*
* <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.
*
* @see #setReorderingMode
* @see #setReorderingOptions
* @see #OPTION_INSERT_MARKS
* @see #INSERT_LRM_FOR_NUMERIC
* @see #REMOVE_BIDI_CONTROLS
*/
public static final int OPTION_REMOVE_CONTROLS = 2; // 0x2
/**
* 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>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>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>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.
*
* @see #setReorderingMode
* @see #setReorderingOptions
* @see #getProcessedLength
*/
public static final int OPTION_STREAMING = 4; // 0x4
/**
* 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.
*
* @see #writeReordered
*/
public static final short OUTPUT_REVERSE = 16; // 0x10
/**
* 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.
*
* @see #writeReordered
* @see #INSERT_LRM_FOR_NUMERIC
*/
public static final short REMOVE_BIDI_CONTROLS = 8; // 0x8
/** Reordering mode: Regular Logical to Visual Bidi algorithm according to Unicode.
* @see #setReorderingMode
*/
public static final short REORDER_DEFAULT = 0; // 0x0
/** Reordering mode: Logical to Visual algorithm grouping numbers with
* adjacent R characters (reversible algorithm).
* @see #setReorderingMode
*/
public static final short REORDER_GROUP_NUMBERS_WITH_R = 2; // 0x2
/** Reordering mode: Inverse Bidi (Visual to Logical) algorithm for the
* <code>REORDER_NUMBERS_SPECIAL</code> Bidi algorithm.
* @see #setReorderingMode
*/
public static final short REORDER_INVERSE_FOR_NUMBERS_SPECIAL = 6; // 0x6
/** Reordering mode: Visual to Logical algorithm equivalent to the regular
* Logical to Visual algorithm.
* @see #setReorderingMode
*/
public static final short REORDER_INVERSE_LIKE_DIRECT = 5; // 0x5
/** Reordering mode: Visual to Logical algorithm which handles numbers
* like L (same algorithm as selected by <code>setInverse(true)</code>.
* @see #setInverse
* @see #setReorderingMode
*/
public static final short REORDER_INVERSE_NUMBERS_AS_L = 4; // 0x4
/** Reordering mode: Logical to Visual algorithm which handles numbers in
* a way which mimicks the behavior of Windows XP.
* @see #setReorderingMode
*/
public static final short REORDER_NUMBERS_SPECIAL = 1; // 0x1
/** 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
*/
public static final short REORDER_RUNS_ONLY = 3; // 0x3
/**
* Right-to-left text.
* <ul>
* <li>As return value for <code>getDirection()</code>, it means
* that the source string contains no left-to-right characters, or
* that the source string is empty and the paragraph level is odd.
* <li>As return value for <code>getBaseDirection()</code>, it
* means that the first strong character of the source string has
* a right-to-left direction.
* </ul>
*/
public static final byte RTL = 1; // 0x1
}