public static bool TryFormat(this TimeSpan value, Span <byte> buffer, out int bytesWritten, TextFormat format = default, SymbolTable symbolTable = null) { if (format.IsDefault) { format.Symbol = 'c'; } Precondition.Require(format.Symbol == 'G' || format.Symbol == 'g' || format.Symbol == 'c' || format.Symbol == 't' || format.Symbol == 'T'); symbolTable = symbolTable ?? SymbolTable.InvariantUtf8; return(TryFormatTimeSpan(value, format.Symbol, buffer, out bytesWritten, symbolTable)); }
public static unsafe bool TryFormat(this Guid value, Span <byte> buffer, out int bytesWritten, TextFormat format) { bool dash = format.Symbol != 'N'; bool bookEnds = (format.Symbol == 'B') || (format.Symbol == 'P'); bytesWritten = GuidChars + (dash ? 4 : 0) + (bookEnds ? 2 : 0); if (buffer.Length < bytesWritten) { bytesWritten = 0; return(false); } ref byte utf8Bytes = ref buffer.DangerousGetPinnableReference();
public static bool TryParseInt16(ReadOnlySpan <byte> text, out short value, out int bytesConsumed, EncodingData encoding = default(EncodingData), TextFormat format = default(TextFormat)) { return(Internal.InternalParser.TryParseInt16(text, encoding, format, out value, out bytesConsumed)); }
public static bool TryFormat(this DateTime value, Span <byte> buffer, out int bytesWritten, TextFormat format = default, SymbolTable symbolTable = null) { if (format.IsDefault) { format.Symbol = 'G'; } Precondition.Require(format.Symbol == 'R' || format.Symbol == 'O' || format.Symbol == 'G'); symbolTable = symbolTable ?? SymbolTable.InvariantUtf8; switch (format.Symbol) { case 'R': return(TryFormatDateTimeRfc1123(value, buffer, out bytesWritten, symbolTable)); case 'O': return(TryFormatDateTimeFormatO(value, NullOffset, buffer, out bytesWritten, symbolTable)); case 'G': return(TryFormatDateTimeFormatG(value, NullOffset, buffer, out bytesWritten, symbolTable)); default: throw new NotImplementedException(); } }
private static bool TryFormatTimeSpanG(TimeSpan value, Span <byte> buffer, TextFormat format, EncodingData encoding, out int bytesWritten) { bytesWritten = 0; if (value.Ticks < 0) { if (!TryWriteChar('-', buffer, encoding.TextEncoding, ref bytesWritten)) { return(false); } } bool daysWritten = false; if (value.Days != 0 || format.Symbol == 'G') { if (!TryWriteInt32(Abs(value.Days), buffer, default(TextFormat), encoding, ref bytesWritten)) { return(false); } daysWritten = true; if (format.Symbol == 'c') { if (!TryWriteChar('.', buffer, encoding.TextEncoding, ref bytesWritten)) { return(false); } } else { if (!TryWriteChar(':', buffer, encoding.TextEncoding, ref bytesWritten)) { return(false); } } } var hourFormat = default(TextFormat); if ((daysWritten || format.Symbol == 'c') && format.Symbol != 'g') { hourFormat = D2; } if (!TryWriteInt32(Abs(value.Hours), buffer, hourFormat, encoding, ref bytesWritten)) { return(false); } if (!TryWriteChar(':', buffer, encoding.TextEncoding, ref bytesWritten)) { return(false); } if (!TryWriteInt32(Abs(value.Minutes), buffer, D2, encoding, ref bytesWritten)) { return(false); } if (!TryWriteChar(':', buffer, encoding.TextEncoding, ref bytesWritten)) { return(false); } if (!TryWriteInt32(Abs(value.Seconds), buffer, D2, encoding, ref bytesWritten)) { return(false); } long remainingTicks; if (value.Ticks != long.MinValue) { remainingTicks = Abs(value.Ticks) % TimeSpan.TicksPerSecond; } else { remainingTicks = long.MaxValue % TimeSpan.TicksPerSecond; remainingTicks = (remainingTicks + 1) % TimeSpan.TicksPerSecond; } var ticksFormat = D7; if (remainingTicks != 0) { if (!TryWriteChar('.', buffer, encoding.TextEncoding, ref bytesWritten)) { return(false); } var fraction = remainingTicks * FractionalTimeScale / TimeSpan.TicksPerSecond; if (!TryWriteInt64(fraction, buffer, ticksFormat, encoding, ref bytesWritten)) { return(false); } } return(true); }
public static bool TryFormat(this DateTime value, Span <byte> buffer, ReadOnlySpan <char> format, EncodingData formattingData, out int bytesWritten) { TextFormat parsedFormat = TextFormat.Parse(format); return(TryFormat(value, buffer, parsedFormat, formattingData, out bytesWritten)); }
public static bool TryFormat(this long value, Span <byte> buffer, out int bytesWritten, TextFormat format, EncodingData encoding) { return(IntegerFormatter.TryFormatInt64(value, 8, buffer, format, encoding, out bytesWritten)); }
public static bool TryFormatNumber(double value, bool isSingle, Span <byte> buffer, out int bytesWritten, TextFormat format = default(TextFormat), TextEncoder encoder = null) { Precondition.Require(format.Symbol == 'G' || format.Symbol == 'E' || format.Symbol == 'F'); encoder = encoder == null ? TextEncoder.Utf8 : encoder; bytesWritten = 0; int written; if (Double.IsNaN(value)) { return(encoder.TryEncode(TextEncoder.Symbol.NaN, buffer, out bytesWritten)); } if (Double.IsInfinity(value)) { if (Double.IsNegativeInfinity(value)) { if (!encoder.TryEncode(TextEncoder.Symbol.MinusSign, buffer, out written)) { bytesWritten = 0; return(false); } bytesWritten += written; } if (!encoder.TryEncode(TextEncoder.Symbol.InfinitySign, buffer.Slice(bytesWritten), out written)) { bytesWritten = 0; return(false); } bytesWritten += written; return(true); } // TODO: the lines below need to be replaced with properly implemented algorithm // the problem is the algorithm is complex, so I am commiting a stub for now var hack = value.ToString(format.Symbol.ToString()); return(encoder.TryEncode(hack, buffer, out bytesWritten)); }
public static bool TryFormat(this Guid value, Span <byte> buffer, TextFormat format, EncodingData encoding, out int bytesWritten) { if (format.IsDefault) { format.Symbol = 'G'; } Precondition.Require(format.Symbol == 'G' || format.Symbol == 'D' || format.Symbol == 'N' || format.Symbol == 'B' || format.Symbol == 'P'); bool dash = true; char tail = '\0'; bytesWritten = 0; switch (format.Symbol) { case 'D': case 'G': break; case 'N': dash = false; break; case 'B': if (!TryWriteChar('{', buffer, encoding.TextEncoding, ref bytesWritten)) { return(false); } tail = '}'; break; case 'P': if (!TryWriteChar('(', buffer, encoding.TextEncoding, ref bytesWritten)) { return(false); } tail = ')'; break; default: Precondition.Require(false); // how did we get here? break; } var byteFormat = new TextFormat('x', 2); unsafe { byte *bytes = (byte *)&value; if (!TryWriteByte(bytes[3], buffer, byteFormat, encoding, ref bytesWritten)) { return(false); } if (!TryWriteByte(bytes[2], buffer, byteFormat, encoding, ref bytesWritten)) { return(false); } if (!TryWriteByte(bytes[1], buffer, byteFormat, encoding, ref bytesWritten)) { return(false); } if (!TryWriteByte(bytes[0], buffer, byteFormat, encoding, ref bytesWritten)) { return(false); } if (dash) { if (!TryWriteChar('-', buffer, encoding.TextEncoding, ref bytesWritten)) { return(false); } } if (!TryWriteByte(bytes[5], buffer, byteFormat, encoding, ref bytesWritten)) { return(false); } if (!TryWriteByte(bytes[4], buffer, byteFormat, encoding, ref bytesWritten)) { return(false); } if (dash) { if (!TryWriteChar('-', buffer, encoding.TextEncoding, ref bytesWritten)) { return(false); } } if (!TryWriteByte(bytes[7], buffer, byteFormat, encoding, ref bytesWritten)) { return(false); } if (!TryWriteByte(bytes[6], buffer, byteFormat, encoding, ref bytesWritten)) { return(false); } if (dash) { if (!TryWriteChar('-', buffer, encoding.TextEncoding, ref bytesWritten)) { return(false); } } if (!TryWriteByte(bytes[8], buffer, byteFormat, encoding, ref bytesWritten)) { return(false); } if (!TryWriteByte(bytes[9], buffer, byteFormat, encoding, ref bytesWritten)) { return(false); } if (dash) { if (!TryWriteChar('-', buffer, encoding.TextEncoding, ref bytesWritten)) { return(false); } } if (!TryWriteByte(bytes[10], buffer, byteFormat, encoding, ref bytesWritten)) { return(false); } if (!TryWriteByte(bytes[11], buffer, byteFormat, encoding, ref bytesWritten)) { return(false); } if (!TryWriteByte(bytes[12], buffer, byteFormat, encoding, ref bytesWritten)) { return(false); } if (!TryWriteByte(bytes[13], buffer, byteFormat, encoding, ref bytesWritten)) { return(false); } if (!TryWriteByte(bytes[14], buffer, byteFormat, encoding, ref bytesWritten)) { return(false); } if (!TryWriteByte(bytes[15], buffer, byteFormat, encoding, ref bytesWritten)) { return(false); } } if (tail != '\0') { if (!TryWriteChar(tail, buffer, encoding.TextEncoding, ref bytesWritten)) { return(false); } } return(true); }
public static bool TryFormat(this float value, Span <byte> buffer, out int bytesWritten, TextFormat format = default(TextFormat), TextEncoder encoder = null) { if (format.IsDefault) { format.Symbol = 'G'; } Precondition.Require(format.Symbol == 'G'); encoder = encoder == null ? TextEncoder.Utf8 : encoder; return(FloatFormatter.TryFormatNumber(value, true, buffer, out bytesWritten, format, encoder)); }
internal static bool TryFormatInt64(long value, ulong mask, Span <byte> buffer, out int bytesWritten, TextFormat format, TextEncoder encoder) { if (value >= 0) { return(TryFormatUInt64(unchecked ((ulong)value), buffer, out bytesWritten, format, encoder)); } else if (format.IsHexadecimal) { return(TryFormatUInt64(unchecked ((ulong)value) & mask, buffer, out bytesWritten, format, encoder)); } else { int minusSignBytes = 0; if (!encoder.TryEncode(TextEncoder.Symbol.MinusSign, buffer, out minusSignBytes)) { bytesWritten = 0; return(false); } int digitBytes = 0; if (!TryFormatUInt64(unchecked ((ulong)-value), buffer.Slice(minusSignBytes), out digitBytes, format, encoder)) { bytesWritten = 0; return(false); } bytesWritten = digitBytes + minusSignBytes; return(true); } }
private static bool TryFormatDecimalInvariantCultureUtf16(ulong value, Span <byte> buffer, out int bytesWritten, TextFormat format) { Precondition.Require(format.Symbol == 'D' || format.Symbol == 'G'); // Count digits var valueToCountDigits = value; var digitsCount = 1; while (valueToCountDigits >= 10UL) { valueToCountDigits = valueToCountDigits / 10UL; digitsCount++; } var index = 0; var bytesCount = digitsCount * 2; // If format is D and precision is greater than digits count, append leading zeros if (format.Symbol == 'D' && format.HasPrecision) { var leadingZerosCount = format.Precision - digitsCount; if (leadingZerosCount > 0) { bytesCount += leadingZerosCount * 2; } if (bytesCount > buffer.Length) { bytesWritten = 0; return(false); } while (leadingZerosCount-- > 0) { buffer[index++] = (byte)'0'; buffer[index++] = 0; } } else if (bytesCount > buffer.Length) { bytesWritten = 0; return(false); } index = bytesCount; while (digitsCount-- > 0) { ulong digit = value % 10UL; value /= 10UL; buffer[--index] = 0; buffer[--index] = (byte)(digit + (ulong)'0'); } bytesWritten = bytesCount; return(true); }
internal static bool TryFormatUInt64(ulong value, Span <byte> buffer, out int bytesWritten, TextFormat format, TextEncoder encoder) { if (format.Symbol == 'g') { format.Symbol = 'G'; } if (format.IsHexadecimal && encoder.IsInvariantUtf16) { return(TryFormatHexadecimalInvariantCultureUtf16(value, buffer, out bytesWritten, format)); } if (format.IsHexadecimal && encoder.IsInvariantUtf8) { return(TryFormatHexadecimalInvariantCultureUtf8(value, buffer, out bytesWritten, format)); } if ((encoder.IsInvariantUtf16) && (format.Symbol == 'D' || format.Symbol == 'G')) { return(TryFormatDecimalInvariantCultureUtf16(value, buffer, out bytesWritten, format)); } if ((encoder.IsInvariantUtf8) && (format.Symbol == 'D' || format.Symbol == 'G')) { return(TryFormatDecimalInvariantCultureUtf8(value, buffer, out bytesWritten, format)); } return(TryFormatDecimal(value, buffer, out bytesWritten, format, encoder)); }
// TODO: this whole routine is too slow. It does div and mod twice, which are both costly (especially that some JITs cannot optimize it). // It does it twice to avoid reversing the formatted buffer, which can be tricky given it should handle arbitrary cultures. // One optimization I thought we could do is to do div/mod once and store digits in a temp buffer (but that would allocate). Modification to the idea would be to store the digits in a local struct // Another idea possibly worth tying would be to special case cultures that have constant digit size, and go back to the format + reverse buffer approach. private static bool TryFormatDecimal(ulong value, Span <byte> buffer, out int bytesWritten, TextFormat format, TextEncoder encoder) { if (format.IsDefault) { format.Symbol = 'G'; } format.Symbol = Char.ToUpperInvariant(format.Symbol); // TODO: this is costly. I think the transformation should happen in Parse Precondition.Require(format.Symbol == 'D' || format.Symbol == 'G' || format.Symbol == 'N'); // Reverse value on decimal basis, count digits and trailing zeros before the decimal separator ulong reversedValueExceptFirst = 0; var digitsCount = 1; var trailingZerosCount = 0; // We reverse the digits in numeric form because reversing encoded digits is hard and/or costly. // If value contains 20 digits, its reversed value will not fit into ulong size. // So reverse it till last digit (reversedValueExceptFirst will have all the digits except the first one). while (value >= 10) { var digit = value % 10UL; value = value / 10UL; if (reversedValueExceptFirst == 0 && digit == 0) { trailingZerosCount++; } else { reversedValueExceptFirst = reversedValueExceptFirst * 10UL + digit; digitsCount++; } } bytesWritten = 0; int digitBytes; // If format is D and precision is greater than digitsCount + trailingZerosCount, append leading zeros if (format.Symbol == 'D' && format.HasPrecision) { var leadingZerosCount = format.Precision - digitsCount - trailingZerosCount; while (leadingZerosCount-- > 0) { if (!encoder.TryEncode(TextEncoder.Symbol.D0, buffer.Slice(bytesWritten), out digitBytes)) { bytesWritten = 0; return(false); } bytesWritten += digitBytes; } } // Append first digit if (!encoder.TryEncode((TextEncoder.Symbol)value, buffer.Slice(bytesWritten), out digitBytes)) { bytesWritten = 0; return(false); } bytesWritten += digitBytes; digitsCount--; if (format.Symbol == 'N') { const int GroupSize = 3; // Count amount of digits before first group separator. It will be reset to groupSize every time digitsLeftInGroup == zero var digitsLeftInGroup = (digitsCount + trailingZerosCount) % GroupSize; if (digitsLeftInGroup == 0) { if (digitsCount + trailingZerosCount > 0) { // There is a new group immediately after the first digit if (!encoder.TryEncode(TextEncoder.Symbol.GroupSeparator, buffer.Slice(bytesWritten), out digitBytes)) { bytesWritten = 0; return(false); } bytesWritten += digitBytes; } digitsLeftInGroup = GroupSize; } // Append digits while (reversedValueExceptFirst > 0) { if (digitsLeftInGroup == 0) { if (!encoder.TryEncode(TextEncoder.Symbol.GroupSeparator, buffer.Slice(bytesWritten), out digitBytes)) { bytesWritten = 0; return(false); } bytesWritten += digitBytes; digitsLeftInGroup = GroupSize; } var nextDigit = reversedValueExceptFirst % 10UL; reversedValueExceptFirst = reversedValueExceptFirst / 10UL; if (!encoder.TryEncode((TextEncoder.Symbol)nextDigit, buffer.Slice(bytesWritten), out digitBytes)) { bytesWritten = 0; return(false); } bytesWritten += digitBytes; digitsLeftInGroup--; } // Append trailing zeros if any while (trailingZerosCount-- > 0) { if (digitsLeftInGroup == 0) { if (!encoder.TryEncode(TextEncoder.Symbol.GroupSeparator, buffer.Slice(bytesWritten), out digitBytes)) { bytesWritten = 0; return(false); } bytesWritten += digitBytes; digitsLeftInGroup = GroupSize; } if (!encoder.TryEncode(TextEncoder.Symbol.D0, buffer.Slice(bytesWritten), out digitBytes)) { bytesWritten = 0; return(false); } bytesWritten += digitBytes; digitsLeftInGroup--; } } else { while (reversedValueExceptFirst > 0) { var bufferSlice = buffer.Slice(bytesWritten); var nextDigit = reversedValueExceptFirst % 10UL; reversedValueExceptFirst = reversedValueExceptFirst / 10UL; if (!encoder.TryEncode((TextEncoder.Symbol)nextDigit, bufferSlice, out digitBytes)) { bytesWritten = 0; return(false); } bytesWritten += digitBytes; } // Append trailing zeros if any while (trailingZerosCount-- > 0) { if (!encoder.TryEncode(TextEncoder.Symbol.D0, buffer.Slice(bytesWritten), out digitBytes)) { bytesWritten = 0; return(false); } bytesWritten += digitBytes; } } // If format is N and precision is not defined or is greater than zero, append trailing zeros after decimal point if (format.Symbol == 'N') { int trailingZerosAfterDecimalCount = format.HasPrecision ? format.Precision : 2; if (trailingZerosAfterDecimalCount > 0) { if (!encoder.TryEncode(TextEncoder.Symbol.DecimalSeparator, buffer.Slice(bytesWritten), out digitBytes)) { bytesWritten = 0; return(false); } bytesWritten += digitBytes; while (trailingZerosAfterDecimalCount-- > 0) { if (!encoder.TryEncode(TextEncoder.Symbol.D0, buffer.Slice(bytesWritten), out digitBytes)) { bytesWritten = 0; return(false); } bytesWritten += digitBytes; } } } return(true); }
private static bool TryFormatHexadecimalInvariantCultureUtf8(ulong value, Span <byte> buffer, out int bytesWritten, TextFormat format) { Precondition.Require(format.Symbol == 'X' || format.Symbol == 'x'); byte firstDigitOffset = (byte)'0'; byte firstHexCharOffset = format.Symbol == 'X' ? (byte)'A' : (byte)'a'; firstHexCharOffset -= 10; // Count amount of hex digits var hexDigitsCount = 1; ulong valueToCount = value; if (valueToCount > 0xFFFFFFFF) { hexDigitsCount += 8; valueToCount >>= 0x20; } if (valueToCount > 0xFFFF) { hexDigitsCount += 4; valueToCount >>= 0x10; } if (valueToCount > 0xFF) { hexDigitsCount += 2; valueToCount >>= 0x8; } if (valueToCount > 0xF) { hexDigitsCount++; } var bytesCount = hexDigitsCount; // Count leading zeros var leadingZerosCount = format.HasPrecision ? format.Precision - hexDigitsCount : 0; bytesCount += leadingZerosCount > 0 ? leadingZerosCount : 0; if (bytesCount > buffer.Length) { bytesWritten = 0; return(false); } var index = bytesCount; while (hexDigitsCount-- > 0) { byte digit = (byte)(value & 0xF); value >>= 0x4; digit += digit < 10 ? firstDigitOffset : firstHexCharOffset; buffer[--index] = digit; } // Write leading zeros if any while (leadingZerosCount-- > 0) { buffer[--index] = firstDigitOffset; } bytesWritten = bytesCount; return(true); }