Bidi

Kotlin |Java

open class Bidi

kotlin.Any
↳	android.icu.text.Bidi

Bidi algorithm for ICU

This is an implementation of the Unicode Bidirectional Algorithm. The algorithm is defined in the Unicode Standard Annex #9.

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".

General remarks about the API:

The "limit" of a sequence of characters is the position just after their last character, i.e., one more than that position.

Some of the API methods provide access to "runs". Such a "run" is defined as a sequence of characters that are at the same embedding level after performing the Bidi algorithm.

Basic concept: paragraph

A piece of text can be divided into several paragraphs by characters with the Bidi class Block Separator. For handling of paragraphs, see:

countParagraphs
getParaLevel
getParagraph
getParagraphByIndex

Basic concept: text direction

The direction of a piece of text may be:

LTR
RTL
MIXED
NEUTRAL

Basic concept: levels

Levels in this API represent embedding levels according to the Unicode Bidirectional Algorithm. Their low-order bit (even/odd value) indicates the visual direction.

Levels can be abstract values when used for the paraLevel and embeddingLevels arguments of setPara(); there:

the high-order bit of an embeddingLevels[] value indicates whether the using application is specifying the level of a character to override whatever the Bidi implementation would resolve it to.
paraLevel can be set to the pseudo-level values LEVEL_DEFAULT_LTR and LEVEL_DEFAULT_RTL.

The related constants are not real, valid level values. DEFAULT_XXX can be used to specify a default for the paragraph level for when the setPara() method shall determine it but there is no strongly typed character in the input.

Note that the value for LEVEL_DEFAULT_LTR is even and the one for LEVEL_DEFAULT_RTL 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.

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.

See Also:

LEVEL_DEFAULT_LTR
LEVEL_DEFAULT_RTL
LEVEL_OVERRIDE
MAX_EXPLICIT_LEVEL
setPara

Basic concept: Reordering Mode

Reordering mode values indicate which variant of the Bidi algorithm to use. See Also:

setReorderingMode
REORDER_DEFAULT
REORDER_NUMBERS_SPECIAL
REORDER_GROUP_NUMBERS_WITH_R
REORDER_RUNS_ONLY
REORDER_INVERSE_NUMBERS_AS_L
REORDER_INVERSE_LIKE_DIRECT
REORDER_INVERSE_FOR_NUMBERS_SPECIAL

Basic concept: Reordering Options

Reordering options can be applied during Bidi text transformations. See Also:

setReorderingOptions
OPTION_DEFAULT
OPTION_INSERT_MARKS
OPTION_REMOVE_CONTROLS
OPTION_STREAMING

Sample code for the ICU Bidi API

Rendering a paragraph with the ICU Bidi API

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.

The basic assumptions are:

