GothenburgBitFactory/timewarrior
1
0
Fork 0
mirror of https://github.com/GothenburgBitFactory/timewarrior.git synced 2025-07-07 20:06:39 +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.
validateAddition (interval);
auto intervalRange = interval.range ();
auto intervalRange = interval.range;
for (auto& segment : segmentRange (intervalRange))
{
// Get the index into _files for the appropriate Datafile, which may be
// 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.
Interval segmentedInterval (interval);
segmentedInterval.range (intervalRange.intersect (segment));
if (! interval.isEnded ())
segmentedInterval.end ({0});
segmentedInterval.range = intervalRange.intersect (segment);
if (! interval.range.ended ())
segmentedInterval.range.end = Datetime (0);
_files[df].addInterval (segmentedInterval);
}
@ -132,18 +132,18 @@ void Database::addInterval (const Interval& interval)
////////////////////////////////////////////////////////////////////////////////
void Database::deleteInterval (const Interval& interval)
{
auto intervalRange = interval.range ();
auto intervalRange = interval.range;
for (auto& segment : segmentRange (intervalRange))
{
// Get the index into _files for the appropriate Datafile, which may be
// 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.
Interval segmentedInterval (interval);
segmentedInterval.range (intervalRange.intersect (segment));
if (! interval.isEnded ())
segmentedInterval.end ({0});
segmentedInterval.range = intervalRange.intersect (segment);
if (! interval.range.ended ())
segmentedInterval.range.end = Datetime (0);
_files[df].deleteInterval (segmentedInterval);
}
@ -218,10 +218,10 @@ std::vector <Range> Database::segmentRange (const Range& range)
{
std::vector <Range> segments;
auto start_y = range.start ().year ();
auto start_m = range.start ().month ();
auto start_y = range.start.year ();
auto start_m = range.start.month ();
auto end = range.end ();
auto end = range.end;
if (end.toEpoch () == 0)
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.
// Note: end date might be zero.
if (_range.overlap (interval.range ()))
if (_range.overlap (interval.range))
{
if (! _lines_loaded)
load_lines ();
@ -125,7 +125,7 @@ void Datafile::deleteInterval (const Interval& interval)
{
// Return false if the interval does not belong in this file.
// Note: end date might be zero.
if (_range.overlap (interval.range ()))
if (_range.overlap (interval.range))
{
if (! _lines_loaded)
load_lines ();
@ -174,8 +174,8 @@ std::string Datafile::dump () const
<< " lines: " << _lines.size () << "\n"
<< " loaded " << (_lines_loaded ? "true" : "false") << "\n"
<< " exclusions: " << _exclusions.size () << "\n"
<< " range: " << _range.start ().toISO () << " - "
<< _range.end ().toISO () << "\n";
<< " range: " << _range.start.toISO () << " - "
<< _range.end.toISO () << "\n";
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)
{
Datetime start = range.start ();
while (start < range.end ())
Datetime start = range.start;
while (start < range.end)
{
if (start.dayOfWeek () == dayOfWeek)
{

80
src/Interval.cpp
View file

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

16
src/Interval.h
View file

@ -38,18 +38,6 @@ public:
void initialize (const std::string&);
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;
std::set <std::string> tags () const;
void tag (const std::string&);
@ -58,8 +46,10 @@ public:
std::string serialize () const;
std::string json () const;
public:
Range range {};
private:
Range _range {};
std::set <std::string> _tags {};
};

91
src/Range.cpp
View file

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

16
src/Range.h
View file

@ -37,23 +37,17 @@ public:
Range (const Datetime&, const Datetime&);
bool operator== (const Range&) const;
Datetime start () const;
void start (const Datetime&);
Datetime end () const;
void end (const Datetime&);
bool isStarted () const;
bool isEnded () const;
bool started () const;
bool ended () const;
bool overlap (const Range&) const;
Range intersect (const Range&) const;
std::vector <Range> subtract (const Range&) const;
std::string dump () const;
private:
Datetime _start {0};
Datetime _end {0};
public:
Datetime start {0};
Datetime end {0};
};
#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.
// If no range is defined, then assume the full range of all the inclusions.
Range overallRange {_range};
if (! overallRange.isStarted () &&
! overallRange.isEnded ())
if (! overallRange.started () &&
! overallRange.ended ())
overallRange = overallRangeFromIntervals (_inclusions);
// Cobmine all the non-trackable time.
@ -83,7 +83,7 @@ std::vector <Interval> Timeline::tracked (Rules& rules) const
std::vector <Interval> combined;
for (auto& interval : _inclusions)
{
std::vector <Range> intervalFragments {interval.range ()};
std::vector <Range> intervalFragments {interval.range};
for (auto& exclusion : nonTrackable)
{
@ -99,7 +99,7 @@ std::vector <Interval> Timeline::tracked (Rules& rules) const
{
// Clone the interval, set the new range.
Interval clipped {interval};
clipped.range (fragment);
clipped.range = fragment;
combined.push_back (clipped);
}
}

8
src/commands/CmdContinue.cpp
View file

@ -37,12 +37,12 @@ int CmdContinue (
auto latest = getLatestInterval (database);
if (! latest.empty ())
{
if (latest.isStarted () &&
latest.isEnded ())
if (latest.range.started () &&
latest.range.ended ())
{
// Open an identical interval.
latest.start ({});
latest.end ({0});
latest.range.start = Datetime ();
latest.range.end = Datetime (0);
// Update database.
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.
auto interval = getLatestInterval (database);
if (interval.isStarted () && ! interval.isEnded ())
if (interval.range.started () && ! interval.range.ended ())
{
if (rules.getBoolean ("verbose"))
std::cout << intervalSummarize (rules, interval);

4
src/commands/CmdReport.cpp
View file

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

9
src/commands/CmdStart.cpp
View file

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

11
src/commands/CmdStop.cpp
View file

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