private JobProgress Deserialize(string text)
{
var match = _deserializeRegex.Match(text);
if (!match.Success)
{
return(null);
}
var start = _instantPattern.Parse(match.Groups[1].ToString());
var end = _instantPattern.Parse(match.Groups[2].ToString());
var nextToken = match.Groups[3].ToString();
if (!start.Success || !end.Success)
{
return(null);
}
if (nextToken.Length == 0)
{
nextToken = null;
}
return(new JobProgress(start.Value, end.Value, nextToken));
}
private Instant?ParseBagInstant(XmlElement element)
{
if (element == null)
{
return(null);
}
return(_bagInstantPattern.Parse(element.InnerText).Value);
}
private static void UpdateProperty(ReadOnlySequence <byte> name, ReadOnlySequence <byte> parameters, ReadOnlySequence <byte> value, Event nextEvent)
{
if (name.MatchesFrom(UTF8Constants.Attendee.Span))
{
nextEvent.Attendees.Add(value.ToString(Encoding.UTF8));
}
else if (name.MatchesFrom(UTF8Constants.UId.Span))
{
nextEvent.UId = value.ToString(Encoding.UTF8);
}
else if (name.MatchesFrom(UTF8Constants.Start.Span))
{
var parseResult = iCalInstantPattern.Parse(value.ToString(Encoding.UTF8));
if (parseResult.Success)
{
nextEvent.Start = parseResult.Value;
}
}
else if (name.MatchesFrom(UTF8Constants.End.Span))
{
var parseResult = iCalInstantPattern.Parse(value.ToString(Encoding.UTF8));
if (parseResult.Success)
{
nextEvent.End = parseResult.Value;
}
}
else if (name.MatchesFrom(UTF8Constants.Duration.Span))
{
var parseResult = PeriodPattern.Roundtrip.Parse(value.ToString(Encoding.UTF8));
if (parseResult.Success)
{
nextEvent.Duration = parseResult.Value.ToDuration();
}
}
else if (name.MatchesFrom(UTF8Constants.Summary.Span))
{
nextEvent.Summary = value.ToString(Encoding.UTF8);
}
else if (name.MatchesFrom(UTF8Constants.Status.Span))
{
nextEvent.Status = EventStatusParser.Parse(value);
}
}
public static ZonedDateTime?GetUtcDateTimeFromString(string dateTime)
{
var instant = InvariantParser.Parse(dateTime);
if (!instant.Success)
{
return(null);
}
return(instant.Value.InUtc());
}
public object FromEntry(DynamoDBEntry entry)
{
if (entry is DynamoDBNull)
{
return(new Instant?());
}
var s = entry.AsString();
var res = pattern.Parse(s);
return(res.GetValueOrThrow());
}
public static Instant?ParseOrNull(this InstantPattern pattern, string?s)
{
if (s is null)
{
return(null);
}
var parseResult = pattern.Parse(s);
if (!parseResult.Success)
{
return(null);
}
return(parseResult.Value);
}
public override object?ParseLiteral(IValueNode literal)
{
if (literal == null)
{
throw new ArgumentNullException(nameof(literal));
}
if (literal is NullValueNode)
{
return(null);
}
if (literal is StringValueNode stringLiteral)
{
return(pattern.Parse(stringLiteral.Value).Value);
}
throw new ArgumentException("The Instant type can only parse string and null literals.", nameof(literal));
}
private static Instant?ParseAbsoluteOrRelativeTime(string absoluteTime, int?relativeTimeSecondsAgo)
{
if (!string.IsNullOrWhiteSpace(absoluteTime))
{
var parsedTime = InstantPattern.Parse(absoluteTime);
if (!parsedTime.Success)
{
throw new ArgumentException($"Time pattern '{absoluteTime}' could not be parsed. ISO-8601 based UTC format without fractions of second is expected.");
}
return(parsedTime.Value);
}
if (relativeTimeSecondsAgo.HasValue)
{
return(InstantUtils.SecondsAgo(relativeTimeSecondsAgo.Value));
}
return(null);
}
public NodaTimeText.ParseResult <Interval> Parse(string text)
{
var slash = text.IndexOf('/');
if (slash == -1)
{
throw new InvalidNodaDataException("Expected ISO-8601-formatted interval; slash was missing.");
}
var startText = text.Substring(0, slash);
var endText = text.Substring(slash + 1);
var startInstant = default(Instant?);
var endInstant = default(Instant?);
if (!string.IsNullOrEmpty(startText))
{
var result = Patterns.InstantPattern.Parse(startText);
if (!result.Success)
{
return(NodaTimeText.ParseResult <Interval> .ForException(() => result.Exception));
}
startInstant = result.Value;
}
if (!string.IsNullOrEmpty(endText))
{
var result = InstantPattern.Parse(endText);
if (!result.Success)
{
return(NodaTimeText.ParseResult <Interval> .ForException(() => result.Exception));
}
endInstant = result.Value;
}
return(NodaTimeText.ParseResult <Interval> .ForValue(new Interval(startInstant, endInstant)));
}
protected Instant?ParseInstant(string text, Func <DateTimeZone> zoneResolver = null)
{
if (LocalDateTimePattern != null)
{
var result = LocalDateTimePattern.Parse(text);
if (result.Success)
{
return(InstantFromLocalDateTime(result.Value, zoneResolver));
}
}
if (InstantPattern != null)
{
var result = InstantPattern.Parse(text);
if (result.Success)
{
return(result.Value.Minus(DefaultBias));
}
}
return(null);
}
public void GeneralPatternParse()
{
GeneralPattern.Parse(SampleStringGeneral);
}
public void NumberPatternParse()
{
NumberPattern.Parse(SampleStringNumber);
}
