private ArgumentNode ParseArgument(ExpressionType expressionType)
{
var arg = new ArgumentNode();
if (IsNext(TokenType.Not))
{
arg.IsExclusion = true;
arg.AddToken(Advance());
}
if (IsNext(TokenType.Wildcard))
{
arg.IsWildcard = true;
arg.AddToken(Advance());
}
else
{
arg.Range = ParseRange(expressionType);
}
if (IsNext(TokenType.Interval))
{
arg.AddToken(Advance());
arg.Interval = ParseIntegerValue(ExpressionType.IntervalValue);
}
return(arg);
}
private ArgumentNode ParseArgument(ExpressionType expressionType)
{
var arg = new ArgumentNode();
if (IsNext(TokenType.Not))
{
arg.IsExclusion = true;
arg.AddToken(Advance());
}
if (IsNext(TokenType.Wildcard))
{
arg.IsWildcard = true;
arg.AddToken(Advance());
}
else
{
arg.Range = ParseRange(expressionType);
}
if (IsNext(TokenType.Interval))
{
arg.AddToken(Advance());
arg.Interval = ParseIntegerValue(ExpressionType.IntervalValue);
}
return arg;
}
private static void CompileDateArgument(IrGroup irGroup, ArgumentNode arg)
{
IrDate irStart;
IrDate?irEnd = null;
var isSplit = false;
if (arg.IsWildcard)
{
irStart = new IrDate(null, 1, 1);
irEnd = new IrDate(null, 12, 31);
}
else
{
var start = (DateValueNode)arg.Range.Start;
irStart = new IrDate(start.Year, start.Month, start.Day);
if (arg.Range.End != null)
{
var end = (DateValueNode)arg.Range.End;
irEnd = new IrDate(end.Year, end.Month, end.Day);
}
else if (arg.HasInterval)
{
// if there is an interval, but no end value specified, then the end value is implied
irEnd = new IrDate(null, 12, 31);
}
// check for split range (spans January 1) - not applicable for dates with explicit years
if (irEnd.HasValue && !start.Year.HasValue)
{
if (irStart.Month >= irEnd.Value.Month &&
(irStart.Month > irEnd.Value.Month || irStart.Day > irEnd.Value.Day))
{
isSplit = true;
}
}
}
var irArg = new IrDateRange(irStart, irEnd, arg.HasInterval ? arg.IntervalValue : 0, isSplit, arg.Range?.IsHalfOpen ?? false);
(arg.IsExclusion ? irGroup.DatesExcluded : irGroup.Dates).Add(irArg);
}
private static void CompileDateArgument(IrGroup irGroup, ArgumentNode arg)
{
IrDate irStart;
IrDate? irEnd = null;
var isSplit = false;
if (arg.IsWildcard)
{
irStart = new IrDate(null, 1, 1);
irEnd = new IrDate(null, 12, 31);
}
else
{
var start = (DateValueNode)arg.Range.Start;
irStart = new IrDate(start.Year, start.Month, start.Day);
if (arg.Range.End != null)
{
var end = (DateValueNode)arg.Range.End;
irEnd = new IrDate(end.Year, end.Month, end.Day);
}
else if (arg.HasInterval)
{
// if there is an interval, but no end value specified, then the end value is implied
irEnd = new IrDate(null, 12, 31);
}
// check for split range (spans January 1) - not applicable for dates with explicit years
if (irEnd.HasValue && !start.Year.HasValue)
{
if (irStart.Month >= irEnd.Value.Month &&
(irStart.Month > irEnd.Value.Month || irStart.Day > irEnd.Value.Day))
{
isSplit = true;
}
}
}
var irArg = new IrDateRange(irStart, irEnd, arg.HasInterval ? arg.IntervalValue : 0, isSplit, arg.Range?.IsHalfOpen ?? false);
(arg.IsExclusion ? irGroup.DatesExcluded : irGroup.Dates).Add(irArg);
}
private static IrIntegerRange CompileIntegerArgument(ArgumentNode arg, int wildStart, int wildEnd)
{
int start;
int?end;
var isSplit = false;
if (arg.IsWildcard)
{
start = wildStart;
end = wildEnd;
}
else
{
start = ((IntegerValueNode)arg.Range.Start).Value;
end = (arg.Range.End as IntegerValueNode)?.Value;
if (!end.HasValue && arg.HasInterval)
{
// if there is an interval, but no end value specified, then the end value is implied
end = wildEnd;
}
// check for a split range
if (end.HasValue && end < start)
{
// Start is greater than end, so it's probably a split range, but there's one exception.
// If this is a month expression, and end is a negative number (counting back from the end of the month)
// then it might not actually be a split range
if (start < 0 || end > 0)
{
// check says that either start is negative or end is positive
// (means we're probably not in the weird day of month scenario)
// todo: implement a better check which looks for possible overlap between a positive start and negative end
isSplit = true;
}
}
}
return(new IrIntegerRange(start, end, arg.HasInterval ? arg.IntervalValue : 0, isSplit, arg.Range?.IsHalfOpen ?? false));
}
internal void AddArgument(ArgumentNode arg)
{
_arguments.Add(arg);
}
private static void CompileDaysOfYearArgument(IrGroup irGroup, ArgumentNode arg)
{
var irArg = CompileIntegerArgument(arg, 1, 366);
(arg.IsExclusion ? irGroup.DaysOfYearExcluded : irGroup.DaysOfYear).Add(irArg);
}
private static void CompileHoursArgument(IrGroup irGroup, ArgumentNode arg)
{
var irArg = CompileIntegerArgument(arg, 0, 23);
(arg.IsExclusion ? irGroup.HoursExcluded : irGroup.Hours).Add(irArg);
}
private static void CompileMinutesArgument(IrGroup irGroup, ArgumentNode arg)
{
var irArg = CompileIntegerArgument(arg, 0, 59);
(arg.IsExclusion ? irGroup.MinutesExcluded : irGroup.Minutes).Add(irArg);
}
private static void CompileDaysOfYearArgument(IrGroup irGroup, ArgumentNode arg)
{
var irArg = CompileIntegerArgument(arg, 1, 366);
(arg.IsExclusion ? irGroup.DaysOfYearExcluded : irGroup.DaysOfYear).Add(irArg);
}
private static void CompileSecondsArgument(IrGroup irGroup, ArgumentNode arg)
{
var irArg = CompileIntegerArgument(arg, 0, 59);
(arg.IsExclusion ? irGroup.SecondsExcluded : irGroup.Seconds).Add(irArg);
}
private static IrIntegerRange CompileIntegerArgument(ArgumentNode arg, int wildStart, int wildEnd)
{
int start;
int? end;
var isSplit = false;
if (arg.IsWildcard)
{
start = wildStart;
end = wildEnd;
}
else
{
start = ((IntegerValueNode)arg.Range.Start).Value;
end = (arg.Range.End as IntegerValueNode)?.Value;
if (!end.HasValue && arg.HasInterval)
{
// if there is an interval, but no end value specified, then the end value is implied
end = wildEnd;
}
// check for a split range
if (end.HasValue && end < start)
{
// Start is greater than end, so it's probably a split range, but there's one exception.
// If this is a month expression, and end is a negative number (counting back from the end of the month)
// then it might not actually be a split range
if (start < 0 || end > 0)
{
// check says that either start is negative or end is positive
// (means we're probably not in the weird day of month scenario)
// todo: implement a better check which looks for possible overlap between a positive start and negative end
isSplit = true;
}
}
}
return new IrIntegerRange(start, end, arg.HasInterval ? arg.IntervalValue : 0, isSplit, arg.Range?.IsHalfOpen ?? false);
}
private static void CompileHoursArgument(IrGroup irGroup, ArgumentNode arg)
{
var irArg = CompileIntegerArgument(arg, 0, 23);
(arg.IsExclusion ? irGroup.HoursExcluded : irGroup.Hours).Add(irArg);
}
internal void AddArgument(ArgumentNode arg)
{
_arguments.Add(arg);
}