Rendering is done from left to right on a horizontal line.
A run of single-style, unidirectional text can be rendered at once.
Such a run of text is passed to the graphics system with characters (code units) in logical order.
The line-breaking algorithm is very complicated and Locale-dependent - and therefore its implementation omitted from this sample code.

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 < styleRunCount; ++i) {
                   styleLimit = styleRuns[i].limit;
                   if (start < styleLimit) {
                       if (styleLimit > limit) {
                           styleLimit = limit;
                       }
                       renderRun(text, start, styleLimit,
                                 direction, styleRuns[i].style);
                       if (styleLimit == limit) {
                           break;
                       }
                       start = styleLimit;
                   }
               }
           } else {
               int styleStart;
 
               for (i = styleRunCount-1; i >= 0; --i) {
                   if (i > 0) {
                       styleStart = styleRuns[i-1].limit;
                   } else {
                       styleStart = 0;
                   }
                   if (limit >= styleStart) {
                       if (styleStart < start) {
                           styleStart = start;
                       }
                       renderRun(text, styleStart, limit, direction,
                                 styleRuns[i].style);
                       if (styleStart == start) {
                           break;
                       }
                       limit = styleStart;
                   }
               }
           }
       }
 
       // the line object represents text[start..limit-1]
       static void renderLine(Bidi line, String text, int start, int limit,
                              StyleRun styleRuns[], int styleRunCount) {
           byte direction = line.getDirection();
           if (direction != Bidi.MIXED) {
               // unidirectional
               if (styleRunCount <= 1) {
                   renderRun(text, start, limit, direction, styleRuns[0].style);
               } else {
                   renderDirectionalRun(text, start, limit, direction,
                                        styleRuns, styleRunCount);
               }
           } else {
               // mixed-directional
               int count, i;
               BidiRun run;
 
               try {
                   count = line.countRuns();
               } catch (IllegalStateException e) {
                   e.printStackTrace();
                   return;
               }
               if (styleRunCount <= 1) {
                   int style = styleRuns[0].style;
 
                   // iterate over directional runs
                   for (i = 0; i < count; ++i) {
                       run = line.getVisualRun(i);
                       renderRun(text, run.getStart(), run.getLimit(),
                                 run.getDirection(), style);
                   }
               } else {
                   // iterate over both directional and style runs
                   for (i = 0; i < count; ++i) {
                       run = line.getVisualRun(i);
                       renderDirectionalRun(text, run.getStart(),
                                            run.getLimit(), run.getDirection(),
                                            styleRuns, styleRunCount);
                   }
               }
           }
       }
 
       static void renderParagraph(String text, byte textDirection,
                                   StyleRun styleRuns[], int styleRunCount,
                                   int lineWidth) {
           int length = text.length();
           Bidi para = new Bidi();
           try {
               para.setPara(text,
                            textDirection != 0 ? Bidi.LEVEL_DEFAULT_RTL
                                               : Bidi.LEVEL_DEFAULT_LTR,
                            null);
           } catch (Exception e) {
               e.printStackTrace();
               return;
           }
           byte paraLevel = (byte)(1 & para.getParaLevel());
           StyleRun styleRun = new StyleRun(length, styleNormal);
 
           if (styleRuns == null || styleRunCount <= 0) {
               styleRuns = new StyleRun[1];
               styleRunCount = 1;
               styleRuns[0] = styleRun;
           }
           // assume styleRuns[styleRunCount-1].limit>=length
 
           int width = getTextWidth(text, 0, length, styleRuns, styleRunCount);
           if (width <= lineWidth) {
               // everything fits onto one line
 
               // prepare rendering a new line from either left or right
               startLine(paraLevel, width);
 
               renderLine(para, text, 0, length, styleRuns, styleRunCount);
           } else {
               // we need to render several lines
               Bidi line = new Bidi(length, 0);
               int start = 0, limit;
               int styleRunStart = 0, styleRunLimit;
 
               for (;;) {
                   limit = length;
                   styleRunLimit = styleRunCount;
                   width = getLineBreak(text, new Bounds(start, limit),
                                        para, styleRuns,
                                        new Bounds(styleRunStart, styleRunLimit));
                   try {
                       line = para.setLine(start, limit);
                   } catch (Exception e) {
                       e.printStackTrace();
                       return;
                   }
                   // prepare rendering a new line
                   // from either left or right
                   startLine(paraLevel, width);
 
                   if (styleRunStart > 0) {
                       int newRunCount = styleRuns.length - styleRunStart;
                       StyleRun[] newRuns = new StyleRun[newRunCount];
                       System.arraycopy(styleRuns, styleRunStart, newRuns, 0,
                                        newRunCount);
                       renderLine(line, text, start, limit, newRuns,
                                  styleRunLimit - styleRunStart);
                   } else {
                       renderLine(line, text, start, limit, styleRuns,
                                  styleRunLimit - styleRunStart);
                   }
                   if (limit == length) {
                       break;
                   }
                   start = limit;
                   styleRunStart = styleRunLimit - 1;
                   if (start >= styleRuns[styleRunStart].limit) {
                       ++styleRunStart;
                   }
               }
           }
       }
 
       public static void main(String[] args)
       {
           renderParagraph("Some Latin text...", Bidi.LTR, null, 0, 80);
           renderParagraph("Some Hebrew text...", Bidi.RTL, null, 0, 60);
       }
   }

Summary

