/// <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));
}
}