public BidiOrder(byte[] types) 
{
    
    //
    // Input
    //
        validateTypes(types);
        this.initialTypes = (byte[])types.clone(); // client type array remains unchanged
        runAlgorithm();
}

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

 public BidiOrder(byte[] types,
    byte paragraphEmbeddingLevel) 
{
        validateTypes(types);
        validateParagraphEmbeddingLevel(paragraphEmbeddingLevel);
        this.initialTypes = (byte[])types.clone(); // client type array remains unchanged
        this.paragraphEmbeddingLevel = paragraphEmbeddingLevel;
        runAlgorithm();
}

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.

 public BidiOrder(char[] text,
    int offset,
    int length,
    byte paragraphEmbeddingLevel) 
{
        initialTypes = new byte[length];
        for (int k = 0; k <  length; ++k) {
            initialTypes[k] = rtypes[text[offset + k]];
        }
        validateParagraphEmbeddingLevel(paragraphEmbeddingLevel);
        this.paragraphEmbeddingLevel = paragraphEmbeddingLevel;
        runAlgorithm();
}

 public byte getBaseLevel() 
{
        return paragraphEmbeddingLevel;
}

Return the base level of the paragraph.

 public static final byte getDirection(char c) 
{
        return rtypes[c];
}

 public byte[] getLevels() 
{
        return getLevels(new int[]{textLength});
}

 public byte[] getLevels(int[] linebreaks) 
{
        
        // Note that since the previous processing has removed all
        // P, S, and WS values from resultTypes, the values referred to
        // in these rules are the initial types, before any processing
        // has been applied (including processing of overrides).
        //
        // This example implementation has reinserted explicit format codes
        // and BN, in order that the levels array correspond to the
        // initial text.  Their final placement is not normative.
        // These codes are treated like WS in this implementation,
        // so they don't interrupt sequences of WS.
        validateLineBreaks(linebreaks, textLength);
        byte[] result = (byte[])resultLevels.clone(); // will be returned to caller
        // don't worry about linebreaks since if there is a break within
        // a series of WS values preceding S, the linebreak itself
        // causes the reset.
        for (int i = 0; i <  result.length; ++i) {
            byte t = initialTypes[i];
            if (t == B || t == S) {
                // Rule L1, clauses one and two.
                result[i] = paragraphEmbeddingLevel;
                // Rule L1, clause three.
                for (int j = i - 1; j  >= 0; --j) {
                    if (isWhitespace(initialTypes[j])) { // including format codes
                        result[j] = paragraphEmbeddingLevel;
                    } else {
                        break;
                    }
                }
            }
        }
        // Rule L1, clause four.
        int start = 0;
        for (int i = 0; i <  linebreaks.length; ++i) {
            int limit = linebreaks[i];
            for (int j = limit - 1; j  >= start; --j) {
                if (isWhitespace(initialTypes[j])) { // including format codes
                    result[j] = paragraphEmbeddingLevel;
                } else {
                    break;
                }
            }
            start = limit;
        }
        return result;
}

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.

 public int[] getReordering(int[] linebreaks) 
{
        validateLineBreaks(linebreaks, textLength);
        byte[] levels = getLevels(linebreaks);
        return computeMultilineReordering(levels, 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.