aboutsummaryrefslogtreecommitdiff
path: root/src/time.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/time.cpp')
-rwxr-xr-xsrc/time.cpp574
1 files changed, 0 insertions, 574 deletions
diff --git a/src/time.cpp b/src/time.cpp
deleted file mode 100755
index 0aa7bd0..0000000
--- a/src/time.cpp
+++ /dev/null
@@ -1,574 +0,0 @@
-#include "time.h"
-
-// Look. listen here. There's no way I'm going to start taking DST into account.
-// DST transition times are decided using skull dice, by the grand wizards of the state.
-// The fact that DST is designed this way, though,
-// makes it so you are unlikely to be on the clock during a DST transition.
-
-
-//
-// --- OPERATOR OVERLOADS ---
-//
-
-long long sortable_time(const moment input_moment) {
- return stoll(std::to_string(input_moment.year)+
- padint(input_moment.month,2)+
- padint(input_moment.day,2)+
- padint(input_moment.hours,2)+
- padint(input_moment.minutes,2));
-}
-
-bool moment::operator<(const moment& other) const{
- return bool(sortable_time(*this) < sortable_time(other));
-}
-
-bool moment::operator>(const moment& other) const{
- return bool(sortable_time(*this) > sortable_time(other));
-}
-
-bool moment::operator==(const moment& other) const {
- return bool(year==other.year &&
- month==other.month &&
- day==other.day &&
- hours==other.hours &&
- minutes==other.minutes);
-}
-
-bool moment::operator<=(const moment& other) const {
- return bool((*this < other) || *this == other);
-}
-
-bool moment::operator>=(const moment& other) const {
- return bool((*this > other) || *this == other);
-}
-
-bool moment::operator!=(const moment& other) const {
- return bool(year!=other.year ||
- month!=other.month ||
- day!=other.day ||
- hours!=other.hours ||
- minutes!=other.minutes);
-}
-moment moment::operator+(const delta& other) const {
- moment output{*this};
- wind(output, other.minutes, other.hours, other.days);
- return output;
-}
-moment moment::operator-(const delta& other) const {
- moment output{*this};
- wind(output, other.minutes*-1, other.hours*-1, other.days*-1);
- return output;
-}
-
-delta moment::operator-(const moment& other) const {
- // Uses what I call an accumulator-decumulator design
- // Count how long it takes to approach a benchmark,
- // and that count is the difference
-
- if(*this==other) return{0,0,0};
- delta accumulator{0,0,0};
-
- // smallest operand becomes benchmark to approach
- const bool reverse{*this<other};
- const moment& benchmark = reverse? *this : other;
- moment decumulator = reverse? other : *this;
-
- // It is possible to write something that does this in months at a time, instead of days,
- // which would be faster, but I am not expecting to have to do this with such
- // long periods of time, so screw that.
- while(decumulator.year - benchmark.year > 1 ||
- decumulator.month - benchmark.month > 1 ||
- decumulator.day - benchmark.day > 1) {
- wind(decumulator, 0, 0, -1);
- accumulator.days++;
- }
-
- while(decumulator.hours - benchmark.hours > 1) {
- wind(decumulator, 0, -1, 0);
- accumulator.hours++;
- }
- while(accumulator.hours > 23) {
- accumulator.hours -= 24;
- accumulator.days++;
- }
-
- while(decumulator != benchmark) {
- wind(decumulator, -1, 0, 0);
- accumulator.minutes++;
- }
- while(accumulator.minutes > 59) {
- accumulator.minutes -= 60;
- accumulator.hours++;
- }
-
- return accumulator;
-}
-
-std::ostream& operator<<(std::ostream& stream, const delta& other) {
- if(other.days==0 && other.hours==0 && other.minutes==0){
- stream << "None.";
- return stream;
- }
- if(other.days) stream << other.days << " days, ";
- if(other.hours) stream << other.hours << " hours, ";
- if(other.minutes) stream << other.minutes << " minutes.";
- return stream;
-}
-
-
-//
-// --- CONSTRUCTORS ---
-//
-
-workday::workday(const moment& previous_wrap,
- const moment& calltime,
- const moment& wraptime,
- const moment& planned_wraptime) {
- call = calltime;
- wrap = wraptime;
- planned_wrap = planned_wraptime;
- timeblock initial_block{call,
- std::max(
- // Paragraph 6.7 says that up to 2 hours of unused warned overtime counts as worktime,
- // though so that at least one hour of the unused overtime is not counted.
- // (It's unclear if an 8-hour day that ends 3 hours in counts as having 5 hours of unused overtime)
- std::clamp(planned_wrap-(delta){0, 1, 0}, wraptime, planned_wraptime+(delta){0, 2, 0}),
- call+(delta){0, 4, 0})};
- // ^ Minimum 4 hour day ^
-
- const int sp_length = 11;
- moment splitpoints[sp_length]{ // --$-- Points where the price may change --$-- //
-
- // NOTE: Maybe this should also contain the valuefactor associated with the split.
- // Probably the valuefactor leading up to the splitpoint, not the one after.
- // Maybe this should be a struct?
- // Or maybe I should just implement this badly at first just to get it working, and replace it later?
-
- previous_wrap+(delta){0, 10, 0}, // Sleepbreach, 10 hours after previous wrap 0x
- (moment){0, 5, call.day, call.month, call.year}, // 2 hours before 7, aka 5 1x
- (moment){0, 6, call.day, call.month, call.year}, // 6 in the morning 2x
- call+(delta){0, 8, 0}, // Normal 8 hours of work 3x
- call+(delta){0, 9, 0}, // 1st hour of overtime is over 4x
- call+(delta){0, 11, 0}, // 3st hour of overtime is over 5x
- planned_wraptime, // End of warned overtime 6x
- call+(delta){0, 14, 0}, // The 14-hour mark 7x
- (moment){0, 22, call.day, call.month, call.year}, // 22:00 in the evening 8x
- (moment){0, 23, call.day, call.month, call.year}+(delta){0, 1, 0}, // Midnight 9x
- (moment){0, 23, call.day, call.month, call.year}+(delta){0, 7, 0}, // 6, next morning 10x
- };
-
- // Eliminate planned wrap, if it occurs within normal 8-hour period.
- // This is to make sure the first period of time becomes a pure 8 hours,
- // which makes detecting the main section of the workday easier.
- if(splitpoints[6] < splitpoints[3]){
- splitpoints[6] = splitpoints[3];
- }
-
- moment splitpoints_sorted[sp_length];
- std::copy(splitpoints, splitpoints+sp_length, splitpoints_sorted);
- std::sort(splitpoints_sorted, splitpoints_sorted + sp_length);
-
- int j = 0;
- for(int i = 0; i<sp_length; i++) {
- const moment* each_moment = &splitpoints_sorted[i];
- //std::cout << "Splitting: " << timeprint(*each_moment) << "\t\tJ: " << j << "\t\tI: " << i << std::endl;
- // If each splitpoint moment is within the workday, and is not equal to the start of the current block
- if(*each_moment > call && *each_moment < wrap && *each_moment != initial_block.start) {
- blocks[j++] = timesplit(initial_block, *each_moment);
- }
- }
-
- blocks[j++] = initial_block;
- total_timeblocks = j;
-
- // THE VALUE-FACTOR CALCULATION PART
-
- // TODO: Consider replacing splitpoints[x] with redoing the math for code flexibility?
-
- for(int ii=0; ii < total_timeblocks; ii++){
- timeblock& each_block = blocks[ii];
- //std::cout << "pricing: " << timeprint(each_block) << std::endl;
-
- if(each_block.end <= splitpoints[0]) each_block.upvalue(3, "Sleep-breach"); // +200% for sleep-breach
- if(each_block.start.hours >= 22) each_block.upvalue(2, "Night"); // Work between 22:00
- if((each_block.end.hours == 6 && each_block.end.minutes == 0) ||// And 06:00
- (each_block.end.hours <= 5)) each_block.upvalue(2, "Night"); // is +100%
- if(each_block.start >= splitpoints[3]) {each_block.upvalue(1.5, "Overtime"); // Overtime
- if(each_block.start.getweekday() == saturday) each_block.upvalue(2, "Saturday overtime");// on saturdays
- }
- if(each_block.start >= splitpoints[5]) each_block.upvalue(2, "Overtime"); // End of 3-hour cheap planned overtime
- if(each_block.start >= planned_wraptime && // Unwarned overtime
- each_block.start >= splitpoints[4]) each_block.upvalue(2, "Overtime"); // +100% after first hour
- if(each_block.start >= splitpoints[7]) each_block.upvalue(3, "Far overtime"); // +200% beyond 14-hour mark
- if(each_block.start.getweekday() == saturday) each_block.upvalue(1.5, "Saturday");// Saturdays are +50%
- if(each_block.start.getweekday() == sunday) each_block.upvalue(2, "Sunday"); // Sundays are +100%
-
- if(!(call < (moment){0, 7, call.day, call.month, call.year} && // On an offset day...
- std::min(call+(delta){0,8,0}, wrap) < (moment){0,17,call.day,call.month,call.year})) {
- // This was added for rule 6.11c, but in a world without a defined normal workday,
- // that rule is already covered already by 6.11g, so this is empty.
- }
-
- // Holidays!
- if(each_block.start.day==1 && each_block.start.month==1) each_block.upvalue(2, "New year");
- if(each_block.start.day==1 && each_block.start.month==5) each_block.upvalue(2, "1st of May");
- if(each_block.start.day==17 && each_block.start.month==5) each_block.upvalue(2, "17st of May");
- if((each_block.start.day==25 || each_block.start.day==26) && each_block.start.month==12)
- each_block.upvalue(2, "Christmas");
- moment easter = gaussEaster(each_block.start.year);
- if(each_block.start.day == (easter-(delta){0,0,3}).day &&
- each_block.start.month == (easter-(delta){0,0,3}).month) each_block.upvalue(2, "Maundy Thursday");
- if(each_block.start.day == (easter-(delta){0,0,2}).day &&
- each_block.start.month == (easter-(delta){0,0,2}).month) each_block.upvalue(2, "Good Friday");
- if(each_block.start.day == easter.day && each_block.start.month == easter.month) each_block.upvalue(2, "Easter");
- if(each_block.start.day == (easter+(delta){0,0,1}).day &&
- each_block.start.month == (easter+(delta){0,0,1}).month) each_block.upvalue(2, "Easter");
- if(each_block.start.day == (easter+(delta){0,0,39}).day &&
- each_block.start.month == (easter+(delta){0,0,39}).month) each_block.upvalue(2, "Feast of the Ascension");
- if(each_block.start.day == (easter+(delta){0,0,49}).day &&
- each_block.start.month == (easter+(delta){0,0,49}).month) each_block.upvalue(2, "Pentecost");
- if(each_block.start.day == (easter+(delta){0,0,50}).day &&
- each_block.start.month == (easter+(delta){0,0,50}).month) each_block.upvalue(2, "Pentecost Monday");
- }
-
-}
-
-void workday::lunch(const moment& lunch_start, const moment& lunch_end) {
- if(lunch_start > lunch_end){
- std::cout << "ERROR: Lunch ends before it began." << std::endl;
- }
- for(int ii=0; ii < total_timeblocks; ii++){
- timeblock& each_block = blocks[ii];
- timeblock& next_block = blocks[ii+1]; // FIXME: On final loop, next_block will be garbage data
-
- if(each_block.start < lunch_start && each_block.end > lunch_end){
- // If lunch simply occurs within a timeblock
- // Split out the section, discarding the middle
- timeblock first_half = timesplit(each_block, lunch_start);
- each_block.start = lunch_end;
- // Move all points after lunch out by 1
- for(int x=total_timeblocks; x>=ii; x--) {
- blocks[x+1] = blocks[x];
- }
- total_timeblocks++;
- // Re-insert second half of split section into ii+1
- blocks[ii] = first_half;
- return;
-
- } else if(ii!=total_timeblocks-1 && each_block.start < lunch_start && lunch_start < each_block.end &&
- next_block.start < lunch_end && lunch_end < next_block.end) {
- // If we're not on the final block AND
- // If lunch occurs between two timeblocks
- each_block.end = lunch_start;
- next_block.start = lunch_end;
- return;
-
- } else if(each_block.start == lunch_start) {
- // If lunch starts at the beginning of a timeblock
- each_block.start = lunch_end;
- return;
-
- } else if(each_block.end == lunch_end) {
- // If lunch ends at the end of a timeblock
- each_block.start = lunch_end;
- return;
- }
- // FIXME: If lunch spans across more than 1 border between timeblocks, bad stuff will happen.
- // Maybe there is a more principled way of solving this, that doesn't require writing code
- // for a bunch of edge-cases. If not, write the code.
- }
- return;
-}
-
-
-//
-// --- METHODS ---
-//
-
-double timeblock::hourcount() {
- delta timedelta = end-start;
- return (timedelta.minutes/60.0f +
- timedelta.hours +
- timedelta.days*24);
-}
-
-float timeblock::upvalue(float suggestion, std::string reason){
- if(suggestion>valuefactor) {
- valuefactor = suggestion;
- price_reason = reason;
- }
- return valuefactor;
-}
-
-weekday moment::getweekday() {
- // Based on implementation from NProg on StackOverflow. Thanks.
- int y = year;
- static int t[] = { 0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4 };
- y -= month < 3;
- return static_cast<weekday>((y + y / 4 - y / 100 + y / 400 + t[month - 1] + day - 1) % 7);
-}
-
-bool moment::isEaster() {
- moment easter = gaussEaster(year);
- return (easter.month==month && easter.day==day);
-}
-
-
-//
-// --- FUNCTIONS ---
-//
-
-moment gaussEaster(int year) {
- // Thanks to Carl Friedrich Gauss for the algorythm
- // Thanks rahulhegde97, bansal_rtk_, code_hunt, sanjoy_62, simranarora5sos
- // and aashutoshparoha on GeeksForGeeks for the implementation I based this on.
- float A, B, C, P, Q, M, N, D, E;
- int easter_month = 0;
- int easter_day = 0;
-
- // All calculations done
- // on the basis of
- // Gauss Easter Algorithm
- A = year % 19;
- B = year % 4;
- C = year % 7;
- P = std::floor((float)year / 100.0);
-
- Q = std::floor((float)(13 + 8 * P) / 25.0);
-
- M = (int)(15 - Q + P - (std::floor)(P / 4)) % 30;
-
- N = (int)(4 + P - (std::floor)(P / 4)) % 7;
-
- D = (int)(19 * A + M) % 30;
-
- E = (int)(2 * B + 4 * C + 6 * D + N) % 7;
-
- int days = (int)(22 + D + E);
- easter_day = days;
-
- // A corner case,
- // when D is 29
- if ((D == 29) && (E == 6)) {
- easter_month = 4;
- easter_day = 19;
- }
- // Another corner case,
- // when D is 28
- else if ((D == 28) && (E == 6)) {
- easter_month = 4;
- easter_day = 18;
- }
- else {
- // If days > 31, move to April
- // April = 4th Month
- if (days > 31) {
- easter_month = 04;
- easter_day = days-31;
- }
- else {
- // Otherwise, stay on March
- // March = 3rd Month
- easter_month = 03;
- }
- }
- return (moment){0,0, easter_day, easter_month, year};
-}
-
-std::string padint(const int input, const int minimum_signs) {
- std::ostringstream output;
- output << std::internal << std::setfill('0') << std::setw(minimum_signs) << input;
- return output.str();
-}
-
-timeblock timesplit(timeblock& input_block, const moment splitpoint) {
- // Splits a timeblock at splitpoint.
- // It changes the input_block to start at splitpoint, and returns a new timeblock
- // that lasts from where the input_block used to start, to splitpoint.
- // BASICALLY: input_block becomes first half, output is second half.
- if(splitpoint <= input_block.start || splitpoint >= input_block.end) {
- std::cerr << "ERROR: Splitpoint outside of timeblock!\n";
- std::cerr << "Timeblock: " << timeprint(input_block) << std::endl;
- std::cerr << "Splitpoint: " << timeprint(splitpoint) << std::endl;
- }
- timeblock output{input_block.start, splitpoint};
- output.valuefactor = input_block.valuefactor;
- output.price_reason = input_block.price_reason;
- input_block.start = splitpoint; // Note: Now, reversed.
- return output;
-}
-
-void wind(moment& input_moment, const int minutes, const int hours, const int days) {
-
- // Adding minutes
- input_moment.minutes += minutes;
- while(input_moment.minutes > 59) {
- input_moment.minutes -= 60;
- input_moment.hours++;
- }
- while(input_moment.minutes < 0) {
- input_moment.minutes += 60;
- input_moment.hours--;
- }
-
- // Adding hours
- input_moment.hours += hours;
- while(input_moment.hours > 23) {
- input_moment.hours -= 24;
- input_moment.day++;
- }
- while(input_moment.hours < 0) {
- input_moment.hours += 24;
- input_moment.day--;
- }
-
- // Adding days
- input_moment.day += days;
- int current_month_length = days_in(input_moment.month, input_moment.year);
- while(input_moment.day > current_month_length) {
- input_moment.day -= current_month_length;
- input_moment.month++;
- if(input_moment.month > 12) {
- input_moment.month -= 12;
- input_moment.year++;
- }
- current_month_length = days_in(input_moment.month, input_moment.year);
- }
- while(input_moment.day < 1) {
- input_moment.month--;
- if(input_moment.month < 1) {
- input_moment.month += 12;
- input_moment.year--;
- }
- current_month_length = days_in(input_moment.month, input_moment.year);
- input_moment.day += current_month_length;
- }
-}
-void wind(moment& input_moment, const delta& time_delta) {
- wind(input_moment, time_delta.minutes, time_delta.hours, time_delta.days);
-}
-
-std::string timeprint(moment input_moment) {
- using namespace std;
- string output =
- padint(input_moment.hours, 2) + ":"
- + padint(input_moment.minutes, 2) + " "
- + to_string(input_moment.year) + "-"
- + padint(input_moment.month, 2) + "-"
- + padint(input_moment.day, 2);
- return output;
-}
-std::string timeprint(moment input_moment, bool clockonly) {
- using namespace std;
- string output;
- if(clockonly) {
- output =
- padint(input_moment.hours, 2) + ":"
- + padint(input_moment.minutes, 2);
- } else {
- output =
- to_string(input_moment.year) + "-"
- + padint(input_moment.month, 2) + "-"
- + padint(input_moment.day, 2);
- }
- return output;
-}
-
-std::string timeprint(timeblock input_timeblock) {
- std::string output{timeprint(input_timeblock.start) + " --> " + timeprint(input_timeblock.end)};
- return output;
-}
-std::string timeprint(timeblock input_timeblock, bool clockonly) {
- std::string output{timeprint(input_timeblock.start, clockonly) + " --> " + timeprint(input_timeblock.end, clockonly)};
- return output;
-}
-
-
-int days_in(int month, int year) {
- // Kind of a stupid and slow way to do this
- // But it's nice to have it as a function
- // because of the leap year arithmatic
- switch (month) {
- case 1:
- return 31;
- case 2:
- if (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)){
- return 29;
- }
- return 28;
- case 3:
- return 31;
- case 4:
- return 30;
- case 5:
- return 31;
- case 6:
- return 30;
- case 7:
- return 31;
- case 8:
- return 31;
- case 9:
- return 30;
- case 10:
- return 31;
- case 11:
- return 30;
- case 12:
- return 31;
- }
- std::cout << "Something just went very wrong. You found month #" << std::to_string(month) << '\n';
- return 5;
-}
-
-// TODO: Add checks for correct formatting, and ask for new input if wrong
-moment timeinput(moment input_moment) {
- char input_string[6];
- std::cout << "HH MM (24-hour format, use space)" << std::endl;
- std::cin.getline(input_string, 6);
-
- // This uglyness is just how you use strtok() to split a string, apparently
- const char* p;
- int split_input[2];
- int i{0};
- p = strtok(input_string, " ");
- while (p != NULL) {
- split_input[i] = int(atoi(p));
- i++;
- p = strtok(NULL, " ");
- }
-
- if((moment){split_input[1], split_input[0],
- input_moment.day, input_moment.month, input_moment.year} < input_moment)
- {
- wind(input_moment, 0, 0, 1);
- }
-
- moment output{split_input[1], split_input[0],
- input_moment.day, input_moment.month, input_moment.year};
- return output;
-}
-
-moment timeinput() {
- char input_string[17];
- std::cout << "YEAR MM DD hh mm (24-hour format, use spaces)\n";
- std::cin.getline(input_string, 17);
-
- // This uglyness is just how you use strtok() to split a string, apparently
- const char* p;
- int split_input[5];
- int i{0};
- p = strtok(input_string, " ");
- while (p != NULL) {
- split_input[i] = int(atoi(p));
- i++;
- p = strtok(NULL, " ");
- }
-
- moment output{split_input[4],
- split_input[3],
- split_input[2],
- split_input[1],
- split_input[0]};
- return output;
-}
generated by cgit v1.2.1 (git 2.18.0) at 2024-11-10 04:12:37 +0000