compareTimeSpans function
Compares time spans representing for example two GpsStay entities.
Comparison must be defined such that comparing A to B gives the opposite result than comparing B to A for the before/after results, but it gives the same result for the same/overlapping results. Without this inverse commutative behaviour, sorting and searching may give very strange behaviour.
The following preconditions are given:
- for any item X: X.start <= X.end Hence it's not needt to check for inverted time segments.
- the stay is defined as being exclusive of X.end itself. That means that for two points M and N with M.end = N.start, M can be regarded as being before N (there is no overlap since at the moment of M.end, i.e. N.start, the position value of N will be valid). However, if M.start == M.end == N.start, there is overlap as both the position of M and that of N are valid at time M.start.
the comparison is defined as follows:
-----------+------------------------+----------------------------------
Rule | Condition | Result
-----------+------------------------+----------------------------------
1) if | (A.end <= B.start && | A before B
| A.start != B.start) |
| |
| A +---+ |
| B +---+ |
| |
| A +---+ |
| B +---+ |
-----------+------------------------+----------------------------------
2) else if | (B.end <= A.start && | A after B (inverse of rule 1)
| A.start != B.start) |
| |
| B +---+ |
| A +---+ |
| |
| B +---+ |
| A +---+ |
-----------+------------------------+----------------------------------
3) else if | (A.start == B.start && | A same as B
| A.end == B.end) |
| |
| A +---+ |
| B +---+ |
-----------+------------------------+----------------------------------
4) else | | overlapping (undefined sorting)
| B +---+ |
| A +---+ |
| |
| A +---+ |
| B +---+ |
| |
| |
| A + |
| B +---+ |
| |
| B + |
| A +---+ |
| |
| A +-------+ |
| B +--+ |
| |
| B +-------+ |
| A +--+ |
-----------+------------------------+----------------------------------
Implementation
TimeComparisonResult compareTimeSpans(
{required int startA,
required int endA,
required int startB,
required int endB}) {
final sameStartAB = startA == startB;
// Rule 1.
final cmpEndAStartB = compareIntRepresentationTime(endA, startB);
if ((cmpEndAStartB == TimeComparisonResult.same ||
cmpEndAStartB == TimeComparisonResult.before) &&
!sameStartAB) {
return TimeComparisonResult.before;
}
// Rule 2.
final cmpEndBStartA = compareIntRepresentationTime(endB, startA);
if ((cmpEndBStartA == TimeComparisonResult.same ||
cmpEndBStartA == TimeComparisonResult.before) &&
!sameStartAB) {
return TimeComparisonResult.after;
}
// Rule 3.
final sameEndAB = endA == endB;
if (sameStartAB && sameEndAB) {
return TimeComparisonResult.same;
}
// Rule 4.
return TimeComparisonResult.overlapping;
}