| private delete ( int par0, int par1 ) : global::java.lang.StringBuilder | ||
| par0 | int | |
| par1 | int | |
| return | global::java.lang.StringBuilder | |
// Returns the national prefix extracted, or an empty string if it is not present.
private String removeNationalPrefixFromNationalNumber()
{
int startOfNationalNumber = 0;
if (isNanpaNumberWithNationalPrefix())
{
startOfNationalNumber = 1;
prefixBeforeNationalNumber.append('1').append(SEPARATOR_BEFORE_NATIONAL_NUMBER);
isCompleteNumber = true;
}
else if (currentMetadata.hasNationalPrefixForParsing())
{
Pattern nationalPrefixForParsing =
regexCache.getPatternForRegex(currentMetadata.getNationalPrefixForParsing());
Matcher m = nationalPrefixForParsing.matcher(nationalNumber);
// Since some national prefix patterns are entirely optional, check that a national prefix
// could actually be extracted.
if (m.lookingAt() && m.end() > 0)
{
// When the national prefix is detected, we use international formatting rules instead of
// national ones, because national formatting rules could contain local formatting rules
// for numbers entered without area code.
isCompleteNumber = true;
startOfNationalNumber = m.end();
prefixBeforeNationalNumber.append(nationalNumber.substring(0, startOfNationalNumber));
}
}
String nationalPrefix = nationalNumber.substring(0, startOfNationalNumber);
nationalNumber.delete(0, startOfNationalNumber);
return(nationalPrefix);
}
private String[] producePermutations(String input) {
if (input.length() == countChars(input, 0, 1))
return new String[] {input};
if (input.length() == countChars(input, 0, 2)) {
int c0 = Character.codePointAt(input, 0);
int c1 = Character.codePointAt(input, Character.charCount(c0));
if (getClass(c1) == getClass(c0)) {
return new String[] {input};
}
String[] result = new String[2];
result[0] = input;
StringBuilder sb = new StringBuilder(2);
sb.appendCodePoint(c1);
sb.appendCodePoint(c0);
result[1] = sb.toString();
return result;
}
int length = 1;
int nCodePoints = countCodePoints(input);
for(int x=1; x<nCodePoints; x++)
length = length * (x+1);
String[] temp = new String[length];
int[] combClass = new int[nCodePoints];
for(int x=0, i=0; x<nCodePoints; x++) {
int c = Character.codePointAt(input, i);
combClass[x] = getClass(c);
i += Character.charCount(c);
}
// For each char, take it out and add the permutations
// of the remaining chars
int index = 0;
int len;
// offset maintains the index in code units.
for(int x=0, offset=0; x<nCodePoints; x++, offset+=len) {
continue1:
len = countChars(input, offset, 1);
boolean skip = false;
for(int y=x-1; y>=0; y--) {
if (combClass[y] == combClass[x]) {
offset+=len;
if (x < nCodePoints) goto continue1;
goto end1;
}
}
StringBuilder sb = new StringBuilder(input);
String otherChars = sb.delete(offset, offset+len).toString();
String[] subResult = producePermutations(otherChars);
String prefix = input.substring(offset, offset+len);
for(int y=0; y<subResult.Length; y++)
temp[index++] = prefix + subResult[y];
}
end1:
String[] _result = new String[index];
for (int x=0; x<index; x++)
_result[x] = temp[x];
return _result;
}
private void transformA (StringBuilder result)
{
if ((arg is float) || (arg is double)) {
result.append (String.Format ("{0:x}", arg));
} else {
throw badArgumentType ();
}
if (!formatToken.isPrecisionSet ()) {
return;
}
int precision = formatToken.getPrecision ();
if (precision == 0) {
precision = 1;
}
int indexOfFirstFractionalDigit = result.indexOf (".") + 1;
int indexOfP = result.indexOf ("p");
int fractionalLength = indexOfP - indexOfFirstFractionalDigit;
if (fractionalLength == precision) {
return;
}
if (fractionalLength < precision) {
char[] zeros = new char[precision - fractionalLength];
java.util.Arrays.fill (zeros, '0');
// %a shouldn't be localized.
result.insert (indexOfP, zeros);
return;
}
result.delete (indexOfFirstFractionalDigit + precision, indexOfP);
}
