protected override Span NextSpan(Pointer.Type pointer)
{
var halfDay = RepeaterDay.DAY_SECONDS / 2;
var fullDay = RepeaterDay.DAY_SECONDS;
var now = Now.Value;
var tick = Value;
var first = false;
if (_currentTime == null)
{
first = true;
var midnight = now.Date;
var yesterdayMidnight = midnight.AddDays(-1);
var tomorrowMidnight = midnight.AddDays(1);
var dstFix = (midnight - midnight.ToUniversalTime()).Seconds -
(tomorrowMidnight - tomorrowMidnight.ToUniversalTime()).Seconds;
var done = false;
DateTime[] candidateDates = null;
if (pointer == Pointer.Type.Future)
{
candidateDates = tick.IsAmbiguous
? new DateTime[]
{
midnight.AddSeconds(tick.ToInt32() + dstFix),
midnight.AddSeconds(tick.ToInt32() + halfDay + dstFix),
tomorrowMidnight.AddSeconds(tick.ToInt32())
}
: new DateTime[]
{
midnight.AddSeconds(tick.ToInt32() + dstFix),
tomorrowMidnight.AddSeconds(tick.ToInt32())
};
foreach (var date in candidateDates)
{
if (date >= now)
{
_currentTime = date;
done = true;
break;
}
}
}
else
{
candidateDates = tick.IsAmbiguous
? new DateTime[]
{
midnight.AddSeconds(tick.ToInt32() + halfDay + dstFix),
midnight.AddSeconds(tick.ToInt32() + dstFix),
yesterdayMidnight.AddSeconds(tick.ToInt32() + halfDay)
}
: new DateTime[]
{
midnight.AddSeconds(tick.ToInt32() + dstFix),
yesterdayMidnight.AddSeconds(tick.ToInt32())
};
foreach (var date in candidateDates)
{
if (date <= now)
{
_currentTime = date;
done = true;
break;
}
}
}
if (!done && _currentTime == null)
{
throw new IllegalStateException(
"Current time cannot be null at this point.");
}
}
if (!first)
{
var increment = tick.IsAmbiguous ? halfDay : fullDay;
var direction = (int)pointer;
_currentTime = _currentTime.Value.AddSeconds(direction * increment);
}
return(new Span(_currentTime.Value,
_currentTime.Value.AddSeconds(GetWidth())));
}
protected abstract Span NextSpan(Pointer.Type pointer);
public override Span GetOffset(Span span, int amount, Pointer.Type pointer)
{
var direction = (int)pointer;
return(span.Add(direction * amount * DAY_SECONDS));
}
public override Span GetOffset(Span span, int amount,
Pointer.Type pointer)
{
throw new NotImplementedException();
}
protected override Span CurrentSpan(Pointer.Type pointer)
{
throw new NotImplementedException();
}
public override Span GetOffset(Span span, int amount, Pointer.Type pointer)
{
var direction = (pointer == Pointer.Type.Future) ? 1 : -1;
return(span.Add(direction * amount * RepeaterWeek.WEEK_SECONDS));
}
protected override Span NextSpan(Pointer.Type pointer)
{
var now = Now.Value;
if (_currentMonthBegin == null)
{
var index = GetMonthIndex();
if (pointer == Pointer.Type.Future)
{
if (now.Month < index)
{
_currentMonthBegin = Time.New(Now.Value.Year, index);
}
else if (now.Month > index)
{
_currentMonthBegin = Time.New(Now.Value.Year + 1, index);
}
}
else if (pointer == Pointer.Type.None)
{
if (now.Month <= index)
{
_currentMonthBegin = Time.New(Now.Value.Year, index);
}
else if (now.Month > index)
{
_currentMonthBegin = Time.New(Now.Value.Year + 1, index);
}
}
else if (pointer == Pointer.Type.Past)
{
if (now.Month >= index)
{
_currentMonthBegin = Time.New(Now.Value.Year, index);
}
else if (now.Month < index)
{
_currentMonthBegin = Time.New(Now.Value.Year - 1, index);
}
}
else
{
throw new ArgumentException(
"Unable to handle pointer " + pointer + ".");
}
if (_currentMonthBegin == null)
{
throw new IllegalStateException(
"Current month should be set by now.");
}
}
else
{
if (pointer == Pointer.Type.Future)
{
_currentMonthBegin = Time.New(_currentMonthBegin.Value.Year + 1, _currentMonthBegin.Value.Month);
}
else if (pointer == Pointer.Type.Past)
{
_currentMonthBegin = Time.New(_currentMonthBegin.Value.Year - 1, _currentMonthBegin.Value.Month);
}
else
{
throw new ArgumentException(
"Unable to handle pointer " + pointer + ".");
}
}
var cur_month_year = _currentMonthBegin.Value.Year;
var cur_month_month = _currentMonthBegin.Value.Month;
var next_month_year = 0;
var next_month_month = 0;
if (cur_month_month == 12)
{
next_month_year = cur_month_year + 1;
next_month_month = 1;
}
else
{
next_month_year = cur_month_year;
next_month_month = cur_month_month + 1;
}
return(new Span(_currentMonthBegin.Value,
Time.New(next_month_year, next_month_month)));
}
public override Span GetOffset(Span span, int amount, Pointer.Type pointer)
{
int direction = (pointer == Pointer.Type.Future) ? 1 : -1;
return(span.Add(direction * amount * RepeaterMinute.MINUTE_SECONDS));
}
public static Span GetAnchor(this IEnumerable <Token> @this,
Options options)
{
var grabber = new Grabber(Grabber.Type.This);
Pointer.Type pointer = Pointer.Type.Future;
List <Token> tokens = @this.ToList();
IList <IRepeater> repeaters = tokens.GetRepeaters();
for (int i = 0; i < repeaters.Count; i++)
{
tokens.RemoveAt(tokens.Count - 1);
}
if (tokens.Count > 0 && tokens[0].IsTaggedAs <Grabber>())
{
grabber = tokens[0].GetTag <Grabber>();
tokens.RemoveAt(tokens.Count - 1);
}
IRepeater head = repeaters[0];
repeaters.RemoveAt(0);
head.Now = options.Clock();
Span outerSpan;
Grabber.Type grabberType = grabber.Value;
if (grabberType == Grabber.Type.Last)
{
outerSpan = head.GetNextSpan(Pointer.Type.Past);
}
else if (grabberType == Grabber.Type.This)
{
if (repeaters.Count > 0)
{
outerSpan = head.GetCurrentSpan(Pointer.Type.None);
}
else
{
outerSpan = head.GetCurrentSpan(options.Context);
}
}
else if (grabberType == Grabber.Type.Next)
{
outerSpan = head.GetNextSpan(Pointer.Type.Future);
}
else
{
throw new ArgumentException("Invalid grabber type " +
grabberType + ".");
}
Logger.Log(() => "Handler-class: " + head.GetType().Name);
Logger.Log(() => "--" + outerSpan.ToString());
Span anchor = repeaters.FindWithin(outerSpan, pointer, options);
return(anchor);
}
public override Span GetOffset(Span span, int amount, Pointer.Type pointer)
{
throw new IllegalStateException("Not implemented.");
}
protected override Span CurrentSpan(Pointer.Type pointer)
{
var now = Now.Value;
return(new Span(now, now.AddSeconds(1)));
}
protected override Span NextSpan(Pointer.Type pointer)
{
throw new System.NotImplementedException();
}
protected override Span NextSpan(Pointer.Type pointer)
{
var range = GetRange(Value);
DateTime rangeStart;
DateTime rangeEnd;
if (_currentSpan == null)
{
var now = Now.Value;
var nowSeconds = (long)Math.Truncate(now.TimeOfDay.TotalSeconds);
if (nowSeconds < range.StartSecond)
{
if (pointer == Pointer.Type.Future)
{
rangeStart = now.Date.AddSeconds(range.StartSecond);
}
else if (pointer == Pointer.Type.Past)
{
rangeStart = now.Date.AddDays(-1).AddSeconds(range.StartSecond);
}
else
{
throw new ArgumentException("Unable to handle pointer type " + pointer, "pointer");
}
}
else if (nowSeconds > range.EndSecond)
{
if (pointer == Pointer.Type.Future)
{
rangeStart = now.Date.AddDays(1).AddSeconds(range.StartSecond);
}
else if (pointer == Pointer.Type.Past)
{
rangeStart = now.Date.AddSeconds(range.StartSecond);
}
else
{
throw new ArgumentException("Unable to handle pointer type " + pointer, "pointer");
}
}
else
{
if (pointer == Pointer.Type.Future)
{
rangeStart = now.Date.AddDays(1).AddSeconds(range.StartSecond);
}
else if (pointer == Pointer.Type.Past)
{
rangeStart = now.Date.AddSeconds(range.StartSecond);
}
else
{
throw new ArgumentException("Unable to handle pointer type " + pointer, "pointer");
}
}
_currentSpan = new Span(rangeStart, rangeStart.AddSeconds(range.Width));
}
else
{
if (pointer == Pointer.Type.Future)
{
_currentSpan = _currentSpan.Add(FULL_DAY_SECONDS);
}
else if (pointer == Pointer.Type.Past)
{
_currentSpan = _currentSpan.Add(-FULL_DAY_SECONDS);
}
else
{
throw new ArgumentException("Unable to handle pointer type " + pointer, "pointer");
}
}
return(_currentSpan);
}
protected abstract Span CurrentSpan(Pointer.Type pointer);
protected override Span NextSpan(Pointer.Type pointer)
{
throw new IllegalStateException("Not implemented.");
}
public abstract Span GetOffset(Span span, int amount, Pointer.Type pointer);
public override Span GetOffset(Span span, int amount, Pointer.Type pointer)
{
var direction = pointer == Pointer.Type.Future ? 1 : -1;
return(span.Add(direction * amount * MINUTE_SECONDS));
}
