| private insert ( int par0, bool par1 ) : global::java.lang.StringBuilder | ||
| par0 | int | |
| par1 | bool | |
| return | global::java.lang.StringBuilder | |
// Some national prefixes are a substring of others. If extracting the shorter NDD doesn't result
// in a number we can format, we try to see if we can extract a longer version here.
private boolean ableToExtractLongerNdd()
{
if (nationalPrefixExtracted.length() > 0)
{
// Put the extracted NDD back to the national number before attempting to extract a new NDD.
nationalNumber.insert(0, nationalPrefixExtracted);
// Remove the previously extracted NDD from prefixBeforeNationalNumber. We cannot simply set
// it to empty string because people sometimes incorrectly enter national prefix after the
// country code, e.g. +44 (0)20-1234-5678.
int indexOfPreviousNdd = prefixBeforeNationalNumber.lastIndexOf(nationalPrefixExtracted);
prefixBeforeNationalNumber.setLength(indexOfPreviousNdd);
}
return(!nationalPrefixExtracted.equals(removeNationalPrefixFromNationalNumber()));
}
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);
}
private CharSequence transformFromFloat ()
{
if (arg == null) {
return transformFromNull ();
} else {
if (arg is float) {
float f = (float)arg;
if (f != f || f == float.PositiveInfinity || f == float.NegativeInfinity)
return transformFromSpecialNumber ((double)f);
} else if (arg is double) {
double d = (double)arg;
if (d != d || d == double.PositiveInfinity || d == double.NegativeInfinity)
return transformFromSpecialNumber (d);
} else {
if (arg is decimal) {
} else {
// BigDecimal can't represent NaN or infinities, but its doubleValue method will return
// infinities if the BigDecimal is too big for a double.
throw badArgumentType ();
}
}
}
char conversionType = formatToken.getConversionType ();
if (conversionType != 'a' && conversionType != 'A' && !formatToken.isPrecisionSet
()) {
formatToken.setPrecision (java.util.Formatter.FormatToken.DEFAULT_PRECISION);
}
StringBuilder result = new StringBuilder ();
switch (conversionType) {
case 'a':
case 'A':
{
transformA (result);
break;
}
case 'e':
case 'E':
{
transformE (result);
break;
}
case 'f':
{
transformF (result);
break;
}
case 'g':
case 'G':
{
transformG (result);
break;
}
default:
{
throw formatToken.unknownFormatConversionException ();
}
}
formatToken.setPrecision (java.util.Formatter.FormatToken.UNSET);
int startIndex = 0;
if (result [0] == localeData.minusSign) {
if (formatToken.flagParenthesis) {
return wrapParentheses (result);
}
} else {
if (formatToken.flagSpace) {
result.insert (0, ' ');
startIndex++;
}
if (formatToken.flagPlus) {
result.insert (0, '+');
startIndex++;
}
}
char firstChar = result [0];
if (formatToken.flagZero && (firstChar == '+' || firstChar == localeData.minusSign
)) {
startIndex = 1;
}
if (conversionType == 'a' || conversionType == 'A') {
startIndex += 2;
}
return padding (result, startIndex);
}
// BigDecimal can't represent NaN or infinities, but its doubleValue method will return
// infinities if the BigDecimal is too big for a double.
private void transformE (StringBuilder result)
{
// All zeros in this method are *pattern* characters, so no localization.
int precision = formatToken.getPrecision ();
string pattern = "0E+00";
if (precision > 0) {
StringBuilder sb = new StringBuilder ("0.");
char[] zeros = new char[precision];
java.util.Arrays.fill (zeros, '0');
sb.append (zeros);
sb.append ("E+00");
pattern = sb.ToString ();
}
result.append (arg.ToString ().Replace ('E', 'e'));
// The # flag requires that we always output a decimal separator.
if (formatToken.flagSharp && precision == 0) {
int indexOfE = result.indexOf ("e");
result.insert (indexOfE, localeData.decimalSeparator);
}
}
private CharSequence transformFromInteger ()
{
int startIndex = 0;
StringBuilder result = new StringBuilder ();
char currentConversionType = formatToken.getConversionType ();
long value;
if (arg is long) {
value = ((long)arg);
} else {
if (arg is int) {
value = (int)arg;
} else {
if (arg is short) {
value = (short)arg;
} else {
if (arg is byte) {
value = (byte)arg;
} else {
throw badArgumentType ();
}
}
}
}
if (formatToken.flagSharp) {
if (currentConversionType == 'o') {
result.append ("0");
startIndex += 1;
} else {
result.append ("0x");
startIndex += 2;
}
}
if (currentConversionType == 'd') {
CharSequence digits = CharSequenceProxy.Wrap (System.Convert.ToString
(value));
if (formatToken.flagComma) {
digits = insertGrouping (digits);
}
if (localeData.zeroDigit != '0') {
digits = localizeDigits (digits);
}
result.append (digits);
if (value < 0) {
if (formatToken.flagParenthesis) {
return wrapParentheses (result);
} else {
if (formatToken.flagZero) {
startIndex++;
}
}
} else {
if (formatToken.flagPlus) {
result.insert (0, '+');
startIndex += 1;
} else {
if (formatToken.flagSpace) {
result.insert (0, ' ');
startIndex += 1;
}
}
}
} else {
// Undo sign-extension, since we'll be using Long.to(Octal|Hex)String.
if (arg is byte) {
value &= unchecked((long)(0xffL));
} else {
if (arg is short) {
value &= unchecked((long)(0xffffL));
} else {
if (arg is int) {
value &= unchecked((long)(0xffffffffL));
}
}
}
if (currentConversionType == 'o') {
result.append (Convert.ToString (value, 10));
} else {
result.append (Convert.ToString (value, 16));
}
}
return padding (result, startIndex);
}
