# diffIntTime function

int diffIntTime({
1. required int startTimeA,
2. required int? endTimeA,
3. required int timeB,
})

Calculates the difference between `timeB` and a time or time span defined by a `startTimeA` and optionally, if it's a span rather than an instance, an `endTimeA`. The result will be negative and equal to `endTimeA`-`timeB` if A is before B, positive and equal to `startTimeA`-`timeB` is A is after B.

Situation | Result -------------------+--------- A +--------+ | > 0 B + | -------------------+--------- A +--------+ | = 0 B + | B + | B + | -------------------+--------- A +--------+ | > 0 B + | -------------------+---------

The result is zero if `timeB` is within the time span defined by the two "A" parameters, even if it's equal to `endTimeA`. This even though the situation of `timeB`==`endTimeA` would not qualify as TimeComparisonResult.overlapping!. This inconsistency is rather hard to avoid, as the infinitesimally small fraction of an instance prior to `endTimeA` does count as/ overlapping - the difference is infinitely small and can therefore not really be expressed in any way.

## Implementation

``````int diffIntTime(
{required int startTimeA, required int? endTimeA, required int timeB}) {
final startDiff = (startTimeA - timeB);
if (endTimeA == null) {
return startDiff;
}

final endDiff = (endTimeA - timeB);

// B is within span A if startDiff is negative and endDiff is positive.
if (0 > startDiff && endDiff > 0) {
return 0;
}

// A is before B -> closest difference will be to the end point.
if (endDiff <= 0) {
return endDiff;
}

// A must be after B -> closest difference will be to the start point.
return startDiff;
}``````