public TkInterval ExtractInterval(TimeSpan timeSpan)
{
var newDatePosition = DateTime.MinValue.AddTicks(end.Ticks - timeSpan.Ticks);
var extractedInterval = new TkInterval(newDatePosition, end);
return(extractedInterval);
}
// The complement of B, ∁B. Is everything that's outside of B
public static TkTimeSet Complement(TkTimeSet set)
{
IEnumerable <TkInterval> complement(TkTimeSet s)
{
var t0 = DateTime.MinValue;
foreach (var interval in s.GetOrderedIntervals())
{
var t1 = interval.start;
if ((t0 - t1).Ticks != 0)
{
var complementInterval = new TkInterval(t0, t1);
yield return(complementInterval);
}
t0 = interval.end;
}
if ((DateTime.MaxValue - t0).Ticks != 0)
{
var lastInterval = new TkInterval(t0, DateTime.MaxValue);
yield return(lastInterval);
}
}
var complementSet = complement(set).ToArray();
return(new TkTimeSet(complementSet));
}
public bool Overlaps(TkInterval other)
{
// Does this interval contain the start or end of the other interval?
return(Contains(other.start) || Contains(other.end) ||
// Does the other interval contain the start or end of this interval?
other.Contains(start) || other.Contains(end));
}
public TkInterval ElementAt(int index)
{
if (index >= Count())
{
return(TkInterval.Null());
}
return(_tkIntervals[index]);
}
public TkTimeSet Copy()
{
var copy = new TkInterval[_tkIntervals.Length];
for (var i = 0; i < _tkIntervals.Length; i++)
{
var interval = _tkIntervals[i];
copy[i] = new TkInterval(interval.start, interval.end);
}
return(new TkTimeSet(copy));
}
// Does not join overlapping tkIntervals
// if an tkInterval in A already contains the space made up by an tkInterval in B, it'll be ignored
public static TkTimeSet Union(TkTimeSet a, TkTimeSet b)
{
if (b.IsNull || b.IsEmpty())
{
return(a);
}
if (a.IsNull || a.IsEmpty())
{
return(b);
}
// The size of the union between a and b will at end be a.count + b.count
var union = new TkInterval[a.Count() + b.Count()];
var unionIndex = a.Count();
// Set the union equal to A
for (var i = 0; i < a._tkIntervals.Length; i++)
{
union[i] = a._tkIntervals[i];
}
// Only insert tkIntervals from B into the union
// if no tkInterval in A claims that space
for (var i = 0; i < b._tkIntervals.Length; i++)
{
var bInterval = b._tkIntervals[i];
var exists = false;
for (var j = 0; j < a._tkIntervals.Length; j++)
{
var aInterval = a._tkIntervals[j];
if (aInterval.Contains(bInterval))
{
exists = true;
break;
}
}
if (!exists)
{
union[unionIndex] = bInterval;
unionIndex++;
}
}
return(new TkTimeSet(union));
}
public int indexOf(TkInterval tkInterval)
{
if (string.IsNullOrEmpty(tkInterval.id))
{
return(-1);
}
for (var i = 0; i < Count(); i++)
{
var _interval = ElementAt(i);
if (_interval.id == tkInterval.id)
{
return(i);
}
}
return(-1);
}
public TkInterval ExtractInterval(TimeSpan timeSpan)
{
var orderedIntervals = GetOrderedIntervals();
var intervalToExtractFrom = orderedIntervals.FirstOrDefault(o => o.Length() > timeSpan);
if (intervalToExtractFrom.isNull)
{
return(TkInterval.Null());
}
var index = indexOf(intervalToExtractFrom);
var extractedInterval = new TkInterval();
if (index != -1)
{
extractedInterval = intervalToExtractFrom.ExtractInterval(timeSpan);
intervalToExtractFrom.SubtractTimeSpan(timeSpan);
var updatedInterval = new TkInterval()
{
id = intervalToExtractFrom.id,
start = intervalToExtractFrom.start,
end = intervalToExtractFrom.end
};
// If we have less than 5 minutes left, remove it
if (updatedInterval.Length() < TimeSpan.FromMinutes(5))
{
Remove(updatedInterval);
}
else
{
_tkIntervals[index] = updatedInterval;
_tkIntervals = GetOrderedIntervals();
}
}
return(extractedInterval);
}
public void Remove(TkInterval tkInterval)
{
_tkIntervals = _tkIntervals.Where(o => o.id != tkInterval.id).ToArray();
}
public static TkTimeSet Intersect(TkTimeSet first, TkTimeSet second)
{
IEnumerable <TkInterval> intersect(TkTimeSet a, TkTimeSet b)
{
int aIndex = 0, bIndex = 0;
while (aIndex < a.Count() &&
bIndex < b.Count())
{
var aInterval = a.ElementAt(aIndex);
var bInterval = b.ElementAt(bIndex);
// If A doesn't contain B
if (!aInterval.Overlaps(bInterval))
{
if (aInterval < bInterval)
{
aIndex++;
}
else
{
bIndex++;
}
}
// If A contains B, return B
else if (aInterval.Encloses(bInterval))
{
yield return(bInterval);
bIndex++;
}
// If B contains A, return A
else if (bInterval.Encloses(aInterval))
{
yield return(aInterval);
aIndex++;
}
// If A and B are separate tkIntervals
else
{
var highestMin = Max(aInterval.start, bInterval.start);
var lowestMax = Min(aInterval.end, bInterval.end);
var interval = new TkInterval(highestMin, lowestMax);
if (interval.Length() > TimeSpan.Zero)
{
yield return(interval);
}
if (aInterval < bInterval)
{
aIndex++;
}
else
{
bIndex++;
}
}
}
}
var intersection = intersect(first, second).ToArray();
return(new TkTimeSet(intersection));
}
public bool Encloses(TkInterval other)
{
return(Contains(other.start) && Contains(other.end));
}
