public bool ParseDate(DateTimeParse parse, int start)
{
int year = 0;
int month = 0;
int day = 0;
var result = (Parse4Digit(parse, start, out year) &&
1 <= year &&
ParseChar(parse, start + Lzyyyy, '-') &&
Parse2Digit(parse, start + Lzyyyy_, out month) &&
1 <= month &&
month <= 12 &&
ParseChar(parse, start + Lzyyyy_MM, '-') &&
Parse2Digit(parse, start + Lzyyyy_MM_, out day) &&
1 <= day &&
day <= DateTime.DaysInMonth(year, month));
parse.Year = year;
parse.Month = month;
parse.Day = day;
return(result);
}
public DateTime CreateDateTime(DateTimeParse dateTimeParser)
{
bool is24Hour;
if (dateTimeParser.Hour == 24)
{
is24Hour = true;
dateTimeParser.Hour = 0;
}
else
{
is24Hour = false;
}
DateTime d = new DateTime(dateTimeParser.Year, dateTimeParser.Month, dateTimeParser.Day, dateTimeParser.Hour, dateTimeParser.Minute, dateTimeParser.Second);
d = d.AddTicks(dateTimeParser.Fraction);
if (is24Hour)
{
d = d.AddDays(1);
}
return(d);
}
public static DateTime ParseDateTimeExact(String value, String format, IFormatProvider provider, DateTimeStyles styles)
{
return(DateTimeParse.ParseExact(value, format, DateTimeFormatInfo.GetInstance(provider), styles));
}
public static Boolean TryParseDateTimeExact(String value, String format, IFormatProvider provider, DateTimeStyles styles, out DateTime result)
{
return(DateTimeParse.TryParseExact(value, format, (DateTimeFormatInfo)provider.GetFormat(typeof(DateTimeFormatInfo)), styles, out result));
}
public static DateTime ParseDateTimeExact(String value, String format, IFormatProvider provider, DateTimeStyles styles, out TimeSpan offset)
{
return(DateTimeParse.ParseExact(value, format, (DateTimeFormatInfo)provider.GetFormat(typeof(DateTimeFormatInfo)), styles, out offset));
}
public static bool TryParseExact(ReadOnlySpan <char> s, string?[]?formats, IFormatProvider?provider, DateTimeStyles style, out DateTime result)
{
DateTimeFormatInfo.ValidateStyles(style, nameof(style));
return(DateTimeParse.TryParseExactMultiple(s, formats, DateTimeFormatInfo.GetInstance(provider), style, out result));
}
public static bool Parse(this DateTimeParse parse, char[] text, int startIndex, int length)
{
return(XDateTimes.Api.Parsing.Parse(parse, text, startIndex, length));
}
public static bool Parse2Digit(this DateTimeParse parse, int start, out int num)
{
return(XDateTimes.Api.Parsing.Parse2Digit(parse, start, out num));
}
public static bool ParseTimeAndZoneAndWhitespace(this DateTimeParse parse, int start)
{
return(XDateTimes.Api.Parsing.ParseTimeAndZoneAndWhitespace(parse, start));
}
public bool ParseChar(DateTimeParse parse, int start, char ch)
{
return(start < parse.End && parse.Text[start] == ch);
}
public bool ParseZone(DateTimeParse parse, int start)
{
if (start < parse.End)
{
char ch = parse.Text[start];
if (ch == 'Z' || ch == 'z')
{
parse.Zone = ParserTimeZone.Utc;
start++;
}
else
{
int zoneHour = 0;
if (start + 2 < parse.End &&
Parse2Digit(parse, start + Lz_, out zoneHour) &&
zoneHour <= 99)
{
switch (ch)
{
case '-':
parse.Zone = ParserTimeZone.LocalWestOfUtc;
start += Lz_zz;
break;
case '+':
parse.Zone = ParserTimeZone.LocalEastOfUtc;
start += Lz_zz;
break;
}
}
if (start < parse.End)
{
int zoneMinute = 0;
if (ParseChar(parse, start, ':'))
{
start += 1;
if (start + 1 < parse.End &&
Parse2Digit(parse, start, out zoneMinute) &&
zoneMinute <= 99)
{
start += 2;
}
}
else
{
if (start + 1 < parse.End &&
Parse2Digit(parse, start, out zoneMinute) &&
zoneMinute <= 99)
{
start += 2;
}
}
parse.ZoneMinute = zoneMinute;
}
}
}
return(start == parse.End);
}
public bool TryParseDateTimeIso(StringReference text, DateTimeZoneHandling dateTimeZoneHandling, out DateTime dt)
{
DateTimeParse dateTimeParser = new DateTimeParse();
if (!dateTimeParser.Parse(text.Chars, text.StartIndex, text.Length))
{
dt = default(DateTime);
return(false);
}
DateTime d = CreateDateTime(dateTimeParser);
long ticks;
switch (dateTimeParser.Zone)
{
case ParserTimeZone.Utc:
d = new DateTime(d.Ticks, DateTimeKind.Utc);
break;
case ParserTimeZone.LocalWestOfUtc:
{
TimeSpan offset = new TimeSpan(dateTimeParser.ZoneHour, dateTimeParser.ZoneMinute, 0);
ticks = d.Ticks + offset.Ticks;
if (ticks <= DateTime.MaxValue.Ticks)
{
d = new DateTime(ticks, DateTimeKind.Utc).ToLocalTime();
}
else
{
ticks += d.GetUtcOffset().Ticks;
if (ticks > DateTime.MaxValue.Ticks)
{
ticks = DateTime.MaxValue.Ticks;
}
d = new DateTime(ticks, DateTimeKind.Local);
}
break;
}
case ParserTimeZone.LocalEastOfUtc:
{
TimeSpan offset = new TimeSpan(dateTimeParser.ZoneHour, dateTimeParser.ZoneMinute, 0);
ticks = d.Ticks - offset.Ticks;
if (ticks >= DateTime.MinValue.Ticks)
{
d = new DateTime(ticks, DateTimeKind.Utc).ToLocalTime();
}
else
{
ticks += d.GetUtcOffset().Ticks;
if (ticks < DateTime.MinValue.Ticks)
{
ticks = DateTime.MinValue.Ticks;
}
d = new DateTime(ticks, DateTimeKind.Local);
}
break;
}
}
dt = EnsureDateTime(d, dateTimeZoneHandling);
return(true);
}
public static Boolean TryParseDateTimeExactMultiple(String value, String[] formats, IFormatProvider provider, DateTimeStyles styles, out DateTime result)
{
return(DateTimeParse.TryParseExactMultiple(value, formats, DateTimeFormatInfo.GetInstance(provider), styles, out result));
}
public static Boolean TryParseDateTimeExact(String value, String format, IFormatProvider provider, DateTimeStyles styles, out DateTime result, out TimeSpan offset)
{
return(DateTimeParse.TryParseExact(value, format, DateTimeFormatInfo.GetInstance(provider), styles, out result, out offset));
}
public static DateTime ParseDateTimeExactMultiple(String value, String[] formats, IFormatProvider provider, DateTimeStyles styles, out TimeSpan offset)
{
return(DateTimeParse.ParseExactMultiple(value, formats, DateTimeFormatInfo.GetInstance(provider), styles, out offset));
}
public static DateTime2 ParseExact(string s, string format, IFormatProvider provider)
{
return(DateTimeParse.ParseExact(s, format, DateTimeFormatInfo.GetInstance(provider), DateTimeStyles.None));
}
public static DateTime2 ParseExact(string s, string[] formats, IFormatProvider provider, DateTimeStyles style)
{
DateTimeFormatInfo.ValidateStyles(style, "style");
return(DateTimeParse.ParseExactMultiple(s, formats, DateTimeFormatInfo.GetInstance(provider), style));
}
public bool ParseTimeAndZoneAndWhitespace(DateTimeParse parse, int start)
{
return(ParseTime(parse, ref start) && ParseZone(parse, start));
}
public static bool ParseZone(this DateTimeParse parse, int start)
{
return(XDateTimes.Api.Parsing.ParseZone(parse, start));
}
public bool ParseTime(DateTimeParse parse, ref int start)
{
int hour = 0;
int minute = 0;
int second = 0;
if (!(Parse2Digit(parse, start, out hour) &&
hour <= 24 &&
ParseChar(parse, start + LzHH, ':') &&
Parse2Digit(parse, start + LzHH_, out minute) &&
minute < 60 &&
ParseChar(parse, start + LzHH_mm, ':') &&
Parse2Digit(parse, start + LzHH_mm_, out second) &&
second < 60 &&
(hour != 24 || (minute == 0 && second == 0)))) // hour can be 24 if minute/second is zero)
{
parse.Hour = hour;
parse.Minute = minute;
parse.Second = second;
return(false);
}
parse.Hour = hour;
parse.Minute = minute;
parse.Second = second;
start += LzHH_mm_ss;
if (ParseChar(parse, start, '.'))
{
parse.Fraction = 0;
int numberOfDigits = 0;
while (++start < parse.End && numberOfDigits < MaxFractionDigits)
{
int digit = parse.Text[start] - '0';
if (digit < 0 || digit > 9)
{
break;
}
parse.Fraction = (parse.Fraction * 10) + digit;
numberOfDigits++;
}
if (numberOfDigits < MaxFractionDigits)
{
if (numberOfDigits == 0)
{
return(false);
}
parse.Fraction *= Power10[MaxFractionDigits - numberOfDigits];
}
if (parse.Hour == 24 && parse.Fraction != 0)
{
return(false);
}
}
return(true);
}
public static bool ParseChar(this DateTimeParse parse, int start, char ch)
{
return(XDateTimes.Api.Parsing.ParseChar(parse, start, ch));
}
public static bool TryParse(string s, out DateTime2 result)
{
return(DateTimeParse.TryParse(s, DateTimeFormatInfo.CurrentInfo, DateTimeStyles.None, out result));
}
public static bool TryParse(ReadOnlySpan <char> s, IFormatProvider?provider, DateTimeStyles styles, out DateTime result)
{
DateTimeFormatInfo.ValidateStyles(styles, nameof(styles));
return(DateTimeParse.TryParse(s, DateTimeFormatInfo.GetInstance(provider), styles, out result));
}
public static bool TryParseExact(string s, string format, IFormatProvider provider, DateTimeStyles style, out DateTime2 result)
{
DateTimeFormatInfo.ValidateStyles(style, "style");
return(DateTimeParse.TryParseExact(s, format, DateTimeFormatInfo.GetInstance(provider), style, out result));
}
public static DateTime ParseDateTime(String value, IFormatProvider provider, DateTimeStyles styles)
{
return(DateTimeParse.Parse(value, (DateTimeFormatInfo)provider.GetFormat(typeof(DateTimeFormatInfo)), styles));
}
public static DateTime2 Parse(string s)
{
return(DateTimeParse.Parse(s, DateTimeFormatInfo.CurrentInfo, DateTimeStyles.None));
}
public static DateTime ParseDateTimeExactMultiple(String value, String[] formats, IFormatProvider provider, DateTimeStyles styles)
{
return(DateTimeParse.ParseExactMultiple(value, formats, (DateTimeFormatInfo)provider.GetFormat(typeof(DateTimeFormatInfo)), styles));
}
public static DateTime2 Parse(string s, IFormatProvider provider, DateTimeStyles styles)
{
DateTimeFormatInfo.ValidateStyles(styles, "styles");
return(DateTimeParse.Parse(s, DateTimeFormatInfo.GetInstance(provider), styles));
}
public static Boolean TryParseDateTimeExactMultiple(String value, String[] formats, IFormatProvider provider, DateTimeStyles styles, out DateTime result, out TimeSpan offset)
{
return(DateTimeParse.TryParseExactMultiple(value, formats, (DateTimeFormatInfo)provider.GetFormat(typeof(DateTimeFormatInfo)), styles, out result, out offset));
}
public static DateTime ParseDateTime(String value, IFormatProvider provider, DateTimeStyles styles, out TimeSpan offset)
{
return(DateTimeParse.Parse(value, DateTimeFormatInfo.GetInstance(provider), styles, out offset));
}