Constants
static Int	`DIRECTION_DEFAULT_LEFT_TO_RIGHT` Constant indicating that the base direction depends on the first strong directional character in the text according to the Unicode Bidirectional Algorithm.
static Int	`DIRECTION_DEFAULT_RIGHT_TO_LEFT` Constant indicating that the base direction depends on the first strong directional character in the text according to the Unicode Bidirectional Algorithm.
static Int	`DIRECTION_LEFT_TO_RIGHT` Constant indicating base direction is left-to-right.
static Int	`DIRECTION_RIGHT_TO_LEFT` Constant indicating base direction is right-to-left.
static Short	`DO_MIRRORING` option bit for writeReordered(): replace characters with the "mirrored" property in RTL runs by their mirror-image mappings
static Short	`INSERT_LRM_FOR_NUMERIC` option bit for writeReordered(): surround the run with LRMs if necessary; this is part of the approximate "inverse Bidi" algorithm
static Short	`KEEP_BASE_COMBINING` option bit for writeReordered(): keep combining characters after their base characters in RTL runs
static Byte	`LEVEL_DEFAULT_LTR` Paragraph level setting
static Byte	`LEVEL_DEFAULT_RTL` Paragraph level setting
static Byte	`LEVEL_OVERRIDE` Bit flag for level input.
static Byte	`LTR` Left-to-right text.
static Int	`MAP_NOWHERE` Special value which can be returned by the mapping methods when a logical index has no corresponding visual index or vice-versa.
static Byte	`MAX_EXPLICIT_LEVEL` Maximum explicit embedding level.
static Byte	`MIXED` Mixed-directional text.
static Byte	`NEUTRAL` No strongly directional text.
static Int	`OPTION_DEFAULT` Option value for `setReorderingOptions`: disable all the options which can be set with this method
static Int	`OPTION_INSERT_MARKS` Option bit for `setReorderingOptions`: insert Bidi marks (LRM or RLM) when needed to ensure correct result of a reordering to a Logical order
static Int	`OPTION_REMOVE_CONTROLS` Option bit for `setReorderingOptions`: remove Bidi control characters
static Int	`OPTION_STREAMING` Option bit for `setReorderingOptions`: process the output as part of a stream to be continued
static Short	`OUTPUT_REVERSE` option bit for writeReordered(): write the output in reverse order
static Short	`REMOVE_BIDI_CONTROLS` option bit for writeReordered(): remove Bidi control characters (this does not affect INSERT_LRM_FOR_NUMERIC)
static Short	`REORDER_DEFAULT` Reordering mode: Regular Logical to Visual Bidi algorithm according to Unicode.
static Short	`REORDER_GROUP_NUMBERS_WITH_R` Reordering mode: Logical to Visual algorithm grouping numbers with adjacent R characters (reversible algorithm).
static Short	`REORDER_INVERSE_FOR_NUMBERS_SPECIAL` Reordering mode: Inverse Bidi (Visual to Logical) algorithm for the `REORDER_NUMBERS_SPECIAL` Bidi algorithm.
static Short	`REORDER_INVERSE_LIKE_DIRECT` Reordering mode: Visual to Logical algorithm equivalent to the regular Logical to Visual algorithm.
static Short	`REORDER_INVERSE_NUMBERS_AS_L` Reordering mode: Visual to Logical algorithm which handles numbers like L (same algorithm as selected by `setInverse(true)`.
static Short	`REORDER_NUMBERS_SPECIAL` Reordering mode: Logical to Visual algorithm which handles numbers in a way which mimicks the behavior of Windows XP.
static Short	`REORDER_RUNS_ONLY` Reordering mode: Reorder runs only to transform a Logical LTR string to the logical RTL string with the same display, or vice-versa.
static Byte	`RTL` Right-to-left text.

Public constructors
`Bidi()` Allocate a `Bidi` object.
`Bidi(text: CharArray!, textStart: Int, embeddings: ByteArray!, embStart: Int, paragraphLength: Int, flags: Int)` Create Bidi from the given text, embedding, and direction information.
`Bidi(maxLength: Int, maxRunCount: Int)` Allocate a `Bidi` object with preallocated memory for internal structures.
`Bidi(paragraph: String!, flags: Int)` Create Bidi from the given paragraph of text and base direction.
`Bidi(paragraph: AttributedCharacterIterator!)` Create Bidi from the given paragraph of text.

Public methods
open Boolean	`baseIsLeftToRight()` Return true if the base direction is left-to-right
open Int	`countParagraphs()` Get the number of paragraphs.
open Int	`countRuns()` Get the number of runs.
open Bidi!	`createLineBidi(lineStart: Int, lineLimit: Int)` Create a Bidi object representing the bidi information on a line of text within the paragraph represented by the current Bidi.
open static Byte	`getBaseDirection(paragraph: CharSequence!)` Get the base direction of the text provided according to the Unicode Bidirectional Algorithm.
open Int	`getBaseLevel()` Return the base level (0 if left-to-right, 1 if right-to-left).
open BidiClassifier!	`getCustomClassifier()` Gets the current custom class classifier used for Bidi class determination.
open Int	`getCustomizedClass(c: Int)` Retrieves the Bidi class for a given code point.
open Byte	`getDirection()` Get the directionality of the text.
open Int	`getLength()` Get the length of the text.
open Byte	`getLevelAt(charIndex: Int)` Get the level for one character.
open ByteArray!	`getLevels()` Get an array of levels for each character.
open Int	`getLogicalIndex(visualIndex: Int)` Get the logical text position from a visual position.
open IntArray!	`getLogicalMap()` Get a logical-to-visual index map (array) for the characters in the `Bidi` (paragraph or line) object.
open BidiRun!	`getLogicalRun(logicalPosition: Int)` Get a logical run.
open Byte	`getParaLevel()` Get the paragraph level of the text.
open BidiRun!	`getParagraph(charIndex: Int)` Get a paragraph, given a position within the text.
open BidiRun!	`getParagraphByIndex(paraIndex: Int)` Get a paragraph, given the index of this paragraph.
open Int	`getParagraphIndex(charIndex: Int)` Get the index of a paragraph, given a position within the text.
open Int	`getProcessedLength()` Get the length of the source text processed by the last call to `setPara()`.
open Int	`getReorderingMode()` What is the requested reordering mode for a given Bidi object?
open Int	`getReorderingOptions()` What are the reordering options applied to a given Bidi object?
open Int	`getResultLength()` Get the length of the reordered text resulting from the last call to `setPara()`.
open Int	`getRunCount()` Return the number of level runs.
open Int	`getRunLevel(run: Int)` Return the level of the nth logical run in this line.
open Int	`getRunLimit(run: Int)` 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.
open Int	`getRunStart(run: Int)` 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.
open CharArray!	`getText()` Get the text.
open String!	`getTextAsString()` Get the text.
open Int	`getVisualIndex(logicalIndex: Int)` Get the visual position from a logical text position.
open IntArray!	`getVisualMap()` Get a visual-to-logical index map (array) for the characters in the `Bidi` (paragraph or line) object.
open BidiRun!	`getVisualRun(runIndex: Int)` Get a `BidiRun` object according to its index.
open static IntArray!	`invertMap(srcMap: IntArray!)` Invert an index map.
open Boolean	`isInverse()` Is this `Bidi` object set to perform the inverse Bidi algorithm?
open Boolean	`isLeftToRight()` Return true if the line is all left-to-right text and the base direction is left-to-right.
open Boolean	`isMixed()` Return true if the line is not left-to-right or right-to-left.
open Boolean	`isOrderParagraphsLTR()` Is this `Bidi` object set to allocate level 0 to block separators so that successive paragraphs progress from left to right?
open Boolean	`isRightToLeft()` Return true if the line is all right-to-left text, and the base direction is right-to-left
open Unit	`orderParagraphsLTR(ordarParaLTR: Boolean)` Specify whether block separators must be allocated level zero, so that successive paragraphs will progress from left to right.
open static IntArray!	`reorderLogical(levels: ByteArray!)` This is a convenience method that does not use a `Bidi` object.
open static IntArray!	`reorderVisual(levels: ByteArray!)` This is a convenience method that does not use a `Bidi` object.
open static Unit	`reorderVisually(levels: ByteArray!, levelStart: Int, objects: Array<Any!>!, objectStart: Int, count: Int)` Reorder the objects in the array into visual order based on their levels.
open static Boolean	`requiresBidi(text: CharArray!, start: Int, limit: Int)` Return true if the specified text requires bidi analysis.
open Unit	`setContext(prologue: String!, epilogue: String!)` Set the context before a call to setPara().
open Unit	`setCustomClassifier(classifier: BidiClassifier!)` Set a custom Bidi classifier used by the UBA implementation for Bidi class determination.
open Unit	`setInverse(isInverse: Boolean)` Modify the operation of the Bidi algorithm such that it approximates an "inverse Bidi" algorithm.
open Bidi!	`setLine(start: Int, limit: Int)` `setLine()` returns a `Bidi` object to contain the reordering information, especially the resolved levels, for all the characters in a line of text.
open Unit	`setPara(chars: CharArray!, paraLevel: Byte, embeddingLevels: ByteArray!)` Perform the Unicode Bidi algorithm.
open Unit	`setPara(text: String!, paraLevel: Byte, embeddingLevels: ByteArray!)` Perform the Unicode Bidi algorithm.
open Unit	`setPara(paragraph: AttributedCharacterIterator!)` Perform the Unicode Bidi algorithm on a given paragraph, as defined in the Unicode Standard Annex #9, version 13, also described in The Unicode Standard, Version 4.
open Unit	`setReorderingMode(reorderingMode: Int)` 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".
open Unit	`setReorderingOptions(options: Int)` Specify which of the reordering options should be applied during Bidi transformations.
open String!	`writeReordered(options: Int)` Take a `Bidi` object containing the reordering information for a piece of text (one or more paragraphs) set by `setPara()` or for a line of text set by `setLine()` and return a string containing the reordered text.
open static String!	`writeReverse(src: String!, options: Int)` Reverse a Right-To-Left run of Unicode text.

Parameters
`text`	CharArray!: an array containing the paragraph of text to process.
`textStart`	Int: the index into the text array of the start of the paragraph.
`embeddings`	ByteArray!: 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.
`embStart`	Int: the index into the embedding array of the start of the paragraph.
`paragraphLength`	Int: the length of the paragraph in the text and embeddings arrays.
`flags`	Int: 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.

Parameters
`paragraph`	String!: a paragraph of text
`flags`	Int: 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.

Parameters
`lineStart`	Int: the offset from the start of the paragraph to the start of the line.
`lineLimit`	Int: the offset from the start of the paragraph to the limit of the line.

Exceptions
`java.lang.IllegalStateException`	if this call is not preceded by a successful call to `setPara`
`java.lang.IllegalArgumentException`	if lineStart and lineLimit are not in the range `0<=lineStart<lineLimit<=getProcessedLength()`, or if the specified line crosses a paragraph boundary

Parameters
`levels`	ByteArray!: an array representing the bidi level of each object
`levelStart`	Int: the start position in the levels array
`objects`	Array<Any!>!: the array of objects to be reordered into visual order
`objectStart`	Int: the start position in the objects array
`count`	Int: the number of objects to reorder

Parameters
`text`	CharArray!: the text containing the characters to test
`start`	Int: the start of the range of characters to test
`limit`	Int: the limit of the range of characters to test

Parameters
`prologue`	String!: 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 `null`.
`epilogue`	String!: 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 `null`.

Parameters
`start`	Int: is the line's first index into the text.
`limit`	Int: is just behind the line's last index into the text (its last index +1).

Parameters
`chars`	CharArray!: contains the text that the Bidi algorithm will be performed on. This text can be retrieved with `getText()` or `getTextAsString`.
`paraLevel`	Byte: 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 `paraLevel` can be set to either `LEVEL_DEFAULT_LTR` or `LEVEL_DEFAULT_RTL`; 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 `MAX_EXPLICIT_LEVEL` is also valid, with odd levels indicating RTL.
`embeddingLevels`	ByteArray!: (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 `LEVEL_OVERRIDE` bit set. Aside from that bit, it must be `paraLevel<=embeddingLevels[]<=MAX_EXPLICIT_LEVEL`, except that level 0 is always allowed. Level 0 for a paragraph separator prevents reordering of paragraphs; this only works reliably if `LEVEL_OVERRIDE` 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. Caution: A reference to this array, not a copy of the levels, will be stored in the `Bidi` object; the `embeddingLevels` should not be modified to avoid unexpected results on subsequent Bidi operations. However, the `setPara()` and `setLine()` methods may modify some or all of the levels. Note: the `embeddingLevels` array must have one entry for each character in `text`.

Parameters
`text`	String!: contains the text that the Bidi algorithm will be performed on. This text can be retrieved with `getText()` or `getTextAsString`.
`paraLevel`	Byte: 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 `paraLevel` can be set to either `LEVEL_DEFAULT_LTR` or `LEVEL_DEFAULT_RTL`; 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 `MAX_EXPLICIT_LEVEL` is also valid, with odd levels indicating RTL.
`embeddingLevels`	ByteArray!: (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 `LEVEL_OVERRIDE` bit set. Aside from that bit, it must be `paraLevel<=embeddingLevels[]<=MAX_EXPLICIT_LEVEL`, except that level 0 is always allowed. Level 0 for a paragraph separator prevents reordering of paragraphs; this only works reliably if `LEVEL_OVERRIDE` 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. Caution: A reference to this array, not a copy of the levels, will be stored in the `Bidi` object; the `embeddingLevels` should not be modified to avoid unexpected results on subsequent Bidi operations. However, the `setPara()` and `setLine()` methods may modify some or all of the levels. Note: the `embeddingLevels` array must have one entry for each character in `text`.

Parameters
`src`	String!: The RTL run text.
`options`	Int: A bit set of options for the reordering that control how the reordered text is written. See the `options` parameter in `writeReordered()`.

Bidi

Bidi algorithm for ICU

General remarks about the API:

Basic concept: paragraph

Basic concept: text direction

Basic concept: levels

Basic concept: Reordering Mode

Basic concept: Reordering Options

Sample code for the ICU Bidi API

Rendering a paragraph with the ICU Bidi API

Summary

Constants

DIRECTION_DEFAULT_LEFT_TO_RIGHT

DIRECTION_DEFAULT_RIGHT_TO_LEFT

DIRECTION_LEFT_TO_RIGHT

DIRECTION_RIGHT_TO_LEFT

DO_MIRRORING

INSERT_LRM_FOR_NUMERIC

KEEP_BASE_COMBINING

LEVEL_DEFAULT_LTR

LEVEL_DEFAULT_RTL

LEVEL_OVERRIDE

LTR

MAP_NOWHERE

MAX_EXPLICIT_LEVEL

MIXED

NEUTRAL

OPTION_DEFAULT

OPTION_INSERT_MARKS

OPTION_REMOVE_CONTROLS

OPTION_STREAMING

OUTPUT_REVERSE

REMOVE_BIDI_CONTROLS

REORDER_DEFAULT

REORDER_GROUP_NUMBERS_WITH_R

REORDER_INVERSE_FOR_NUMBERS_SPECIAL

REORDER_INVERSE_LIKE_DIRECT

REORDER_INVERSE_NUMBERS_AS_L

REORDER_NUMBERS_SPECIAL

REORDER_RUNS_ONLY

RTL

Public constructors

Bidi

Bidi

Bidi

Bidi

Bidi

Public methods

baseIsLeftToRight

countParagraphs

countRuns

createLineBidi

getBaseDirection

getBaseLevel

getCustomClassifier

getCustomizedClass

getDirection

getLength

getLevelAt

getLevels

getLogicalIndex

getLogicalMap

getLogicalRun

getParaLevel

getParagraph

getParagraphByIndex

getParagraphIndex

getProcessedLength

getReorderingMode

getReorderingOptions

getResultLength

getRunCount

getRunLevel

getRunLimit

getRunStart

getText

getTextAsString

getVisualIndex

getVisualMap

getVisualRun