public final Class CaseFolding

Returns the case-folded form of the specified code point according to the Unicode case folding mappings.

If the code point has no case folding mapping defined, this method returns the original code point. Possible combinations of the returning case-folding form as a long value +---+---------+--------+---------+--------+--------+ | 1:1 mapping | 0000 | 0000 | 000x | xxxx | 0041 => 0061 or 1E921 => 1E943 +---+---------+--------+---------+--------+--------+ | 1:2 mapping | 0002 | 0000 | xxxx | xxxx | FB02 => 0066 006C +---+---------+--------+---------+--------+--------+ | 1:3 mapping | 0003 | xxxx | xxxx | xxxx | FB03 => 0066 0066 0069 +---+---------+--------+---------+--------+--------+

Parameters

cp:int

the Unicode code point to fold

Returns:long

a long value representing the case-folded form of the input code point, encoded as TBD

Returns an expansion set to "close" a given regex Unicode character class range for case-sensitive matching, according to the Simple Loose Matches rule defined in Unicode Technical Standard #18: Unicode Regular Expressions.

To conform with Level 1 of UTS #18, specifically RL1.5: Simple Loose Matches, simple case folding must be applied to literals and (optionally) to character classes. When applied to character classes, each character class is expected to be closed under simple case folding. See the standard for the detailed explanation and example of "closed".

RL1.5 states: To meet this requirement, an implementation that supports case-sensitive matching should

1. Provide at least the simple, default Unicode case-insensitive matching, and
2. Specify which character properties or constructs are closed under the matching.

In the Pattern implementation, 5 types of constructs maybe case-sensitive when matching: back-refs, string slice (sequences), single, family(char-property) and class range. Single and family may appears independently or within a class.

For loose/case-insensitive matching, the back-refs, slices and singles apply toUpperCase and toLowerCase to both the pattern and the input string. This effectively 'close' the class for matching.

The family/char-properties are not "closed" and should remain unchanged. This is acceptable per RL1.5, if their behavior is clearly specified.

This method addresses that requirement for the "range" construct within in character class by computing the additional characters that should be included to close the range under simple case folding:

For each character in the input range [start, end] (inclusive), if the character has a simple case folding mapping in Unicode's CaseFolding.txt, the mapping is not a round-trip map, and the mapped character is not already in the range, then that mapped character (typically lowercase) is added to the expansion set.

This allows regex character class "range" implementation to use the returned expansion set to support additional case-insensitive matching, without duplicating characters already covered by the existing regex range implementation. The expectation is the matching is done using both the uppercase and lowercase forms of the input character, for example

ch -> inRange(lower, Character.toUpperCase(ch), upper) ||
          inRange(lower, Character.toLower(ch), upper) ||
          additionalClosingCharacters.contains(Character.toUpperCase(ch)) ||
          additionalClosingCharacters.contains(Character.toUpperCase(ch))

Parameters

start:int

the starting code point of the character range

end:int

the ending code point of the character range

Returns:int[]

a int[] containing the all simple case equivalents of characters in the range, excluding those already in the range

External Specification

https://www.unicode.org/reports/tr18/#Simple_Loose_Matches

Tests whether the specified code point has a folding mapping entry defined.

Parameters

cp:int

the Unicode code point to test

Returns:boolean

true if the given code point has a case folding mapping entry defined in (@code caseFoldingMap}, false otherwise