com.lowagie.text.pdf

## Class BidiOrder

- java.lang.Object
- - com.lowagie.text.pdf.BidiOrder

-     public final class BidiOrder
      extends java.lang.Object

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static byte` | `AL` Right-to-Left Arabic
    `static byte` | `AN` Arabic Number
    `static byte` | `B` Paragraph Separator
    `private static char[]` | `baseTypes`
    `static byte` | `BN` Boundary Neutral
    `static byte` | `CS` Common Number Separator
    `private byte[]` | `embeddings`
    `static byte` | `EN` European Number
    `static byte` | `ES` European Number Separator
    `static byte` | `ET` European Number Terminator
    `private byte[]` | `initialTypes`
    `static byte` | `L` Left-to-right
    `static byte` | `LRE` Left-to-Right Embedding
    `static byte` | `LRO` Left-to-Right Override
    `static byte` | `NSM` Non-Spacing Mark
    `static byte` | `ON` Other Neutrals
    `private byte` | `paragraphEmbeddingLevel`
    `static byte` | `PDF` Pop Directional Format
    `static byte` | `R` Right-to-Left
    `private byte[]` | `resultLevels`
    `private byte[]` | `resultTypes`
    `static byte` | `RLE` Right-to-Left Embedding
    `static byte` | `RLO` Right-to-Left Override
    `private static byte[]` | `rtypes`
    `static byte` | `S` Segment Separator
    `private int` | `textLength`
    `static byte` | `TYPE_MAX` Maximum bidi type value.
    `static byte` | `TYPE_MIN` Minimum bidi type value.
    `static byte` | `WS` Whitespace

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `BidiOrder(byte[] types)` Initialize using an array of direction types.
    `BidiOrder(byte[] types, byte paragraphEmbeddingLevel)` Initialize using an array of direction types and an externally supplied paragraph embedding level.
    `BidiOrder(char[] text, int offset, int length, byte paragraphEmbeddingLevel)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `private static int[]` | `computeMultilineReordering(byte[] levels, int[] linebreaks)` Return multiline reordering array for a given level array.
    `private static int[]` | `computeReordering(byte[] levels)` Return reordering array for a given level array.
    `private void` | `determineExplicitEmbeddingLevels()` Process embedding format codes.
    `private void` | `determineParagraphEmbeddingLevel()` 1) determining the paragraph level.
    `private int` | `findRunLimit(int index, int limit, byte[] validSet)` Return the limit of the run starting at index that includes only resultTypes in validSet.
    `private int` | `findRunStart(int index, byte[] validSet)` Return the start of the run including index that includes only resultTypes in validSet.
    `byte` | `getBaseLevel()` Return the base level of the paragraph.
    `static byte` | `getDirection(char c)`
    `byte[]` | `getLevels()`
    `byte[]` | `getLevels(int[] linebreaks)` Return levels array breaking lines at offsets in linebreaks.
    `int[]` | `getReordering(int[] linebreaks)` Return reordering array breaking lines at offsets in linebreaks.
    `private static boolean` | `isWhitespace(byte biditype)` Return true if the type is considered a whitespace type for the line break rules.
    `private static byte[]` | `processEmbeddings(byte[] resultTypes, byte paragraphEmbeddingLevel)` 2) determining explicit levels Rules X1 - X8 The interaction of these rules makes handling them a bit complex.
    `private int` | `reinsertExplicitCodes(int textLength)` Reinsert levels information for explicit codes.
    `private int` | `removeExplicitCodes()` Rules X9.
    `private void` | `resolveImplicitLevels(int start, int limit, byte level, byte sor, byte eor)` 7) resolving implicit embedding levels Rules I1, I2.
    `private void` | `resolveNeutralTypes(int start, int limit, byte level, byte sor, byte eor)` 6) resolving neutral types Rules N1-N2.
    `private void` | `resolveWeakTypes(int start, int limit, byte level, byte sor, byte eor)` 3) resolving weak types Rules W1-W7.
    `private void` | `runAlgorithm()` The algorithm.
    `private void` | `setLevels(int start, int limit, byte newLevel)` Set resultLevels from start up to (but not including) limit to newLevel.
    `private void` | `setTypes(int start, int limit, byte newType)` Set resultTypes from start up to (but not including) limit to newType.
    `private static byte` | `typeForLevel(int level)` Return the strong type (L or R) corresponding to the level.
    `private static void` | `validateLineBreaks(int[] linebreaks, int textLength)` Throw exception if line breaks array is invalid.
    `private static void` | `validateParagraphEmbeddingLevel(byte paragraphEmbeddingLevel)` Throw exception if paragraph embedding level is invalid.
    `private static void` | `validateTypes(byte[] types)` Throw exception if type array is invalid.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### initialTypes

          private byte[] initialTypes

    - #### embeddings

          private byte[] embeddings

    - #### paragraphEmbeddingLevel

          private byte paragraphEmbeddingLevel

    - #### textLength

          private int textLength

    - #### resultTypes

          private byte[] resultTypes

    - #### resultLevels

          private byte[] resultLevels

    - #### L

          public static final byte L

      Left-to-right
      See Also:
        Constant Field Values

    - #### LRE

          public static final byte LRE

      Left-to-Right Embedding
      See Also:
        Constant Field Values

    - #### LRO

          public static final byte LRO

      Left-to-Right Override
      See Also:
        Constant Field Values

    - #### R

          public static final byte R

      Right-to-Left
      See Also:
        Constant Field Values

    - #### AL

          public static final byte AL

      Right-to-Left Arabic
      See Also:
        Constant Field Values

    - #### RLE

          public static final byte RLE

      Right-to-Left Embedding
      See Also:
        Constant Field Values

    - #### RLO

          public static final byte RLO

      Right-to-Left Override
      See Also:
        Constant Field Values

    - #### PDF

          public static final byte PDF

      Pop Directional Format
      See Also:
        Constant Field Values

    - #### EN

          public static final byte EN

      European Number
      See Also:
        Constant Field Values

    - #### ES

          public static final byte ES

      European Number Separator
      See Also:
        Constant Field Values

    - #### ET

          public static final byte ET

      European Number Terminator
      See Also:
        Constant Field Values

    - #### AN

          public static final byte AN

      Arabic Number
      See Also:
        Constant Field Values

    - #### CS

          public static final byte CS

      Common Number Separator
      See Also:
        Constant Field Values

    - #### NSM

          public static final byte NSM

      Non-Spacing Mark
      See Also:
        Constant Field Values

    - #### BN

          public static final byte BN

      Boundary Neutral
      See Also:
        Constant Field Values

    - #### B

          public static final byte B

      Paragraph Separator
      See Also:
        Constant Field Values

    - #### S

          public static final byte S

      Segment Separator
      See Also:
        Constant Field Values

    - #### WS

          public static final byte WS

      Whitespace
      See Also:
        Constant Field Values

    - #### ON

          public static final byte ON

      Other Neutrals
      See Also:
        Constant Field Values

    - #### TYPE_MIN

          public static final byte TYPE_MIN

      Minimum bidi type value.
      See Also:
        Constant Field Values

    - #### TYPE_MAX

          public static final byte TYPE_MAX

      Maximum bidi type value.
      See Also:
        Constant Field Values

    - #### rtypes

          private static final byte[] rtypes

    - #### baseTypes

          private static char[] baseTypes

  - ### Constructor Detail

    - #### BidiOrder

          public BidiOrder(byte[] types)

      Initialize using an array of direction types. Types range from TYPE_MIN to TYPE_MAX inclusive and represent the direction codes of the characters in the text.
      Parameters:
        `types` - the types array

    - #### BidiOrder

          public BidiOrder(byte[] types,
                   byte paragraphEmbeddingLevel)

      Initialize using an array of direction types and an externally supplied paragraph embedding level. The embedding level may be -1, 0, or 1. -1 means to apply the default algorithm (rules P2 and P3), 0 is for LTR paragraphs, and 1 is for RTL paragraphs.
      Parameters:
        `types` - the types array
        `paragraphEmbeddingLevel` - the externally supplied paragraph embedding level.

    - #### BidiOrder

          public BidiOrder(char[] text,
                   int offset,
                   int length,
                   byte paragraphEmbeddingLevel)

  - ### Method Detail

    - #### getDirection

          public static final byte getDirection(char c)

    - #### runAlgorithm

          private void runAlgorithm()

      The algorithm. Does not include line-based processing (Rules L1, L2). These are applied later in the line-based phase of the algorithm.

    - #### determineParagraphEmbeddingLevel

          private void determineParagraphEmbeddingLevel()

      1) determining the paragraph level.

      Rules P2, P3.

      At the end of this function, the member variable paragraphEmbeddingLevel is set to either 0 or 1.

    - #### determineExplicitEmbeddingLevels

          private void determineExplicitEmbeddingLevels()

      Process embedding format codes.

      Calls processEmbeddings to generate an embedding array from the explicit format codes. The embedding overrides in the array are then applied to the result types, and the result levels are initialized.

      See Also:
        `processEmbeddings(byte[], byte)`

    - #### removeExplicitCodes

          private int removeExplicitCodes()

      Rules X9. Remove explicit codes so that they may be ignored during the remainder of the main portion of the algorithm. The length of the resulting text is returned.
      Returns:
        the length of the data excluding explicit codes and BN.

    - #### reinsertExplicitCodes

          private int reinsertExplicitCodes(int textLength)

      Reinsert levels information for explicit codes. This is for ease of relating the level information to the original input data. Note that the levels assigned to these codes are arbitrary, they're chosen so as to avoid breaking level runs.
      Parameters:
        `textLength` - the length of the data after compression
      Returns:
        the length of the data (original length of types array supplied to constructor)

    - #### processEmbeddings

          private static byte[] processEmbeddings(byte[] resultTypes,
                                 byte paragraphEmbeddingLevel)

      2) determining explicit levels Rules X1 - X8 The interaction of these rules makes handling them a bit complex. This examines resultTypes but does not modify it. It returns embedding and override information in the result array. The low 7 bits are the level, the high bit is set if the level is an override, and clear if it is an embedding.

    - #### resolveWeakTypes

          private void resolveWeakTypes(int start,
                              int limit,
                              byte level,
                              byte sor,
                              byte eor)

      3) resolving weak types Rules W1-W7. Note that some weak types (EN, AN) remain after this processing is complete.

    - #### resolveNeutralTypes

          private void resolveNeutralTypes(int start,
                                 int limit,
                                 byte level,
                                 byte sor,
                                 byte eor)

      6) resolving neutral types Rules N1-N2.

    - #### resolveImplicitLevels

          private void resolveImplicitLevels(int start,
                                   int limit,
                                   byte level,
                                   byte sor,
                                   byte eor)

      7) resolving implicit embedding levels Rules I1, I2.

    - #### getLevels

          public byte[] getLevels()

    - #### getLevels

          public byte[] getLevels(int[] linebreaks)

      Return levels array breaking lines at offsets in linebreaks.
      Rule L1.

      The returned levels array contains the resolved level for each bidi code passed to the constructor.

      The linebreaks array must include at least one value. The values must be in strictly increasing order (no duplicates) between 1 and the length of the text, inclusive. The last value must be the length of the text.

      Parameters:
        `linebreaks` - the offsets at which to break the paragraph
      Returns:
        the resolved levels of the text

    - #### getReordering

          public int[] getReordering(int[] linebreaks)

      Return reordering array breaking lines at offsets in linebreaks.

      The reordering array maps from a visual index to a logical index. Lines are concatenated from left to right. So for example, the fifth character from the left on the third line is

           getReordering(linebreaks)[linebreaks[1] + 4]

      (linebreaks[1] is the position after the last character of the second line, which is also the index of the first character on the third line, and adding four gets the fifth character from the left).

      The linebreaks array must include at least one value. The values must be in strictly increasing order (no duplicates) between 1 and the length of the text, inclusive. The last value must be the length of the text.

      Parameters:
        `linebreaks` - the offsets at which to break the paragraph.

    - #### computeMultilineReordering

          private static int[] computeMultilineReordering(byte[] levels,
                                         int[] linebreaks)

      Return multiline reordering array for a given level array. Reordering does not occur across a line break.

    - #### computeReordering

          private static int[] computeReordering(byte[] levels)

      Return reordering array for a given level array. This reorders a single line. The reordering is a visual to logical map. For example, the leftmost char is string.charAt(order[0]). Rule L2.

    - #### getBaseLevel

          public byte getBaseLevel()

      Return the base level of the paragraph.

    - #### isWhitespace

          private static boolean isWhitespace(byte biditype)

      Return true if the type is considered a whitespace type for the line break rules.

    - #### typeForLevel

          private static byte typeForLevel(int level)

      Return the strong type (L or R) corresponding to the level.

    - #### findRunLimit

          private int findRunLimit(int index,
                         int limit,
                         byte[] validSet)

      Return the limit of the run starting at index that includes only resultTypes in validSet. This checks the value at index, and will return index if that value is not in validSet.

    - #### findRunStart

          private int findRunStart(int index,
                         byte[] validSet)

      Return the start of the run including index that includes only resultTypes in validSet. This assumes the value at index is valid, and does not check it.

    - #### setTypes

          private void setTypes(int start,
                      int limit,
                      byte newType)

      Set resultTypes from start up to (but not including) limit to newType.

    - #### setLevels

          private void setLevels(int start,
                       int limit,
                       byte newLevel)

      Set resultLevels from start up to (but not including) limit to newLevel.

    - #### validateTypes

          private static void validateTypes(byte[] types)

      Throw exception if type array is invalid.

    - #### validateParagraphEmbeddingLevel

          private static void validateParagraphEmbeddingLevel(byte paragraphEmbeddingLevel)

      Throw exception if paragraph embedding level is invalid. Special allowance for -1 so that default processing can still be performed when using this API.

    - #### validateLineBreaks

          private static void validateLineBreaks(int[] linebreaks,
                                int textLength)

      Throw exception if line breaks array is invalid.