private CharSequence transformFromCharacter() { if (arg == null) { return(padding(CharSequenceProxy.Wrap("null"), 0)); } if (arg is char) { return(padding(CharSequenceProxy.Wrap(Sharpen.StringHelper.GetValueOf(arg)), 0)); } else { throw badArgumentType(); } }
private CharSequence transform(FormatToken token, object argument) { this.formatToken = token; this.arg = argument; // There are only two format specifiers that matter: "%d" and "%s". // Nothing else is common in the wild. We fast-path these two to // avoid the heavyweight machinery needed to cope with flags, width, // and precision. if (token.isDefault()) { switch (token.getConversionType()) { case 's': { if (arg == null) { return(CharSequenceProxy.Wrap("null")); } else { if (!(arg is java.util.Formattable)) { return(CharSequenceProxy.Wrap(arg.ToString())); } } break; } case 'd': { if (_out is StringBuilder) { if ((arg is int) || (arg is short) || (arg is byte) || (arg is long)) { ((StringBuilder)_out).append(arg.ToString()); return(null); } } if (arg is int || arg is long || arg is short || arg is byte) { return(CharSequenceProxy.Wrap(arg.ToString())); } } break; } } formatToken.checkFlags(arg); CharSequence result_1; switch (token.getConversionType()) { case 'B': case 'b': { result_1 = transformFromBoolean(); break; } case 'H': case 'h': { result_1 = transformFromHashCode(); break; } case 'S': case 's': { result_1 = transformFromString(); break; } case 'C': case 'c': { result_1 = transformFromCharacter(); break; } case 'd': case 'o': case 'x': case 'X': { result_1 = transformFromInteger(); break; } case 'A': case 'a': case 'E': case 'e': case 'f': case 'G': case 'g': { result_1 = transformFromFloat(); break; } case '%': { result_1 = transformFromPercent(); break; } case 'n': { result_1 = CharSequenceProxy.Wrap(Environment.NewLine); break; } case 't': case 'T': { result_1 = transformFromDateTime(); break; } default: { throw token.unknownFormatConversionException(); } } if (System.Char.IsUpper(token.getConversionType())) { if (result_1 != null) { result_1 = CharSequenceProxy.Wrap(result_1.ToString().ToUpper(_locale)); } } return(result_1); }
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)); }
public static CharSequence SubSequence(this string str, int start, int length) { return(CharSequenceProxy.Wrap(str.Substring(start, length))); }