|
public AddAll ( IEnumerable |
||
| timePeriods | IEnumerable |
|
| return | void | |
public void GetGapTest()
{
DateTime now = ClockProxy.Clock.Now;
SchoolDay schoolDay = new SchoolDay( now );
TimePeriodCollection excludePeriods = new TimePeriodCollection();
TimeGapCalculator<TimeRange> gapCalculator = new TimeGapCalculator<TimeRange>();
excludePeriods.AddAll( schoolDay );
Assert.AreEqual( gapCalculator.GetGaps( excludePeriods ).Count, 0 );
Assert.AreEqual( gapCalculator.GetGaps( excludePeriods, schoolDay ).Count, 0 );
excludePeriods.Clear();
excludePeriods.Add( schoolDay.Lesson1 );
excludePeriods.Add( schoolDay.Lesson2 );
excludePeriods.Add( schoolDay.Lesson3 );
excludePeriods.Add( schoolDay.Lesson4 );
ITimePeriodCollection gaps2 = gapCalculator.GetGaps( excludePeriods );
Assert.AreEqual( gaps2.Count, 3 );
Assert.IsTrue( gaps2[ 0 ].IsSamePeriod( schoolDay.Break1 ) );
Assert.IsTrue( gaps2[ 1 ].IsSamePeriod( schoolDay.Break2 ) );
Assert.IsTrue( gaps2[ 2 ].IsSamePeriod( schoolDay.Break3 ) );
TimeRange testRange3 = new TimeRange( schoolDay.Lesson1.Start, schoolDay.Lesson4.End );
ITimePeriodCollection gaps3 = gapCalculator.GetGaps( excludePeriods, testRange3 );
Assert.AreEqual( gaps3.Count, 3 );
Assert.IsTrue( gaps3[ 0 ].IsSamePeriod( schoolDay.Break1 ) );
Assert.IsTrue( gaps3[ 1 ].IsSamePeriod( schoolDay.Break2 ) );
Assert.IsTrue( gaps3[ 2 ].IsSamePeriod( schoolDay.Break3 ) );
TimeRange testRange4 = new TimeRange( schoolDay.Start.AddHours( -1 ), schoolDay.End.AddHours( 1 ) );
ITimePeriodCollection gaps4 = gapCalculator.GetGaps( excludePeriods, testRange4 );
Assert.AreEqual( gaps4.Count, 5 );
Assert.IsTrue( gaps4[ 0 ].IsSamePeriod( new TimeRange( testRange4.Start, schoolDay.Start ) ) );
Assert.IsTrue( gaps4[ 1 ].IsSamePeriod( schoolDay.Break1 ) );
Assert.IsTrue( gaps4[ 2 ].IsSamePeriod( schoolDay.Break2 ) );
Assert.IsTrue( gaps4[ 3 ].IsSamePeriod( schoolDay.Break3 ) );
Assert.IsTrue( gaps4[ 4 ].IsSamePeriod( new TimeRange( testRange4.End, testRange3.End ) ) );
excludePeriods.Clear();
excludePeriods.Add( schoolDay.Lesson1 );
ITimePeriodCollection gaps8 = gapCalculator.GetGaps( excludePeriods, schoolDay.Lesson1 );
Assert.AreEqual( gaps8.Count, 0 );
TimeRange testRange9 = new TimeRange( schoolDay.Lesson1.Start.Subtract( new TimeSpan( 1 ) ), schoolDay.Lesson1.End.Add( new TimeSpan( 1 ) ) );
ITimePeriodCollection gaps9 = gapCalculator.GetGaps( excludePeriods, testRange9 );
Assert.AreEqual( gaps9.Count, 2 );
Assert.AreEqual( gaps9[ 0 ].Duration, new TimeSpan( 1 ) );
Assert.AreEqual( gaps9[ 1 ].Duration, new TimeSpan( 1 ) );
}
public void AddAllTest()
{
DateTime now = ClockProxy.Clock.Now;
SchoolDay schoolDay = new SchoolDay( now );
TimePeriodCollection timePeriods = new TimePeriodCollection();
Assert.AreEqual( timePeriods.Count, 0 );
timePeriods.AddAll( schoolDay );
Assert.AreEqual( timePeriods.Count, schoolDay.Count );
timePeriods.Clear();
Assert.AreEqual( timePeriods.Count, 0 );
}
// ----------------------------------------------------------------------
protected DateTime? CalculateEnd( DateTime start, TimeSpan offset,
SeekDirection seekDirection, SeekBoundaryMode seekBoundaryMode, out TimeSpan? remaining)
{
if ( offset < TimeSpan.Zero )
{
throw new InvalidOperationException( "time span must be positive" );
}
remaining = offset;
// search periods
TimePeriodCollection searchPeriods = new TimePeriodCollection( includePeriods );
// no search periods specified: search anytime
if ( searchPeriods.Count == 0 )
{
searchPeriods.Add( TimeRange.Anytime );
}
// available periods
ITimePeriodCollection availablePeriods = new TimePeriodCollection();
// no exclude periods specified: use all search periods
if ( excludePeriods.Count == 0 )
{
availablePeriods.AddAll( searchPeriods );
}
else // remove exclude periods
{
TimeGapCalculator<TimeRange> gapCalculator = new TimeGapCalculator<TimeRange>();
foreach ( ITimePeriod searchPeriod in searchPeriods )
{
// no overlaps: use the entire search range
if ( !excludePeriods.HasOverlapPeriods( searchPeriod ) )
{
availablePeriods.Add( searchPeriod );
}
else // add gaps of search period using the exclude periods
{
availablePeriods.AddAll( gapCalculator.GetGaps( excludePeriods, searchPeriod ) );
}
}
}
// no periods available
if ( availablePeriods.Count == 0 )
{
return null;
}
// combine the available periods, ensure no overlapping
// used for FindNextPeriod/FindPreviousPeriod
if ( availablePeriods.Count > 1 )
{
TimePeriodCombiner<TimeRange> periodCombiner = new TimePeriodCombiner<TimeRange>();
availablePeriods = periodCombiner.CombinePeriods( availablePeriods );
}
// find the starting search period
ITimePeriod startPeriod = null;
DateTime seekMoment = start;
switch ( seekDirection )
{
case SeekDirection.Forward:
startPeriod = FindNextPeriod( start, availablePeriods, out seekMoment );
break;
case SeekDirection.Backward:
startPeriod = FindPreviousPeriod( start, availablePeriods, out seekMoment );
break;
}
// no starting period available
if ( startPeriod == null )
{
return null;
}
// no offset: use the search staring position
// maybe moved to the next available search period
if ( offset == TimeSpan.Zero )
{
return seekMoment;
}
// setup destination search
switch ( seekDirection )
{
case SeekDirection.Forward:
for ( int i = availablePeriods.IndexOf( startPeriod ); i < availablePeriods.Count; i++ )
{
ITimePeriod gap = availablePeriods[ i ];
TimeSpan gapRemining = gap.End - seekMoment;
bool isTargetPeriod = false;
switch ( seekBoundaryMode )
{
case SeekBoundaryMode.Fill:
isTargetPeriod = gapRemining >= remaining;
break;
case SeekBoundaryMode.Next:
isTargetPeriod = gapRemining > remaining;
break;
}
if ( isTargetPeriod )
{
DateTime end = seekMoment + remaining.Value;
remaining = null;
return end;
}
remaining = remaining - gapRemining;
if ( i == availablePeriods.Count - 1 )
{
return null;
}
seekMoment = availablePeriods[ i + 1 ].Start; // next period
}
break;
case SeekDirection.Backward:
for ( int i = availablePeriods.IndexOf( startPeriod ); i >= 0; i-- )
{
ITimePeriod gap = availablePeriods[ i ];
TimeSpan gapRemining = seekMoment - gap.Start;
bool isTargetPeriod = false;
switch ( seekBoundaryMode )
{
case SeekBoundaryMode.Fill:
isTargetPeriod = gapRemining >= remaining;
break;
case SeekBoundaryMode.Next:
isTargetPeriod = gapRemining > remaining;
break;
}
if ( isTargetPeriod )
{
DateTime end = seekMoment - remaining.Value;
remaining = null;
return end;
}
remaining = remaining - gapRemining;
if ( i == 0 )
{
return null;
}
seekMoment = availablePeriods[ i - 1 ].End; // previous period
}
break;
}
return null;
}
public void ClearTest()
{
TimePeriodCollection timePeriods = new TimePeriodCollection();
Assert.AreEqual( timePeriods.Count, 0 );
timePeriods.Clear();
Assert.AreEqual( timePeriods.Count, 0 );
timePeriods.AddAll( new SchoolDay() );
Assert.AreEqual( timePeriods.Count, 7 );
timePeriods.Clear();
Assert.AreEqual( timePeriods.Count, 0 );
}
public void SortByEndTest()
{
DateTime now = ClockProxy.Clock.Now;
SchoolDay schoolDay = new SchoolDay( now );
TimePeriodCollection timePeriods = new TimePeriodCollection();
timePeriods.AddAll( schoolDay );
timePeriods.SortByEnd();
Assert.AreEqual( timePeriods[ 0 ], schoolDay.Lesson4 );
Assert.AreEqual( timePeriods[ 1 ], schoolDay.Break3 );
Assert.AreEqual( timePeriods[ 2 ], schoolDay.Lesson3 );
Assert.AreEqual( timePeriods[ 3 ], schoolDay.Break2 );
Assert.AreEqual( timePeriods[ 4 ], schoolDay.Lesson2 );
Assert.AreEqual( timePeriods[ 5 ], schoolDay.Break1 );
Assert.AreEqual( timePeriods[ 6 ], schoolDay.Lesson1 );
}
public void ItemIndexTest()
{
TimePeriodCollection timePeriods = new TimePeriodCollection();
SchoolDay schoolDay = new SchoolDay();
timePeriods.AddAll( schoolDay );
Assert.AreEqual( timePeriods[ 0 ], schoolDay.Lesson1 );
Assert.AreEqual( timePeriods[ 1 ], schoolDay.Break1 );
Assert.AreEqual( timePeriods[ 2 ], schoolDay.Lesson2 );
Assert.AreEqual( timePeriods[ 3 ], schoolDay.Break2 );
Assert.AreEqual( timePeriods[ 4 ], schoolDay.Lesson3 );
Assert.AreEqual( timePeriods[ 5 ], schoolDay.Break3 );
Assert.AreEqual( timePeriods[ 6 ], schoolDay.Lesson4 );
}
public void IndexOfTest()
{
DateTime now = ClockProxy.Clock.Now;
SchoolDay schoolDay = new SchoolDay( now );
TimePeriodCollection timePeriods = new TimePeriodCollection();
Assert.AreEqual( timePeriods.IndexOf( new TimeRange() ), -1 );
Assert.AreEqual( timePeriods.IndexOf( new TimeBlock() ), -1 );
timePeriods.AddAll( schoolDay );
Assert.AreEqual( timePeriods.IndexOf( schoolDay.Lesson1 ), 0 );
Assert.AreEqual( timePeriods.IndexOf( schoolDay.Break1 ), 1 );
Assert.AreEqual( timePeriods.IndexOf( schoolDay.Lesson2 ), 2 );
Assert.AreEqual( timePeriods.IndexOf( schoolDay.Break2 ), 3 );
Assert.AreEqual( timePeriods.IndexOf( schoolDay.Lesson3 ), 4 );
Assert.AreEqual( timePeriods.IndexOf( schoolDay.Break3 ), 5 );
Assert.AreEqual( timePeriods.IndexOf( schoolDay.Lesson4 ), 6 );
timePeriods.Remove( schoolDay.Lesson1 );
Assert.AreEqual( timePeriods.IndexOf( schoolDay.Lesson1 ), -1 );
}
public void CountTest()
{
TimePeriodCollection timePeriods = new TimePeriodCollection();
Assert.AreEqual( timePeriods.Count, 0 );
timePeriods.AddAll( timeRangeTestData.AllPeriods );
Assert.AreEqual( timePeriods.Count, timeRangeTestData.AllPeriods.Count );
timePeriods.Clear();
Assert.AreEqual( timePeriods.Count, 0 );
}
} // Add
// ----------------------------------------------------------------------
protected DateTime?CalculateEnd(DateTime start, TimeSpan offset,
SeekDirection seekDirection, SeekBoundaryMode seekBoundaryMode, out TimeSpan?remaining)
{
if (offset < TimeSpan.Zero)
{
throw new InvalidOperationException("time span must be positive");
}
remaining = offset;
// search periods
TimePeriodCollection searchPeriods = new TimePeriodCollection(includePeriods);
// no search periods specified: search anytime
if (searchPeriods.Count == 0)
{
searchPeriods.Add(TimeRange.Anytime);
}
// available periods
ITimePeriodCollection availablePeriods = new TimePeriodCollection();
// no exclude periods specified: use all search periods
if (excludePeriods.Count == 0)
{
availablePeriods.AddAll(searchPeriods);
}
else // remove exclude periods
{
TimeGapCalculator <TimeRange> gapCalculator = new TimeGapCalculator <TimeRange>();
foreach (ITimePeriod searchPeriod in searchPeriods)
{
// no overlaps: use the entire search range
if (!excludePeriods.HasOverlapPeriods(searchPeriod))
{
availablePeriods.Add(searchPeriod);
}
else // add gaps of search period using the exclude periods
{
availablePeriods.AddAll(gapCalculator.GetGaps(excludePeriods, searchPeriod));
}
}
}
// no periods available
if (availablePeriods.Count == 0)
{
return(null);
}
// combine the available periods, ensure no overlapping
// used for FindNextPeriod/FindPreviousPeriod
if (availablePeriods.Count > 1)
{
TimePeriodCombiner <TimeRange> periodCombiner = new TimePeriodCombiner <TimeRange>();
availablePeriods = periodCombiner.CombinePeriods(availablePeriods);
}
// find the starting search period
ITimePeriod startPeriod = null;
DateTime seekMoment = start;
switch (seekDirection)
{
case SeekDirection.Forward:
startPeriod = FindNextPeriod(start, availablePeriods, out seekMoment);
break;
case SeekDirection.Backward:
startPeriod = FindPreviousPeriod(start, availablePeriods, out seekMoment);
break;
}
// no starting period available
if (startPeriod == null)
{
return(null);
}
// no offset: use the search staring position
// maybe moved to the next available search period
if (offset == TimeSpan.Zero)
{
return(seekMoment);
}
// setup destination search
switch (seekDirection)
{
case SeekDirection.Forward:
for (int i = availablePeriods.IndexOf(startPeriod); i < availablePeriods.Count; i++)
{
ITimePeriod gap = availablePeriods[i];
TimeSpan gapRemining = gap.End - seekMoment;
bool isTargetPeriod = false;
switch (seekBoundaryMode)
{
case SeekBoundaryMode.Fill:
isTargetPeriod = gapRemining >= remaining;
break;
case SeekBoundaryMode.Next:
isTargetPeriod = gapRemining > remaining;
break;
}
if (isTargetPeriod)
{
DateTime end = seekMoment + remaining.Value;
remaining = null;
return(end);
}
remaining = remaining - gapRemining;
if (i == availablePeriods.Count - 1)
{
return(null);
}
seekMoment = availablePeriods[i + 1].Start; // next period
}
break;
case SeekDirection.Backward:
for (int i = availablePeriods.IndexOf(startPeriod); i >= 0; i--)
{
ITimePeriod gap = availablePeriods[i];
TimeSpan gapRemining = seekMoment - gap.Start;
bool isTargetPeriod = false;
switch (seekBoundaryMode)
{
case SeekBoundaryMode.Fill:
isTargetPeriod = gapRemining >= remaining;
break;
case SeekBoundaryMode.Next:
isTargetPeriod = gapRemining > remaining;
break;
}
if (isTargetPeriod)
{
DateTime end = seekMoment - remaining.Value;
remaining = null;
return(end);
}
remaining = remaining - gapRemining;
if (i == 0)
{
return(null);
}
seekMoment = availablePeriods[i - 1].End; // previous period
}
break;
}
return(null);
} // CalculateEnd
