/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/* $Id$ */
package org.apache.fop.complexscripts.util;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
// CSOFF: LineLengthCheck
/**
* <p>Implementation of Number to String Conversion algorithm specified by
* XSL Transformations (XSLT) Version 2.0, W3C Recommendation, 23 January 2007.</p>
*
* <p>This algorithm differs from that specified in XSLT 1.0 in the following
* ways:</p>
* <ul>
* <li>input numbers are greater than or equal to zero rather than greater than zero;</li>
* <li>introduces format tokens { w, W, Ww };</li>
* <li>introduces ordinal parameter to generate ordinal numbers;</li>
* </ul>
*
* <p>Implementation Defaults and Limitations</p>
* <ul>
* <li>If language parameter is unspecified (null or empty string), then the value
* of DEFAULT_LANGUAGE is used, which is defined below as "eng" (English).</li>
* <li>Only English, French, and Spanish word numerals are supported, and only if less than one trillion (1,000,000,000,000).</li>
* <li>Ordinal word numerals are supported for French and Spanish only when less than or equal to ten (10).</li>
* </ul>
*
* <p>Implementation Notes</p>
* <ul>
* <li>In order to handle format tokens outside the Unicode BMP, all processing is
* done in Unicode Scalar Values represented with Integer and Integer[]
* types. Without affecting behavior, this may be subsequently optimized to
* use int and int[] types.</li>
* <li>In order to communicate various sub-parameters, including ordinalization, a <em>features</em>
* is employed, which consists of comma separated name and optional value tokens, where name and value
* are separated by an equals '=' sign.</li>
* <li>Ordinal numbers are selected by specifying a word based format token in combination with a 'ordinal' feature with no value, in which case
* the features 'male' and 'female' may be used to specify gender for gender sensitive languages. For example, the feature string "ordinal,female"
* selects female ordinals.</li>
* </ul>
*
* <p>This work was originally authored by Glenn Adams (gadams@apache.org).</p>
*/
public class NumberConverter {
/** alphabetical */
public static final int LETTER_VALUE_ALPHABETIC = 1;
/** traditional */
public static final int LETTER_VALUE_TRADITIONAL = 2;
/** no token type */
private static final int TOKEN_NONE = 0;
/** alhphanumeric token type */
private static final int TOKEN_ALPHANUMERIC = 1;
/** nonalphanumeric token type */
private static final int TOKEN_NONALPHANUMERIC = 2;
/** default token */
private static final Integer[] DEFAULT_TOKEN = new Integer[] { (int) '1' };
/** default separator */
private static final Integer[] DEFAULT_SEPARATOR = new Integer[] { (int) '.' };
/** default language */
private static final String DEFAULT_LANGUAGE = "eng";
/** prefix token */
private Integer[] prefix;
/** suffix token */
private Integer[] suffix;
/** sequence of tokens, as parsed from format */
private Integer[][] tokens;
/** sequence of separators, as parsed from format */
private Integer[][] separators;
/** grouping separator */
private int groupingSeparator;
/** grouping size */
private int groupingSize;
/** letter value */
private int letterValue;
/** letter value system */
private String features;
/** language */
private String language;
/** country */
private String country;
/**
* Construct parameterized number converter.
* @param format format for the page number (may be null or empty, which is treated as null)
* @param groupingSeparator grouping separator (if zero, then no grouping separator applies)
* @param groupingSize grouping size (if zero or negative, then no grouping size applies)
* @param letterValue letter value (must be one of the above letter value enumeration values)
* @param features features (feature sub-parameters)
* @param language (may be null or empty, which is treated as null)
* @param country (may be null or empty, which is treated as null)
* @throws IllegalArgumentException if format is not a valid UTF-16 string (e.g., has unpaired surrogate)
*/
public NumberConverter(String format, int groupingSeparator, int groupingSize, int letterValue, String features, String language, String country)
throws IllegalArgumentException {
this.groupingSeparator = groupingSeparator;
this.groupingSize = groupingSize;
this.letterValue = letterValue;
this.features = features;
this.language = (language != null) ? language.toLowerCase() : null;
this.country = (country != null) ? country.toLowerCase() : null;
parseFormatTokens(format);
}
/**
* Convert a number to string according to conversion parameters.
* @param number number to conver
* @return string representing converted number
*/
public String convert(long number) {
List<Long> numbers = new ArrayList<Long>();
numbers.add(number);
return convert(numbers);
}
/**
* Convert list of numbers to string according to conversion parameters.
* @param numbers list of numbers to convert
* @return string representing converted list of numbers
*/
public String convert(List<Long> numbers) {
List<Integer> scalars = new ArrayList<Integer>();
if (prefix != null) {
appendScalars(scalars, prefix);
}
convertNumbers(scalars, numbers);
if (suffix != null) {
appendScalars(scalars, suffix);
}
return scalarsToString(scalars);
}
private void parseFormatTokens(String format) throws IllegalArgumentException {
List<Integer[]> tokens = new ArrayList<Integer[]>();
List<Integer[]> separators = new ArrayList<Integer[]>();
if ((format == null) || (format.length() == 0)) {
format = "1";
}
int tokenType = TOKEN_NONE;
List<Integer> token = new ArrayList<Integer>();
Integer[] ca = UTF32.toUTF32(format, 0, true);
for (Integer c : ca) {
int tokenTypeNew = isAlphaNumeric(c) ? TOKEN_ALPHANUMERIC : TOKEN_NONALPHANUMERIC;
if (tokenTypeNew != tokenType) {
if (token.size() > 0) {
if (tokenType == TOKEN_ALPHANUMERIC) {
tokens.add(token.toArray(new Integer[token.size()]));
} else {
separators.add(token.toArray(new Integer[token.size()]));
}
token.clear();
}
tokenType = tokenTypeNew;
}
token.add(c);
}
if (token.size() > 0) {
if (tokenType == TOKEN_ALPHANUMERIC) {
tokens.add(token.toArray(new Integer [ token.size() ]));
} else {
separators.add(token.toArray(new Integer [ token.size() ]));
}
}
if (!separators.isEmpty()) {
this.prefix = separators.remove(0);
}
if (!separators.isEmpty()) {
this.suffix = separators.remove(separators.size() - 1);
}
this.separators = separators.toArray(new Integer [ separators.size() ] []);
this.tokens = tokens.toArray(new Integer [ tokens.size() ] []);
}
private static boolean isAlphaNumeric(int c) {
switch (Character.getType(c)) {
case Character.DECIMAL_DIGIT_NUMBER: // Nd
case Character.LETTER_NUMBER: // Nl
case Character.OTHER_NUMBER: // No
case Character.UPPERCASE_LETTER: // Lu
case Character.LOWERCASE_LETTER: // Ll
case Character.TITLECASE_LETTER: // Lt
case Character.MODIFIER_LETTER: // Lm
case Character.OTHER_LETTER: // Lo
return true;
default:
return false;
}
}
private void convertNumbers(List<Integer> scalars, List<Long> numbers) {
Integer[] tknLast = DEFAULT_TOKEN;
int tknIndex = 0;
int tknCount = tokens.length;
int sepIndex = 0;
int sepCount = separators.length;
int numIndex = 0;
for (Long number : numbers) {
Integer[] sep = null;
Integer[] tkn;
if (tknIndex < tknCount) {
if (numIndex > 0) {
if (sepIndex < sepCount) {
sep = separators [ sepIndex++ ];
} else {
sep = DEFAULT_SEPARATOR;
}
}
tkn = tokens [ tknIndex++ ];
} else {
tkn = tknLast;
}
appendScalars(scalars, convertNumber(number, sep, tkn));
tknLast = tkn;
numIndex++;
}
}
private Integer[] convertNumber(long number, Integer[] separator, Integer[] token) {
List<Integer> sl = new ArrayList<Integer>();
if (separator != null) {
appendScalars(sl, separator);
}
if (token != null) {
appendScalars(sl, formatNumber(number, token));
}
return sl.toArray(new Integer [ sl.size() ]);
}
private Integer[] formatNumber(long number, Integer[] token) {
Integer[] fn = null;
assert token.length > 0;
if (number < 0) {
throw new IllegalArgumentException("number must be non-negative");
} else if (token.length == 1) {
int s = token[0];
switch (s) {
case (int) '1':
fn = formatNumberAsDecimal(number, (int) '1', 1);
break;
case (int) 'W':
case (int) 'w':
fn = formatNumberAsWord(number, (s == (int) 'W') ? Character.UPPERCASE_LETTER : Character.LOWERCASE_LETTER);
break;
case (int) 'A': // handled as numeric sequence
case (int) 'a': // handled as numeric sequence
case (int) 'I': // handled as numeric special
case (int) 'i': // handled as numeric special
default:
if (isStartOfDecimalSequence(s)) {
fn = formatNumberAsDecimal(number, s, 1);
} else if (isStartOfAlphabeticSequence(s)) {
fn = formatNumberAsSequence(number, s, getSequenceBase(s), null);
} else if (isStartOfNumericSpecial(s)) {
fn = formatNumberAsSpecial(number, s);
} else {
fn = null;
}
break;
}
} else if ((token.length == 2) && (token[0] == (int) 'W') && (token[1] == (int) 'w')) {
fn = formatNumberAsWord(number, Character.TITLECASE_LETTER);
} else if (isPaddedOne(token)) {
int s = token[token.length - 1];
fn = formatNumberAsDecimal(number, s, token.length);
} else {
throw new IllegalArgumentException("invalid format token: \"" + UTF32.fromUTF32(token) + "\"");
}
if (fn == null) {
fn = formatNumber(number, DEFAULT_TOKEN);
}
assert fn != null;
return fn;
}
/**
* Format NUMBER as decimal using characters denoting digits that start at ONE,
* adding one or more (zero) padding characters as needed to fill out field WIDTH.
* @param number to be formatted
* @param one unicode scalar value denoting numeric value 1
* @param width non-negative integer denoting field width of number, possible including padding
* @return formatted number as array of unicode scalars
*/
private Integer[] formatNumberAsDecimal(long number, int one, int width) {
assert Character.getNumericValue(one) == 1;
assert Character.getNumericValue(one - 1) == 0;
assert Character.getNumericValue(one + 8) == 9;
List<Integer> sl = new ArrayList<Integer>();
int zero = one - 1;
while (number > 0) {
long digit = number % 10;
sl.add(0, zero + (int) digit);
number = number / 10;
}
while (width > sl.size()) {
sl.add(0, zero);
}
if ((groupingSize != 0) && (groupingSeparator != 0)) {
sl = performGrouping(sl, groupingSize, groupingSeparator);
}
return sl.toArray(new Integer [ sl.size() ]);
}
private static List<Integer> performGrouping(List<Integer> sl, int groupingSize, int groupingSeparator) {
assert groupingSize > 0;
assert groupingSeparator != 0;
if (sl.size() > groupingSize) {
List<Integer> gl = new ArrayList<Integer>();
for (int i = 0, n = sl.size(), g = 0; i < n; i++) {
int k = n - i - 1;
if (g == groupingSize) {
gl.add(0, groupingSeparator);
g = 1;
} else {
g++;
}
gl.add(0, sl.get(k));
}
return gl;
} else {
return sl;
}
}
/**
* Format NUMBER as using sequence of characters that start at ONE, and
* having BASE radix.
* @param number to be formatted
* @param one unicode scalar value denoting start of sequence (numeric value 1)
* @param base number of elements in sequence
* @param map if non-null, then maps sequences indices to unicode scalars
* @return formatted number as array of unicode scalars
*/
private Integer[] formatNumberAsSequence(long number, int one, int base, int[] map) {
assert base > 1;
assert (map == null) || (map.length >= base);
List<Integer> sl = new ArrayList<Integer>();
if (number == 0) {
return null;
} else {
long n = number;
while (n > 0) {
int d = (int) ((n - 1) % (long) base);
int s = (map != null) ? map [ d ] : (one + d);
sl.add(0, s);
n = (n - 1) / base;
}
return sl.toArray(new Integer [ sl.size() ]);
}
}
/**
* Format NUMBER as using special system that starts at ONE.
* @param number to be formatted
* @param one unicode scalar value denoting start of system (numeric value 1)
* @return formatted number as array of unicode scalars
*/
private Integer[] formatNumberAsSpecial(long number, int one) {
SpecialNumberFormatter f = getSpecialFormatter(one, letterValue, features, language, country);
if (f != null) {
return f.format(number, one, letterValue, features, language, country);
} else {
return null;
}
}
/**
* Format NUMBER as word according to TYPE, which must be either
* Character.UPPERCASE_LETTER, Character.LOWERCASE_LETTER, or
* Character.TITLECASE_LETTER. Makes use of this.language to
* determine language of word.
* @param number to be formatted
* @param caseType unicode character type for case conversion
* @return formatted number as array of unicode scalars
*/
private Integer[] formatNumberAsWord(long number, int caseType) {
SpecialNumberFormatter f = null;
if (isLanguage("eng")) {
f = new EnglishNumberAsWordFormatter(caseType);
} else if (isLanguage("spa")) {
f = new SpanishNumberAsWordFormatter(caseType);
} else if (isLanguage("fra")) {
f = new FrenchNumberAsWordFormatter(caseType);
} else {
f = new EnglishNumberAsWordFormatter(caseType);
}
return f.format(number, 0, letterValue, features, language, country);
}
private boolean isLanguage(String iso3Code) {
if (language == null) {
return false;
} else if (language.equals(iso3Code)) {
return true;
} else {
return isSameLanguage(iso3Code, language);
}
}
private static String[][] equivalentLanguages = {
{ "eng", "en" },
{ "fra", "fre", "fr" },
{ "spa", "es" },
};
private static boolean isSameLanguage(String i3c, String lc) {
for (String[] el : equivalentLanguages) {
assert el.length >= 2;
if (el[0].equals(i3c)) {
for (String anEl : el) {
if (anEl.equals(lc)) {
return true;
}
}
return false;
}
}
return false;
}
private static boolean hasFeature(String features, String feature) {
if (features != null) {
assert feature != null;
assert feature.length() != 0;
String[] fa = features.split(",");
for (String f : fa) {
String[] fp = f.split("=");
assert fp.length > 0;
String fn = fp[0];
String fv = (fp.length > 1) ? fp[1] : "";
if (fn.equals(feature)) {
return true;
}
}
}
return false;
}
/* not yet used
private static String getFeatureValue ( String features, String feature ) {
if ( features != null ) {
assert feature != null;
assert feature.length() != 0;
String[] fa = features.split(",");
for ( String f : fa ) {
String[] fp = f.split("=");
assert fp.length > 0;
String fn = fp[0];
String fv = ( fp.length > 1 ) ? fp[1] : "";
if ( fn.equals ( feature ) ) {
return fv;
}
}
}
return "";
}
*/
private static void appendScalars(List<Integer> scalars, Integer[] sa) {
Collections.addAll(scalars, sa);
}
private static String scalarsToString(List<Integer> scalars) {
Integer[] sa = scalars.toArray(new Integer [ scalars.size() ]);
return UTF32.fromUTF32(sa);
}
private static boolean isPaddedOne(Integer[] token) {
if (getDecimalValue(token [ token.length - 1 ]) != 1) {
return false;
} else {
for (int i = 0, n = token.length - 1; i < n; i++) {
if (getDecimalValue(token [ i ]) != 0) {
return false;
}
}
return true;
}
}
private static int getDecimalValue(Integer scalar) {
int s = scalar;
if (Character.getType(s) == Character.DECIMAL_DIGIT_NUMBER) {
return Character.getNumericValue(s);
} else {
return -1;
}
}
private static boolean isStartOfDecimalSequence(int s) {
return (Character.getNumericValue(s) == 1)
&& (Character.getNumericValue(s - 1) == 0)
&& (Character.getNumericValue(s + 8) == 9);
}
private static int[][] supportedAlphabeticSequences = {
{ 'A', 26 }, // A...Z
{ 'a', 26 }, // a...z
};
private static boolean isStartOfAlphabeticSequence(int s) {
for (int[] ss : supportedAlphabeticSequences) {
assert ss.length >= 2;
if (ss[0] == s) {
return true;
}
}
return false;
}
private static int getSequenceBase(int s) {
for (int[] ss : supportedAlphabeticSequences) {
assert ss.length >= 2;
if (ss[0] == s) {
return ss[1];
}
}
return 0;
}
private static int[][] supportedSpecials = {
{ 'I' }, // latin - uppercase roman numerals
{ 'i' }, // latin - lowercase roman numerals
{ '\u0391' }, // greek - uppercase isopsephry numerals
{ '\u03B1' }, // greek - lowercase isopsephry numerals
{ '\u05D0' }, // hebrew - gematria numerals
{ '\u0623' }, // arabic - abjadi numberals
{ '\u0627' }, // arabic - either abjadi or hijai alphabetic sequence
{ '\u0E01' }, // thai - default alphabetic sequence
{ '\u3042' }, // kana - hiragana (gojuon) - default alphabetic sequence
{ '\u3044' }, // kana - hiragana (iroha)
{ '\u30A2' }, // kana - katakana (gojuon) - default alphabetic sequence
{ '\u30A4' }, // kana - katakana (iroha)
};
private static boolean isStartOfNumericSpecial(int s) {
for (int[] ss : supportedSpecials) {
assert ss.length >= 1;
if (ss[0] == s) {
return true;
}
}
return false;
}
private SpecialNumberFormatter getSpecialFormatter(int one, int letterValue, String features, String language, String country) {
if (one == (int) 'I') {
return new RomanNumeralsFormatter();
} else if (one == (int) 'i') {
return new RomanNumeralsFormatter();
} else if (one == (int) '\u0391') {
return new IsopsephryNumeralsFormatter();
} else if (one == (int) '\u03B1') {
return new IsopsephryNumeralsFormatter();
} else if (one == (int) '\u05D0') {
return new GematriaNumeralsFormatter();
} else if (one == (int) '\u0623') {
return new ArabicNumeralsFormatter();
} else if (one == (int) '\u0627') {
return new ArabicNumeralsFormatter();
} else if (one == (int) '\u0E01') {
return new ThaiNumeralsFormatter();
} else if (one == (int) '\u3042') {
return new KanaNumeralsFormatter();
} else if (one == (int) '\u3044') {
return new KanaNumeralsFormatter();
} else if (one == (int) '\u30A2') {
return new KanaNumeralsFormatter();
} else if (one == (int) '\u30A4') {
return new KanaNumeralsFormatter();
} else {
return null;
}
}
private static Integer[] toUpperCase(Integer[] sa) {
assert sa != null;
for (int i = 0, n = sa.length; i < n; i++) {
Integer s = sa [ i ];
sa [ i ] = Character.toUpperCase(s);
}
return sa;
}
private static Integer[] toLowerCase(Integer[] sa) {
assert sa != null;
for (int i = 0, n = sa.length; i < n; i++) {
Integer s = sa [ i ];
sa [ i ] = Character.toLowerCase(s);
}
return sa;
}
/* not yet used
private static Integer[] toTitleCase ( Integer[] sa ) {
assert sa != null;
if ( sa.length > 0 ) {
sa [ 0 ] = Character.toTitleCase ( sa [ 0 ] );
}
return sa;
}
*/
private static List<String> convertWordCase(List<String> words, int caseType) {
List<String> wl = new ArrayList<String>();
for (String w : words) {
wl.add(convertWordCase(w, caseType));
}
return wl;
}
private static String convertWordCase(String word, int caseType) {
if (caseType == Character.UPPERCASE_LETTER) {
return word.toUpperCase();
} else if (caseType == Character.LOWERCASE_LETTER) {
return word.toLowerCase();
} else if (caseType == Character.TITLECASE_LETTER) {
StringBuffer sb = new StringBuffer();
for (int i = 0, n = word.length(); i < n; i++) {
String s = word.substring(i, i + 1);
if (i == 0) {
sb.append(s.toUpperCase());
} else {
sb.append(s.toLowerCase());
}
}
return sb.toString();
} else {
return word;
}
}
private static String joinWords(List<String> words, String separator) {
StringBuffer sb = new StringBuffer();
for (String w : words) {
if (sb.length() > 0) {
sb.append(separator);
}
sb.append(w);
}
return sb.toString();
}
/**
* Special number formatter.
*/
interface SpecialNumberFormatter {
/**
* Format number with special numeral system.
* @param number to be formatted
* @param one unicode scalar value denoting numeric value 1
* @param letterValue letter value (must be one of the above letter value enumeration values)
* @param features features (feature sub-parameters)
* @param language denotes applicable language
* @param country denotes applicable country
* @return formatted number as array of unicode scalars
*/
Integer[] format(long number, int one, int letterValue, String features, String language, String country);
}
/**
* English Word Numerals
*/
private static String[] englishWordOnes = { "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine" };
private static String[] englishWordTeens = { "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen" };
private static String[] englishWordTens = { "", "ten", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety" };
private static String[] englishWordOthers = { "hundred", "thousand", "million", "billion" };
private static String[] englishWordOnesOrd = { "none", "first", "second", "third", "fourth", "fifth", "sixth", "seventh", "eighth", "ninth" };
private static String[] englishWordTeensOrd = { "tenth", "eleventh", "twelfth", "thirteenth", "fourteenth", "fifteenth", "sixteenth", "seventeenth", "eighteenth", "nineteenth" };
private static String[] englishWordTensOrd = { "", "tenth", "twentieth", "thirtieth", "fortieth", "fiftieth", "sixtieth", "seventieth", "eightieth", "ninetith" };
private static String[] englishWordOthersOrd = { "hundredth", "thousandth", "millionth", "billionth" };
private static class EnglishNumberAsWordFormatter implements SpecialNumberFormatter {
private int caseType = Character.UPPERCASE_LETTER;
EnglishNumberAsWordFormatter(int caseType) {
this.caseType = caseType;
}
public Integer[] format(long number, int one, int letterValue, String features, String language, String country) {
List<String> wl = new ArrayList<String>();
if (number >= 1000000000000L) {
return null;
} else {
boolean ordinal = hasFeature(features, "ordinal");
if (number == 0) {
wl.add(englishWordOnes [ 0 ]);
} else if (ordinal && (number < 10)) {
wl.add(englishWordOnesOrd [ (int) number ]);
} else {
int ones = (int) (number % 1000);
int thousands = (int) ((number / 1000) % 1000);
int millions = (int) ((number / 1000000) % 1000);
int billions = (int) ((number / 1000000000) % 1000);
if (billions > 0) {
wl = formatOnesInThousand(wl, billions);
if (ordinal && ((number % 1000000000) == 0)) {
wl.add(englishWordOthersOrd[3]);
} else {
wl.add(englishWordOthers[3]);
}
}
if (millions > 0) {
wl = formatOnesInThousand(wl, millions);
if (ordinal && ((number % 1000000) == 0)) {
wl.add(englishWordOthersOrd[2]);
} else {
wl.add(englishWordOthers[2]);
}
}
if (thousands > 0) {
wl = formatOnesInThousand(wl, thousands);
if (ordinal && ((number % 1000) == 0)) {
wl.add(englishWordOthersOrd[1]);
} else {
wl.add(englishWordOthers[1]);
}
}
if (ones > 0) {
wl = formatOnesInThousand(wl, ones, ordinal);
}
}
wl = convertWordCase(wl, caseType);
return UTF32.toUTF32(joinWords(wl, " "), 0, true);
}
}
private List<String> formatOnesInThousand(List<String> wl, int number) {
return formatOnesInThousand(wl, number, false);
}
private List<String> formatOnesInThousand(List<String> wl, int number, boolean ordinal) {
assert number < 1000;
int ones = number % 10;
int tens = (number / 10) % 10;
int hundreds = (number / 100) % 10;
if (hundreds > 0) {
wl.add(englishWordOnes [ hundreds ]);
if (ordinal && ((number % 100) == 0)) {
wl.add(englishWordOthersOrd[0]);
} else {
wl.add(englishWordOthers[0]);
}
}
if (tens > 0) {
if (tens == 1) {
if (ordinal) {
wl.add(englishWordTeensOrd [ ones ]);
} else {
wl.add(englishWordTeens [ ones ]);
}
} else {
if (ordinal && (ones == 0)) {
wl.add(englishWordTensOrd [ tens ]);
} else {
wl.add(englishWordTens [ tens ]);
}
if (ones > 0) {
if (ordinal) {
wl.add(englishWordOnesOrd [ ones ]);
} else {
wl.add(englishWordOnes [ ones ]);
}
}
}
} else if (ones > 0) {
if (ordinal) {
wl.add(englishWordOnesOrd [ ones ]);
} else {
wl.add(englishWordOnes [ ones ]);
}
}
return wl;
}
}
/**
* French Word Numerals
*/
private static String[] frenchWordOnes = { "z\u00e9ro", "un", "deux", "trois", "quatre", "cinq", "six", "sept", "huit", "neuf" };
private static String[] frenchWordTeens = { "dix", "onze", "douze", "treize", "quatorze", "quinze", "seize", "dix-sept", "dix-huit", "dix-neuf" };
private static String[] frenchWordTens = { "", "dix", "vingt", "trente", "quarante", "cinquante", "soixante", "soixante-dix", "quatre-vingt", "quatre-vingt-dix" };
private static String[] frenchWordOthers = { "cent", "cents", "mille", "million", "millions", "milliard", "milliards" };
private static String[] frenchWordOnesOrdMale = { "premier", "deuxi\u00e8me", "troisi\u00e8me", "quatri\u00e8me", "cinqui\u00e8me", "sixi\u00e8me", "septi\u00e8me", "huiti\u00e8me", "neuvi\u00e8me", "dixi\u00e8me" };
private static String[] frenchWordOnesOrdFemale = { "premi\u00e8re", "deuxi\u00e8me", "troisi\u00e8me", "quatri\u00e8me", "cinqui\u00e8me", "sixi\u00e8me", "septi\u00e8me", "huiti\u00e8me", "neuvi\u00e8me", "dixi\u00e8me" };
private static class FrenchNumberAsWordFormatter implements SpecialNumberFormatter {
private int caseType = Character.UPPERCASE_LETTER;
FrenchNumberAsWordFormatter(int caseType) {
this.caseType = caseType;
}
public Integer[] format(long number, int one, int letterValue, String features, String language, String country) {
List<String> wl = new ArrayList<String>();
if (number >= 1000000000000L) {
return null;
} else {
boolean ordinal = hasFeature(features, "ordinal");
if (number == 0) {
wl.add(frenchWordOnes [ 0 ]);
} else if (ordinal && (number <= 10)) {
boolean female = hasFeature(features, "female");
if (female) {
wl.add(frenchWordOnesOrdFemale [ (int) number ]);
} else {
wl.add(frenchWordOnesOrdMale [ (int) number ]);
}
} else {
int ones = (int) (number % 1000);
int thousands = (int) ((number / 1000) % 1000);
int millions = (int) ((number / 1000000) % 1000);
int billions = (int) ((number / 1000000000) % 1000);
if (billions > 0) {
wl = formatOnesInThousand(wl, billions);
if (billions == 1) {
wl.add(frenchWordOthers[5]);
} else {
wl.add(frenchWordOthers[6]);
}
}
if (millions > 0) {
wl = formatOnesInThousand(wl, millions);
if (millions == 1) {
wl.add(frenchWordOthers[3]);
} else {
wl.add(frenchWordOthers[4]);
}
}
if (thousands > 0) {
if (thousands > 1) {
wl = formatOnesInThousand(wl, thousands);
}
wl.add(frenchWordOthers[2]);
}
if (ones > 0) {
wl = formatOnesInThousand(wl, ones);
}
}
wl = convertWordCase(wl, caseType);
return UTF32.toUTF32(joinWords(wl, " "), 0, true);
}
}
private List<String> formatOnesInThousand(List<String> wl, int number) {
assert number < 1000;
int ones = number % 10;
int tens = (number / 10) % 10;
int hundreds = (number / 100) % 10;
if (hundreds > 0) {
if (hundreds > 1) {
wl.add(frenchWordOnes [ hundreds ]);
}
if ((hundreds > 1) && (tens == 0) && (ones == 0)) {
wl.add(frenchWordOthers[1]);
} else {
wl.add(frenchWordOthers[0]);
}
}
if (tens > 0) {
if (tens == 1) {
wl.add(frenchWordTeens [ ones ]);
} else if (tens < 7) {
if (ones == 1) {
wl.add(frenchWordTens [ tens ]);
wl.add("et");
wl.add(frenchWordOnes [ ones ]);
} else {
StringBuffer sb = new StringBuffer();
sb.append(frenchWordTens [ tens ]);
if (ones > 0) {
sb.append('-');
sb.append(frenchWordOnes [ ones ]);
}
wl.add(sb.toString());
}
} else if (tens == 7) {
if (ones == 1) {
wl.add(frenchWordTens [ 6 ]);
wl.add("et");
wl.add(frenchWordTeens [ ones ]);
} else {
StringBuffer sb = new StringBuffer();
sb.append(frenchWordTens [ 6 ]);
sb.append('-');
sb.append(frenchWordTeens [ ones ]);
wl.add(sb.toString());
}
} else if (tens == 8) {
StringBuffer sb = new StringBuffer();
sb.append(frenchWordTens [ tens ]);
if (ones > 0) {
sb.append('-');
sb.append(frenchWordOnes [ ones ]);
} else {
sb.append('s');
}
wl.add(sb.toString());
} else if (tens == 9) {
StringBuffer sb = new StringBuffer();
sb.append(frenchWordTens [ 8 ]);
sb.append('-');
sb.append(frenchWordTeens [ ones ]);
wl.add(sb.toString());
}
} else if (ones > 0) {
wl.add(frenchWordOnes [ ones ]);
}
return wl;
}
}
/**
* Spanish Word Numerals
*/
private static String[] spanishWordOnes = { "cero", "uno", "dos", "tres", "cuatro", "cinco", "seise", "siete", "ocho", "nueve" };
private static String[] spanishWordTeens = { "diez", "once", "doce", "trece", "catorce", "quince", "diecis\u00e9is", "diecisiete", "dieciocho", "diecinueve" };
private static String[] spanishWordTweens = { "veinte", "veintiuno", "veintid\u00f3s", "veintitr\u00e9s", "veinticuatro", "veinticinco", "veintis\u00e9is", "veintisiete", "veintiocho", "veintinueve" };
private static String[] spanishWordTens = { "", "diez", "veinte", "treinta", "cuarenta", "cincuenta", "sesenta", "setenta", "ochenta", "noventa" };
private static String[] spanishWordHundreds = { "", "ciento", "doscientos", "trescientos", "cuatrocientos", "quinientos", "seiscientos", "setecientos", "ochocientos", "novecientos" };
private static String[] spanishWordOthers = { "un", "cien", "mil", "mill\u00f3n", "millones" };
private static String[] spanishWordOnesOrdMale = { "ninguno", "primero", "segundo", "tercero", "cuarto", "quinto", "sexto", "s\u00e9ptimo", "octavo", "novento", "d\u00e9cimo" };
private static String[] spanishWordOnesOrdFemale = { "ninguna", "primera", "segunda", "tercera", "cuarta", "quinta", "sexta", "s\u00e9ptima", "octava", "noventa", "d\u00e9cima" };
private static class SpanishNumberAsWordFormatter implements SpecialNumberFormatter {
private int caseType = Character.UPPERCASE_LETTER;
SpanishNumberAsWordFormatter(int caseType) {
this.caseType = caseType;
}
public Integer[] format(long number, int one, int letterValue, String features, String language, String country) {
List<String> wl = new ArrayList<String>();
if (number >= 1000000000000L) {
return null;
} else {
boolean ordinal = hasFeature(features, "ordinal");
if (number == 0) {
wl.add(spanishWordOnes [ 0 ]);
} else if (ordinal && (number <= 10)) {
boolean female = hasFeature(features, "female");
if (female) {
wl.add(spanishWordOnesOrdFemale [ (int) number ]);
} else {
wl.add(spanishWordOnesOrdMale [ (int) number ]);
}
} else {
int ones = (int) (number % 1000);
int thousands = (int) ((number / 1000) % 1000);
int millions = (int) ((number / 1000000) % 1000);
int billions = (int) ((number / 1000000000) % 1000);
if (billions > 0) {
if (billions > 1) {
wl = formatOnesInThousand(wl, billions);
}
wl.add(spanishWordOthers[2]);
wl.add(spanishWordOthers[4]);
}
if (millions > 0) {
if (millions == 1) {
wl.add(spanishWordOthers[0]);
} else {
wl = formatOnesInThousand(wl, millions);
}
if (millions > 1) {
wl.add(spanishWordOthers[4]);
} else {
wl.add(spanishWordOthers[3]);
}
}
if (thousands > 0) {
if (thousands > 1) {
wl = formatOnesInThousand(wl, thousands);
}
wl.add(spanishWordOthers[2]);
}
if (ones > 0) {
wl = formatOnesInThousand(wl, ones);
}
}
wl = convertWordCase(wl, caseType);
return UTF32.toUTF32(joinWords(wl, " "), 0, true);
}
}
private List<String> formatOnesInThousand(List<String> wl, int number) {
assert number < 1000;
int ones = number % 10;
int tens = (number / 10) % 10;
int hundreds = (number / 100) % 10;
if (hundreds > 0) {
if ((hundreds == 1) && (tens == 0) && (ones == 0)) {
wl.add(spanishWordOthers[1]);
} else {
wl.add(spanishWordHundreds [ hundreds ]);
}
}
if (tens > 0) {
if (tens == 1) {
wl.add(spanishWordTeens [ ones ]);
} else if (tens == 2) {
wl.add(spanishWordTweens [ ones ]);
} else {
wl.add(spanishWordTens [ tens ]);
if (ones > 0) {
wl.add("y");
wl.add(spanishWordOnes [ ones ]);
}
}
} else if (ones > 0) {
wl.add(spanishWordOnes [ ones ]);
}
return wl;
}
}
/**
* Roman (Latin) Numerals
*/
private static int[] romanMapping = {
100000,
90000,
50000,
40000,
10000,
9000,
5000,
4000,
1000,
900,
500,
400,
100,
90,
50,
40,
10,
9,
8,
7,
6,
5,
4,
3,
2,
1
};
private static String[] romanStandardForms = {
null,
null,
null,
null,
null,
null,
null,
null,
"m",
"cm",
"d",
"cd",
"c",
"xc",
"l",
"xl",
"x",
"ix",
null,
null,
null,
"v",
"iv",
null,
null,
"i"
};
private static String[] romanLargeForms = {
"\u2188",
"\u2182\u2188",
"\u2187",
"\u2182\u2187",
"\u2182",
"\u2180\u2182",
"\u2181",
"\u2180\u2181",
"m",
"cm",
"d",
"cd",
"c",
"xc",
"l",
"xl",
"x",
"ix",
null,
null,
null,
"v",
"iv",
null,
null,
"i"
};
private static String[] romanNumberForms = {
"\u2188",
"\u2182\u2188",
"\u2187",
"\u2182\u2187",
"\u2182",
"\u2180\u2182",
"\u2181",
"\u2180\u2181",
"\u216F",
"\u216D\u216F",
"\u216E",
"\u216D\u216E",
"\u216D",
"\u2169\u216D",
"\u216C",
"\u2169\u216C",
"\u2169",
"\u2168",
"\u2167",
"\u2166",
"\u2165",
"\u2164",
"\u2163",
"\u2162",
"\u2161",
"\u2160"
};
private static class RomanNumeralsFormatter implements SpecialNumberFormatter {
public Integer[] format(long number, int one, int letterValue, String features, String language, String country) {
List<Integer> sl = new ArrayList<Integer>();
if (number == 0) {
return null;
} else {
String[] forms;
int maxNumber;
if (hasFeature(features, "unicode-number-forms")) {
forms = romanNumberForms;
maxNumber = 199999;
} else if (hasFeature(features, "large")) {
forms = romanLargeForms;
maxNumber = 199999;
} else {
forms = romanStandardForms;
maxNumber = 4999;
}
if (number > maxNumber) {
return null;
} else {
while (number > 0) {
for (int i = 0, n = romanMapping.length; i < n; i++) {
int d = romanMapping [ i ];
if ((number >= d) && (forms [ i ] != null)) {
appendScalars(sl, UTF32.toUTF32(forms [ i ], 0, true));
number = number - d;
break;
}
}
}
if (one == (int) 'I') {
return toUpperCase(sl.toArray(new Integer [ sl.size() ]));
} else if (one == (int) 'i') {
return toLowerCase(sl.toArray(new Integer [ sl.size() ]));
} else {
return null;
}
}
}
}
}
/**
* Isopsephry (Greek) Numerals
*/
private static class IsopsephryNumeralsFormatter implements SpecialNumberFormatter {
public Integer[] format(long number, int one, int letterValue, String features, String language, String country) {
return null;
}
}
/**
* Gematria (Hebrew) Numerals
*/
private static int[] hebrewGematriaAlphabeticMap = {
// ones
0x05D0, // ALEF
0x05D1, // BET
0x05D2, // GIMEL
0x05D3, // DALET
0x05D4, // HE
0x05D5, // VAV
0x05D6, // ZAYIN
0x05D7, // HET
0x05D8, // TET
// tens
0x05D9, // YOD
0x05DB, // KAF
0x05DC, // LAMED
0x05DE, // MEM
0x05E0, // NUN
0x05E1, // SAMEKH
0x05E2, // AYIN
0x05E4, // PE
0x05E6, // TSADHI
// hundreds
0x05E7, // QOF
0x05E8, // RESH
0x05E9, // SHIN
0x05EA, // TAV
0x05DA, // FINAL KAF
0x05DD, // FINAL MEM
0x05DF, // FINAL NUN
0x05E3, // FINAL PE
0x05E5, // FINAL TSADHI
};
private class GematriaNumeralsFormatter implements SpecialNumberFormatter {
public Integer[] format(long number, int one, int letterValue, String features, String language, String country) {
if (one == 0x05D0) {
if (letterValue == LETTER_VALUE_ALPHABETIC) {
return formatNumberAsSequence(number, one, hebrewGematriaAlphabeticMap.length, hebrewGematriaAlphabeticMap);
} else if (letterValue == LETTER_VALUE_TRADITIONAL) {
if ((number == 0) || (number > 1999)) {
return null;
} else {
return formatAsGematriaNumber(number, features, language, country);
}
} else {
return null;
}
} else {
return null;
}
}
private Integer[] formatAsGematriaNumber(long number, String features, String language, String country) {
List<Integer> sl = new ArrayList<Integer>();
assert hebrewGematriaAlphabeticMap.length == 27;
assert hebrewGematriaAlphabeticMap[0] == 0x05D0; // ALEF
assert hebrewGematriaAlphabeticMap[21] == 0x05EA; // TAV
assert number != 0;
assert number < 2000;
int[] map = hebrewGematriaAlphabeticMap;
int thousands = (int) ((number / 1000) % 10);
int hundreds = (int) ((number / 100) % 10);
int tens = (int) ((number / 10) % 10);
int ones = (int) ((number / 1) % 10);
if (thousands > 0) {
sl.add(map [ 0 + (thousands - 1) ]);
sl.add(0x05F3);
}
if (hundreds > 0) {
if (hundreds < 5) {
sl.add(map [ 18 + (hundreds - 1) ]);
} else if (hundreds < 9) {
sl.add(map [ 18 + (4 - 1) ]);
sl.add(0x05F4);
sl.add(map [ 18 + (hundreds - 5) ]);
} else if (hundreds == 9) {
sl.add(map [ 18 + (4 - 1) ]);
sl.add(map [ 18 + (4 - 1) ]);
sl.add(0x05F4);
sl.add(map [ 18 + (hundreds - 9) ]);
}
assert hundreds < 10;
}
if (number == 15) {
sl.add(map [ 9 - 1]);
sl.add(0x05F4);
sl.add(map [ 6 - 1]);
} else if (number == 16) {
sl.add(map [ 9 - 1 ]);
sl.add(0x05F4);
sl.add(map [ 7 - 1 ]);
} else {
if (tens > 0) {
assert tens < 10;
sl.add(map [ 9 + (tens - 1) ]);
}
if (ones > 0) {
assert ones < 10;
sl.add(map [ 0 + (ones - 1) ]);
}
}
return sl.toArray(new Integer [ sl.size() ]);
}
}
/**
* Arabic Numerals
*/
private static int[] arabicAbjadiAlphabeticMap = {
// ones
0x0623, // ALEF WITH HAMZA ABOVE
0x0628, // BEH
0x062C, // JEEM
0x062F, // DAL
0x0647, // HEH
0x0648, // WAW
0x0632, // ZAIN
0x062D, // HAH
0x0637, // TAH
// tens
0x0649, // ALEF MAQSURA
0x0643, // KAF
0x0644, // LAM
0x0645, // MEEM
0x0646, // NOON
0x0633, // SEEN
0x0639, // AIN
0x0641, // FEH
0x0635, // SAD
// hundreds
0x0642, // QAF
0x0631, // REH
0x0634, // SHEEN
0x062A, // TEH
0x062B, // THEH
0x062E, // KHAH
0x0630, // THAL
0x0636, // DAD
0x0638, // ZAH
// thousands
0x063A, // GHAIN
};
private static int[] arabicHijaiAlphabeticMap = {
0x0623, // ALEF WITH HAMZA ABOVE
0x0628, // BEH
0x062A, // TEH
0x062B, // THEH
0x062C, // JEEM
0x062D, // HAH
0x062E, // KHAH
0x062F, // DAL
0x0630, // THAL
0x0631, // REH
0x0632, // ZAIN
0x0633, // SEEN
0x0634, // SHEEN
0x0635, // SAD
0x0636, // DAD
0x0637, // TAH
0x0638, // ZAH
0x0639, // AIN
0x063A, // GHAIN
0x0641, // FEH
0x0642, // QAF
0x0643, // KAF
0x0644, // LAM
0x0645, // MEEM
0x0646, // NOON
0x0647, // HEH
0x0648, // WAW
0x0649, // ALEF MAQSURA
};
private class ArabicNumeralsFormatter implements SpecialNumberFormatter {
public Integer[] format(long number, int one, int letterValue, String features, String language, String country) {
if (one == 0x0627) {
int[] map;
if (letterValue == LETTER_VALUE_TRADITIONAL) {
map = arabicAbjadiAlphabeticMap;
} else if (letterValue == LETTER_VALUE_ALPHABETIC) {
map = arabicHijaiAlphabeticMap;
} else {
map = arabicAbjadiAlphabeticMap;
}
return formatNumberAsSequence(number, one, map.length, map);
} else if (one == 0x0623) {
if ((number == 0) || (number > 1999)) {
return null;
} else {
return formatAsAbjadiNumber(number, features, language, country);
}
} else {
return null;
}
}
private Integer[] formatAsAbjadiNumber(long number, String features, String language, String country) {
List<Integer> sl = new ArrayList<Integer>();
assert arabicAbjadiAlphabeticMap.length == 28;
assert arabicAbjadiAlphabeticMap[0] == 0x0623; // ALEF WITH HAMZA ABOVE
assert arabicAbjadiAlphabeticMap[27] == 0x063A; // GHAIN
assert number != 0;
assert number < 2000;
int[] map = arabicAbjadiAlphabeticMap;
int thousands = (int) ((number / 1000) % 10);
int hundreds = (int) ((number / 100) % 10);
int tens = (int) ((number / 10) % 10);
int ones = (int) ((number / 1) % 10);
if (thousands > 0) {
assert thousands < 2;
sl.add(map [ 27 + (thousands - 1) ]);
}
if (hundreds > 0) {
assert thousands < 10;
sl.add(map [ 18 + (hundreds - 1) ]);
}
if (tens > 0) {
assert tens < 10;
sl.add(map [ 9 + (tens - 1) ]);
}
if (ones > 0) {
assert ones < 10;
sl.add(map [ 0 + (ones - 1) ]);
}
return sl.toArray(new Integer [ sl.size() ]);
}
}
/**
* Kana (Japanese) Numerals
*/
private static int[] hiraganaGojuonAlphabeticMap = {
0x3042, // A
0x3044, // I
0x3046, // U
0x3048, // E
0x304A, // O
0x304B, // KA
0x304D, // KI
0x304F, // KU
0x3051, // KE
0x3053, // KO
0x3055, // SA
0x3057, // SI
0x3059, // SU
0x305B, // SE
0x305D, // SO
0x305F, // TA
0x3061, // TI
0x3064, // TU
0x3066, // TE
0x3068, // TO
0x306A, // NA
0x306B, // NI
0x306C, // NU
0x306D, // NE
0x306E, // NO
0x306F, // HA
0x3072, // HI
0x3075, // HU
0x3078, // HE
0x307B, // HO
0x307E, // MA
0x307F, // MI
0x3080, // MU
0x3081, // ME
0x3082, // MO
0x3084, // YA
0x3086, // YU
0x3088, // YO
0x3089, // RA
0x308A, // RI
0x308B, // RU
0x308C, // RE
0x308D, // RO
0x308F, // WA
0x3090, // WI
0x3091, // WE
0x3092, // WO
0x3093, // N
};
private static int[] katakanaGojuonAlphabeticMap = {
0x30A2, // A
0x30A4, // I
0x30A6, // U
0x30A8, // E
0x30AA, // O
0x30AB, // KA
0x30AD, // KI
0x30AF, // KU
0x30B1, // KE
0x30B3, // KO
0x30B5, // SA
0x30B7, // SI
0x30B9, // SU
0x30BB, // SE
0x30BD, // SO
0x30BF, // TA
0x30C1, // TI
0x30C4, // TU
0x30C6, // TE
0x30C8, // TO
0x30CA, // NA
0x30CB, // NI
0x30CC, // NU
0x30CD, // NE
0x30CE, // NO
0x30CF, // HA
0x30D2, // HI
0x30D5, // HU
0x30D8, // HE
0x30DB, // HO
0x30DE, // MA
0x30DF, // MI
0x30E0, // MU
0x30E1, // ME
0x30E2, // MO
0x30E4, // YA
0x30E6, // YU
0x30E8, // YO
0x30E9, // RA
0x30EA, // RI
0x30EB, // RU
0x30EC, // RE
0x30ED, // RO
0x30EF, // WA
0x30F0, // WI
0x30F1, // WE
0x30F2, // WO
0x30F3, // N
};
private class KanaNumeralsFormatter implements SpecialNumberFormatter {
public Integer[] format(long number, int one, int letterValue, String features, String language, String country) {
if ((one == 0x3042) && (letterValue == LETTER_VALUE_ALPHABETIC)) {
return formatNumberAsSequence(number, one, hiraganaGojuonAlphabeticMap.length, hiraganaGojuonAlphabeticMap);
} else if ((one == 0x30A2) && (letterValue == LETTER_VALUE_ALPHABETIC)) {
return formatNumberAsSequence(number, one, katakanaGojuonAlphabeticMap.length, katakanaGojuonAlphabeticMap);
} else {
return null;
}
}
}
/**
* Thai Numerals
*/
private static int[] thaiAlphabeticMap = {
0x0E01,
0x0E02,
0x0E03,
0x0E04,
0x0E05,
0x0E06,
0x0E07,
0x0E08,
0x0E09,
0x0E0A,
0x0E0B,
0x0E0C,
0x0E0D,
0x0E0E,
0x0E0F,
0x0E10,
0x0E11,
0x0E12,
0x0E13,
0x0E14,
0x0E15,
0x0E16,
0x0E17,
0x0E18,
0x0E19,
0x0E1A,
0x0E1B,
0x0E1C,
0x0E1D,
0x0E1E,
0x0E1F,
0x0E20,
0x0E21,
0x0E22,
0x0E23,
// 0x0E24, // RU - not used in modern sequence
0x0E25,
// 0x0E26, // LU - not used in modern sequence
0x0E27,
0x0E28,
0x0E29,
0x0E2A,
0x0E2B,
0x0E2C,
0x0E2D,
0x0E2E,
};
private class ThaiNumeralsFormatter implements SpecialNumberFormatter {
public Integer[] format(long number, int one, int letterValue, String features, String language, String country) {
if ((one == 0x0E01) && (letterValue == LETTER_VALUE_ALPHABETIC)) {
return formatNumberAsSequence(number, one, thaiAlphabeticMap.length, thaiAlphabeticMap);
} else {
return null;
}
}
}
}