/// <summary> /// Parses a Boolean at the start of a Utf8 string. /// </summary> /// <param name="source">The Utf8 string to parse</param> /// <param name="value">Receives the parsed value</param> /// <param name="bytesConsumed">On a successful parse, receives the length in bytes of the substring that was parsed </param> /// <param name="standardFormat">Expected format of the Utf8 string</param> /// <returns> /// true for success. "bytesConsumed" contains the length in bytes of the substring that was parsed. /// false if the string was not syntactically valid or an overflow or underflow occurred. "bytesConsumed" is set to 0. /// </returns> /// <remarks> /// Formats supported: /// G (default) True/False /// l true/false /// </remarks> /// <exceptions> /// <cref>System.FormatException</cref> if the format is not valid for this data type. /// </exceptions> public static bool TryParse(ReadOnlySpan <byte> source, out bool value, out int bytesConsumed, char standardFormat = default) { if (!(standardFormat == default(char) || standardFormat == 'G' || standardFormat == 'l')) { return(ParserHelpers.TryParseThrowFormatException(out value, out bytesConsumed)); } if (source.Length >= 4) { int dw = BinaryPrimitives.ReadInt32LittleEndian(source) & ~0x20202020; if (dw == 0x45555254 /* 'EURT' */) { bytesConsumed = 4; value = true; return(true); } if (source.Length >= 5) { if (dw == 0x534c4146 /* 'SLAF' */ && (source[4] & ~0x20) == 'E') { bytesConsumed = 5; value = false; return(true); } } } bytesConsumed = 0; value = default; return(false); }
/// <summary> /// Parses an Int16 at the start of a Utf8 string. /// </summary> /// <param name="source">The Utf8 string to parse</param> /// <param name="value">Receives the parsed value</param> /// <param name="bytesConsumed">On a successful parse, receives the length in bytes of the substring that was parsed </param> /// <param name="standardFormat">Expected format of the Utf8 string</param> /// <returns> /// true for success. "bytesConsumed" contains the length in bytes of the substring that was parsed. /// false if the string was not syntactically valid or an overflow or underflow occurred. "bytesConsumed" is set to 0. /// </returns> /// <remarks> /// Formats supported: /// G/g (default) /// D/d 32767 /// N/n 32,767 /// X/x 7fff /// </remarks> /// <exceptions> /// <cref>System.FormatException</cref> if the format is not valid for this data type. /// </exceptions> public static bool TryParse(ReadOnlySpan <byte> source, out short value, out int bytesConsumed, char standardFormat = default) { FastPath: if (standardFormat == default) { return(TryParseInt16D(source, out value, out bytesConsumed)); } // There's small but measurable overhead when entering the switch block below. // We optimize for the default case by hoisting it above the switch block. switch (standardFormat | 0x20) // convert to lowercase { case 'g': case 'd': case 'r': standardFormat = default; goto FastPath; case 'n': return(TryParseInt16N(source, out value, out bytesConsumed)); case 'x': Unsafe.SkipInit(out value); // will be populated by TryParseUInt16X return(TryParseUInt16X(source, out Unsafe.As <short, ushort>(ref value), out bytesConsumed)); default: return(ParserHelpers.TryParseThrowFormatException(source, out value, out bytesConsumed)); } }
private static bool TryParseNormalAsFloatingPoint(ReadOnlySpan <byte> source, ref Number.NumberBuffer number, out int bytesConsumed, char standardFormat) { ParseNumberOptions options; switch (standardFormat) { case default(char): case 'G': case 'g': case 'E': case 'e': options = ParseNumberOptions.AllowExponent; break; case 'F': case 'f': options = default; break; default: return(ParserHelpers.TryParseThrowFormatException(out bytesConsumed)); } if (!TryParseNumber(source, ref number, out bytesConsumed, options, out bool textUsedExponentNotation)) { return(false); } if ((!textUsedExponentNotation) && (standardFormat == 'E' || standardFormat == 'e')) { bytesConsumed = 0; return(false); } return(true); }
/// <summary> /// Parses a DateTimeOffset at the start of a Utf8 string. /// </summary> /// <param name="source">The Utf8 string to parse</param> /// <param name="value">Receives the parsed value</param> /// <param name="bytesConsumed">On a successful parse, receives the length in bytes of the substring that was parsed </param> /// <param name="standardFormat">Expected format of the Utf8 string</param> /// <returns> /// true for success. "bytesConsumed" contains the length in bytes of the substring that was parsed. /// false if the string was not syntactically valid or an overflow or underflow occurred. "bytesConsumed" is set to 0. /// </returns> /// <remarks> /// Formats supported: /// G (default) 05/25/2017 10:30:15 /// R Tue, 03 Jan 2017 08:08:05 GMT (RFC 1123) /// l tue, 03 jan 2017 08:08:05 gmt (Lowercase RFC 1123) /// O 2017-06-12T05:30:45.7680000-07:00 (Round-trippable) /// </remarks> /// <exceptions> /// <cref>System.FormatException</cref> if the format is not valid for this data type. /// </exceptions> public static bool TryParse(ReadOnlySpan <byte> source, out DateTimeOffset value, out int bytesConsumed, char standardFormat = default) { return(standardFormat switch { 'R' => TryParseDateTimeOffsetR(source, NoFlipCase, out value, out bytesConsumed), 'l' => TryParseDateTimeOffsetR(source, FlipCase, out value, out bytesConsumed), 'O' => TryParseDateTimeOffsetO(source, out value, out bytesConsumed, out _), default(char) => TryParseDateTimeOffsetDefault(source, out value, out bytesConsumed), 'G' => TryParseDateTimeG(source, out DateTime _, out value, out bytesConsumed), _ => ParserHelpers.TryParseThrowFormatException(out value, out bytesConsumed), });
/// <summary> /// Parses a TimeSpan at the start of a Utf8 string. /// </summary> /// <param name="source">The Utf8 string to parse</param> /// <param name="value">Receives the parsed value</param> /// <param name="bytesConsumed">On a successful parse, receives the length in bytes of the substring that was parsed </param> /// <param name="standardFormat">Expected format of the Utf8 string</param> /// <returns> /// true for success. "bytesConsumed" contains the length in bytes of the substring that was parsed. /// false if the string was not syntactically valid or an overflow or underflow occurred. "bytesConsumed" is set to 0. /// </returns> /// <remarks> /// Formats supported: /// c/t/T (default) [-][d.]hh:mm:ss[.fffffff] (constant format) /// G [-]d:hh:mm:ss.fffffff (general long) /// g [-][d:]h:mm:ss[.f[f[f[f[f[f[f[]]]]]]] (general short) /// </remarks> /// <exceptions> /// <cref>System.FormatException</cref> if the format is not valid for this data type. /// </exceptions> public static bool TryParse(ReadOnlySpan <byte> source, out TimeSpan value, out int bytesConsumed, char standardFormat = default) { switch (standardFormat) { case default(char): case 'c': case 't': case 'T': return(TryParseTimeSpanC(source, out value, out bytesConsumed)); case 'G': return(TryParseTimeSpanBigG(source, out value, out bytesConsumed)); case 'g': return(TryParseTimeSpanLittleG(source, out value, out bytesConsumed)); default: return(ParserHelpers.TryParseThrowFormatException(out value, out bytesConsumed)); } }
/// <summary> /// Parses a DateTimeOffset at the start of a Utf8 string. /// </summary> /// <param name="source">The Utf8 string to parse</param> /// <param name="value">Receives the parsed value</param> /// <param name="bytesConsumed">On a successful parse, receives the length in bytes of the substring that was parsed </param> /// <param name="standardFormat">Expected format of the Utf8 string</param> /// <returns> /// true for success. "bytesConsumed" contains the length in bytes of the substring that was parsed. /// false if the string was not syntactically valid or an overflow or underflow occurred. "bytesConsumed" is set to 0. /// </returns> /// <remarks> /// Formats supported: /// G (default) 05/25/2017 10:30:15 /// R Tue, 03 Jan 2017 08:08:05 GMT (RFC 1123) /// l tue, 03 jan 2017 08:08:05 gmt (Lowercase RFC 1123) /// O 2017-06-12T05:30:45.7680000-07:00 (Round-trippable) /// </remarks> /// <exceptions> /// <cref>System.FormatException</cref> if the format is not valid for this data type. /// </exceptions> public static bool TryParse(ReadOnlySpan <byte> source, out DateTimeOffset value, out int bytesConsumed, char standardFormat = default) { switch (standardFormat) { case 'R': return(TryParseDateTimeOffsetR(source, NoFlipCase, out value, out bytesConsumed)); case 'l': return(TryParseDateTimeOffsetR(source, FlipCase, out value, out bytesConsumed)); case 'O': return(TryParseDateTimeOffsetO(source, out value, out bytesConsumed, out _)); case default(char): return(TryParseDateTimeOffsetDefault(source, out value, out bytesConsumed)); case 'G': return(TryParseDateTimeG(source, out DateTime _, out value, out bytesConsumed)); default: return(ParserHelpers.TryParseThrowFormatException(out value, out bytesConsumed)); } }
/// <summary> /// Parses an Int16 at the start of a Utf8 string. /// </summary> /// <param name="source">The Utf8 string to parse</param> /// <param name="value">Receives the parsed value</param> /// <param name="bytesConsumed">On a successful parse, receives the length in bytes of the substring that was parsed </param> /// <param name="standardFormat">Expected format of the Utf8 string</param> /// <returns> /// true for success. "bytesConsumed" contains the length in bytes of the substring that was parsed. /// false if the string was not syntactically valid or an overflow or underflow occurred. "bytesConsumed" is set to 0. /// </returns> /// <remarks> /// Formats supported: /// G/g (default) /// D/d 32767 /// N/n 32,767 /// X/x 7fff /// </remarks> /// <exceptions> /// <cref>System.FormatException</cref> if the format is not valid for this data type. /// </exceptions> public static bool TryParse(ReadOnlySpan <byte> source, out short value, out int bytesConsumed, char standardFormat = default) { switch (standardFormat) { case default(char): case 'g': case 'G': case 'd': case 'D': return(TryParseInt16D(source, out value, out bytesConsumed)); case 'n': case 'N': return(TryParseInt16N(source, out value, out bytesConsumed)); case 'x': case 'X': value = default; return(TryParseUInt16X(source, out Unsafe.As <short, ushort>(ref value), out bytesConsumed)); default: return(ParserHelpers.TryParseThrowFormatException(out value, out bytesConsumed)); } }
/// <summary> /// Parses a DateTime at the start of a Utf8 string. /// </summary> /// <param name="source">The Utf8 string to parse</param> /// <param name="value">Receives the parsed value</param> /// <param name="bytesConsumed">On a successful parse, receives the length in bytes of the substring that was parsed </param> /// <param name="standardFormat">Expected format of the Utf8 string</param> /// <returns> /// true for success. "bytesConsumed" contains the length in bytes of the substring that was parsed. /// false if the string was not syntactically valid or an overflow or underflow occurred. "bytesConsumed" is set to 0. /// </returns> /// <remarks> /// Formats supported: /// default 05/25/2017 10:30:15 -08:00 /// G 05/25/2017 10:30:15 /// R Tue, 03 Jan 2017 08:08:05 GMT (RFC 1123) /// l tue, 03 jan 2017 08:08:05 gmt (Lowercase RFC 1123) /// O 2017-06-12T05:30:45.7680000-07:00 (Round-trippable) /// </remarks> /// <exceptions> /// <cref>System.FormatException</cref> if the format is not valid for this data type. /// </exceptions> public static bool TryParse(ReadOnlySpan <byte> source, out DateTime value, out int bytesConsumed, char standardFormat = default) { switch (standardFormat) { case 'R': { if (!TryParseDateTimeOffsetR(source, NoFlipCase, out DateTimeOffset dateTimeOffset, out bytesConsumed)) { value = default; return(false); } value = dateTimeOffset.DateTime; // (returns a DateTimeKind.Unspecified to match DateTime.ParseExact(). Maybe better to return UtcDateTime instead?) return(true); } case 'l': { if (!TryParseDateTimeOffsetR(source, FlipCase, out DateTimeOffset dateTimeOffset, out bytesConsumed)) { value = default; return(false); } value = dateTimeOffset.DateTime; // (returns a DateTimeKind.Unspecified to match DateTime.ParseExact(). Maybe better to return UtcDateTime instead?) return(true); } case 'O': { // Emulates DateTime.ParseExact(text, "O", CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind) // In particular, the formatted string "encodes" the DateTimeKind according to the following table: // // 2017-06-12T05:30:45.7680000 - Unspecified // 2017-06-12T05:30:45.7680000+00:00 - Local // 2017-06-12T05:30:45.7680000Z - Utc if (!TryParseDateTimeOffsetO(source, out DateTimeOffset dateTimeOffset, out bytesConsumed, out DateTimeKind kind)) { value = default; bytesConsumed = 0; return(false); } switch (kind) { case DateTimeKind.Local: value = dateTimeOffset.LocalDateTime; break; case DateTimeKind.Utc: value = dateTimeOffset.UtcDateTime; break; default: Debug.Assert(kind == DateTimeKind.Unspecified); value = dateTimeOffset.DateTime; break; } return(true); } case default(char): case 'G': return(TryParseDateTimeG(source, out value, out _, out bytesConsumed)); default: return(ParserHelpers.TryParseThrowFormatException(out value, out bytesConsumed)); } }