GothenburgBitFactory/timewarrior
1
0
Fork 0
mirror of https://github.com/GothenburgBitFactory/timewarrior.git synced 2025-06-26 10:54:28 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Interval: Now has pubic ::range, which has public ::start, ::end

Browse source
This commit is contained in:
Paul Beckingham 2016-04-23 10:35:06 -04:00
parent 7fe116f75a
commit 63a6255412
17 changed files with 413 additions and 506 deletions
Download patch file Download diff file Expand all files Collapse all files

26
src/Database.cpp
View file

@ -112,18 +112,18 @@ void Database::addInterval (const Interval& interval)
// Unless the tags that overlap are allowed to overlap. // Unless the tags that overlap are allowed to overlap.
validateAddition (interval); validateAddition (interval);
auto intervalRange = interval.range (); auto intervalRange = interval.range;
for (auto& segment : segmentRange (intervalRange)) for (auto& segment : segmentRange (intervalRange))
{ {
// Get the index into _files for the appropriate Datafile, which may be // Get the index into _files for the appropriate Datafile, which may be
// created on demand. // created on demand.
auto df = getDatafile (segment.start ().year (), segment.start ().month ()); auto df = getDatafile (segment.start.year (), segment.start.month ());
// Intersect the original interval range, and the segment. // Intersect the original interval range, and the segment.
Interval segmentedInterval (interval); Interval segmentedInterval (interval);
segmentedInterval.range (intervalRange.intersect (segment)); segmentedInterval.range = intervalRange.intersect (segment);
if (! interval.isEnded ()) if (! interval.range.ended ())
segmentedInterval.end ({0}); segmentedInterval.range.end = Datetime (0);
_files[df].addInterval (segmentedInterval); _files[df].addInterval (segmentedInterval);
} }
@ -132,18 +132,18 @@ void Database::addInterval (const Interval& interval)
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
void Database::deleteInterval (const Interval& interval) void Database::deleteInterval (const Interval& interval)
{ {
auto intervalRange = interval.range (); auto intervalRange = interval.range;
for (auto& segment : segmentRange (intervalRange)) for (auto& segment : segmentRange (intervalRange))
{ {
// Get the index into _files for the appropriate Datafile, which may be // Get the index into _files for the appropriate Datafile, which may be
// created on demand. // created on demand.
auto df = getDatafile (segment.start ().year (), segment.start ().month ()); auto df = getDatafile (segment.start.year (), segment.start.month ());
// Intersect the original interval range, and the segment. // Intersect the original interval range, and the segment.
Interval segmentedInterval (interval); Interval segmentedInterval (interval);
segmentedInterval.range (intervalRange.intersect (segment)); segmentedInterval.range = intervalRange.intersect (segment);
if (! interval.isEnded ()) if (! interval.range.ended ())
segmentedInterval.end ({0}); segmentedInterval.range.end = Datetime (0);
_files[df].deleteInterval (segmentedInterval); _files[df].deleteInterval (segmentedInterval);
} }
@ -218,10 +218,10 @@ std::vector <Range> Database::segmentRange (const Range& range)
{ {
std::vector <Range> segments; std::vector <Range> segments;
auto start_y = range.start ().year (); auto start_y = range.start.year ();
auto start_m = range.start ().month (); auto start_m = range.start.month ();
auto end = range.end (); auto end = range.end;
if (end.toEpoch () == 0) if (end.toEpoch () == 0)
end = Datetime (); end = Datetime ();

8
src/Datafile.cpp
View file

@ -103,7 +103,7 @@ void Datafile::addInterval (const Interval& interval)
{ {
// Return false if the interval does not belong in this file. // Return false if the interval does not belong in this file.
// Note: end date might be zero. // Note: end date might be zero.
if (_range.overlap (interval.range ())) if (_range.overlap (interval.range))
{ {
if (! _lines_loaded) if (! _lines_loaded)
load_lines (); load_lines ();
@ -125,7 +125,7 @@ void Datafile::deleteInterval (const Interval& interval)
{ {
// Return false if the interval does not belong in this file. // Return false if the interval does not belong in this file.
// Note: end date might be zero. // Note: end date might be zero.
if (_range.overlap (interval.range ())) if (_range.overlap (interval.range))
{ {
if (! _lines_loaded) if (! _lines_loaded)
load_lines (); load_lines ();
@ -174,8 +174,8 @@ std::string Datafile::dump () const
<< " lines: " << _lines.size () << "\n" << " lines: " << _lines.size () << "\n"
<< " loaded " << (_lines_loaded ? "true" : "false") << "\n" << " loaded " << (_lines_loaded ? "true" : "false") << "\n"
<< " exclusions: " << _exclusions.size () << "\n" << " exclusions: " << _exclusions.size () << "\n"
<< " range: " << _range.start ().toISO () << " - " << " range: " << _range.start.toISO () << " - "
<< _range.end ().toISO () << "\n"; << _range.end.toISO () << "\n";
return out.str (); return out.str ();
} }

4
src/Exclusion.cpp
View file

@ -112,8 +112,8 @@ std::vector <Range> Exclusion::ranges (const Range& range) const
else if ((dayOfWeek = Datetime::dayOfWeek (_tokens[1])) != -1) else if ((dayOfWeek = Datetime::dayOfWeek (_tokens[1])) != -1)
{ {
Datetime start = range.start (); Datetime start = range.start;
while (start < range.end ()) while (start < range.end)
{ {
if (start.dayOfWeek () == dayOfWeek) if (start.dayOfWeek () == dayOfWeek)
{ {

78
src/Interval.cpp
View file

@ -53,7 +53,7 @@ void Interval::initialize (const std::string& line)
if (tokens.size () > 1 && if (tokens.size () > 1 &&
tokens[1].length () == 16) tokens[1].length () == 16)
{ {
_range.start (Datetime (tokens[1])); range.start = Datetime (tokens[1]);
offset = 1; offset = 1;
// Optional '-' <iso> // Optional '-' <iso>
@ -61,7 +61,7 @@ void Interval::initialize (const std::string& line)
tokens[2] == "-" && tokens[2] == "-" &&
tokens[3].length () == 16) tokens[3].length () == 16)
{ {
_range.end (Datetime (tokens[3])); range.end = Datetime (tokens[3]);
offset = 3; offset = 3;
} }
} }
@ -84,59 +84,11 @@ void Interval::initialize (const std::string& line)
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
bool Interval::empty () const bool Interval::empty () const
{ {
return _range.start ().toEpoch () == 0 && return range.start.toEpoch () == 0 &&
_range.end ().toEpoch () == 0 && range.end.toEpoch () == 0 &&
_tags.size () == 0; _tags.size () == 0;
} }
////////////////////////////////////////////////////////////////////////////////
Range Interval::range () const
{
return _range;
}
////////////////////////////////////////////////////////////////////////////////
void Interval::range (const Range& range)
{
_range = range;
}
////////////////////////////////////////////////////////////////////////////////
Datetime Interval::start () const
{
return _range.start ();
}
////////////////////////////////////////////////////////////////////////////////
void Interval::start (const Datetime& value)
{
_range.start (value);
}
////////////////////////////////////////////////////////////////////////////////
Datetime Interval::end () const
{
return _range.end ();
}
////////////////////////////////////////////////////////////////////////////////
void Interval::end (const Datetime& value)
{
_range.end (value);
}
////////////////////////////////////////////////////////////////////////////////
bool Interval::isStarted () const
{
return _range.isStarted ();
}
////////////////////////////////////////////////////////////////////////////////
bool Interval::isEnded () const
{
return _range.isEnded ();
}
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
bool Interval::hasTag (const std::string& tag) const bool Interval::hasTag (const std::string& tag) const
{ {
@ -168,11 +120,11 @@ std::string Interval::serialize () const
std::stringstream out; std::stringstream out;
out << "inc"; out << "inc";
if (_range.start ().toEpoch ()) if (range.start.toEpoch ())
out << " " << _range.start ().toISO (); out << " " << range.start.toISO ();
if (_range.end ().toEpoch ()) if (range.end.toEpoch ())
out << " - " << _range.end ().toISO (); out << " - " << range.end.toISO ();
if (_tags.size ()) if (_tags.size ())
{ {
@ -190,14 +142,14 @@ std::string Interval::json () const
std::stringstream out; std::stringstream out;
out << '{'; out << '{';
if (_range.isStarted ()) if (range.started ())
out << "\"start\":\"" << _range.start ().toISO () << "\""; out << "\"start\":\"" << range.start.toISO () << "\"";
if (_range.isEnded ()) if (range.ended ())
{ {
if (_range.isStarted ()) if (range.started ())
out << ','; out << ',';
out << "\"end\":\"" << _range.end ().toISO () << "\""; out << "\"end\":\"" << range.end.toISO () << "\"";
} }
if (_tags.size ()) if (_tags.size ())
@ -211,8 +163,8 @@ std::string Interval::json () const
tags += "\"" + tag + "\""; tags += "\"" + tag + "\"";
} }
if (_range.start ().toEpoch () || if (range.start.toEpoch () ||
_range.end ().toEpoch ()) range.end.toEpoch ())
out << ','; out << ',';
out << "\"tags\":[" out << "\"tags\":["

16
src/Interval.h
View file

@ -38,18 +38,6 @@ public:
void initialize (const std::string&); void initialize (const std::string&);
bool empty () const; bool empty () const;
Range range () const;
void range (const Range&);
Datetime start () const;
void start (const Datetime&);
Datetime end () const;
void end (const Datetime&);
bool isStarted () const;
bool isEnded () const;
bool hasTag (const std::string&) const; bool hasTag (const std::string&) const;
std::set <std::string> tags () const; std::set <std::string> tags () const;
void tag (const std::string&); void tag (const std::string&);
@ -58,8 +46,10 @@ public:
std::string serialize () const; std::string serialize () const;
std::string json () const; std::string json () const;
public:
Range range {};
private: private:
Range _range {};
std::set <std::string> _tags {}; std::set <std::string> _tags {};
}; };

91
src/Range.cpp
View file

@ -34,53 +34,29 @@
// //
// [start, end) // [start, end)
// //
Range::Range (const Datetime& start, const Datetime& end) Range::Range (const Datetime& start_value, const Datetime& end_value)
{ {
_start = start; start = start_value;
_end = end; end = end_value;
} }
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
bool Range::operator== (const Range& other) const bool Range::operator== (const Range& other) const
{ {
return _start == other._start && return start == other.start &&
_end == other._end; end == other.end;
} }
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
Datetime Range::start () const bool Range::started () const
{ {
return _start; return start.toEpoch () > 0;
} }
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
void Range::start (const Datetime& value) bool Range::ended () const
{ {
_start = value; return end.toEpoch () > 0;
}
////////////////////////////////////////////////////////////////////////////////
Datetime Range::end () const
{
return _end;
}
////////////////////////////////////////////////////////////////////////////////
void Range::end (const Datetime& value)
{
_end = value;
}
////////////////////////////////////////////////////////////////////////////////
bool Range::isStarted () const
{
return _start.toEpoch () > 0;
}
////////////////////////////////////////////////////////////////////////////////
bool Range::isEnded () const
{
return _end.toEpoch () > 0;
} }
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
@ -110,18 +86,15 @@ bool Range::isEnded () const
// //
bool Range::overlap (const Range& other) const bool Range::overlap (const Range& other) const
{ {
if (! isStarted () || if (! started () || ! other.started ())
! other.isStarted ())
return false; return false;
// Other range ends before this range starts. // Other range ends before this range starts.
if (other.isEnded () && if (other.ended () && other.end < start)
other.end () < start ())
return false; return false;
// Other range starts after this range ends. // Other range starts after this range ends.
if (isEnded () && if (ended () && other.start >= end)
other.start () >= end ())
return false; return false;
return true; return true;
@ -159,20 +132,20 @@ Range Range::intersect (const Range& other) const
if (overlap (other)) if (overlap (other))
{ {
// Intersection is choosing the later of the two starts, and the earlier of // Intersection is choosing the later of the two starts, and the earlier of
// the two ends, of two overlapping ranges. // the two ends, provided the two ranges overlap.
result.start (start () > other.start () ? start () : other.start ()); result.start = start > other.start ? start : other.start;
if (isEnded ()) if (ended ())
{ {
if (other.isEnded ()) if (other.ended ())
result.end (end () < other.end () ? end () : other.end ()); result.end = end < other.end ? end : other.end;
else else
result.end (end ()); result.end = end;
} }
else else
{ {
if (other.isEnded ()) if (other.ended ())
result.end (other.end ()); result.end = other.end;
} }
} }
@ -210,28 +183,28 @@ std::vector <Range> Range::subtract (const Range& other) const
if (overlap (other)) if (overlap (other))
{ {
if (start () < other.start ()) if (start < other.start)
{ {
results.push_back (Range (start (), other.start ())); results.push_back (Range (start, other.start));
if (other.isEnded () && if (other.ended () &&
(! isEnded () || end () > other.end ())) (! ended () || end > other.end))
{ {
results.push_back (Range (other.end (), end ())); results.push_back (Range (other.end, end));
} }
} }
else else
{ {
if (other.isEnded ()) if (other.ended ())
{ {
if (isEnded ()) if (ended ())
{ {
if (end () > other.end ()) if (end > other.end)
results.push_back (Range (other.end (), end ())); results.push_back (Range (other.end, end));
} }
else else
{ {
results.push_back (Range (other.end (), end ())); results.push_back (Range (other.end, end));
} }
} }
} }
@ -251,9 +224,9 @@ std::string Range::dump () const
{ {
std::stringstream out; std::stringstream out;
out << "Range " out << "Range "
<< (_start.toEpoch () ? _start.toISOLocalExtended () : "n/a") << (start.toEpoch () ? start.toISOLocalExtended () : "n/a")
<< " - " << " - "
<< (_end.toEpoch () ? _end.toISOLocalExtended () : "n/a"); << (end.toEpoch () ? end.toISOLocalExtended () : "n/a");
return out.str (); return out.str ();
} }

16
src/Range.h
View file

@ -37,23 +37,17 @@ public:
Range (const Datetime&, const Datetime&); Range (const Datetime&, const Datetime&);
bool operator== (const Range&) const; bool operator== (const Range&) const;
Datetime start () const; bool started () const;
void start (const Datetime&); bool ended () const;
Datetime end () const;
void end (const Datetime&);
bool isStarted () const;
bool isEnded () const;
bool overlap (const Range&) const; bool overlap (const Range&) const;
Range intersect (const Range&) const; Range intersect (const Range&) const;
std::vector <Range> subtract (const Range&) const; std::vector <Range> subtract (const Range&) const;
std::string dump () const; std::string dump () const;
private: public:
Datetime _start {0}; Datetime start {0};
Datetime _end {0}; Datetime end {0};
}; };
#endif #endif

8
src/Timeline.cpp
View file

@ -73,8 +73,8 @@ std::vector <Interval> Timeline::tracked (Rules& rules) const
// Create a range representing the whole timeline. // Create a range representing the whole timeline.
// If no range is defined, then assume the full range of all the inclusions. // If no range is defined, then assume the full range of all the inclusions.
Range overallRange {_range}; Range overallRange {_range};
if (! overallRange.isStarted () && if (! overallRange.started () &&
! overallRange.isEnded ()) ! overallRange.ended ())
overallRange = overallRangeFromIntervals (_inclusions); overallRange = overallRangeFromIntervals (_inclusions);
// Cobmine all the non-trackable time. // Cobmine all the non-trackable time.
@ -83,7 +83,7 @@ std::vector <Interval> Timeline::tracked (Rules& rules) const
std::vector <Interval> combined; std::vector <Interval> combined;
for (auto& interval : _inclusions) for (auto& interval : _inclusions)
{ {
std::vector <Range> intervalFragments {interval.range ()}; std::vector <Range> intervalFragments {interval.range};
for (auto& exclusion : nonTrackable) for (auto& exclusion : nonTrackable)
{ {
@ -99,7 +99,7 @@ std::vector <Interval> Timeline::tracked (Rules& rules) const
{ {
// Clone the interval, set the new range. // Clone the interval, set the new range.
Interval clipped {interval}; Interval clipped {interval};
clipped.range (fragment); clipped.range = fragment;
combined.push_back (clipped); combined.push_back (clipped);
} }
} }

8
src/commands/CmdContinue.cpp
View file

@ -37,12 +37,12 @@ int CmdContinue (
auto latest = getLatestInterval (database); auto latest = getLatestInterval (database);
if (! latest.empty ()) if (! latest.empty ())
{ {
if (latest.isStarted () && if (latest.range.started () &&
latest.isEnded ()) latest.range.ended ())
{ {
// Open an identical interval. // Open an identical interval.
latest.start ({}); latest.range.start = Datetime ();
latest.end ({0}); latest.range.end = Datetime (0);
// Update database. // Update database.
database.addInterval (latest); database.addInterval (latest);

2
src/commands/CmdDefault.cpp
View file

@ -37,7 +37,7 @@ int CmdDefault (Rules& rules, Database& database)
// Load the most recent interval, summarize and display. // Load the most recent interval, summarize and display.
auto interval = getLatestInterval (database); auto interval = getLatestInterval (database);
if (interval.isStarted () && ! interval.isEnded ()) if (interval.range.started () && ! interval.range.ended ())
{ {
if (rules.getBoolean ("verbose")) if (rules.getBoolean ("verbose"))
std::cout << intervalSummarize (rules, interval); std::cout << intervalSummarize (rules, interval);

4
src/commands/CmdReport.cpp
View file

@ -84,8 +84,8 @@ int CmdReport (
auto intervals = timeline.tracked (rules); auto intervals = timeline.tracked (rules);
// Compose Header info. // Compose Header info.
rules.set ("temp.report.start", filter.range ().start ().toEpoch () > 0 ? filter.range ().start ().toISO () : ""); rules.set ("temp.report.start", filter.range.start.toEpoch () > 0 ? filter.range.start.toISO () : "");
rules.set ("temp.report.end", filter.range ().end ().toEpoch () > 0 ? filter.range ().end ().toISO () : ""); rules.set ("temp.report.end", filter.range.end.toEpoch () > 0 ? filter.range.end.toISO () : "");
std::string combinedTags; std::string combinedTags;
for (auto& tag : filter.tags ()) for (auto& tag : filter.tags ())
{ {

9
src/commands/CmdStart.cpp
View file

@ -40,13 +40,12 @@ int CmdStart (
auto latest = getLatestInterval (database); auto latest = getLatestInterval (database);
// If the latest interval is open, close it. // If the latest interval is open, close it.
if ( latest.isStarted () && if ( latest.range.started () &&
! latest.isEnded ()) ! latest.range.ended ())
{ {
// Stop it. // Stop it.
Interval modified {latest}; Interval modified {latest};
Datetime now; modified.range.end = Datetime ();
modified.end (now);
// Update database. // Update database.
database.modifyInterval (latest, modified); database.modifyInterval (latest, modified);
@ -58,7 +57,7 @@ int CmdStart (
// Create a new interval. // Create a new interval.
Interval now; Interval now;
now.start (Datetime ()); now.range.start = Datetime ();
// Apply tags. // Apply tags.
auto words = cli.getWords (); auto words = cli.getWords ();

11
src/commands/CmdStop.cpp
View file

@ -41,13 +41,12 @@ int CmdStop (
auto latest = getLatestInterval (database); auto latest = getLatestInterval (database);
// Verify the interval is open. // Verify the interval is open.
if ( latest.isStarted () && if ( latest.range.started () &&
! latest.isEnded ()) ! latest.range.ended ())
{ {
// Stop it. // Stop it.
Interval modified {latest}; Interval modified {latest};
Datetime now; modified.range.end = Datetime ();
modified.end (now);
database.modifyInterval (latest, modified); database.modifyInterval (latest, modified);
// User feedback. // User feedback.
@ -65,8 +64,8 @@ int CmdStop (
latest.tags ().size ()) latest.tags ().size ())
{ {
// Contiguous with previous interval. // Contiguous with previous interval.
latest.start (modified.end ()); latest.range.start = modified.range.end;
latest.end ({0}); latest.range.end = Datetime (0);
database.addInterval (latest); database.addInterval (latest);

78
src/helper.cpp
View file

@ -51,7 +51,7 @@ Color tagColor (const Rules& rules, const std::string& tag)
std::string intervalSummarize (const Rules& rules, const Interval& interval) std::string intervalSummarize (const Rules& rules, const Interval& interval)
{ {
std::stringstream out; std::stringstream out;
if (interval.isStarted ()) if (interval.range.started ())
{ {
// Combine and colorize tags. // Combine and colorize tags.
std::string tags; std::string tags;
@ -64,21 +64,21 @@ std::string intervalSummarize (const Rules& rules, const Interval& interval)
} }
// Interval closed. // Interval closed.
if (interval.isEnded ()) if (interval.range.ended ())
{ {
Duration dur (Datetime (interval.end ()) - Datetime (interval.start ())); Duration dur (Datetime (interval.range.end) - Datetime (interval.range.start));
out << "Recorded " << tags << "\n" out << "Recorded " << tags << "\n"
<< " Started " << interval.start ().toISOLocalExtended () << "\n" << " Started " << interval.range.start.toISOLocalExtended () << "\n"
<< " Ended " << interval.end ().toISOLocalExtended () << "\n" << " Ended " << interval.range.end.toISOLocalExtended () << "\n"
<< " Elapsed " << std::setw (19) << std::setfill (' ') << dur.format () << "\n"; << " Elapsed " << std::setw (19) << std::setfill (' ') << dur.format () << "\n";
} }
// Interval open. // Interval open.
else else
{ {
Duration dur (Datetime () - interval.start ()); Duration dur (Datetime () - interval.range.start);
out << "Tracking " << tags << "\n" out << "Tracking " << tags << "\n"
<< " Started " << interval.start ().toISOLocalExtended () << "\n"; << " Started " << interval.range.start.toISOLocalExtended () << "\n";
if (dur.toTime_t () > 10) if (dur.toTime_t () > 10)
out << " Elapsed " << std::setw (19) << std::setfill (' ') << dur.format () << "\n"; out << " Elapsed " << std::setw (19) << std::setfill (' ') << dur.format () << "\n";
@ -182,8 +182,8 @@ Interval createFilterIntervalFromCLI (const CLI& cli)
if (args.size () == 1 && if (args.size () == 1 &&
args[0] == "<date>") args[0] == "<date>")
{ {
range.start (Datetime (start)); range.start = Datetime (start);
range.end (Datetime ("now")); range.end = Datetime ("now");
} }
// from <date> // from <date>
@ -191,8 +191,8 @@ Interval createFilterIntervalFromCLI (const CLI& cli)
args[0] == "from" && args[0] == "from" &&
args[1] == "<date>") args[1] == "<date>")
{ {
range.start (Datetime (start)); range.start = Datetime (start);
range.end (Datetime ("now")); range.end = Datetime ("now");
} }
// <date> to/- <date> // <date> to/- <date>
@ -201,8 +201,8 @@ Interval createFilterIntervalFromCLI (const CLI& cli)
(args[1] == "to" || args[1] == "-") && (args[1] == "to" || args[1] == "-") &&
args[2] == "<date>") args[2] == "<date>")
{ {
range.start (Datetime (start)); range.start = Datetime (start);
range.end (Datetime (end)); range.end = Datetime (end);
} }
// from/since <date> to/- <date> // from/since <date> to/- <date>
@ -212,8 +212,8 @@ Interval createFilterIntervalFromCLI (const CLI& cli)
(args[2] == "to" || args[2] == "-") && (args[2] == "to" || args[2] == "-") &&
args[3] == "<date>") args[3] == "<date>")
{ {
range.start (Datetime (start)); range.start = Datetime (start);
range.end (Datetime (end)); range.end = Datetime (end);
} }
// <date> for <duration> // <date> for <duration>
@ -222,8 +222,8 @@ Interval createFilterIntervalFromCLI (const CLI& cli)
args[1] == "for" && args[1] == "for" &&
args[2] == "<duration>") args[2] == "<duration>")
{ {
range.start (Datetime (start)); range.start = Datetime (start);
range.end (Datetime (start) + Duration (duration).toTime_t ()); range.end = Datetime (start) + Duration (duration).toTime_t ();
} }
// from/since <date> for <duration> // from/since <date> for <duration>
@ -233,8 +233,8 @@ Interval createFilterIntervalFromCLI (const CLI& cli)
args[2] == "for" && args[2] == "for" &&
args[3] == "<duration>") args[3] == "<duration>")
{ {
range.start (Datetime (start)); range.start = Datetime (start);
range.end (Datetime (start) + Duration (duration).toTime_t ()); range.end = Datetime (start) + Duration (duration).toTime_t ();
} }
// <duration> before <date> // <duration> before <date>
@ -243,8 +243,8 @@ Interval createFilterIntervalFromCLI (const CLI& cli)
args[1] == "before" && args[1] == "before" &&
args[2] == "<date>") args[2] == "<date>")
{ {
range.start (Datetime (start) - Duration (duration).toTime_t ()); range.start = Datetime (start) - Duration (duration).toTime_t ();
range.end (Datetime (start)); range.end = Datetime (start);
} }
// <duration> after <date> // <duration> after <date>
@ -253,16 +253,16 @@ Interval createFilterIntervalFromCLI (const CLI& cli)
args[1] == "after" && args[1] == "after" &&
args[2] == "<date>") args[2] == "<date>")
{ {
range.start (Datetime (start)); range.start = Datetime (start);
range.end (Datetime (start) + Duration (duration).toTime_t ()); range.end = Datetime (start) + Duration (duration).toTime_t ();
} }
// <duration> // <duration>
else if (args.size () == 1 && else if (args.size () == 1 &&
args[0] == "<duration>") args[0] == "<duration>")
{ {
range.start (Datetime ("now") - Duration (duration).toTime_t ()); range.start = Datetime ("now") - Duration (duration).toTime_t ();
range.end (Datetime ("now")); range.end = Datetime ("now");
} }
// Unrecognized date range construct. // Unrecognized date range construct.
@ -271,7 +271,7 @@ Interval createFilterIntervalFromCLI (const CLI& cli)
throw std::string ("Unrecognized date range: '") + join (" ", args) + "'."; throw std::string ("Unrecognized date range: '") + join (" ", args) + "'.";
} }
filter.range (range); filter.range = range;
return filter; return filter;
} }
@ -296,7 +296,7 @@ Timeline createTimelineFromData (
const Interval& filter) const Interval& filter)
{ {
Timeline t; Timeline t;
t.range (filter.range ()); t.range (filter.range);
// Add filtered intervals. // Add filtered intervals.
for (auto& line : database.allLines ()) for (auto& line : database.allLines ())
@ -340,13 +340,13 @@ Interval getLatestInterval (Database& database)
// filter interval tags are found in the interval. // filter interval tags are found in the interval.
bool intervalMatchesFilterInterval (const Interval& interval, const Interval& filter) bool intervalMatchesFilterInterval (const Interval& interval, const Interval& filter)
{ {
if ((filter.start ().toEpoch () == 0 && if ((filter.range.start.toEpoch () == 0 &&
filter.end ().toEpoch () == 0) filter.range.end.toEpoch () == 0)
|| ||
(interval.end () > filter.start () && (interval.range.end > filter.range.start &&
interval.start () < filter.end ())) interval.range.start < filter.range.end))
{ {
for (auto& tag : filter.tags ()) for (auto& tag : filter.tags ())
if (! interval.hasTag (tag)) if (! interval.hasTag (tag))
@ -404,9 +404,9 @@ std::vector <Range> rangesFromHolidays (const Rules& rules)
{ {
Range r; Range r;
Datetime d (holiday.substr (lastDot + 1), "Y_M_D"); Datetime d (holiday.substr (lastDot + 1), "Y_M_D");
r.start (d); r.start = d;
++d; ++d;
r.end (d); r.end = d;
results.push_back (r); results.push_back (r);
} }
} }
@ -463,15 +463,15 @@ Range overallRangeFromIntervals (const std::vector <Interval>& intervals)
for (auto& interval : intervals) for (auto& interval : intervals)
{ {
if (interval.start () < overall.start () || overall.start ().toEpoch () == 0) if (interval.range.start < overall.start || overall.start.toEpoch () == 0)
overall.start (interval.start ()); overall.start = interval.range.start;
// Deliberately mixed start/end. // Deliberately mixed start/end.
if (interval.start () > overall.end ()) if (interval.range.start > overall.end)
overall.end (interval.start ()); overall.end = interval.range.start;
if (interval.end () > overall.end ()) if (interval.range.end > overall.end)
overall.end (interval.end ()); overall.end = interval.range.end;
} }
return overall; return overall;

380
test/exclusion.t.cpp
View file

@ -63,33 +63,33 @@ int main (int, char**)
auto ranges = e.ranges (r); auto ranges = e.ranges (r);
t.ok (ranges.size () == 12, "Exclusion ranges --> [12]"); t.ok (ranges.size () == 12, "Exclusion ranges --> [12]");
t.is (ranges[0].start ().toISOLocalExtended (), "2015-12-21T00:00:00", "Exclusion range[0].start() --> 2015-12-21T00:00:00"); t.is (ranges[0].start.toISOLocalExtended (), "2015-12-21T00:00:00", "Exclusion range[0].start() --> 2015-12-21T00:00:00");
t.is (ranges[0].end ().toISOLocalExtended (), "2015-12-21T08:00:00", "Exclusion range[0].end() --> 2015-12-21T08:00:00"); t.is (ranges[0].end.toISOLocalExtended (), "2015-12-21T08:00:00", "Exclusion range[0].end() --> 2015-12-21T08:00:00");
t.is (ranges[1].start ().toISOLocalExtended (), "2015-12-21T12:00:00", "Exclusion range[1].start() --> 2015-12-21T12:00:00"); t.is (ranges[1].start.toISOLocalExtended (), "2015-12-21T12:00:00", "Exclusion range[1].start() --> 2015-12-21T12:00:00");
t.is (ranges[1].end ().toISOLocalExtended (), "2015-12-21T12:45:00", "Exclusion range[1].end() --> 2015-12-21T12:45:00"); t.is (ranges[1].end.toISOLocalExtended (), "2015-12-21T12:45:00", "Exclusion range[1].end() --> 2015-12-21T12:45:00");
t.is (ranges[2].start ().toISOLocalExtended (), "2015-12-21T17:30:00", "Exclusion range[2].start() --> 2015-12-21T17:30:00"); t.is (ranges[2].start.toISOLocalExtended (), "2015-12-21T17:30:00", "Exclusion range[2].start() --> 2015-12-21T17:30:00");
t.is (ranges[2].end ().toISOLocalExtended (), "2015-12-22T00:00:00", "Exclusion range[2].end() --> 2015-12-22T00:00:00"); t.is (ranges[2].end.toISOLocalExtended (), "2015-12-22T00:00:00", "Exclusion range[2].end() --> 2015-12-22T00:00:00");
t.is (ranges[3].start ().toISOLocalExtended (), "2015-12-28T00:00:00", "Exclusion range[3].start() --> 2015-12-28T00:00:00"); t.is (ranges[3].start.toISOLocalExtended (), "2015-12-28T00:00:00", "Exclusion range[3].start() --> 2015-12-28T00:00:00");
t.is (ranges[3].end ().toISOLocalExtended (), "2015-12-28T08:00:00", "Exclusion range[3].end() --> 2015-12-28T08:00:00"); t.is (ranges[3].end.toISOLocalExtended (), "2015-12-28T08:00:00", "Exclusion range[3].end() --> 2015-12-28T08:00:00");
t.is (ranges[4].start ().toISOLocalExtended (), "2015-12-28T12:00:00", "Exclusion range[4].start() --> 2015-12-28T12:00:00"); t.is (ranges[4].start.toISOLocalExtended (), "2015-12-28T12:00:00", "Exclusion range[4].start() --> 2015-12-28T12:00:00");
t.is (ranges[4].end ().toISOLocalExtended (), "2015-12-28T12:45:00", "Exclusion range[4].end() --> 2015-12-28T12:45:00"); t.is (ranges[4].end.toISOLocalExtended (), "2015-12-28T12:45:00", "Exclusion range[4].end() --> 2015-12-28T12:45:00");
t.is (ranges[5].start ().toISOLocalExtended (), "2015-12-28T17:30:00", "Exclusion range[5].start() --> 2015-12-28T17:30:00"); t.is (ranges[5].start.toISOLocalExtended (), "2015-12-28T17:30:00", "Exclusion range[5].start() --> 2015-12-28T17:30:00");
t.is (ranges[5].end ().toISOLocalExtended (), "2015-12-29T00:00:00", "Exclusion range[5].end() --> 2015-12-29T00:00:00"); t.is (ranges[5].end.toISOLocalExtended (), "2015-12-29T00:00:00", "Exclusion range[5].end() --> 2015-12-29T00:00:00");
t.is (ranges[6].start ().toISOLocalExtended (), "2016-01-04T00:00:00", "Exclusion range[6].start() --> 2016-01-04T00:00:00"); t.is (ranges[6].start.toISOLocalExtended (), "2016-01-04T00:00:00", "Exclusion range[6].start() --> 2016-01-04T00:00:00");
t.is (ranges[6].end ().toISOLocalExtended (), "2016-01-04T08:00:00", "Exclusion range[6].end() --> 2016-01-04T08:00:00"); t.is (ranges[6].end.toISOLocalExtended (), "2016-01-04T08:00:00", "Exclusion range[6].end() --> 2016-01-04T08:00:00");
t.is (ranges[7].start ().toISOLocalExtended (), "2016-01-04T12:00:00", "Exclusion range[7].start() --> 2016-01-04T12:00:00"); t.is (ranges[7].start.toISOLocalExtended (), "2016-01-04T12:00:00", "Exclusion range[7].start() --> 2016-01-04T12:00:00");
t.is (ranges[7].end ().toISOLocalExtended (), "2016-01-04T12:45:00", "Exclusion range[7].end() --> 2016-01-04T12:45:00"); t.is (ranges[7].end.toISOLocalExtended (), "2016-01-04T12:45:00", "Exclusion range[7].end() --> 2016-01-04T12:45:00");
t.is (ranges[8].start ().toISOLocalExtended (), "2016-01-04T17:30:00", "Exclusion range[8].start() --> 2016-01-04T17:30:00"); t.is (ranges[8].start.toISOLocalExtended (), "2016-01-04T17:30:00", "Exclusion range[8].start() --> 2016-01-04T17:30:00");
t.is (ranges[8].end ().toISOLocalExtended (), "2016-01-05T00:00:00", "Exclusion range[8].end() --> 2016-01-05T00:00:00"); t.is (ranges[8].end.toISOLocalExtended (), "2016-01-05T00:00:00", "Exclusion range[8].end() --> 2016-01-05T00:00:00");
t.is (ranges[9].start ().toISOLocalExtended (), "2016-01-11T00:00:00", "Exclusion range[9].start() --> 2016-01-11T00:00:00"); t.is (ranges[9].start.toISOLocalExtended (), "2016-01-11T00:00:00", "Exclusion range[9].start() --> 2016-01-11T00:00:00");
t.is (ranges[9].end ().toISOLocalExtended (), "2016-01-11T08:00:00", "Exclusion range[9].end() --> 2016-01-11T08:00:00"); t.is (ranges[9].end.toISOLocalExtended (), "2016-01-11T08:00:00", "Exclusion range[9].end() --> 2016-01-11T08:00:00");
t.is (ranges[10].start ().toISOLocalExtended (), "2016-01-11T12:00:00", "Exclusion range[10].start() --> 2016-01-11T12:00:00"); t.is (ranges[10].start.toISOLocalExtended (), "2016-01-11T12:00:00", "Exclusion range[10].start() --> 2016-01-11T12:00:00");
t.is (ranges[10].end ().toISOLocalExtended (), "2016-01-11T12:45:00", "Exclusion range[10].end() --> 2016-01-11T12:45:00"); t.is (ranges[10].end.toISOLocalExtended (), "2016-01-11T12:45:00", "Exclusion range[10].end() --> 2016-01-11T12:45:00");
t.is (ranges[11].start ().toISOLocalExtended (), "2016-01-11T17:30:00", "Exclusion range[11].start() --> 2016-01-11T17:30:00"); t.is (ranges[11].start.toISOLocalExtended (), "2016-01-11T17:30:00", "Exclusion range[11].start() --> 2016-01-11T17:30:00");
t.is (ranges[11].end ().toISOLocalExtended (), "2016-01-12T00:00:00", "Exclusion range[11].end() --> 2016-01-12T00:00:00"); t.is (ranges[11].end.toISOLocalExtended (), "2016-01-12T00:00:00", "Exclusion range[11].end() --> 2016-01-12T00:00:00");
e.initialize ("exc tuesday <8:00:00 12:00:00-12:45:00 >17:30:00"); e.initialize ("exc tuesday <8:00:00 12:00:00-12:45:00 >17:30:00");
tokens = e.tokens (); tokens = e.tokens ();
@ -102,40 +102,40 @@ int main (int, char**)
ranges = e.ranges (r); ranges = e.ranges (r);
t.ok (ranges.size () == 15, "Exclusion ranges --> [15]"); t.ok (ranges.size () == 15, "Exclusion ranges --> [15]");
t.is (ranges[0].start ().toISOLocalExtended (), "2015-12-15T00:00:00", "Exclusion range[0].start() --> 2015-12-15T00:00:00"); t.is (ranges[0].start.toISOLocalExtended (), "2015-12-15T00:00:00", "Exclusion range[0].start() --> 2015-12-15T00:00:00");
t.is (ranges[0].end ().toISOLocalExtended (), "2015-12-15T08:00:00", "Exclusion range[0].end() --> 2015-12-15T08:00:00"); t.is (ranges[0].end.toISOLocalExtended (), "2015-12-15T08:00:00", "Exclusion range[0].end() --> 2015-12-15T08:00:00");
t.is (ranges[1].start ().toISOLocalExtended (), "2015-12-15T12:00:00", "Exclusion range[1].start() --> 2015-12-15T12:00:00"); t.is (ranges[1].start.toISOLocalExtended (), "2015-12-15T12:00:00", "Exclusion range[1].start() --> 2015-12-15T12:00:00");
t.is (ranges[1].end ().toISOLocalExtended (), "2015-12-15T12:45:00", "Exclusion range[1].end() --> 2015-12-15T12:45:00"); t.is (ranges[1].end.toISOLocalExtended (), "2015-12-15T12:45:00", "Exclusion range[1].end() --> 2015-12-15T12:45:00");
t.is (ranges[2].start ().toISOLocalExtended (), "2015-12-15T17:30:00", "Exclusion range[2].start() --> 2015-12-15T17:30:00"); t.is (ranges[2].start.toISOLocalExtended (), "2015-12-15T17:30:00", "Exclusion range[2].start() --> 2015-12-15T17:30:00");
t.is (ranges[2].end ().toISOLocalExtended (), "2015-12-16T00:00:00", "Exclusion range[2].end() --> 2015-12-16T00:00:00"); t.is (ranges[2].end.toISOLocalExtended (), "2015-12-16T00:00:00", "Exclusion range[2].end() --> 2015-12-16T00:00:00");
t.is (ranges[3].start ().toISOLocalExtended (), "2015-12-22T00:00:00", "Exclusion range[3].start() --> 2015-12-22T00:00:00"); t.is (ranges[3].start.toISOLocalExtended (), "2015-12-22T00:00:00", "Exclusion range[3].start() --> 2015-12-22T00:00:00");
t.is (ranges[3].end ().toISOLocalExtended (), "2015-12-22T08:00:00", "Exclusion range[3].end() --> 2015-12-22T08:00:00"); t.is (ranges[3].end.toISOLocalExtended (), "2015-12-22T08:00:00", "Exclusion range[3].end() --> 2015-12-22T08:00:00");
t.is (ranges[4].start ().toISOLocalExtended (), "2015-12-22T12:00:00", "Exclusion range[4].start() --> 2015-12-22T12:00:00"); t.is (ranges[4].start.toISOLocalExtended (), "2015-12-22T12:00:00", "Exclusion range[4].start() --> 2015-12-22T12:00:00");
t.is (ranges[4].end ().toISOLocalExtended (), "2015-12-22T12:45:00", "Exclusion range[4].end() --> 2015-12-22T12:45:00"); t.is (ranges[4].end.toISOLocalExtended (), "2015-12-22T12:45:00", "Exclusion range[4].end() --> 2015-12-22T12:45:00");
t.is (ranges[5].start ().toISOLocalExtended (), "2015-12-22T17:30:00", "Exclusion range[5].start() --> 2015-12-22T17:30:00"); t.is (ranges[5].start.toISOLocalExtended (), "2015-12-22T17:30:00", "Exclusion range[5].start() --> 2015-12-22T17:30:00");
t.is (ranges[5].end ().toISOLocalExtended (), "2015-12-23T00:00:00", "Exclusion range[5].end() --> 2015-12-23T00:00:00"); t.is (ranges[5].end.toISOLocalExtended (), "2015-12-23T00:00:00", "Exclusion range[5].end() --> 2015-12-23T00:00:00");
t.is (ranges[6].start ().toISOLocalExtended (), "2015-12-29T00:00:00", "Exclusion range[6].start() --> 2015-12-29T00:00:00"); t.is (ranges[6].start.toISOLocalExtended (), "2015-12-29T00:00:00", "Exclusion range[6].start() --> 2015-12-29T00:00:00");
t.is (ranges[6].end ().toISOLocalExtended (), "2015-12-29T08:00:00", "Exclusion range[6].end() --> 2015-12-29T08:00:00"); t.is (ranges[6].end.toISOLocalExtended (), "2015-12-29T08:00:00", "Exclusion range[6].end() --> 2015-12-29T08:00:00");
t.is (ranges[7].start ().toISOLocalExtended (), "2015-12-29T12:00:00", "Exclusion range[7].start() --> 2015-12-29T12:00:00"); t.is (ranges[7].start.toISOLocalExtended (), "2015-12-29T12:00:00", "Exclusion range[7].start() --> 2015-12-29T12:00:00");
t.is (ranges[7].end ().toISOLocalExtended (), "2015-12-29T12:45:00", "Exclusion range[7].end() --> 2015-12-29T12:45:00"); t.is (ranges[7].end.toISOLocalExtended (), "2015-12-29T12:45:00", "Exclusion range[7].end() --> 2015-12-29T12:45:00");
t.is (ranges[8].start ().toISOLocalExtended (), "2015-12-29T17:30:00", "Exclusion range[8].start() --> 2015-12-29T17:30:00"); t.is (ranges[8].start.toISOLocalExtended (), "2015-12-29T17:30:00", "Exclusion range[8].start() --> 2015-12-29T17:30:00");
t.is (ranges[8].end ().toISOLocalExtended (), "2015-12-30T00:00:00", "Exclusion range[8].end() --> 2015-12-30T00:00:00"); t.is (ranges[8].end.toISOLocalExtended (), "2015-12-30T00:00:00", "Exclusion range[8].end() --> 2015-12-30T00:00:00");
t.is (ranges[9].start ().toISOLocalExtended (), "2016-01-05T00:00:00", "Exclusion range[9].start() --> 2016-01-05T00:00:00"); t.is (ranges[9].start.toISOLocalExtended (), "2016-01-05T00:00:00", "Exclusion range[9].start() --> 2016-01-05T00:00:00");
t.is (ranges[9].end ().toISOLocalExtended (), "2016-01-05T08:00:00", "Exclusion range[9].end() --> 2016-01-05T08:00:00"); t.is (ranges[9].end.toISOLocalExtended (), "2016-01-05T08:00:00", "Exclusion range[9].end() --> 2016-01-05T08:00:00");
t.is (ranges[10].start ().toISOLocalExtended (), "2016-01-05T12:00:00", "Exclusion range[10].start() --> 2016-01-05T12:00:00"); t.is (ranges[10].start.toISOLocalExtended (), "2016-01-05T12:00:00", "Exclusion range[10].start() --> 2016-01-05T12:00:00");
t.is (ranges[10].end ().toISOLocalExtended (), "2016-01-05T12:45:00", "Exclusion range[10].end() --> 2016-01-05T12:45:00"); t.is (ranges[10].end.toISOLocalExtended (), "2016-01-05T12:45:00", "Exclusion range[10].end() --> 2016-01-05T12:45:00");
t.is (ranges[11].start ().toISOLocalExtended (), "2016-01-05T17:30:00", "Exclusion range[11].start() --> 2016-01-05T17:30:00"); t.is (ranges[11].start.toISOLocalExtended (), "2016-01-05T17:30:00", "Exclusion range[11].start() --> 2016-01-05T17:30:00");
t.is (ranges[11].end ().toISOLocalExtended (), "2016-01-06T00:00:00", "Exclusion range[11].end() --> 2016-01-06T00:00:00"); t.is (ranges[11].end.toISOLocalExtended (), "2016-01-06T00:00:00", "Exclusion range[11].end() --> 2016-01-06T00:00:00");
t.is (ranges[12].start ().toISOLocalExtended (), "2016-01-12T00:00:00", "Exclusion range[12].start() --> 2016-01-12T00:00:00"); t.is (ranges[12].start.toISOLocalExtended (), "2016-01-12T00:00:00", "Exclusion range[12].start() --> 2016-01-12T00:00:00");
t.is (ranges[12].end ().toISOLocalExtended (), "2016-01-12T08:00:00", "Exclusion range[12].end() --> 2016-01-12T08:00:00"); t.is (ranges[12].end.toISOLocalExtended (), "2016-01-12T08:00:00", "Exclusion range[12].end() --> 2016-01-12T08:00:00");
t.is (ranges[13].start ().toISOLocalExtended (), "2016-01-12T12:00:00", "Exclusion range[13].start() --> 2016-01-12T12:00:00"); t.is (ranges[13].start.toISOLocalExtended (), "2016-01-12T12:00:00", "Exclusion range[13].start() --> 2016-01-12T12:00:00");
t.is (ranges[13].end ().toISOLocalExtended (), "2016-01-12T12:45:00", "Exclusion range[13].end() --> 2016-01-12T12:45:00"); t.is (ranges[13].end.toISOLocalExtended (), "2016-01-12T12:45:00", "Exclusion range[13].end() --> 2016-01-12T12:45:00");
t.is (ranges[14].start ().toISOLocalExtended (), "2016-01-12T17:30:00", "Exclusion range[14].start() --> 2016-01-12T17:30:00"); t.is (ranges[14].start.toISOLocalExtended (), "2016-01-12T17:30:00", "Exclusion range[14].start() --> 2016-01-12T17:30:00");
t.is (ranges[14].end ().toISOLocalExtended (), "2016-01-13T00:00:00", "Exclusion range[14].end() --> 2016-01-13T00:00:00"); t.is (ranges[14].end.toISOLocalExtended (), "2016-01-13T00:00:00", "Exclusion range[14].end() --> 2016-01-13T00:00:00");
e.initialize ("exc wednesday <8:00:00 12:00:00-12:45:00 >17:30:00"); e.initialize ("exc wednesday <8:00:00 12:00:00-12:45:00 >17:30:00");
tokens = e.tokens (); tokens = e.tokens ();
@ -148,40 +148,40 @@ int main (int, char**)
ranges = e.ranges (r); ranges = e.ranges (r);
t.ok (ranges.size () == 15, "Exclusion ranges --> [15]"); t.ok (ranges.size () == 15, "Exclusion ranges --> [15]");
t.is (ranges[0].start ().toISOLocalExtended (), "2015-12-16T00:00:00", "Exclusion range[0].start() --> 2015-12-16T00:00:00"); t.is (ranges[0].start.toISOLocalExtended (), "2015-12-16T00:00:00", "Exclusion range[0].start() --> 2015-12-16T00:00:00");
t.is (ranges[0].end ().toISOLocalExtended (), "2015-12-16T08:00:00", "Exclusion range[0].end() --> 2015-12-16T08:00:00"); t.is (ranges[0].end.toISOLocalExtended (), "2015-12-16T08:00:00", "Exclusion range[0].end() --> 2015-12-16T08:00:00");
t.is (ranges[1].start ().toISOLocalExtended (), "2015-12-16T12:00:00", "Exclusion range[1].start() --> 2015-12-16T12:00:00"); t.is (ranges[1].start.toISOLocalExtended (), "2015-12-16T12:00:00", "Exclusion range[1].start() --> 2015-12-16T12:00:00");
t.is (ranges[1].end ().toISOLocalExtended (), "2015-12-16T12:45:00", "Exclusion range[1].end() --> 2015-12-16T12:45:00"); t.is (ranges[1].end.toISOLocalExtended (), "2015-12-16T12:45:00", "Exclusion range[1].end() --> 2015-12-16T12:45:00");
t.is (ranges[2].start ().toISOLocalExtended (), "2015-12-16T17:30:00", "Exclusion range[2].start() --> 2015-12-16T17:30:00"); t.is (ranges[2].start.toISOLocalExtended (), "2015-12-16T17:30:00", "Exclusion range[2].start() --> 2015-12-16T17:30:00");
t.is (ranges[2].end ().toISOLocalExtended (), "2015-12-17T00:00:00", "Exclusion range[2].end() --> 2015-12-17T00:00:00"); t.is (ranges[2].end.toISOLocalExtended (), "2015-12-17T00:00:00", "Exclusion range[2].end() --> 2015-12-17T00:00:00");
t.is (ranges[3].start ().toISOLocalExtended (), "2015-12-23T00:00:00", "Exclusion range[3].start() --> 2015-12-23T00:00:00"); t.is (ranges[3].start.toISOLocalExtended (), "2015-12-23T00:00:00", "Exclusion range[3].start() --> 2015-12-23T00:00:00");
t.is (ranges[3].end ().toISOLocalExtended (), "2015-12-23T08:00:00", "Exclusion range[3].end() --> 2015-12-23T08:00:00"); t.is (ranges[3].end.toISOLocalExtended (), "2015-12-23T08:00:00", "Exclusion range[3].end() --> 2015-12-23T08:00:00");
t.is (ranges[4].start ().toISOLocalExtended (), "2015-12-23T12:00:00", "Exclusion range[4].start() --> 2015-12-23T12:00:00"); t.is (ranges[4].start.toISOLocalExtended (), "2015-12-23T12:00:00", "Exclusion range[4].start() --> 2015-12-23T12:00:00");
t.is (ranges[4].end ().toISOLocalExtended (), "2015-12-23T12:45:00", "Exclusion range[4].end() --> 2015-12-23T12:45:00"); t.is (ranges[4].end.toISOLocalExtended (), "2015-12-23T12:45:00", "Exclusion range[4].end() --> 2015-12-23T12:45:00");
t.is (ranges[5].start ().toISOLocalExtended (), "2015-12-23T17:30:00", "Exclusion range[5].start() --> 2015-12-23T17:30:00"); t.is (ranges[5].start.toISOLocalExtended (), "2015-12-23T17:30:00", "Exclusion range[5].start() --> 2015-12-23T17:30:00");
t.is (ranges[5].end ().toISOLocalExtended (), "2015-12-24T00:00:00", "Exclusion range[5].end() --> 2015-12-24T00:00:00"); t.is (ranges[5].end.toISOLocalExtended (), "2015-12-24T00:00:00", "Exclusion range[5].end() --> 2015-12-24T00:00:00");
t.is (ranges[6].start ().toISOLocalExtended (), "2015-12-30T00:00:00", "Exclusion range[6].start() --> 2015-12-30T00:00:00"); t.is (ranges[6].start.toISOLocalExtended (), "2015-12-30T00:00:00", "Exclusion range[6].start() --> 2015-12-30T00:00:00");
t.is (ranges[6].end ().toISOLocalExtended (), "2015-12-30T08:00:00", "Exclusion range[6].end() --> 2015-12-30T08:00:00"); t.is (ranges[6].end.toISOLocalExtended (), "2015-12-30T08:00:00", "Exclusion range[6].end() --> 2015-12-30T08:00:00");
t.is (ranges[7].start ().toISOLocalExtended (), "2015-12-30T12:00:00", "Exclusion range[7].start() --> 2015-12-30T12:00:00"); t.is (ranges[7].start.toISOLocalExtended (), "2015-12-30T12:00:00", "Exclusion range[7].start() --> 2015-12-30T12:00:00");
t.is (ranges[7].end ().toISOLocalExtended (), "2015-12-30T12:45:00", "Exclusion range[7].end() --> 2015-12-30T12:45:00"); t.is (ranges[7].end.toISOLocalExtended (), "2015-12-30T12:45:00", "Exclusion range[7].end() --> 2015-12-30T12:45:00");
t.is (ranges[8].start ().toISOLocalExtended (), "2015-12-30T17:30:00", "Exclusion range[8].start() --> 2015-12-30T17:30:00"); t.is (ranges[8].start.toISOLocalExtended (), "2015-12-30T17:30:00", "Exclusion range[8].start() --> 2015-12-30T17:30:00");
t.is (ranges[8].end ().toISOLocalExtended (), "2015-12-31T00:00:00", "Exclusion range[8].end() --> 2015-12-31T00:00:00"); t.is (ranges[8].end.toISOLocalExtended (), "2015-12-31T00:00:00", "Exclusion range[8].end() --> 2015-12-31T00:00:00");
t.is (ranges[9].start ().toISOLocalExtended (), "2016-01-06T00:00:00", "Exclusion range[9].start() --> 2016-01-06T00:00:00"); t.is (ranges[9].start.toISOLocalExtended (), "2016-01-06T00:00:00", "Exclusion range[9].start() --> 2016-01-06T00:00:00");
t.is (ranges[9].end ().toISOLocalExtended (), "2016-01-06T08:00:00", "Exclusion range[9].end() --> 2016-01-06T08:00:00"); t.is (ranges[9].end.toISOLocalExtended (), "2016-01-06T08:00:00", "Exclusion range[9].end() --> 2016-01-06T08:00:00");
t.is (ranges[10].start ().toISOLocalExtended (), "2016-01-06T12:00:00", "Exclusion range[10].start() --> 2016-01-06T12:00:00"); t.is (ranges[10].start.toISOLocalExtended (), "2016-01-06T12:00:00", "Exclusion range[10].start() --> 2016-01-06T12:00:00");
t.is (ranges[10].end ().toISOLocalExtended (), "2016-01-06T12:45:00", "Exclusion range[10].end() --> 2016-01-06T12:45:00"); t.is (ranges[10].end.toISOLocalExtended (), "2016-01-06T12:45:00", "Exclusion range[10].end() --> 2016-01-06T12:45:00");
t.is (ranges[11].start ().toISOLocalExtended (), "2016-01-06T17:30:00", "Exclusion range[11].start() --> 2016-01-06T17:30:00"); t.is (ranges[11].start.toISOLocalExtended (), "2016-01-06T17:30:00", "Exclusion range[11].start() --> 2016-01-06T17:30:00");
t.is (ranges[11].end ().toISOLocalExtended (), "2016-01-07T00:00:00", "Exclusion range[11].end() --> 2016-01-07T00:00:00"); t.is (ranges[11].end.toISOLocalExtended (), "2016-01-07T00:00:00", "Exclusion range[11].end() --> 2016-01-07T00:00:00");
t.is (ranges[12].start ().toISOLocalExtended (), "2016-01-13T00:00:00", "Exclusion range[12].start() --> 2016-01-13T00:00:00"); t.is (ranges[12].start.toISOLocalExtended (), "2016-01-13T00:00:00", "Exclusion range[12].start() --> 2016-01-13T00:00:00");
t.is (ranges[12].end ().toISOLocalExtended (), "2016-01-13T08:00:00", "Exclusion range[12].end() --> 2016-01-13T08:00:00"); t.is (ranges[12].end.toISOLocalExtended (), "2016-01-13T08:00:00", "Exclusion range[12].end() --> 2016-01-13T08:00:00");
t.is (ranges[13].start ().toISOLocalExtended (), "2016-01-13T12:00:00", "Exclusion range[13].start() --> 2016-01-13T12:00:00"); t.is (ranges[13].start.toISOLocalExtended (), "2016-01-13T12:00:00", "Exclusion range[13].start() --> 2016-01-13T12:00:00");
t.is (ranges[13].end ().toISOLocalExtended (), "2016-01-13T12:45:00", "Exclusion range[13].end() --> 2016-01-13T12:45:00"); t.is (ranges[13].end.toISOLocalExtended (), "2016-01-13T12:45:00", "Exclusion range[13].end() --> 2016-01-13T12:45:00");
t.is (ranges[14].start ().toISOLocalExtended (), "2016-01-13T17:30:00", "Exclusion range[14].start() --> 2016-01-13T17:30:00"); t.is (ranges[14].start.toISOLocalExtended (), "2016-01-13T17:30:00", "Exclusion range[14].start() --> 2016-01-13T17:30:00");
t.is (ranges[14].end ().toISOLocalExtended (), "2016-01-14T00:00:00", "Exclusion range[14].end() --> 2016-01-14T00:00:00"); t.is (ranges[14].end.toISOLocalExtended (), "2016-01-14T00:00:00", "Exclusion range[14].end() --> 2016-01-14T00:00:00");
e.initialize ("exc thursday <8:00:00 12:00:00-12:45:00 >17:30:00"); e.initialize ("exc thursday <8:00:00 12:00:00-12:45:00 >17:30:00");
tokens = e.tokens (); tokens = e.tokens ();
@ -194,40 +194,40 @@ int main (int, char**)
ranges = e.ranges (r); ranges = e.ranges (r);
t.ok (ranges.size () == 15, "Exclusion ranges --> [15]"); t.ok (ranges.size () == 15, "Exclusion ranges --> [15]");
t.is (ranges[0].start ().toISOLocalExtended (), "2015-12-17T00:00:00", "Exclusion range[0].start() --> 2015-12-17T00:00:00"); t.is (ranges[0].start.toISOLocalExtended (), "2015-12-17T00:00:00", "Exclusion range[0].start() --> 2015-12-17T00:00:00");
t.is (ranges[0].end ().toISOLocalExtended (), "2015-12-17T08:00:00", "Exclusion range[0].end() --> 2015-12-17T08:00:00"); t.is (ranges[0].end.toISOLocalExtended (), "2015-12-17T08:00:00", "Exclusion range[0].end() --> 2015-12-17T08:00:00");
t.is (ranges[1].start ().toISOLocalExtended (), "2015-12-17T12:00:00", "Exclusion range[1].start() --> 2015-12-17T12:00:00"); t.is (ranges[1].start.toISOLocalExtended (), "2015-12-17T12:00:00", "Exclusion range[1].start() --> 2015-12-17T12:00:00");
t.is (ranges[1].end ().toISOLocalExtended (), "2015-12-17T12:45:00", "Exclusion range[1].end() --> 2015-12-17T12:45:00"); t.is (ranges[1].end.toISOLocalExtended (), "2015-12-17T12:45:00", "Exclusion range[1].end() --> 2015-12-17T12:45:00");
t.is (ranges[2].start ().toISOLocalExtended (), "2015-12-17T17:30:00", "Exclusion range[2].start() --> 2015-12-17T17:30:00"); t.is (ranges[2].start.toISOLocalExtended (), "2015-12-17T17:30:00", "Exclusion range[2].start() --> 2015-12-17T17:30:00");
t.is (ranges[2].end ().toISOLocalExtended (), "2015-12-18T00:00:00", "Exclusion range[2].end() --> 2015-12-18T00:00:00"); t.is (ranges[2].end.toISOLocalExtended (), "2015-12-18T00:00:00", "Exclusion range[2].end() --> 2015-12-18T00:00:00");
t.is (ranges[3].start ().toISOLocalExtended (), "2015-12-24T00:00:00", "Exclusion range[3].start() --> 2015-12-24T00:00:00"); t.is (ranges[3].start.toISOLocalExtended (), "2015-12-24T00:00:00", "Exclusion range[3].start() --> 2015-12-24T00:00:00");
t.is (ranges[3].end ().toISOLocalExtended (), "2015-12-24T08:00:00", "Exclusion range[3].end() --> 2015-12-24T08:00:00"); t.is (ranges[3].end.toISOLocalExtended (), "2015-12-24T08:00:00", "Exclusion range[3].end() --> 2015-12-24T08:00:00");
t.is (ranges[4].start ().toISOLocalExtended (), "2015-12-24T12:00:00", "Exclusion range[4].start() --> 2015-12-24T12:00:00"); t.is (ranges[4].start.toISOLocalExtended (), "2015-12-24T12:00:00", "Exclusion range[4].start() --> 2015-12-24T12:00:00");
t.is (ranges[4].end ().toISOLocalExtended (), "2015-12-24T12:45:00", "Exclusion range[4].end() --> 2015-12-24T12:45:00"); t.is (ranges[4].end.toISOLocalExtended (), "2015-12-24T12:45:00", "Exclusion range[4].end() --> 2015-12-24T12:45:00");
t.is (ranges[5].start ().toISOLocalExtended (), "2015-12-24T17:30:00", "Exclusion range[5].start() --> 2015-12-24T17:30:00"); t.is (ranges[5].start.toISOLocalExtended (), "2015-12-24T17:30:00", "Exclusion range[5].start() --> 2015-12-24T17:30:00");
t.is (ranges[5].end ().toISOLocalExtended (), "2015-12-25T00:00:00", "Exclusion range[5].end() --> 2015-12-25T00:00:00"); t.is (ranges[5].end.toISOLocalExtended (), "2015-12-25T00:00:00", "Exclusion range[5].end() --> 2015-12-25T00:00:00");
t.is (ranges[6].start ().toISOLocalExtended (), "2015-12-31T00:00:00", "Exclusion range[6].start() --> 2015-12-31T00:00:00"); t.is (ranges[6].start.toISOLocalExtended (), "2015-12-31T00:00:00", "Exclusion range[6].start() --> 2015-12-31T00:00:00");
t.is (ranges[6].end ().toISOLocalExtended (), "2015-12-31T08:00:00", "Exclusion range[6].end() --> 2015-12-31T08:00:00"); t.is (ranges[6].end.toISOLocalExtended (), "2015-12-31T08:00:00", "Exclusion range[6].end() --> 2015-12-31T08:00:00");
t.is (ranges[7].start ().toISOLocalExtended (), "2015-12-31T12:00:00", "Exclusion range[7].start() --> 2015-12-31T12:00:00"); t.is (ranges[7].start.toISOLocalExtended (), "2015-12-31T12:00:00", "Exclusion range[7].start() --> 2015-12-31T12:00:00");
t.is (ranges[7].end ().toISOLocalExtended (), "2015-12-31T12:45:00", "Exclusion range[7].end() --> 2015-12-31T12:45:00"); t.is (ranges[7].end.toISOLocalExtended (), "2015-12-31T12:45:00", "Exclusion range[7].end() --> 2015-12-31T12:45:00");
t.is (ranges[8].start ().toISOLocalExtended (), "2015-12-31T17:30:00", "Exclusion range[8].start() --> 2015-12-31T17:30:00"); t.is (ranges[8].start.toISOLocalExtended (), "2015-12-31T17:30:00", "Exclusion range[8].start() --> 2015-12-31T17:30:00");
t.is (ranges[8].end ().toISOLocalExtended (), "2016-01-01T00:00:00", "Exclusion range[8].end() --> 2016-01-01T00:00:00"); t.is (ranges[8].end.toISOLocalExtended (), "2016-01-01T00:00:00", "Exclusion range[8].end() --> 2016-01-01T00:00:00");
t.is (ranges[9].start ().toISOLocalExtended (), "2016-01-07T00:00:00", "Exclusion range[9].start() --> 2016-01-07T00:00:00"); t.is (ranges[9].start.toISOLocalExtended (), "2016-01-07T00:00:00", "Exclusion range[9].start() --> 2016-01-07T00:00:00");
t.is (ranges[9].end ().toISOLocalExtended (), "2016-01-07T08:00:00", "Exclusion range[9].end() --> 2016-01-07T08:00:00"); t.is (ranges[9].end.toISOLocalExtended (), "2016-01-07T08:00:00", "Exclusion range[9].end() --> 2016-01-07T08:00:00");
t.is (ranges[10].start ().toISOLocalExtended (), "2016-01-07T12:00:00", "Exclusion range[10].start() --> 2016-01-07T12:00:00"); t.is (ranges[10].start.toISOLocalExtended (), "2016-01-07T12:00:00", "Exclusion range[10].start() --> 2016-01-07T12:00:00");
t.is (ranges[10].end ().toISOLocalExtended (), "2016-01-07T12:45:00", "Exclusion range[10].end() --> 2016-01-07T12:45:00"); t.is (ranges[10].end.toISOLocalExtended (), "2016-01-07T12:45:00", "Exclusion range[10].end() --> 2016-01-07T12:45:00");
t.is (ranges[11].start ().toISOLocalExtended (), "2016-01-07T17:30:00", "Exclusion range[11].start() --> 2016-01-07T17:30:00"); t.is (ranges[11].start.toISOLocalExtended (), "2016-01-07T17:30:00", "Exclusion range[11].start() --> 2016-01-07T17:30:00");
t.is (ranges[11].end ().toISOLocalExtended (), "2016-01-08T00:00:00", "Exclusion range[11].end() --> 2016-01-08T00:00:00"); t.is (ranges[11].end.toISOLocalExtended (), "2016-01-08T00:00:00", "Exclusion range[11].end() --> 2016-01-08T00:00:00");
t.is (ranges[12].start ().toISOLocalExtended (), "2016-01-14T00:00:00", "Exclusion range[12].start() --> 2016-01-14T00:00:00"); t.is (ranges[12].start.toISOLocalExtended (), "2016-01-14T00:00:00", "Exclusion range[12].start() --> 2016-01-14T00:00:00");
t.is (ranges[12].end ().toISOLocalExtended (), "2016-01-14T08:00:00", "Exclusion range[12].end() --> 2016-01-14T08:00:00"); t.is (ranges[12].end.toISOLocalExtended (), "2016-01-14T08:00:00", "Exclusion range[12].end() --> 2016-01-14T08:00:00");
t.is (ranges[13].start ().toISOLocalExtended (), "2016-01-14T12:00:00", "Exclusion range[13].start() --> 2016-01-14T12:00:00"); t.is (ranges[13].start.toISOLocalExtended (), "2016-01-14T12:00:00", "Exclusion range[13].start() --> 2016-01-14T12:00:00");
t.is (ranges[13].end ().toISOLocalExtended (), "2016-01-14T12:45:00", "Exclusion range[13].end() --> 2016-01-14T12:45:00"); t.is (ranges[13].end.toISOLocalExtended (), "2016-01-14T12:45:00", "Exclusion range[13].end() --> 2016-01-14T12:45:00");
t.is (ranges[14].start ().toISOLocalExtended (), "2016-01-14T17:30:00", "Exclusion range[14].start() --> 2016-01-14T17:30:00"); t.is (ranges[14].start.toISOLocalExtended (), "2016-01-14T17:30:00", "Exclusion range[14].start() --> 2016-01-14T17:30:00");
t.is (ranges[14].end ().toISOLocalExtended (), "2016-01-15T00:00:00", "Exclusion range[14].end() --> 2016-01-15T00:00:00"); t.is (ranges[14].end.toISOLocalExtended (), "2016-01-15T00:00:00", "Exclusion range[14].end() --> 2016-01-15T00:00:00");
e.initialize ("exc friday <8:00:00 12:00:00-12:45:00 >17:30:00"); e.initialize ("exc friday <8:00:00 12:00:00-12:45:00 >17:30:00");
tokens = e.tokens (); tokens = e.tokens ();
@ -240,33 +240,33 @@ int main (int, char**)
ranges = e.ranges (r); ranges = e.ranges (r);
t.ok (ranges.size () == 12, "Exclusion ranges --> [12]"); t.ok (ranges.size () == 12, "Exclusion ranges --> [12]");
t.is (ranges[0].start ().toISOLocalExtended (), "2015-12-18T00:00:00", "Exclusion range[0].start() --> 2015-12-18T00:00:00"); t.is (ranges[0].start.toISOLocalExtended (), "2015-12-18T00:00:00", "Exclusion range[0].start() --> 2015-12-18T00:00:00");
t.is (ranges[0].end ().toISOLocalExtended (), "2015-12-18T08:00:00", "Exclusion range[0].end() --> 2015-12-18T08:00:00"); t.is (ranges[0].end.toISOLocalExtended (), "2015-12-18T08:00:00", "Exclusion range[0].end() --> 2015-12-18T08:00:00");
t.is (ranges[1].start ().toISOLocalExtended (), "2015-12-18T12:00:00", "Exclusion range[1].start() --> 2015-12-18T12:00:00"); t.is (ranges[1].start.toISOLocalExtended (), "2015-12-18T12:00:00", "Exclusion range[1].start() --> 2015-12-18T12:00:00");
t.is (ranges[1].end ().toISOLocalExtended (), "2015-12-18T12:45:00", "Exclusion range[1].end() --> 2015-12-18T12:45:00"); t.is (ranges[1].end.toISOLocalExtended (), "2015-12-18T12:45:00", "Exclusion range[1].end() --> 2015-12-18T12:45:00");
t.is (ranges[2].start ().toISOLocalExtended (), "2015-12-18T17:30:00", "Exclusion range[2].start() --> 2015-12-18T17:30:00"); t.is (ranges[2].start.toISOLocalExtended (), "2015-12-18T17:30:00", "Exclusion range[2].start() --> 2015-12-18T17:30:00");
t.is (ranges[2].end ().toISOLocalExtended (), "2015-12-19T00:00:00", "Exclusion range[2].end() --> 2015-12-19T00:00:00"); t.is (ranges[2].end.toISOLocalExtended (), "2015-12-19T00:00:00", "Exclusion range[2].end() --> 2015-12-19T00:00:00");
t.is (ranges[3].start ().toISOLocalExtended (), "2015-12-25T00:00:00", "Exclusion range[3].start() --> 2015-12-25T00:00:00"); t.is (ranges[3].start.toISOLocalExtended (), "2015-12-25T00:00:00", "Exclusion range[3].start() --> 2015-12-25T00:00:00");
t.is (ranges[3].end ().toISOLocalExtended (), "2015-12-25T08:00:00", "Exclusion range[3].end() --> 2015-12-25T08:00:00"); t.is (ranges[3].end.toISOLocalExtended (), "2015-12-25T08:00:00", "Exclusion range[3].end() --> 2015-12-25T08:00:00");
t.is (ranges[4].start ().toISOLocalExtended (), "2015-12-25T12:00:00", "Exclusion range[4].start() --> 2015-12-25T12:00:00"); t.is (ranges[4].start.toISOLocalExtended (), "2015-12-25T12:00:00", "Exclusion range[4].start() --> 2015-12-25T12:00:00");
t.is (ranges[4].end ().toISOLocalExtended (), "2015-12-25T12:45:00", "Exclusion range[4].end() --> 2015-12-25T12:45:00"); t.is (ranges[4].end.toISOLocalExtended (), "2015-12-25T12:45:00", "Exclusion range[4].end() --> 2015-12-25T12:45:00");
t.is (ranges[5].start ().toISOLocalExtended (), "2015-12-25T17:30:00", "Exclusion range[5].start() --> 2015-12-25T17:30:00"); t.is (ranges[5].start.toISOLocalExtended (), "2015-12-25T17:30:00", "Exclusion range[5].start() --> 2015-12-25T17:30:00");
t.is (ranges[5].end ().toISOLocalExtended (), "2015-12-26T00:00:00", "Exclusion range[5].end() --> 2015-12-26T00:00:00"); t.is (ranges[5].end.toISOLocalExtended (), "2015-12-26T00:00:00", "Exclusion range[5].end() --> 2015-12-26T00:00:00");
t.is (ranges[6].start ().toISOLocalExtended (), "2016-01-01T00:00:00", "Exclusion range[6].start() --> 2016-01-01T00:00:00"); t.is (ranges[6].start.toISOLocalExtended (), "2016-01-01T00:00:00", "Exclusion range[6].start() --> 2016-01-01T00:00:00");
t.is (ranges[6].end ().toISOLocalExtended (), "2016-01-01T08:00:00", "Exclusion range[6].end() --> 2016-01-01T08:00:00"); t.is (ranges[6].end.toISOLocalExtended (), "2016-01-01T08:00:00", "Exclusion range[6].end() --> 2016-01-01T08:00:00");
t.is (ranges[7].start ().toISOLocalExtended (), "2016-01-01T12:00:00", "Exclusion range[7].start() --> 2016-01-01T12:00:00"); t.is (ranges[7].start.toISOLocalExtended (), "2016-01-01T12:00:00", "Exclusion range[7].start() --> 2016-01-01T12:00:00");
t.is (ranges[7].end ().toISOLocalExtended (), "2016-01-01T12:45:00", "Exclusion range[7].end() --> 2016-01-01T12:45:00"); t.is (ranges[7].end.toISOLocalExtended (), "2016-01-01T12:45:00", "Exclusion range[7].end() --> 2016-01-01T12:45:00");
t.is (ranges[8].start ().toISOLocalExtended (), "2016-01-01T17:30:00", "Exclusion range[8].start() --> 2016-01-01T17:30:00"); t.is (ranges[8].start.toISOLocalExtended (), "2016-01-01T17:30:00", "Exclusion range[8].start() --> 2016-01-01T17:30:00");
t.is (ranges[8].end ().toISOLocalExtended (), "2016-01-02T00:00:00", "Exclusion range[8].end() --> 2016-01-02T00:00:00"); t.is (ranges[8].end.toISOLocalExtended (), "2016-01-02T00:00:00", "Exclusion range[8].end() --> 2016-01-02T00:00:00");
t.is (ranges[9].start ().toISOLocalExtended (), "2016-01-08T00:00:00", "Exclusion range[9].start() --> 2016-01-08T00:00:00"); t.is (ranges[9].start.toISOLocalExtended (), "2016-01-08T00:00:00", "Exclusion range[9].start() --> 2016-01-08T00:00:00");
t.is (ranges[9].end ().toISOLocalExtended (), "2016-01-08T08:00:00", "Exclusion range[9].end() --> 2016-01-08T08:00:00"); t.is (ranges[9].end.toISOLocalExtended (), "2016-01-08T08:00:00", "Exclusion range[9].end() --> 2016-01-08T08:00:00");
t.is (ranges[10].start ().toISOLocalExtended (), "2016-01-08T12:00:00", "Exclusion range[10].start() --> 2016-01-08T12:00:00"); t.is (ranges[10].start.toISOLocalExtended (), "2016-01-08T12:00:00", "Exclusion range[10].start() --> 2016-01-08T12:00:00");
t.is (ranges[10].end ().toISOLocalExtended (), "2016-01-08T12:45:00", "Exclusion range[10].end() --> 2016-01-08T12:45:00"); t.is (ranges[10].end.toISOLocalExtended (), "2016-01-08T12:45:00", "Exclusion range[10].end() --> 2016-01-08T12:45:00");
t.is (ranges[11].start ().toISOLocalExtended (), "2016-01-08T17:30:00", "Exclusion range[11].start() --> 2016-01-08T17:30:00"); t.is (ranges[11].start.toISOLocalExtended (), "2016-01-08T17:30:00", "Exclusion range[11].start() --> 2016-01-08T17:30:00");
t.is (ranges[11].end ().toISOLocalExtended (), "2016-01-09T00:00:00", "Exclusion range[11].end() --> 2016-01-09T00:00:00"); t.is (ranges[11].end.toISOLocalExtended (), "2016-01-09T00:00:00", "Exclusion range[11].end() --> 2016-01-09T00:00:00");
e.initialize ("exc saturday <8:00:00 12:00:00-12:45:00 >17:30:00"); e.initialize ("exc saturday <8:00:00 12:00:00-12:45:00 >17:30:00");
tokens = e.tokens (); tokens = e.tokens ();
@ -279,33 +279,33 @@ int main (int, char**)
ranges = e.ranges (r); ranges = e.ranges (r);
t.ok (ranges.size () == 12, "Exclusion ranges --> [12]"); t.ok (ranges.size () == 12, "Exclusion ranges --> [12]");
t.is (ranges[0].start ().toISOLocalExtended (), "2015-12-19T00:00:00", "Exclusion range[0].start() --> 2015-12-19T00:00:00"); t.is (ranges[0].start.toISOLocalExtended (), "2015-12-19T00:00:00", "Exclusion range[0].start() --> 2015-12-19T00:00:00");
t.is (ranges[0].end ().toISOLocalExtended (), "2015-12-19T08:00:00", "Exclusion range[0].end() --> 2015-12-19T08:00:00"); t.is (ranges[0].end.toISOLocalExtended (), "2015-12-19T08:00:00", "Exclusion range[0].end() --> 2015-12-19T08:00:00");
t.is (ranges[1].start ().toISOLocalExtended (), "2015-12-19T12:00:00", "Exclusion range[1].start() --> 2015-12-19T12:00:00"); t.is (ranges[1].start.toISOLocalExtended (), "2015-12-19T12:00:00", "Exclusion range[1].start() --> 2015-12-19T12:00:00");
t.is (ranges[1].end ().toISOLocalExtended (), "2015-12-19T12:45:00", "Exclusion range[1].end() --> 2015-12-19T12:45:00"); t.is (ranges[1].end.toISOLocalExtended (), "2015-12-19T12:45:00", "Exclusion range[1].end() --> 2015-12-19T12:45:00");
t.is (ranges[2].start ().toISOLocalExtended (), "2015-12-19T17:30:00", "Exclusion range[2].start() --> 2015-12-19T17:30:00"); t.is (ranges[2].start.toISOLocalExtended (), "2015-12-19T17:30:00", "Exclusion range[2].start() --> 2015-12-19T17:30:00");
t.is (ranges[2].end ().toISOLocalExtended (), "2015-12-20T00:00:00", "Exclusion range[2].end() --> 2015-12-20T00:00:00"); t.is (ranges[2].end.toISOLocalExtended (), "2015-12-20T00:00:00", "Exclusion range[2].end() --> 2015-12-20T00:00:00");
t.is (ranges[3].start ().toISOLocalExtended (), "2015-12-26T00:00:00", "Exclusion range[3].start() --> 2015-12-26T00:00:00"); t.is (ranges[3].start.toISOLocalExtended (), "2015-12-26T00:00:00", "Exclusion range[3].start() --> 2015-12-26T00:00:00");
t.is (ranges[3].end ().toISOLocalExtended (), "2015-12-26T08:00:00", "Exclusion range[3].end() --> 2015-12-26T08:00:00"); t.is (ranges[3].end.toISOLocalExtended (), "2015-12-26T08:00:00", "Exclusion range[3].end() --> 2015-12-26T08:00:00");
t.is (ranges[4].start ().toISOLocalExtended (), "2015-12-26T12:00:00", "Exclusion range[4].start() --> 2015-12-26T12:00:00"); t.is (ranges[4].start.toISOLocalExtended (), "2015-12-26T12:00:00", "Exclusion range[4].start() --> 2015-12-26T12:00:00");
t.is (ranges[4].end ().toISOLocalExtended (), "2015-12-26T12:45:00", "Exclusion range[4].end() --> 2015-12-26T12:45:00"); t.is (ranges[4].end.toISOLocalExtended (), "2015-12-26T12:45:00", "Exclusion range[4].end() --> 2015-12-26T12:45:00");
t.is (ranges[5].start ().toISOLocalExtended (), "2015-12-26T17:30:00", "Exclusion range[5].start() --> 2015-12-26T17:30:00"); t.is (ranges[5].start.toISOLocalExtended (), "2015-12-26T17:30:00", "Exclusion range[5].start() --> 2015-12-26T17:30:00");
t.is (ranges[5].end ().toISOLocalExtended (), "2015-12-27T00:00:00", "Exclusion range[5].end() --> 2015-12-27T00:00:00"); t.is (ranges[5].end.toISOLocalExtended (), "2015-12-27T00:00:00", "Exclusion range[5].end() --> 2015-12-27T00:00:00");
t.is (ranges[6].start ().toISOLocalExtended (), "2016-01-02T00:00:00", "Exclusion range[6].start() --> 2016-01-02T00:00:00"); t.is (ranges[6].start.toISOLocalExtended (), "2016-01-02T00:00:00", "Exclusion range[6].start() --> 2016-01-02T00:00:00");
t.is (ranges[6].end ().toISOLocalExtended (), "2016-01-02T08:00:00", "Exclusion range[6].end() --> 2016-01-02T08:00:00"); t.is (ranges[6].end.toISOLocalExtended (), "2016-01-02T08:00:00", "Exclusion range[6].end() --> 2016-01-02T08:00:00");
t.is (ranges[7].start ().toISOLocalExtended (), "2016-01-02T12:00:00", "Exclusion range[7].start() --> 2016-01-02T12:00:00"); t.is (ranges[7].start.toISOLocalExtended (), "2016-01-02T12:00:00", "Exclusion range[7].start() --> 2016-01-02T12:00:00");
t.is (ranges[7].end ().toISOLocalExtended (), "2016-01-02T12:45:00", "Exclusion range[7].end() --> 2016-01-02T12:45:00"); t.is (ranges[7].end.toISOLocalExtended (), "2016-01-02T12:45:00", "Exclusion range[7].end() --> 2016-01-02T12:45:00");
t.is (ranges[8].start ().toISOLocalExtended (), "2016-01-02T17:30:00", "Exclusion range[8].start() --> 2016-01-02T17:30:00"); t.is (ranges[8].start.toISOLocalExtended (), "2016-01-02T17:30:00", "Exclusion range[8].start() --> 2016-01-02T17:30:00");
t.is (ranges[8].end ().toISOLocalExtended (), "2016-01-03T00:00:00", "Exclusion range[8].end() --> 2016-01-03T00:00:00"); t.is (ranges[8].end.toISOLocalExtended (), "2016-01-03T00:00:00", "Exclusion range[8].end() --> 2016-01-03T00:00:00");
t.is (ranges[9].start ().toISOLocalExtended (), "2016-01-09T00:00:00", "Exclusion range[9].start() --> 2016-01-09T00:00:00"); t.is (ranges[9].start.toISOLocalExtended (), "2016-01-09T00:00:00", "Exclusion range[9].start() --> 2016-01-09T00:00:00");
t.is (ranges[9].end ().toISOLocalExtended (), "2016-01-09T08:00:00", "Exclusion range[9].end() --> 2016-01-09T08:00:00"); t.is (ranges[9].end.toISOLocalExtended (), "2016-01-09T08:00:00", "Exclusion range[9].end() --> 2016-01-09T08:00:00");
t.is (ranges[10].start ().toISOLocalExtended (), "2016-01-09T12:00:00", "Exclusion range[10].start() --> 2016-01-09T12:00:00"); t.is (ranges[10].start.toISOLocalExtended (), "2016-01-09T12:00:00", "Exclusion range[10].start() --> 2016-01-09T12:00:00");
t.is (ranges[10].end ().toISOLocalExtended (), "2016-01-09T12:45:00", "Exclusion range[10].end() --> 2016-01-09T12:45:00"); t.is (ranges[10].end.toISOLocalExtended (), "2016-01-09T12:45:00", "Exclusion range[10].end() --> 2016-01-09T12:45:00");
t.is (ranges[11].start ().toISOLocalExtended (), "2016-01-09T17:30:00", "Exclusion range[11].start() --> 2016-01-09T17:30:00"); t.is (ranges[11].start.toISOLocalExtended (), "2016-01-09T17:30:00", "Exclusion range[11].start() --> 2016-01-09T17:30:00");
t.is (ranges[11].end ().toISOLocalExtended (), "2016-01-10T00:00:00", "Exclusion range[11].end() --> 2016-01-10T00:00:00"); t.is (ranges[11].end.toISOLocalExtended (), "2016-01-10T00:00:00", "Exclusion range[11].end() --> 2016-01-10T00:00:00");
e.initialize ("exc sunday <8:00:00 12:00:00-12:45:00 >17:30:00"); e.initialize ("exc sunday <8:00:00 12:00:00-12:45:00 >17:30:00");
tokens = e.tokens (); tokens = e.tokens ();
@ -318,33 +318,33 @@ int main (int, char**)
ranges = e.ranges (r); ranges = e.ranges (r);
t.ok (ranges.size () == 12, "Exclusion ranges --> [12]"); t.ok (ranges.size () == 12, "Exclusion ranges --> [12]");
t.is (ranges[0].start ().toISOLocalExtended (), "2015-12-20T00:00:00", "Exclusion range[0].start() --> 2015-12-20T00:00:00"); t.is (ranges[0].start.toISOLocalExtended (), "2015-12-20T00:00:00", "Exclusion range[0].start() --> 2015-12-20T00:00:00");
t.is (ranges[0].end ().toISOLocalExtended (), "2015-12-20T08:00:00", "Exclusion range[0].end() --> 2015-12-20T08:00:00"); t.is (ranges[0].end.toISOLocalExtended (), "2015-12-20T08:00:00", "Exclusion range[0].end() --> 2015-12-20T08:00:00");
t.is (ranges[1].start ().toISOLocalExtended (), "2015-12-20T12:00:00", "Exclusion range[1].start() --> 2015-12-20T12:00:00"); t.is (ranges[1].start.toISOLocalExtended (), "2015-12-20T12:00:00", "Exclusion range[1].start() --> 2015-12-20T12:00:00");
t.is (ranges[1].end ().toISOLocalExtended (), "2015-12-20T12:45:00", "Exclusion range[1].end() --> 2015-12-20T12:45:00"); t.is (ranges[1].end.toISOLocalExtended (), "2015-12-20T12:45:00", "Exclusion range[1].end() --> 2015-12-20T12:45:00");
t.is (ranges[2].start ().toISOLocalExtended (), "2015-12-20T17:30:00", "Exclusion range[2].start() --> 2015-12-20T17:30:00"); t.is (ranges[2].start.toISOLocalExtended (), "2015-12-20T17:30:00", "Exclusion range[2].start() --> 2015-12-20T17:30:00");
t.is (ranges[2].end ().toISOLocalExtended (), "2015-12-21T00:00:00", "Exclusion range[2].end() --> 2015-12-21T00:00:00"); t.is (ranges[2].end.toISOLocalExtended (), "2015-12-21T00:00:00", "Exclusion range[2].end() --> 2015-12-21T00:00:00");
t.is (ranges[3].start ().toISOLocalExtended (), "2015-12-27T00:00:00", "Exclusion range[3].start() --> 2015-12-27T00:00:00"); t.is (ranges[3].start.toISOLocalExtended (), "2015-12-27T00:00:00", "Exclusion range[3].start() --> 2015-12-27T00:00:00");
t.is (ranges[3].end ().toISOLocalExtended (), "2015-12-27T08:00:00", "Exclusion range[3].end() --> 2015-12-27T08:00:00"); t.is (ranges[3].end.toISOLocalExtended (), "2015-12-27T08:00:00", "Exclusion range[3].end() --> 2015-12-27T08:00:00");
t.is (ranges[4].start ().toISOLocalExtended (), "2015-12-27T12:00:00", "Exclusion range[4].start() --> 2015-12-27T12:00:00"); t.is (ranges[4].start.toISOLocalExtended (), "2015-12-27T12:00:00", "Exclusion range[4].start() --> 2015-12-27T12:00:00");
t.is (ranges[4].end ().toISOLocalExtended (), "2015-12-27T12:45:00", "Exclusion range[4].end() --> 2015-12-27T12:45:00"); t.is (ranges[4].end.toISOLocalExtended (), "2015-12-27T12:45:00", "Exclusion range[4].end() --> 2015-12-27T12:45:00");
t.is (ranges[5].start ().toISOLocalExtended (), "2015-12-27T17:30:00", "Exclusion range[5].start() --> 2015-12-22717:30:00"); t.is (ranges[5].start.toISOLocalExtended (), "2015-12-27T17:30:00", "Exclusion range[5].start() --> 2015-12-22717:30:00");
t.is (ranges[5].end ().toISOLocalExtended (), "2015-12-28T00:00:00", "Exclusion range[5].end() --> 2015-12-28T00:00:00"); t.is (ranges[5].end.toISOLocalExtended (), "2015-12-28T00:00:00", "Exclusion range[5].end() --> 2015-12-28T00:00:00");
t.is (ranges[6].start ().toISOLocalExtended (), "2016-01-03T00:00:00", "Exclusion range[6].start() --> 2016-01-03T00:00:00"); t.is (ranges[6].start.toISOLocalExtended (), "2016-01-03T00:00:00", "Exclusion range[6].start() --> 2016-01-03T00:00:00");
t.is (ranges[6].end ().toISOLocalExtended (), "2016-01-03T08:00:00", "Exclusion range[6].end() --> 2016-01-03T08:00:00"); t.is (ranges[6].end.toISOLocalExtended (), "2016-01-03T08:00:00", "Exclusion range[6].end() --> 2016-01-03T08:00:00");
t.is (ranges[7].start ().toISOLocalExtended (), "2016-01-03T12:00:00", "Exclusion range[7].start() --> 2016-01-03T12:00:00"); t.is (ranges[7].start.toISOLocalExtended (), "2016-01-03T12:00:00", "Exclusion range[7].start() --> 2016-01-03T12:00:00");
t.is (ranges[7].end ().toISOLocalExtended (), "2016-01-03T12:45:00", "Exclusion range[7].end() --> 2016-01-03T12:45:00"); t.is (ranges[7].end.toISOLocalExtended (), "2016-01-03T12:45:00", "Exclusion range[7].end() --> 2016-01-03T12:45:00");
t.is (ranges[8].start ().toISOLocalExtended (), "2016-01-03T17:30:00", "Exclusion range[8].start() --> 2016-01-03T17:30:00"); t.is (ranges[8].start.toISOLocalExtended (), "2016-01-03T17:30:00", "Exclusion range[8].start() --> 2016-01-03T17:30:00");
t.is (ranges[8].end ().toISOLocalExtended (), "2016-01-04T00:00:00", "Exclusion range[8].end() --> 2016-01-04T00:00:00"); t.is (ranges[8].end.toISOLocalExtended (), "2016-01-04T00:00:00", "Exclusion range[8].end() --> 2016-01-04T00:00:00");
t.is (ranges[9].start ().toISOLocalExtended (), "2016-01-10T00:00:00", "Exclusion range[9].start() --> 2016-01-10T00:00:00"); t.is (ranges[9].start.toISOLocalExtended (), "2016-01-10T00:00:00", "Exclusion range[9].start() --> 2016-01-10T00:00:00");
t.is (ranges[9].end ().toISOLocalExtended (), "2016-01-10T08:00:00", "Exclusion range[9].end() --> 2016-01-10T08:00:00"); t.is (ranges[9].end.toISOLocalExtended (), "2016-01-10T08:00:00", "Exclusion range[9].end() --> 2016-01-10T08:00:00");
t.is (ranges[10].start ().toISOLocalExtended (), "2016-01-10T12:00:00", "Exclusion range[10].start() --> 2016-01-10T12:00:00"); t.is (ranges[10].start.toISOLocalExtended (), "2016-01-10T12:00:00", "Exclusion range[10].start() --> 2016-01-10T12:00:00");
t.is (ranges[10].end ().toISOLocalExtended (), "2016-01-10T12:45:00", "Exclusion range[10].end() --> 2016-01-10T12:45:00"); t.is (ranges[10].end.toISOLocalExtended (), "2016-01-10T12:45:00", "Exclusion range[10].end() --> 2016-01-10T12:45:00");
t.is (ranges[11].start ().toISOLocalExtended (), "2016-01-10T17:30:00", "Exclusion range[11].start() --> 2016-01-10T17:30:00"); t.is (ranges[11].start.toISOLocalExtended (), "2016-01-10T17:30:00", "Exclusion range[11].start() --> 2016-01-10T17:30:00");
t.is (ranges[11].end ().toISOLocalExtended (), "2016-01-11T00:00:00", "Exclusion range[11].end() --> 2016-01-11T00:00:00"); t.is (ranges[11].end.toISOLocalExtended (), "2016-01-11T00:00:00", "Exclusion range[11].end() --> 2016-01-11T00:00:00");
// exc day on 2016-01-01 // exc day on 2016-01-01
e.initialize ("exc day on 2016-01-01"); e.initialize ("exc day on 2016-01-01");
@ -357,8 +357,8 @@ int main (int, char**)
ranges = e.ranges (r); ranges = e.ranges (r);
t.ok (ranges.size () == 1, "Exclusion ranges --> [1]"); t.ok (ranges.size () == 1, "Exclusion ranges --> [1]");
t.is (ranges[0].start ().toString ("Y-M-D"), "2016-01-01", "Exclusion range[0].start() --> 2016-01-01"); t.is (ranges[0].start.toString ("Y-M-D"), "2016-01-01", "Exclusion range[0].start() --> 2016-01-01");
t.is (ranges[0].end ().toString ("Y-M-D"), "2016-01-02", "Exclusion range[0].end() --> 2016-01-02"); t.is (ranges[0].end.toString ("Y-M-D"), "2016-01-02", "Exclusion range[0].end() --> 2016-01-02");
t.ok (e.additive (), "Exclusion 'day on ...' --> additive"); t.ok (e.additive (), "Exclusion 'day on ...' --> additive");
// exc day off 2016-01-01 // exc day off 2016-01-01
@ -372,8 +372,8 @@ int main (int, char**)
ranges = e.ranges (r); ranges = e.ranges (r);
t.ok (ranges.size () == 1, "Exclusion ranges --> [1]"); t.ok (ranges.size () == 1, "Exclusion ranges --> [1]");
t.is (ranges[0].start ().toString ("Y-M-D"), "2016-01-01", "Exclusion range[0].start() --> 2016-01-01"); t.is (ranges[0].start.toString ("Y-M-D"), "2016-01-01", "Exclusion range[0].start() --> 2016-01-01");
t.is (ranges[0].end ().toString ("Y-M-D"), "2016-01-02", "Exclusion range[0].end() --> 2016-01-02"); t.is (ranges[0].end.toString ("Y-M-D"), "2016-01-02", "Exclusion range[0].end() --> 2016-01-02");
t.notok (e.additive (), "Exclusion 'day off ...' --> !additive"); t.notok (e.additive (), "Exclusion 'day off ...' --> !additive");
} }

24
test/interval.t.cpp
View file

@ -33,23 +33,23 @@ int main (int, char**)
{ {
UnitTest t (38); UnitTest t (38);
// bool isStarted () const; // bool started () const;
// bool isEnded () const; // bool ended () const;
Interval i1; Interval i1;
t.is (i1.empty (), true, "Interval().empty -> true"); t.is (i1.empty (), true, "Interval().empty -> true");
t.is (i1.isStarted (), false, "Interval().isStarted -> false"); t.is (i1.range.started (), false, "Interval().started -> false");
t.is (i1.isEnded (), false, "Interval().isEnded -> false"); t.is (i1.range.ended (), false, "Interval().ended -> false");
// void start (Datetime); // void start (Datetime);
i1.start (Datetime ()); i1.range.start = Datetime ();
t.is (i1.empty (), false, "Interval().empty -> false"); t.is (i1.empty (), false, "Interval().empty -> false");
t.is (i1.isStarted (), true, "Interval(start=now).isStarted -> true"); t.is (i1.range.started (), true, "Interval(start=now).started -> true");
t.is (i1.isEnded (), false, "Interval(start=now).isEnded -> false"); t.is (i1.range.ended (), false, "Interval(start=now).ended -> false");
// void end (Datetime); // void end (Datetime);
i1.end (Datetime ()); i1.range.end = Datetime ();
t.is (i1.isStarted (), true, "Interval(start=now,end=now).isStarted -> true"); t.is (i1.range.started (), true, "Interval(start=now,end=now).started -> true");
t.is (i1.isEnded (), true, "Interval(start=now,end=now).isEnded -> true"); t.is (i1.range.ended (), true, "Interval(start=now,end=now).ended -> true");
// std::set <std::string> tags () const; // std::set <std::string> tags () const;
// void tag (const std::string&); // void tag (const std::string&);
@ -73,9 +73,9 @@ int main (int, char**)
t.is (i3.serialize (), "inc # foo", "Interval().serialize -> 'inc # foo'"); t.is (i3.serialize (), "inc # foo", "Interval().serialize -> 'inc # foo'");
i3.tag ("bar"); i3.tag ("bar");
t.is (i3.serialize (), "inc # bar foo", "Interval().serialize -> 'inc # bar foo'"); t.is (i3.serialize (), "inc # bar foo", "Interval().serialize -> 'inc # bar foo'");
i3.start (Datetime(1)); i3.range.start = Datetime(1);
t.is (i3.serialize (), "inc 19700101T000001Z # bar foo", "Interval(Datetime(1)).serialize -> 'inc 19700101T000001Z # bar foo'"); t.is (i3.serialize (), "inc 19700101T000001Z # bar foo", "Interval(Datetime(1)).serialize -> 'inc 19700101T000001Z # bar foo'");
i3.end (Datetime(2)); i3.range.end = Datetime(2);
t.is (i3.serialize (), "inc 19700101T000001Z - 19700101T000002Z # bar foo", "Interval(Datetime(1)).serialize -> 'inc 19700101T000001Z - 19700101T000002Z # bar foo'"); t.is (i3.serialize (), "inc 19700101T000001Z - 19700101T000002Z # bar foo", "Interval(Datetime(1)).serialize -> 'inc 19700101T000001Z - 19700101T000002Z # bar foo'");
i3.tag ("Trans-Europe Express"); i3.tag ("Trans-Europe Express");
t.is (i3.serialize (), "inc 19700101T000001Z - 19700101T000002Z # \"Trans-Europe Express\" bar foo", "Interval(Datetime(1)).serialize -> 'inc 19700101T000001Z - 19700101T000002Z # \"Trans-Europe Express\" bar foo'"); t.is (i3.serialize (), "inc 19700101T000001Z - 19700101T000002Z # \"Trans-Europe Express\" bar foo", "Interval(Datetime(1)).serialize -> 'inc 19700101T000001Z - 19700101T000002Z # \"Trans-Europe Express\" bar foo'");

106
test/range.t.cpp
View file

@ -33,21 +33,21 @@ int main (int, char**)
{ {
UnitTest t (60); UnitTest t (60);
// bool isStarted () const; // bool started () const;
// bool isEnded () const; // bool ended () const;
Range i1; Range i1;
t.is (i1.isStarted (), false, "Range().isStarted -> false"); t.is (i1.started (), false, "Range().started -> false");
t.is (i1.isEnded (), false, "Range().isEnded -> false"); t.is (i1.ended (), false, "Range().ended -> false");
// void start (Datetime); // void start (Datetime);
i1.start (Datetime ()); i1.start = Datetime ();
t.is (i1.isStarted (), true, "Range(start=now).isStarted -> true"); t.is (i1.started (), true, "Range(start=now).started -> true");
t.is (i1.isEnded (), false, "Range(start=now).isEnded -> false"); t.is (i1.ended (), false, "Range(start=now).ended -> false");
// void end (Datetime); // void end (Datetime);
i1.end (Datetime ()); i1.end = Datetime ();
t.is (i1.isStarted (), true, "Range(start=now,end=now).isStarted -> true"); t.is (i1.started (), true, "Range(start=now,end=now).started -> true");
t.is (i1.isEnded (), true, "Range(start=now,end=now).isEnded -> true"); t.is (i1.ended (), true, "Range(start=now,end=now).ended -> true");
// this [--------) // this [--------)
// A [--------) // A [--------)
@ -60,18 +60,18 @@ int main (int, char**)
// H [... // H [...
// I [... // I [...
Range refClosed; Range refClosed;
refClosed.start (Datetime (6, 1, 2016)); refClosed.start = Datetime (6, 1, 2016);
refClosed.end (Datetime (6, 30, 2016)); refClosed.end = Datetime (6, 30, 2016);
Range testA; testA.start (Datetime (4, 1, 2016)); testA.end (Datetime (4, 30, 2016)); Range testA; testA.start = Datetime (4, 1, 2016); testA.end = Datetime (4, 30, 2016);
Range testB; testB.start (Datetime (5, 15, 2016)); testB.end (Datetime (6, 15, 2016)); Range testB; testB.start = Datetime (5, 15, 2016); testB.end = Datetime (6, 15, 2016);
Range testC; testC.start (Datetime (6, 10, 2016)); testC.end (Datetime (6, 20, 2016)); Range testC; testC.start = Datetime (6, 10, 2016); testC.end = Datetime (6, 20, 2016);
Range testD; testD.start (Datetime (6, 15, 2016)); testD.end (Datetime (7, 15, 2016)); Range testD; testD.start = Datetime (6, 15, 2016); testD.end = Datetime (7, 15, 2016);
Range testE; testE.start (Datetime (8, 1, 2016)); testE.end (Datetime (8, 31, 2016)); Range testE; testE.start = Datetime (8, 1, 2016); testE.end = Datetime (8, 31, 2016);
Range testF; testF.start (Datetime (5, 15, 2016)); testF.end (Datetime (7, 15, 2016)); Range testF; testF.start = Datetime (5, 15, 2016); testF.end = Datetime (7, 15, 2016);
Range testG; testG.start (Datetime (5, 15, 2016)); Range testG; testG.start = Datetime (5, 15, 2016);
Range testH; testH.start (Datetime (6, 15, 2016)); Range testH; testH.start = Datetime (6, 15, 2016);
Range testI; testI.start (Datetime (7, 15, 2016)); Range testI; testI.start = Datetime (7, 15, 2016);
t.notok (refClosed.overlap (testA), "Range: ! refClosed.overlap(testA)"); t.notok (refClosed.overlap (testA), "Range: ! refClosed.overlap(testA)");
t.ok (refClosed.overlap (testB), "Range: refClosed.overlap(testB)"); t.ok (refClosed.overlap (testB), "Range: refClosed.overlap(testB)");
@ -94,7 +94,7 @@ int main (int, char**)
// H [... // H [...
// I [... // I [...
Range refOpen; Range refOpen;
refOpen.start (Datetime (6, 1, 2016)); refOpen.start = Datetime (6, 1, 2016);
t.notok (refOpen.overlap (testA), "Range: ! refOpen.overlap(testA)"); t.notok (refOpen.overlap (testA), "Range: ! refOpen.overlap(testA)");
t.ok (refOpen.overlap (testB), "Range: refOpen.overlap(testB)"); t.ok (refOpen.overlap (testB), "Range: refOpen.overlap(testB)");
@ -118,13 +118,13 @@ int main (int, char**)
// I [... // I [...
Range empty; Range empty;
t.ok (refClosed.intersect (testA) == empty, "Range: refClosed.intersect(testA) == empty"); t.ok (refClosed.intersect (testA) == empty, "Range: refClosed.intersect(testA) == empty");
t.ok (refClosed.intersect (testB) == Range (refClosed.start (), testB.end ()), "Range: refClosed.intersect(testB) == Range(refClosed.start(),testB.end())"); t.ok (refClosed.intersect (testB) == Range (refClosed.start, testB.end), "Range: refClosed.intersect(testB) == Range(refClosed.start,testB.end)");
t.ok (refClosed.intersect (testC) == testC, "Range: refClosed.intersect(testB) == testC"); t.ok (refClosed.intersect (testC) == testC, "Range: refClosed.intersect(testB) == testC");
t.ok (refClosed.intersect (testD) == Range (testD.start (), refClosed.end ()), "Range: refClosed.intersect(testB) == Range(testD.start(),refClosed.end())"); t.ok (refClosed.intersect (testD) == Range (testD.start, refClosed.end), "Range: refClosed.intersect(testB) == Range(testD.start,refClosed.end)");
t.ok (refClosed.intersect (testE) == empty, "Range: refClosed.intersect(testE) == empty"); t.ok (refClosed.intersect (testE) == empty, "Range: refClosed.intersect(testE) == empty");
t.ok (refClosed.intersect (testF) == refClosed, "Range: refClosed.intersect(testF) == refClosed"); t.ok (refClosed.intersect (testF) == refClosed, "Range: refClosed.intersect(testF) == refClosed");
t.ok (refClosed.intersect (testG) == refClosed, "Range: refClosed.intersect(testG) == refClosed"); t.ok (refClosed.intersect (testG) == refClosed, "Range: refClosed.intersect(testG) == refClosed");
t.ok (refClosed.intersect (testH) == Range (testH.start (), refClosed.end ()), "Range: refClosed.intersect(testH) == Range(testH.start(),refClosed.end())"); t.ok (refClosed.intersect (testH) == Range (testH.start, refClosed.end), "Range: refClosed.intersect(testH) == Range(testH.start,refClosed.end)");
t.ok (refClosed.intersect (testI) == empty, "Range: refClosed.intersect(testI) == empty"); t.ok (refClosed.intersect (testI) == empty, "Range: refClosed.intersect(testI) == empty");
// this [... // this [...
@ -138,11 +138,11 @@ int main (int, char**)
// H [... // H [...
// I [... // I [...
t.ok (refOpen.intersect (testA) == empty, "Range: refOpen.intersect(testA) == empty"); t.ok (refOpen.intersect (testA) == empty, "Range: refOpen.intersect(testA) == empty");
t.ok (refOpen.intersect (testB) == Range (refOpen.start (), testB.end ()), "Range: refOpen.intersect(testB) == Range(refOpen.start(),testB.end())"); t.ok (refOpen.intersect (testB) == Range (refOpen.start, testB.end), "Range: refOpen.intersect(testB) == Range(refOpen.start,testB.end)");
t.ok (refOpen.intersect (testC) == testC, "Range: refOpen.intersect(testC) == testC"); t.ok (refOpen.intersect (testC) == testC, "Range: refOpen.intersect(testC) == testC");
t.ok (refOpen.intersect (testD) == testD, "Range: refOpen.intersect(testD) == testD"); t.ok (refOpen.intersect (testD) == testD, "Range: refOpen.intersect(testD) == testD");
t.ok (refOpen.intersect (testE) == testE, "Range: refOpen.intersect(testE) == testE"); t.ok (refOpen.intersect (testE) == testE, "Range: refOpen.intersect(testE) == testE");
t.ok (refOpen.intersect (testF) == Range (refOpen.start (), testF.end ()), "Range: refOpen.intersect(testF) == Range(refOpen.start(),testF.end()"); t.ok (refOpen.intersect (testF) == Range (refOpen.start, testF.end), "Range: refOpen.intersect(testF) == Range(refOpen.start,testF.end");
t.ok (refOpen.intersect (testG) == refOpen, "Range: refOpen.intersect(testG) == refOpen"); t.ok (refOpen.intersect (testG) == refOpen, "Range: refOpen.intersect(testG) == refOpen");
t.ok (refOpen.intersect (testH) == testH, "Range: refOpen.intersect(testH) == testH"); t.ok (refOpen.intersect (testH) == testH, "Range: refOpen.intersect(testH) == testH");
t.ok (refOpen.intersect (testI) == testI, "Range: refOpen.intersect(testI) == testI"); t.ok (refOpen.intersect (testI) == testI, "Range: refOpen.intersect(testI) == testI");
@ -158,24 +158,24 @@ int main (int, char**)
// H [... // H [...
// I [... // I [...
std::vector <Range> closedSubtractA {refClosed}; std::vector <Range> closedSubtractA {refClosed};
std::vector <Range> closedSubtractB {Range (testB.end (), refClosed.end ())}; std::vector <Range> closedSubtractB {Range (testB.end, refClosed.end)};
std::vector <Range> closedSubtractC {Range (refClosed.start (), testC.start ()), Range (testC.end (), refClosed.end ())}; std::vector <Range> closedSubtractC {Range (refClosed.start, testC.start), Range (testC.end, refClosed.end)};
std::vector <Range> closedSubtractD {Range (refClosed.start (), testD.start ())}; std::vector <Range> closedSubtractD {Range (refClosed.start, testD.start)};
std::vector <Range> closedSubtractE {refClosed}; std::vector <Range> closedSubtractE {refClosed};
std::vector <Range> closedSubtractF {}; std::vector <Range> closedSubtractF {};
std::vector <Range> closedSubtractG {}; std::vector <Range> closedSubtractG {};
std::vector <Range> closedSubtractH {Range (refClosed.start (), testH.start ())}; std::vector <Range> closedSubtractH {Range (refClosed.start, testH.start)};
std::vector <Range> closedSubtractI {refClosed}; std::vector <Range> closedSubtractI {refClosed};
t.ok (refClosed.subtract (testA) == closedSubtractA, "Range: refClosed.subtract(testA) == {refClosed}"); t.ok (refClosed.subtract (testA) == closedSubtractA, "Range: refClosed.subtract(testA) == {refClosed}");
t.ok (refClosed.subtract (testB) == closedSubtractB, "Range: refClosed.subtract(testB) == {Range(testB.end(),refClosed.end())}"); t.ok (refClosed.subtract (testB) == closedSubtractB, "Range: refClosed.subtract(testB) == {Range(testB.end,refClosed.end)}");
t.ok (refClosed.subtract (testC) == closedSubtractC, "Range: refClosed.subtract(testC) == {Range(refClosed.start(),testC.start())," t.ok (refClosed.subtract (testC) == closedSubtractC, "Range: refClosed.subtract(testC) == {Range(refClosed.start,testC.start),"
"Range(testC.end(),refClosed.end()}"); "Range(testC.end,refClosed.end}");
t.ok (refClosed.subtract (testD) == closedSubtractD, "Range: refClosed.subtract(testD) == {Range(refClosed.start(),testD.start())}"); t.ok (refClosed.subtract (testD) == closedSubtractD, "Range: refClosed.subtract(testD) == {Range(refClosed.start,testD.start)}");
t.ok (refClosed.subtract (testE) == closedSubtractE, "Range: refClosed.subtract(testE) == {refClosed}"); t.ok (refClosed.subtract (testE) == closedSubtractE, "Range: refClosed.subtract(testE) == {refClosed}");
t.ok (refClosed.subtract (testF) == closedSubtractF, "Range: refClosed.subtract(testF) == {}"); t.ok (refClosed.subtract (testF) == closedSubtractF, "Range: refClosed.subtract(testF) == {}");
t.ok (refClosed.subtract (testG) == closedSubtractG, "Range: refClosed.subtract(testG) == {}"); t.ok (refClosed.subtract (testG) == closedSubtractG, "Range: refClosed.subtract(testG) == {}");
t.ok (refClosed.subtract (testH) == closedSubtractH, "Range: refClosed.subtract(testH) == {refClosed.start(),testH.start()}"); t.ok (refClosed.subtract (testH) == closedSubtractH, "Range: refClosed.subtract(testH) == {refClosed.start,testH.start}");
t.ok (refClosed.subtract (testI) == closedSubtractI, "Range: refClosed.subtract(testI) == {refClosed}"); t.ok (refClosed.subtract (testI) == closedSubtractI, "Range: refClosed.subtract(testI) == {refClosed}");
// this [... // this [...
@ -189,27 +189,27 @@ int main (int, char**)
// H [... // H [...
// I [... // I [...
std::vector <Range> openSubtractA {refOpen}; std::vector <Range> openSubtractA {refOpen};
std::vector <Range> openSubtractB {Range (testB.end (), refOpen.end ())}; std::vector <Range> openSubtractB {Range (testB.end, refOpen.end)};
std::vector <Range> openSubtractC {Range (refOpen.start (), testC.start ()), Range (testC.end (), refOpen.end ())}; std::vector <Range> openSubtractC {Range (refOpen.start, testC.start), Range (testC.end, refOpen.end)};
std::vector <Range> openSubtractD {Range (refOpen.start (), testD.start ()), Range (testD.end (), refOpen.end ())}; std::vector <Range> openSubtractD {Range (refOpen.start, testD.start), Range (testD.end, refOpen.end)};
std::vector <Range> openSubtractE {Range (refOpen.start (), testE.start ()), Range (testE.end (), refOpen.end ())}; std::vector <Range> openSubtractE {Range (refOpen.start, testE.start), Range (testE.end, refOpen.end)};
std::vector <Range> openSubtractF {Range (testF.end (), refOpen.end ())}; std::vector <Range> openSubtractF {Range (testF.end, refOpen.end)};
std::vector <Range> openSubtractG {}; std::vector <Range> openSubtractG {};
std::vector <Range> openSubtractH {Range (refOpen.start (), testH.start ())}; std::vector <Range> openSubtractH {Range (refOpen.start, testH.start)};
std::vector <Range> openSubtractI {Range (refOpen.start (), testI.start ())}; std::vector <Range> openSubtractI {Range (refOpen.start, testI.start)};
t.ok (refOpen.subtract (testA) == openSubtractA, "Range: refOpen.subtract(testA) == {refOpen}"); t.ok (refOpen.subtract (testA) == openSubtractA, "Range: refOpen.subtract(testA) == {refOpen}");
t.ok (refOpen.subtract (testB) == openSubtractB, "Range: refOpen.subtract(testB) == {Range(testB.end(),refOpen.end()}"); t.ok (refOpen.subtract (testB) == openSubtractB, "Range: refOpen.subtract(testB) == {Range(testB.end,refOpen.end}");
t.ok (refOpen.subtract (testC) == openSubtractC, "Range: refOpen.subtract(testC) == {Range(refOpen.start(),testC.start())," t.ok (refOpen.subtract (testC) == openSubtractC, "Range: refOpen.subtract(testC) == {Range(refOpen.start,testC.start),"
"Range(testC.end(),refOpen.end()}"); "Range(testC.end,refOpen.end}");
t.ok (refOpen.subtract (testD) == openSubtractD, "Range: refOpen.subtract(testD) == {Range(refOpen.start(),testD.start())," t.ok (refOpen.subtract (testD) == openSubtractD, "Range: refOpen.subtract(testD) == {Range(refOpen.start,testD.start),"
"Range(testD.end(),refOpen.end()}"); "Range(testD.end,refOpen.end}");
t.ok (refOpen.subtract (testE) == openSubtractE, "Range: refOpen.subtract(testE) == {Range(refOpen.start(),testE.start())," t.ok (refOpen.subtract (testE) == openSubtractE, "Range: refOpen.subtract(testE) == {Range(refOpen.start,testE.start),"
"Range(testE.end(),refOpen.end()}"); "Range(testE.end,refOpen.end}");
t.ok (refOpen.subtract (testF) == openSubtractF, "Range: refOpen.subtract(testF) == {Range(testF.end(),refOpen.end()}"); t.ok (refOpen.subtract (testF) == openSubtractF, "Range: refOpen.subtract(testF) == {Range(testF.end,refOpen.end}");
t.ok (refOpen.subtract (testG) == openSubtractG, "Range: refOpen.subtract(testG) == {}"); t.ok (refOpen.subtract (testG) == openSubtractG, "Range: refOpen.subtract(testG) == {}");
t.ok (refOpen.subtract (testH) == openSubtractH, "Range: refOpen.subtract(testH) == {Range(refOpen.start(),testH.start()}"); t.ok (refOpen.subtract (testH) == openSubtractH, "Range: refOpen.subtract(testH) == {Range(refOpen.start,testH.start}");
t.ok (refOpen.subtract (testI) == openSubtractI, "Range: refOpen.subtract(testI) == {Range(refOpen.start(),testI.start()}"); t.ok (refOpen.subtract (testI) == openSubtractI, "Range: refOpen.subtract(testI) == {Range(refOpen.start,testI.start}");
return 0; return 0;
} }