diff --git a/NEWS.md b/NEWS.md index 5d5e905c..ba10845e 100644 --- a/NEWS.md +++ b/NEWS.md @@ -1,5 +1,8 @@ # clock (development version) +* clock now compiles significantly faster (on a 2018 Intel Mac, it used to take + ~70 seconds for a full compilation, and now takes ~25 seconds) (#322). + * Skipped a test on 32-bit architectures to work around a bug in base R (#312). * Fixed `vec_ptype_full()` and `vec_ptype_abbr()` methods for sys-time and diff --git a/src/quarterly-shim.h b/src/quarterly-shim.h new file mode 100644 index 00000000..98c76b01 --- /dev/null +++ b/src/quarterly-shim.h @@ -0,0 +1,701 @@ +#ifndef CLOCK_QUARTERLY_SHIM_H +#define CLOCK_QUARTERLY_SHIM_H + +/* + * This file contains a minimal shim around the classes in `quarterly.h` that + * exposes those classes in a template free way. The templating is necessary + * in `quarterly.h` to correctly define the type, since the quarter start month + * is a part of the type itself, but we can gloss over some of those details + * for use in `quarterly-year-quarter-day.h`. Encapsulating the templates here + * reduces the compilation time of clock significantly (around 3x, on an Intel + * Mac the compilation time dropped from 70s to 25s). + */ + +#include +#include "quarterly.h" + +namespace rclock { +namespace rquarterly { +namespace quarterly_shim { + +class year; + +class year_quarternum; + +class year_quarternum_quarterday; +class year_quarternum_quarterday_last; + +// date composition operators + +CONSTCD11 year_quarternum operator/(const year& y, const quarterly::quarternum& qn) NOEXCEPT; +CONSTCD11 year_quarternum operator/(const year& y, int qn) NOEXCEPT; + +CONSTCD11 year_quarternum_quarterday operator/(const year_quarternum& yqn, const quarterly::quarterday& qd) NOEXCEPT; +CONSTCD11 year_quarternum_quarterday operator/(const year_quarternum& yqn, int qd) NOEXCEPT; + +CONSTCD11 year_quarternum_quarterday_last operator/(const year_quarternum& yqn, quarterly::last_spec) NOEXCEPT; + +// year + +class year +{ + short y_; + quarterly::start s_; + +public: + year() = default; + explicit CONSTCD11 year(int y, quarterly::start s) NOEXCEPT; + + CONSTCD11 quarterly::start start() const NOEXCEPT; + + CONSTCD11 explicit operator int() const NOEXCEPT; + CONSTCD14 bool ok() const NOEXCEPT; +}; + +CONSTCD14 year operator+(const year& x, const quarterly::years& y) NOEXCEPT; + +CONSTCD14 quarterly::years operator-(const year& x, const year& y) NOEXCEPT; + +// year_quarternum + +class year_quarternum +{ + quarterly_shim::year y_; + quarterly::quarternum qn_; + +public: + year_quarternum() = default; + CONSTCD11 year_quarternum(const quarterly_shim::year& y, + const quarterly::quarternum& qn) NOEXCEPT; + + CONSTCD11 quarterly_shim::year year() const NOEXCEPT; + CONSTCD11 quarterly::quarternum quarternum() const NOEXCEPT; + + CONSTCD14 bool ok() const NOEXCEPT; +}; + +CONSTCD14 year_quarternum operator+(const year_quarternum& yqn, const quarterly::quarters& dq) NOEXCEPT; + +CONSTCD14 quarterly::quarters operator-(const year_quarternum& x, const year_quarternum& y) NOEXCEPT; + +// year_quarternum_quarterday + +class year_quarternum_quarterday +{ + quarterly_shim::year y_; + quarterly::quarternum qn_; + quarterly::quarterday qd_; + +public: + year_quarternum_quarterday() = default; + CONSTCD11 year_quarternum_quarterday(const quarterly_shim::year& y, + const quarterly::quarternum& qn, + const quarterly::quarterday& qd) NOEXCEPT; + CONSTCD11 year_quarternum_quarterday(const quarterly_shim::year_quarternum& yqn, + const quarterly::quarterday& qd) NOEXCEPT; + CONSTCD14 year_quarternum_quarterday(const year_quarternum_quarterday_last& yqnqdl) NOEXCEPT; + CONSTCD14 year_quarternum_quarterday(const date::sys_days& dp, quarterly::start s) NOEXCEPT; + CONSTCD14 year_quarternum_quarterday(const date::local_days& dp, quarterly::start s) NOEXCEPT; + + CONSTCD11 quarterly_shim::year year() const NOEXCEPT; + CONSTCD11 quarterly::quarternum quarternum() const NOEXCEPT; + CONSTCD11 quarterly::quarterday quarterday() const NOEXCEPT; + + CONSTCD14 operator date::sys_days() const NOEXCEPT; + CONSTCD14 explicit operator date::local_days() const NOEXCEPT; + CONSTCD14 bool ok() const NOEXCEPT; + +private: + CONSTCD14 year_quarternum_quarterday from_sys_days(const date::sys_days& dp, quarterly::start s) NOEXCEPT; + CONSTCD14 year_quarternum_quarterday from_local_days(const date::local_days& dp, quarterly::start s) NOEXCEPT; +}; + +// year_quarternum_quarterday_last + +class year_quarternum_quarterday_last +{ + quarterly_shim::year y_; + quarterly::quarternum qn_; + +public: + year_quarternum_quarterday_last() = default; + CONSTCD11 year_quarternum_quarterday_last(const quarterly_shim::year& y, + const quarterly::quarternum& qn) NOEXCEPT; + CONSTCD11 year_quarternum_quarterday_last(const quarterly_shim::year_quarternum& yqn) NOEXCEPT; + + CONSTCD11 quarterly_shim::year year() const NOEXCEPT; + CONSTCD11 quarterly::quarternum quarternum() const NOEXCEPT; + CONSTCD14 quarterly::quarterday quarterday() const NOEXCEPT; +}; + +//----------------+ +// Implementation | +//----------------+ + +namespace detail { + +static +inline +void +never_reached [[noreturn]] () { + // Compiler hint to allow [[noreturn]] attribute. This is never executed since + // `never_reached()` is never actually called. + throw std::runtime_error("[[noreturn]]"); +} + +} // namespace detail + +namespace detail { + +template +CONSTCD14 +inline +quarterly::year +to_quarterly(const quarterly_shim::year& y) NOEXCEPT { + return quarterly::year(static_cast(y)); +} + +template +CONSTCD14 +inline +quarterly::year_quarternum +to_quarterly(const quarterly_shim::year_quarternum& yqn) NOEXCEPT { + return quarterly::year_quarternum( + to_quarterly(yqn.year()), + yqn.quarternum() + ); +} + +template +CONSTCD14 +inline +quarterly::year_quarternum_quarterday +to_quarterly(const quarterly_shim::year_quarternum_quarterday& yqnqd) NOEXCEPT { + return quarterly::year_quarternum_quarterday( + to_quarterly(yqnqd.year()), + yqnqd.quarternum(), + yqnqd.quarterday() + ); +} + +template +CONSTCD14 +inline +quarterly::year_quarternum_quarterday_last +to_quarterly(const quarterly_shim::year_quarternum_quarterday_last& yqnqdl) NOEXCEPT { + return quarterly::year_quarternum_quarterday_last( + to_quarterly(yqnqdl.year()), + yqnqdl.quarternum() + ); +} + +template +CONSTCD14 +inline +quarterly_shim::year +from_quarterly(const quarterly::year& y) NOEXCEPT { + return quarterly_shim::year(static_cast(y), y.start()); +} + +template +CONSTCD14 +inline +quarterly_shim::year_quarternum +from_quarterly(const quarterly::year_quarternum& yqn) NOEXCEPT { + return quarterly_shim::year_quarternum( + from_quarterly(yqn.year()), + yqn.quarternum() + ); +} + +template +CONSTCD14 +inline +quarterly_shim::year_quarternum_quarterday +from_quarterly(const quarterly::year_quarternum_quarterday& yqnqd) NOEXCEPT { + return quarterly_shim::year_quarternum_quarterday( + from_quarterly(yqnqd.year()), + yqnqd.quarternum(), + yqnqd.quarterday() + ); +} + +} // namespace detail + +// year + +CONSTCD11 +inline +year::year(int y, quarterly::start s) NOEXCEPT + : y_(static_cast(y)), + s_(s) + {} + +CONSTCD11 +inline +year::operator int() const NOEXCEPT +{ + return y_; +} + +CONSTCD14 +inline +bool +year::ok() const NOEXCEPT +{ + using start = quarterly::start; + using detail::to_quarterly; + + switch (s_) { + case start::january: return to_quarterly(*this).ok(); + case start::february: return to_quarterly(*this).ok(); + case start::march: return to_quarterly(*this).ok(); + case start::april: return to_quarterly(*this).ok(); + case start::may: return to_quarterly(*this).ok(); + case start::june: return to_quarterly(*this).ok(); + case start::july: return to_quarterly(*this).ok(); + case start::august: return to_quarterly(*this).ok(); + case start::september: return to_quarterly(*this).ok(); + case start::october: return to_quarterly(*this).ok(); + case start::november: return to_quarterly(*this).ok(); + case start::december: return to_quarterly(*this).ok(); + default: detail::never_reached(); + } +} + +CONSTCD11 +inline +quarterly::start +year::start() const NOEXCEPT +{ + return s_; +} + +CONSTCD14 +inline +year +operator+(const year& x, const quarterly::years& y) NOEXCEPT +{ + using start = quarterly::start; + using detail::from_quarterly; + using detail::to_quarterly; + + switch (x.start()) { + case start::january: return from_quarterly(to_quarterly(x) + y); + case start::february: return from_quarterly(to_quarterly(x) + y); + case start::march: return from_quarterly(to_quarterly(x) + y); + case start::april: return from_quarterly(to_quarterly(x) + y); + case start::may: return from_quarterly(to_quarterly(x) + y); + case start::june: return from_quarterly(to_quarterly(x) + y); + case start::july: return from_quarterly(to_quarterly(x) + y); + case start::august: return from_quarterly(to_quarterly(x) + y); + case start::september: return from_quarterly(to_quarterly(x) + y); + case start::october: return from_quarterly(to_quarterly(x) + y); + case start::november: return from_quarterly(to_quarterly(x) + y); + case start::december: return from_quarterly(to_quarterly(x) + y); + default: detail::never_reached(); + } +} + +CONSTCD14 +inline +quarterly::years +operator-(const year& x, const year& y) NOEXCEPT +{ + using start = quarterly::start; + using detail::to_quarterly; + + // Assumes `x.start()` and `y.start()` are the same, verified by caller + switch (x.start()) { + case start::january: return to_quarterly(x) - to_quarterly(y); + case start::february: return to_quarterly(x) - to_quarterly(y); + case start::march: return to_quarterly(x) - to_quarterly(y); + case start::april: return to_quarterly(x) - to_quarterly(y); + case start::may: return to_quarterly(x) - to_quarterly(y); + case start::june: return to_quarterly(x) - to_quarterly(y); + case start::july: return to_quarterly(x) - to_quarterly(y); + case start::august: return to_quarterly(x) - to_quarterly(y); + case start::september: return to_quarterly(x) - to_quarterly(y); + case start::october: return to_quarterly(x) - to_quarterly(y); + case start::november: return to_quarterly(x) - to_quarterly(y); + case start::december: return to_quarterly(x) - to_quarterly(y); + default: detail::never_reached(); + } +} + +// year_quarternum + +CONSTCD11 +inline +year_quarternum::year_quarternum(const quarterly_shim::year& y, + const quarterly::quarternum& qn) NOEXCEPT + : y_(y) + , qn_(qn) + {} + +CONSTCD14 +inline +bool +year_quarternum::ok() const NOEXCEPT +{ + using start = quarterly::start; + using detail::to_quarterly; + + switch (y_.start()) { + case start::january: return to_quarterly(*this).ok(); + case start::february: return to_quarterly(*this).ok(); + case start::march: return to_quarterly(*this).ok(); + case start::april: return to_quarterly(*this).ok(); + case start::may: return to_quarterly(*this).ok(); + case start::june: return to_quarterly(*this).ok(); + case start::july: return to_quarterly(*this).ok(); + case start::august: return to_quarterly(*this).ok(); + case start::september: return to_quarterly(*this).ok(); + case start::october: return to_quarterly(*this).ok(); + case start::november: return to_quarterly(*this).ok(); + case start::december: return to_quarterly(*this).ok(); + default: detail::never_reached(); + } +} + +CONSTCD11 +inline +quarterly_shim::year +year_quarternum::year() const NOEXCEPT +{ + return y_; +} + +CONSTCD11 +inline +quarterly::quarternum +year_quarternum::quarternum() const NOEXCEPT +{ + return qn_; +} + +CONSTCD14 +inline +year_quarternum +operator+(const year_quarternum& yqn, const quarterly::quarters& dq) NOEXCEPT +{ + using start = quarterly::start; + using detail::from_quarterly; + using detail::to_quarterly; + + switch (yqn.year().start()) { + case start::january: return from_quarterly(to_quarterly(yqn) + dq); + case start::february: return from_quarterly(to_quarterly(yqn) + dq); + case start::march: return from_quarterly(to_quarterly(yqn) + dq); + case start::april: return from_quarterly(to_quarterly(yqn) + dq); + case start::may: return from_quarterly(to_quarterly(yqn) + dq); + case start::june: return from_quarterly(to_quarterly(yqn) + dq); + case start::july: return from_quarterly(to_quarterly(yqn) + dq); + case start::august: return from_quarterly(to_quarterly(yqn) + dq); + case start::september: return from_quarterly(to_quarterly(yqn) + dq); + case start::october: return from_quarterly(to_quarterly(yqn) + dq); + case start::november: return from_quarterly(to_quarterly(yqn) + dq); + case start::december: return from_quarterly(to_quarterly(yqn) + dq); + default: detail::never_reached(); + } +} + +CONSTCD14 +inline +quarterly::quarters +operator-(const year_quarternum& x, const year_quarternum& y) NOEXCEPT +{ + using start = quarterly::start; + using detail::to_quarterly; + + // Assumes `x.year().start()` and `y.year().start()` are the same, verified by caller + switch (x.year().start()) { + case start::january: return to_quarterly(x) - to_quarterly(y); + case start::february: return to_quarterly(x) - to_quarterly(y); + case start::march: return to_quarterly(x) - to_quarterly(y); + case start::april: return to_quarterly(x) - to_quarterly(y); + case start::may: return to_quarterly(x) - to_quarterly(y); + case start::june: return to_quarterly(x) - to_quarterly(y); + case start::july: return to_quarterly(x) - to_quarterly(y); + case start::august: return to_quarterly(x) - to_quarterly(y); + case start::september: return to_quarterly(x) - to_quarterly(y); + case start::october: return to_quarterly(x) - to_quarterly(y); + case start::november: return to_quarterly(x) - to_quarterly(y); + case start::december: return to_quarterly(x) - to_quarterly(y); + default: detail::never_reached(); + } +} + +// year_quarternum_quarterday + +CONSTCD11 +inline +year_quarternum_quarterday::year_quarternum_quarterday(const quarterly_shim::year& y, + const quarterly::quarternum& qn, + const quarterly::quarterday& qd) NOEXCEPT + : y_(y) + , qn_(qn) + , qd_(qd) + {} + +CONSTCD11 +inline +year_quarternum_quarterday::year_quarternum_quarterday(const quarterly_shim::year_quarternum& yqn, + const quarterly::quarterday& qd) NOEXCEPT + : y_(yqn.year()) + , qn_(yqn.quarternum()) + , qd_(qd) + {} + +CONSTCD14 +inline +year_quarternum_quarterday::year_quarternum_quarterday(const year_quarternum_quarterday_last& yqnqdl) NOEXCEPT + : y_(yqnqdl.year()) + , qn_(yqnqdl.quarternum()) + , qd_(yqnqdl.quarterday()) + {} + +CONSTCD14 +inline +year_quarternum_quarterday::year_quarternum_quarterday(const date::sys_days& dp, quarterly::start s) NOEXCEPT + : year_quarternum_quarterday(from_sys_days(dp, s)) + {} + +CONSTCD14 +inline +year_quarternum_quarterday::year_quarternum_quarterday(const date::local_days& dp, quarterly::start s) NOEXCEPT + : year_quarternum_quarterday(from_local_days(dp, s)) + {} + +CONSTCD14 +inline +year_quarternum_quarterday +year_quarternum_quarterday::from_sys_days(const date::sys_days& dp, quarterly::start s) NOEXCEPT { + using start = quarterly::start; + using detail::from_quarterly; + + switch (s) { + case start::january: return from_quarterly(quarterly::year_quarternum_quarterday(dp)); + case start::february: return from_quarterly(quarterly::year_quarternum_quarterday(dp)); + case start::march: return from_quarterly(quarterly::year_quarternum_quarterday(dp)); + case start::april: return from_quarterly(quarterly::year_quarternum_quarterday(dp)); + case start::may: return from_quarterly(quarterly::year_quarternum_quarterday(dp)); + case start::june: return from_quarterly(quarterly::year_quarternum_quarterday(dp)); + case start::july: return from_quarterly(quarterly::year_quarternum_quarterday(dp)); + case start::august: return from_quarterly(quarterly::year_quarternum_quarterday(dp)); + case start::september: return from_quarterly(quarterly::year_quarternum_quarterday(dp)); + case start::october: return from_quarterly(quarterly::year_quarternum_quarterday(dp)); + case start::november: return from_quarterly(quarterly::year_quarternum_quarterday(dp)); + case start::december: return from_quarterly(quarterly::year_quarternum_quarterday(dp)); + default: detail::never_reached(); + } +} + +CONSTCD14 +inline +year_quarternum_quarterday +year_quarternum_quarterday::from_local_days(const date::local_days& dp, quarterly::start s) NOEXCEPT { + return from_sys_days(date::sys_days(dp.time_since_epoch()), s); +} + +CONSTCD11 +inline +quarterly_shim::year +year_quarternum_quarterday::year() const NOEXCEPT +{ + return y_; +} + +CONSTCD11 +inline +quarterly::quarternum +year_quarternum_quarterday::quarternum() const NOEXCEPT +{ + return qn_; +} + +CONSTCD11 +inline +quarterly::quarterday +year_quarternum_quarterday::quarterday() const NOEXCEPT +{ + return qd_; +} + +CONSTCD14 +inline +year_quarternum_quarterday::operator date::sys_days() const NOEXCEPT +{ + using start = quarterly::start; + using detail::to_quarterly; + + switch (y_.start()) { + case start::january: return to_quarterly(*this); + case start::february: return to_quarterly(*this); + case start::march: return to_quarterly(*this); + case start::april: return to_quarterly(*this); + case start::may: return to_quarterly(*this); + case start::june: return to_quarterly(*this); + case start::july: return to_quarterly(*this); + case start::august: return to_quarterly(*this); + case start::september: return to_quarterly(*this); + case start::october: return to_quarterly(*this); + case start::november: return to_quarterly(*this); + case start::december: return to_quarterly(*this); + default: detail::never_reached(); + } +} + +CONSTCD14 +inline +year_quarternum_quarterday::operator date::local_days() const NOEXCEPT +{ + using start = quarterly::start; + using detail::to_quarterly; + + switch (y_.start()) { + case start::january: return date::local_days(to_quarterly(*this)); + case start::february: return date::local_days(to_quarterly(*this)); + case start::march: return date::local_days(to_quarterly(*this)); + case start::april: return date::local_days(to_quarterly(*this)); + case start::may: return date::local_days(to_quarterly(*this)); + case start::june: return date::local_days(to_quarterly(*this)); + case start::july: return date::local_days(to_quarterly(*this)); + case start::august: return date::local_days(to_quarterly(*this)); + case start::september: return date::local_days(to_quarterly(*this)); + case start::october: return date::local_days(to_quarterly(*this)); + case start::november: return date::local_days(to_quarterly(*this)); + case start::december: return date::local_days(to_quarterly(*this)); + default: detail::never_reached(); + } +} + +CONSTCD14 +inline +bool +year_quarternum_quarterday::ok() const NOEXCEPT +{ + using start = quarterly::start; + using detail::to_quarterly; + + switch (y_.start()) { + case start::january: return to_quarterly(*this).ok(); + case start::february: return to_quarterly(*this).ok(); + case start::march: return to_quarterly(*this).ok(); + case start::april: return to_quarterly(*this).ok(); + case start::may: return to_quarterly(*this).ok(); + case start::june: return to_quarterly(*this).ok(); + case start::july: return to_quarterly(*this).ok(); + case start::august: return to_quarterly(*this).ok(); + case start::september: return to_quarterly(*this).ok(); + case start::october: return to_quarterly(*this).ok(); + case start::november: return to_quarterly(*this).ok(); + case start::december: return to_quarterly(*this).ok(); + default: detail::never_reached(); + } +} + +// year_quarternum_quarterday_last + +CONSTCD11 +inline +year_quarternum_quarterday_last::year_quarternum_quarterday_last(const quarterly_shim::year& y, + const quarterly::quarternum& qn) NOEXCEPT + : y_(y) + , qn_(qn) + {} + +CONSTCD11 +inline +year_quarternum_quarterday_last::year_quarternum_quarterday_last(const quarterly_shim::year_quarternum& yqn) NOEXCEPT + : y_(yqn.year()) + , qn_(yqn.quarternum()) + {} + +CONSTCD11 +inline +quarterly_shim::year +year_quarternum_quarterday_last::year() const NOEXCEPT +{ + return y_; +} + +CONSTCD11 +inline +quarterly::quarternum +year_quarternum_quarterday_last::quarternum() const NOEXCEPT +{ + return qn_; +} + +CONSTCD14 +inline +quarterly::quarterday +year_quarternum_quarterday_last::quarterday() const NOEXCEPT +{ + using start = quarterly::start; + using detail::to_quarterly; + + switch (y_.start()) { + case start::january: return to_quarterly(*this).quarterday(); + case start::february: return to_quarterly(*this).quarterday(); + case start::march: return to_quarterly(*this).quarterday(); + case start::april: return to_quarterly(*this).quarterday(); + case start::may: return to_quarterly(*this).quarterday(); + case start::june: return to_quarterly(*this).quarterday(); + case start::july: return to_quarterly(*this).quarterday(); + case start::august: return to_quarterly(*this).quarterday(); + case start::september: return to_quarterly(*this).quarterday(); + case start::october: return to_quarterly(*this).quarterday(); + case start::november: return to_quarterly(*this).quarterday(); + case start::december: return to_quarterly(*this).quarterday(); + default: detail::never_reached(); + } +} + +// year_quarternum from operator/() + +CONSTCD11 +inline +year_quarternum +operator/(const year& y, const quarterly::quarternum& qn) NOEXCEPT { + return {y, qn}; +} + +CONSTCD11 +inline +year_quarternum +operator/(const year& y, int qn) NOEXCEPT { + return y / quarterly::quarternum(static_cast(qn)); +} + +// year_quarternum_quarterday from operator/() + +CONSTCD11 +inline +year_quarternum_quarterday +operator/(const year_quarternum& yqn, const quarterly::quarterday& qd) NOEXCEPT { + return {yqn, qd}; +} + +CONSTCD11 +inline +year_quarternum_quarterday +operator/(const year_quarternum& yqn, int qd) NOEXCEPT { + return yqn / quarterly::quarterday(static_cast(qd)); +} + +// year_quarternum_quarterday_last from operator/() + +CONSTCD11 +inline +year_quarternum_quarterday_last +operator/(const year_quarternum& yqn, quarterly::last_spec) NOEXCEPT { + return year_quarternum_quarterday_last{yqn}; +} + +} // namespace quarterly_shim +} // namespace rquarterly +} // namespace rclock + +#endif diff --git a/src/quarterly-year-quarter-day.cpp b/src/quarterly-year-quarter-day.cpp index b90c1f6c..cb929560 100644 --- a/src/quarterly-year-quarter-day.cpp +++ b/src/quarterly-year-quarter-day.cpp @@ -1,4 +1,5 @@ #include "quarterly-year-quarter-day.h" +#include "quarterly-shim.h" #include "calendar.h" #include "duration.h" #include "check.h" @@ -64,14 +65,15 @@ year_quarter_day_restore(SEXP x, SEXP to) { // ----------------------------------------------------------------------------- -template -static -inline +[[cpp11::register]] cpp11::writable::list -collect_year_quarter_day_fields_impl(cpp11::list_of fields, - const cpp11::integers& precision_int) { +collect_year_quarter_day_fields(cpp11::list_of fields, + const cpp11::integers& precision_int, + const cpp11::integers& start_int) { using namespace rclock; + const quarterly::start start = parse_start(start_int); + cpp11::integers year = rquarterly::get_year(fields); cpp11::integers quarter = rquarterly::get_quarter(fields); cpp11::integers day = rquarterly::get_day(fields); @@ -80,15 +82,15 @@ collect_year_quarter_day_fields_impl(cpp11::list_of fields, cpp11::integers second = rquarterly::get_second(fields); cpp11::integers subsecond = rquarterly::get_subsecond(fields); - rquarterly::y y{year}; - rquarterly::yqn yqn{year, quarter}; - rquarterly::yqnqd yqnqd{year, quarter, day}; - rquarterly::yqnqdh yqnqdh{year, quarter, day, hour}; - rquarterly::yqnqdhm yqnqdhm{year, quarter, day, hour, minute}; - rquarterly::yqnqdhms yqnqdhms{year, quarter, day, hour, minute, second}; - rquarterly::yqnqdhmss yqnqdhmss1{year, quarter, day, hour, minute, second, subsecond}; - rquarterly::yqnqdhmss yqnqdhmss2{year, quarter, day, hour, minute, second, subsecond}; - rquarterly::yqnqdhmss yqnqdhmss3{year, quarter, day, hour, minute, second, subsecond}; + rquarterly::y y{year, start}; + rquarterly::yqn yqn{year, quarter, start}; + rquarterly::yqnqd yqnqd{year, quarter, day, start}; + rquarterly::yqnqdh yqnqdh{year, quarter, day, hour, start}; + rquarterly::yqnqdhm yqnqdhm{year, quarter, day, hour, minute, start}; + rquarterly::yqnqdhms yqnqdhms{year, quarter, day, hour, minute, second, start}; + rquarterly::yqnqdhmss yqnqdhmss1{year, quarter, day, hour, minute, second, subsecond, start}; + rquarterly::yqnqdhmss yqnqdhmss2{year, quarter, day, hour, minute, second, subsecond, start}; + rquarterly::yqnqdhmss yqnqdhmss3{year, quarter, day, hour, minute, second, subsecond, start}; switch (parse_precision(precision_int)) { case precision::year: { @@ -163,44 +165,20 @@ collect_year_quarter_day_fields_impl(cpp11::list_of fields, default: clock_abort("Internal error: Invalid precision."); } - never_reached("collect_year_quarter_day_fields_impl"); -} - -[[cpp11::register]] -cpp11::writable::list -collect_year_quarter_day_fields(cpp11::list_of fields, - const cpp11::integers& precision_int, - const cpp11::integers& start_int) { - using namespace quarterly; - - switch (parse_start(start_int)) { - case start::january: return collect_year_quarter_day_fields_impl(fields, precision_int); - case start::february: return collect_year_quarter_day_fields_impl(fields, precision_int); - case start::march: return collect_year_quarter_day_fields_impl(fields, precision_int); - case start::april: return collect_year_quarter_day_fields_impl(fields, precision_int); - case start::may: return collect_year_quarter_day_fields_impl(fields, precision_int); - case start::june: return collect_year_quarter_day_fields_impl(fields, precision_int); - case start::july: return collect_year_quarter_day_fields_impl(fields, precision_int); - case start::august: return collect_year_quarter_day_fields_impl(fields, precision_int); - case start::september: return collect_year_quarter_day_fields_impl(fields, precision_int); - case start::october: return collect_year_quarter_day_fields_impl(fields, precision_int); - case start::november: return collect_year_quarter_day_fields_impl(fields, precision_int); - case start::december: return collect_year_quarter_day_fields_impl(fields, precision_int); - } - never_reached("collect_year_quarter_day_fields"); } // ----------------------------------------------------------------------------- -template -static -inline +[[cpp11::register]] cpp11::writable::strings -format_year_quarter_day_impl(cpp11::list_of fields, - const cpp11::integers& precision_int) { +format_year_quarter_day_cpp(cpp11::list_of fields, + const cpp11::integers& precision_int, + const cpp11::integers& start_int) { using namespace rclock; + const quarterly::start start = parse_start(start_int); + cpp11::integers year = rquarterly::get_year(fields); cpp11::integers quarter = rquarterly::get_quarter(fields); cpp11::integers day = rquarterly::get_day(fields); @@ -209,15 +187,15 @@ format_year_quarter_day_impl(cpp11::list_of fields, cpp11::integers second = rquarterly::get_second(fields); cpp11::integers subsecond = rquarterly::get_subsecond(fields); - rquarterly::y y{year}; - rquarterly::yqn yqn{year, quarter}; - rquarterly::yqnqd yqnqd{year, quarter, day}; - rquarterly::yqnqdh yqnqdh{year, quarter, day, hour}; - rquarterly::yqnqdhm yqnqdhm{year, quarter, day, hour, minute}; - rquarterly::yqnqdhms yqnqdhms{year, quarter, day, hour, minute, second}; - rquarterly::yqnqdhmss yqnqdhmss1{year, quarter, day, hour, minute, second, subsecond}; - rquarterly::yqnqdhmss yqnqdhmss2{year, quarter, day, hour, minute, second, subsecond}; - rquarterly::yqnqdhmss yqnqdhmss3{year, quarter, day, hour, minute, second, subsecond}; + rquarterly::y y{year, start}; + rquarterly::yqn yqn{year, quarter, start}; + rquarterly::yqnqd yqnqd{year, quarter, day, start}; + rquarterly::yqnqdh yqnqdh{year, quarter, day, hour, start}; + rquarterly::yqnqdhm yqnqdhm{year, quarter, day, hour, minute, start}; + rquarterly::yqnqdhms yqnqdhms{year, quarter, day, hour, minute, second, start}; + rquarterly::yqnqdhmss yqnqdhmss1{year, quarter, day, hour, minute, second, subsecond, start}; + rquarterly::yqnqdhmss yqnqdhmss2{year, quarter, day, hour, minute, second, subsecond, start}; + rquarterly::yqnqdhmss yqnqdhmss3{year, quarter, day, hour, minute, second, subsecond, start}; switch (parse_precision(precision_int)) { case precision::year: return format_calendar_impl(y); @@ -232,42 +210,20 @@ format_year_quarter_day_impl(cpp11::list_of fields, default: clock_abort("Internal error: Invalid precision."); } - never_reached("format_year_quarter_day_impl"); -} - -[[cpp11::register]] -cpp11::writable::strings -format_year_quarter_day_cpp(cpp11::list_of fields, - const cpp11::integers& precision_int, - const cpp11::integers& start_int) { - using namespace quarterly; - - switch (parse_start(start_int)) { - case start::january: return format_year_quarter_day_impl(fields, precision_int); - case start::february: return format_year_quarter_day_impl(fields, precision_int); - case start::march: return format_year_quarter_day_impl(fields, precision_int); - case start::april: return format_year_quarter_day_impl(fields, precision_int); - case start::may: return format_year_quarter_day_impl(fields, precision_int); - case start::june: return format_year_quarter_day_impl(fields, precision_int); - case start::july: return format_year_quarter_day_impl(fields, precision_int); - case start::august: return format_year_quarter_day_impl(fields, precision_int); - case start::september: return format_year_quarter_day_impl(fields, precision_int); - case start::october: return format_year_quarter_day_impl(fields, precision_int); - case start::november: return format_year_quarter_day_impl(fields, precision_int); - case start::december: return format_year_quarter_day_impl(fields, precision_int); - } - never_reached("format_year_quarter_day_cpp"); } // ----------------------------------------------------------------------------- -template +[[cpp11::register]] cpp11::writable::logicals -invalid_detect_year_quarter_day_impl(cpp11::list_of fields, - const cpp11::integers& precision_int) { +invalid_detect_year_quarter_day_cpp(cpp11::list_of fields, + const cpp11::integers& precision_int, + const cpp11::integers& start_int) { using namespace rclock; + const quarterly::start start = parse_start(start_int); + cpp11::integers year = rquarterly::get_year(fields); cpp11::integers quarter = rquarterly::get_quarter(fields); cpp11::integers day = rquarterly::get_day(fields); @@ -276,15 +232,15 @@ invalid_detect_year_quarter_day_impl(cpp11::list_of fields, cpp11::integers second = rquarterly::get_second(fields); cpp11::integers subsecond = rquarterly::get_subsecond(fields); - rquarterly::y y{year}; - rquarterly::yqn yqn{year, quarter}; - rquarterly::yqnqd yqnqd{year, quarter, day}; - rquarterly::yqnqdh yqnqdh{year, quarter, day, hour}; - rquarterly::yqnqdhm yqnqdhm{year, quarter, day, hour, minute}; - rquarterly::yqnqdhms yqnqdhms{year, quarter, day, hour, minute, second}; - rquarterly::yqnqdhmss yqnqdhmss1{year, quarter, day, hour, minute, second, subsecond}; - rquarterly::yqnqdhmss yqnqdhmss2{year, quarter, day, hour, minute, second, subsecond}; - rquarterly::yqnqdhmss yqnqdhmss3{year, quarter, day, hour, minute, second, subsecond}; + rquarterly::y y{year, start}; + rquarterly::yqn yqn{year, quarter, start}; + rquarterly::yqnqd yqnqd{year, quarter, day, start}; + rquarterly::yqnqdh yqnqdh{year, quarter, day, hour, start}; + rquarterly::yqnqdhm yqnqdhm{year, quarter, day, hour, minute, start}; + rquarterly::yqnqdhms yqnqdhms{year, quarter, day, hour, minute, second, start}; + rquarterly::yqnqdhmss yqnqdhmss1{year, quarter, day, hour, minute, second, subsecond, start}; + rquarterly::yqnqdhmss yqnqdhmss2{year, quarter, day, hour, minute, second, subsecond, start}; + rquarterly::yqnqdhmss yqnqdhmss3{year, quarter, day, hour, minute, second, subsecond, start}; switch (parse_precision(precision_int)) { case precision::year: return invalid_detect_calendar_impl(y); @@ -299,44 +255,20 @@ invalid_detect_year_quarter_day_impl(cpp11::list_of fields, default: clock_abort("Internal error: Invalid precision."); } - never_reached("invalid_detect_year_quarter_day_impl"); -} - -[[cpp11::register]] -cpp11::writable::logicals -invalid_detect_year_quarter_day_cpp(cpp11::list_of fields, - const cpp11::integers& precision_int, - const cpp11::integers& start_int) { - using namespace quarterly; - - switch (parse_start(start_int)) { - case start::january: return invalid_detect_year_quarter_day_impl(fields, precision_int); - case start::february: return invalid_detect_year_quarter_day_impl(fields, precision_int); - case start::march: return invalid_detect_year_quarter_day_impl(fields, precision_int); - case start::april: return invalid_detect_year_quarter_day_impl(fields, precision_int); - case start::may: return invalid_detect_year_quarter_day_impl(fields, precision_int); - case start::june: return invalid_detect_year_quarter_day_impl(fields, precision_int); - case start::july: return invalid_detect_year_quarter_day_impl(fields, precision_int); - case start::august: return invalid_detect_year_quarter_day_impl(fields, precision_int); - case start::september: return invalid_detect_year_quarter_day_impl(fields, precision_int); - case start::october: return invalid_detect_year_quarter_day_impl(fields, precision_int); - case start::november: return invalid_detect_year_quarter_day_impl(fields, precision_int); - case start::december: return invalid_detect_year_quarter_day_impl(fields, precision_int); - } - never_reached("invalid_detect_year_quarter_day_cpp"); } // ----------------------------------------------------------------------------- -template -static -inline +[[cpp11::register]] bool -invalid_any_year_quarter_day_impl(cpp11::list_of fields, - const cpp11::integers& precision_int) { +invalid_any_year_quarter_day_cpp(cpp11::list_of fields, + const cpp11::integers& precision_int, + const cpp11::integers& start_int) { using namespace rclock; + const quarterly::start start = parse_start(start_int); + cpp11::integers year = rquarterly::get_year(fields); cpp11::integers quarter = rquarterly::get_quarter(fields); cpp11::integers day = rquarterly::get_day(fields); @@ -345,15 +277,15 @@ invalid_any_year_quarter_day_impl(cpp11::list_of fields, cpp11::integers second = rquarterly::get_second(fields); cpp11::integers subsecond = rquarterly::get_subsecond(fields); - rquarterly::y y{year}; - rquarterly::yqn yqn{year, quarter}; - rquarterly::yqnqd yqnqd{year, quarter, day}; - rquarterly::yqnqdh yqnqdh{year, quarter, day, hour}; - rquarterly::yqnqdhm yqnqdhm{year, quarter, day, hour, minute}; - rquarterly::yqnqdhms yqnqdhms{year, quarter, day, hour, minute, second}; - rquarterly::yqnqdhmss yqnqdhmss1{year, quarter, day, hour, minute, second, subsecond}; - rquarterly::yqnqdhmss yqnqdhmss2{year, quarter, day, hour, minute, second, subsecond}; - rquarterly::yqnqdhmss yqnqdhmss3{year, quarter, day, hour, minute, second, subsecond}; + rquarterly::y y{year, start}; + rquarterly::yqn yqn{year, quarter, start}; + rquarterly::yqnqd yqnqd{year, quarter, day, start}; + rquarterly::yqnqdh yqnqdh{year, quarter, day, hour, start}; + rquarterly::yqnqdhm yqnqdhm{year, quarter, day, hour, minute, start}; + rquarterly::yqnqdhms yqnqdhms{year, quarter, day, hour, minute, second, start}; + rquarterly::yqnqdhmss yqnqdhmss1{year, quarter, day, hour, minute, second, subsecond, start}; + rquarterly::yqnqdhmss yqnqdhmss2{year, quarter, day, hour, minute, second, subsecond, start}; + rquarterly::yqnqdhmss yqnqdhmss3{year, quarter, day, hour, minute, second, subsecond, start}; switch (parse_precision(precision_int)) { case precision::year: return invalid_any_calendar_impl(y); @@ -368,44 +300,20 @@ invalid_any_year_quarter_day_impl(cpp11::list_of fields, default: clock_abort("Internal error: Invalid precision."); } - never_reached("invalid_any_year_quarter_day_impl"); -} - -[[cpp11::register]] -bool -invalid_any_year_quarter_day_cpp(cpp11::list_of fields, - const cpp11::integers& precision_int, - const cpp11::integers& start_int) { - using namespace quarterly; - - switch (parse_start(start_int)) { - case start::january: return invalid_any_year_quarter_day_impl(fields, precision_int); - case start::february: return invalid_any_year_quarter_day_impl(fields, precision_int); - case start::march: return invalid_any_year_quarter_day_impl(fields, precision_int); - case start::april: return invalid_any_year_quarter_day_impl(fields, precision_int); - case start::may: return invalid_any_year_quarter_day_impl(fields, precision_int); - case start::june: return invalid_any_year_quarter_day_impl(fields, precision_int); - case start::july: return invalid_any_year_quarter_day_impl(fields, precision_int); - case start::august: return invalid_any_year_quarter_day_impl(fields, precision_int); - case start::september: return invalid_any_year_quarter_day_impl(fields, precision_int); - case start::october: return invalid_any_year_quarter_day_impl(fields, precision_int); - case start::november: return invalid_any_year_quarter_day_impl(fields, precision_int); - case start::december: return invalid_any_year_quarter_day_impl(fields, precision_int); - } - never_reached("invalid_any_year_quarter_day_cpp"); } // ----------------------------------------------------------------------------- -template -static -inline +[[cpp11::register]] int -invalid_count_year_quarter_day_impl(cpp11::list_of fields, - const cpp11::integers& precision_int) { +invalid_count_year_quarter_day_cpp(cpp11::list_of fields, + const cpp11::integers& precision_int, + const cpp11::integers& start_int) { using namespace rclock; + const quarterly::start start = parse_start(start_int); + cpp11::integers year = rquarterly::get_year(fields); cpp11::integers quarter = rquarterly::get_quarter(fields); cpp11::integers day = rquarterly::get_day(fields); @@ -414,15 +322,15 @@ invalid_count_year_quarter_day_impl(cpp11::list_of fields, cpp11::integers second = rquarterly::get_second(fields); cpp11::integers subsecond = rquarterly::get_subsecond(fields); - rquarterly::y y{year}; - rquarterly::yqn yqn{year, quarter}; - rquarterly::yqnqd yqnqd{year, quarter, day}; - rquarterly::yqnqdh yqnqdh{year, quarter, day, hour}; - rquarterly::yqnqdhm yqnqdhm{year, quarter, day, hour, minute}; - rquarterly::yqnqdhms yqnqdhms{year, quarter, day, hour, minute, second}; - rquarterly::yqnqdhmss yqnqdhmss1{year, quarter, day, hour, minute, second, subsecond}; - rquarterly::yqnqdhmss yqnqdhmss2{year, quarter, day, hour, minute, second, subsecond}; - rquarterly::yqnqdhmss yqnqdhmss3{year, quarter, day, hour, minute, second, subsecond}; + rquarterly::y y{year, start}; + rquarterly::yqn yqn{year, quarter, start}; + rquarterly::yqnqd yqnqd{year, quarter, day, start}; + rquarterly::yqnqdh yqnqdh{year, quarter, day, hour, start}; + rquarterly::yqnqdhm yqnqdhm{year, quarter, day, hour, minute, start}; + rquarterly::yqnqdhms yqnqdhms{year, quarter, day, hour, minute, second, start}; + rquarterly::yqnqdhmss yqnqdhmss1{year, quarter, day, hour, minute, second, subsecond, start}; + rquarterly::yqnqdhmss yqnqdhmss2{year, quarter, day, hour, minute, second, subsecond, start}; + rquarterly::yqnqdhmss yqnqdhmss3{year, quarter, day, hour, minute, second, subsecond, start}; switch (parse_precision(precision_int)) { case precision::year: return invalid_count_calendar_impl(y); @@ -437,44 +345,20 @@ invalid_count_year_quarter_day_impl(cpp11::list_of fields, default: clock_abort("Internal error: Invalid precision."); } - never_reached("invalid_count_year_quarter_day_impl"); -} - -[[cpp11::register]] -int -invalid_count_year_quarter_day_cpp(cpp11::list_of fields, - const cpp11::integers& precision_int, - const cpp11::integers& start_int) { - using namespace quarterly; - - switch (parse_start(start_int)) { - case start::january: return invalid_count_year_quarter_day_impl(fields, precision_int); - case start::february: return invalid_count_year_quarter_day_impl(fields, precision_int); - case start::march: return invalid_count_year_quarter_day_impl(fields, precision_int); - case start::april: return invalid_count_year_quarter_day_impl(fields, precision_int); - case start::may: return invalid_count_year_quarter_day_impl(fields, precision_int); - case start::june: return invalid_count_year_quarter_day_impl(fields, precision_int); - case start::july: return invalid_count_year_quarter_day_impl(fields, precision_int); - case start::august: return invalid_count_year_quarter_day_impl(fields, precision_int); - case start::september: return invalid_count_year_quarter_day_impl(fields, precision_int); - case start::october: return invalid_count_year_quarter_day_impl(fields, precision_int); - case start::november: return invalid_count_year_quarter_day_impl(fields, precision_int); - case start::december: return invalid_count_year_quarter_day_impl(fields, precision_int); - } - never_reached("invalid_count_year_quarter_day_cpp"); } // ----------------------------------------------------------------------------- -template -static -inline +[[cpp11::register]] cpp11::writable::list -invalid_resolve_year_quarter_day_impl(cpp11::list_of fields, - const cpp11::integers& precision_int, - const cpp11::strings& invalid_string) { +invalid_resolve_year_quarter_day_cpp(cpp11::list_of fields, + const cpp11::integers& precision_int, + const cpp11::integers& start_int, + const cpp11::strings& invalid_string) { using namespace rclock; + + const quarterly::start start = parse_start(start_int); const enum invalid invalid_val = parse_invalid(invalid_string); cpp11::integers year = rquarterly::get_year(fields); @@ -485,15 +369,15 @@ invalid_resolve_year_quarter_day_impl(cpp11::list_of fields, cpp11::integers second = rquarterly::get_second(fields); cpp11::integers subsecond = rquarterly::get_subsecond(fields); - rquarterly::y y{year}; - rquarterly::yqn yqn{year, quarter}; - rquarterly::yqnqd yqnqd{year, quarter, day}; - rquarterly::yqnqdh yqnqdh{year, quarter, day, hour}; - rquarterly::yqnqdhm yqnqdhm{year, quarter, day, hour, minute}; - rquarterly::yqnqdhms yqnqdhms{year, quarter, day, hour, minute, second}; - rquarterly::yqnqdhmss yqnqdhmss1{year, quarter, day, hour, minute, second, subsecond}; - rquarterly::yqnqdhmss yqnqdhmss2{year, quarter, day, hour, minute, second, subsecond}; - rquarterly::yqnqdhmss yqnqdhmss3{year, quarter, day, hour, minute, second, subsecond}; + rquarterly::y y{year, start}; + rquarterly::yqn yqn{year, quarter, start}; + rquarterly::yqnqd yqnqd{year, quarter, day, start}; + rquarterly::yqnqdh yqnqdh{year, quarter, day, hour, start}; + rquarterly::yqnqdhm yqnqdhm{year, quarter, day, hour, minute, start}; + rquarterly::yqnqdhms yqnqdhms{year, quarter, day, hour, minute, second, start}; + rquarterly::yqnqdhmss yqnqdhmss1{year, quarter, day, hour, minute, second, subsecond, start}; + rquarterly::yqnqdhmss yqnqdhmss2{year, quarter, day, hour, minute, second, subsecond, start}; + rquarterly::yqnqdhmss yqnqdhmss3{year, quarter, day, hour, minute, second, subsecond, start}; switch (parse_precision(precision_int)) { case precision::year: return invalid_resolve_calendar_impl(y, invalid_val); @@ -508,45 +392,22 @@ invalid_resolve_year_quarter_day_impl(cpp11::list_of fields, default: clock_abort("Internal error: Invalid precision."); } - never_reached("invalid_resolve_year_quarter_day_impl"); -} - -[[cpp11::register]] -cpp11::writable::list -invalid_resolve_year_quarter_day_cpp(cpp11::list_of fields, - const cpp11::integers& precision_int, - const cpp11::integers& start_int, - const cpp11::strings& invalid_string) { - using namespace quarterly; - - switch (parse_start(start_int)) { - case start::january: return invalid_resolve_year_quarter_day_impl(fields, precision_int, invalid_string); - case start::february: return invalid_resolve_year_quarter_day_impl(fields, precision_int, invalid_string); - case start::march: return invalid_resolve_year_quarter_day_impl(fields, precision_int, invalid_string); - case start::april: return invalid_resolve_year_quarter_day_impl(fields, precision_int, invalid_string); - case start::may: return invalid_resolve_year_quarter_day_impl(fields, precision_int, invalid_string); - case start::june: return invalid_resolve_year_quarter_day_impl(fields, precision_int, invalid_string); - case start::july: return invalid_resolve_year_quarter_day_impl(fields, precision_int, invalid_string); - case start::august: return invalid_resolve_year_quarter_day_impl(fields, precision_int, invalid_string); - case start::september: return invalid_resolve_year_quarter_day_impl(fields, precision_int, invalid_string); - case start::october: return invalid_resolve_year_quarter_day_impl(fields, precision_int, invalid_string); - case start::november: return invalid_resolve_year_quarter_day_impl(fields, precision_int, invalid_string); - case start::december: return invalid_resolve_year_quarter_day_impl(fields, precision_int, invalid_string); - } - never_reached("invalid_resolve_year_quarter_day_cpp"); } // ----------------------------------------------------------------------------- -template -static +[[cpp11::register]] cpp11::writable::list -set_field_year_quarter_day_impl(cpp11::list_of fields, - const cpp11::integers& value, - const cpp11::integers& precision_fields, - const cpp11::integers& precision_value) { +set_field_year_quarter_day_cpp(cpp11::list_of fields, + const cpp11::integers& value, + const cpp11::integers& precision_fields, + const cpp11::integers& precision_value, + const cpp11::integers& start_int) { using namespace rclock; + + const quarterly::start start = parse_start(start_int); + rclock::integers value2(value); cpp11::integers year = rquarterly::get_year(fields); @@ -557,15 +418,15 @@ set_field_year_quarter_day_impl(cpp11::list_of fields, cpp11::integers second = rquarterly::get_second(fields); cpp11::integers subsecond = rquarterly::get_subsecond(fields); - rquarterly::y y{year}; - rquarterly::yqn yqn{year, quarter}; - rquarterly::yqnqd yqnqd{year, quarter, day}; - rquarterly::yqnqdh yqnqdh{year, quarter, day, hour}; - rquarterly::yqnqdhm yqnqdhm{year, quarter, day, hour, minute}; - rquarterly::yqnqdhms yqnqdhms{year, quarter, day, hour, minute, second}; - rquarterly::yqnqdhmss yqnqdhmss1{year, quarter, day, hour, minute, second, subsecond}; - rquarterly::yqnqdhmss yqnqdhmss2{year, quarter, day, hour, minute, second, subsecond}; - rquarterly::yqnqdhmss yqnqdhmss3{year, quarter, day, hour, minute, second, subsecond}; + rquarterly::y y{year, start}; + rquarterly::yqn yqn{year, quarter, start}; + rquarterly::yqnqd yqnqd{year, quarter, day, start}; + rquarterly::yqnqdh yqnqdh{year, quarter, day, hour, start}; + rquarterly::yqnqdhm yqnqdhm{year, quarter, day, hour, minute, start}; + rquarterly::yqnqdhms yqnqdhms{year, quarter, day, hour, minute, second, start}; + rquarterly::yqnqdhmss yqnqdhmss1{year, quarter, day, hour, minute, second, subsecond, start}; + rquarterly::yqnqdhmss yqnqdhmss2{year, quarter, day, hour, minute, second, subsecond, start}; + rquarterly::yqnqdhmss yqnqdhmss3{year, quarter, day, hour, minute, second, subsecond, start}; switch (parse_precision(precision_fields)) { case precision::year: { @@ -666,37 +527,10 @@ set_field_year_quarter_day_impl(cpp11::list_of fields, default: clock_abort("Internal error: Invalid precision."); } - never_reached("set_field_year_quarter_day_impl"); -} - -[[cpp11::register]] -cpp11::writable::list -set_field_year_quarter_day_cpp(cpp11::list_of fields, - const cpp11::integers& value, - const cpp11::integers& precision_fields, - const cpp11::integers& precision_value, - const cpp11::integers& start_int) { - using namespace quarterly; - - switch (parse_start(start_int)) { - case start::january: return set_field_year_quarter_day_impl(fields, value, precision_fields, precision_value); - case start::february: return set_field_year_quarter_day_impl(fields, value, precision_fields, precision_value); - case start::march: return set_field_year_quarter_day_impl(fields, value, precision_fields, precision_value); - case start::april: return set_field_year_quarter_day_impl(fields, value, precision_fields, precision_value); - case start::may: return set_field_year_quarter_day_impl(fields, value, precision_fields, precision_value); - case start::june: return set_field_year_quarter_day_impl(fields, value, precision_fields, precision_value); - case start::july: return set_field_year_quarter_day_impl(fields, value, precision_fields, precision_value); - case start::august: return set_field_year_quarter_day_impl(fields, value, precision_fields, precision_value); - case start::september: return set_field_year_quarter_day_impl(fields, value, precision_fields, precision_value); - case start::october: return set_field_year_quarter_day_impl(fields, value, precision_fields, precision_value); - case start::november: return set_field_year_quarter_day_impl(fields, value, precision_fields, precision_value); - case start::december: return set_field_year_quarter_day_impl(fields, value, precision_fields, precision_value); - } - never_reached("set_field_year_quarter_day_cpp"); } -template +template cpp11::writable::list set_field_year_quarter_day_last_impl(const Calendar& x) { const r_ssize size = x.size(); @@ -706,7 +540,7 @@ set_field_year_quarter_day_last_impl(const Calendar& x) { if (x.is_na(i)) { value[i] = r_int_na; } else { - quarterly::year_quarternum_quarterday yqnqdl = x.to_year_quarternum(i) / quarterly::last; + rclock::rquarterly::quarterly_shim::year_quarternum_quarterday_last yqnqdl{x.to_year_quarternum(i)}; value[i] = static_cast(static_cast(yqnqdl.quarterday())); } } @@ -717,12 +551,15 @@ set_field_year_quarter_day_last_impl(const Calendar& x) { return out; } -template +[[cpp11::register]] cpp11::writable::list -set_field_year_quarter_day_last_switch(cpp11::list_of fields, - const cpp11::integers& precision_fields) { +set_field_year_quarter_day_last_cpp(cpp11::list_of fields, + const cpp11::integers& precision_fields, + const cpp11::integers& start_int) { using namespace rclock; + const quarterly::start start = parse_start(start_int); + cpp11::integers year = rquarterly::get_year(fields); cpp11::integers quarter = rquarterly::get_quarter(fields); cpp11::integers day = rquarterly::get_day(fields); @@ -731,66 +568,43 @@ set_field_year_quarter_day_last_switch(cpp11::list_of fields, cpp11::integers second = rquarterly::get_second(fields); cpp11::integers subsecond = rquarterly::get_subsecond(fields); - rquarterly::y y{year}; - rquarterly::yqn yqn{year, quarter}; - rquarterly::yqnqd yqnqd{year, quarter, day}; - rquarterly::yqnqdh yqnqdh{year, quarter, day, hour}; - rquarterly::yqnqdhm yqnqdhm{year, quarter, day, hour, minute}; - rquarterly::yqnqdhms yqnqdhms{year, quarter, day, hour, minute, second}; - rquarterly::yqnqdhmss yqnqdhmss1{year, quarter, day, hour, minute, second, subsecond}; - rquarterly::yqnqdhmss yqnqdhmss2{year, quarter, day, hour, minute, second, subsecond}; - rquarterly::yqnqdhmss yqnqdhmss3{year, quarter, day, hour, minute, second, subsecond}; + rquarterly::yqn yqn{year, quarter, start}; + rquarterly::yqnqd yqnqd{year, quarter, day, start}; + rquarterly::yqnqdh yqnqdh{year, quarter, day, hour, start}; + rquarterly::yqnqdhm yqnqdhm{year, quarter, day, hour, minute, start}; + rquarterly::yqnqdhms yqnqdhms{year, quarter, day, hour, minute, second, start}; + rquarterly::yqnqdhmss yqnqdhmss1{year, quarter, day, hour, minute, second, subsecond, start}; + rquarterly::yqnqdhmss yqnqdhmss2{year, quarter, day, hour, minute, second, subsecond, start}; + rquarterly::yqnqdhmss yqnqdhmss3{year, quarter, day, hour, minute, second, subsecond, start}; switch (parse_precision(precision_fields)) { - case precision::quarter: return set_field_year_quarter_day_last_impl(yqn); - case precision::day: return set_field_year_quarter_day_last_impl(yqnqd); - case precision::hour: return set_field_year_quarter_day_last_impl(yqnqdh); - case precision::minute: return set_field_year_quarter_day_last_impl(yqnqdhm); - case precision::second: return set_field_year_quarter_day_last_impl(yqnqdhms); - case precision::millisecond: return set_field_year_quarter_day_last_impl(yqnqdhmss1); - case precision::microsecond: return set_field_year_quarter_day_last_impl(yqnqdhmss2); - case precision::nanosecond: return set_field_year_quarter_day_last_impl(yqnqdhmss3); + case precision::quarter: return set_field_year_quarter_day_last_impl(yqn); + case precision::day: return set_field_year_quarter_day_last_impl(yqnqd); + case precision::hour: return set_field_year_quarter_day_last_impl(yqnqdh); + case precision::minute: return set_field_year_quarter_day_last_impl(yqnqdhm); + case precision::second: return set_field_year_quarter_day_last_impl(yqnqdhms); + case precision::millisecond: return set_field_year_quarter_day_last_impl(yqnqdhmss1); + case precision::microsecond: return set_field_year_quarter_day_last_impl(yqnqdhmss2); + case precision::nanosecond: return set_field_year_quarter_day_last_impl(yqnqdhmss3); default: clock_abort("Internal error: Invalid precision."); } - never_reached("set_field_year_quarter_day_last_switch"); -} - -[[cpp11::register]] -cpp11::writable::list -set_field_year_quarter_day_last_cpp(cpp11::list_of fields, - const cpp11::integers& precision_fields, - const cpp11::integers& start_int) { - using namespace quarterly; - - switch (parse_start(start_int)) { - case start::january: return set_field_year_quarter_day_last_switch(fields, precision_fields); - case start::february: return set_field_year_quarter_day_last_switch(fields, precision_fields); - case start::march: return set_field_year_quarter_day_last_switch(fields, precision_fields); - case start::april: return set_field_year_quarter_day_last_switch(fields, precision_fields); - case start::may: return set_field_year_quarter_day_last_switch(fields, precision_fields); - case start::june: return set_field_year_quarter_day_last_switch(fields, precision_fields); - case start::july: return set_field_year_quarter_day_last_switch(fields, precision_fields); - case start::august: return set_field_year_quarter_day_last_switch(fields, precision_fields); - case start::september: return set_field_year_quarter_day_last_switch(fields, precision_fields); - case start::october: return set_field_year_quarter_day_last_switch(fields, precision_fields); - case start::november: return set_field_year_quarter_day_last_switch(fields, precision_fields); - case start::december: return set_field_year_quarter_day_last_switch(fields, precision_fields); - } - never_reached("set_field_year_quarter_day_last_cpp"); } // ----------------------------------------------------------------------------- -template +[[cpp11::register]] cpp11::writable::list -year_quarter_day_plus_duration_impl(cpp11::list_of fields, - cpp11::list_of fields_n, - const cpp11::integers& precision_fields, - const cpp11::integers& precision_n) { +year_quarter_day_plus_duration_cpp(cpp11::list_of fields, + cpp11::list_of fields_n, + const cpp11::integers& precision_fields, + const cpp11::integers& precision_n, + const cpp11::integers& start_int) { using namespace rclock; + const quarterly::start start = parse_start(start_int); + const enum precision precision_fields_val = parse_precision(precision_fields); const enum precision precision_n_val = parse_precision(precision_n); @@ -802,15 +616,15 @@ year_quarter_day_plus_duration_impl(cpp11::list_of fields, cpp11::integers second = rquarterly::get_second(fields); cpp11::integers subsecond = rquarterly::get_subsecond(fields); - rquarterly::y y{year}; - rquarterly::yqn yqn{year, quarter}; - rquarterly::yqnqd yqnqd{year, quarter, day}; - rquarterly::yqnqdh yqnqdh{year, quarter, day, hour}; - rquarterly::yqnqdhm yqnqdhm{year, quarter, day, hour, minute}; - rquarterly::yqnqdhms yqnqdhms{year, quarter, day, hour, minute, second}; - rquarterly::yqnqdhmss yqnqdhmss1{year, quarter, day, hour, minute, second, subsecond}; - rquarterly::yqnqdhmss yqnqdhmss2{year, quarter, day, hour, minute, second, subsecond}; - rquarterly::yqnqdhmss yqnqdhmss3{year, quarter, day, hour, minute, second, subsecond}; + rquarterly::y y{year, start}; + rquarterly::yqn yqn{year, quarter, start}; + rquarterly::yqnqd yqnqd{year, quarter, day, start}; + rquarterly::yqnqdh yqnqdh{year, quarter, day, hour, start}; + rquarterly::yqnqdhm yqnqdhm{year, quarter, day, hour, minute, start}; + rquarterly::yqnqdhms yqnqdhms{year, quarter, day, hour, minute, second, start}; + rquarterly::yqnqdhmss yqnqdhmss1{year, quarter, day, hour, minute, second, subsecond, start}; + rquarterly::yqnqdhmss yqnqdhmss2{year, quarter, day, hour, minute, second, subsecond, start}; + rquarterly::yqnqdhmss yqnqdhmss3{year, quarter, day, hour, minute, second, subsecond, start}; cpp11::integers ticks = duration::get_ticks(fields_n); @@ -874,44 +688,20 @@ year_quarter_day_plus_duration_impl(cpp11::list_of fields, default: clock_abort("Internal error: Invalid precision."); } - never_reached("year_quarter_day_plus_duration_impl"); -} - -[[cpp11::register]] -cpp11::writable::list -year_quarter_day_plus_duration_cpp(cpp11::list_of fields, - cpp11::list_of fields_n, - const cpp11::integers& precision_fields, - const cpp11::integers& precision_n, - const cpp11::integers& start_int) { - using namespace quarterly; - - switch (parse_start(start_int)) { - case start::january: return year_quarter_day_plus_duration_impl(fields, fields_n, precision_fields, precision_n); - case start::february: return year_quarter_day_plus_duration_impl(fields, fields_n, precision_fields, precision_n); - case start::march: return year_quarter_day_plus_duration_impl(fields, fields_n, precision_fields, precision_n); - case start::april: return year_quarter_day_plus_duration_impl(fields, fields_n, precision_fields, precision_n); - case start::may: return year_quarter_day_plus_duration_impl(fields, fields_n, precision_fields, precision_n); - case start::june: return year_quarter_day_plus_duration_impl(fields, fields_n, precision_fields, precision_n); - case start::july: return year_quarter_day_plus_duration_impl(fields, fields_n, precision_fields, precision_n); - case start::august: return year_quarter_day_plus_duration_impl(fields, fields_n, precision_fields, precision_n); - case start::september: return year_quarter_day_plus_duration_impl(fields, fields_n, precision_fields, precision_n); - case start::october: return year_quarter_day_plus_duration_impl(fields, fields_n, precision_fields, precision_n); - case start::november: return year_quarter_day_plus_duration_impl(fields, fields_n, precision_fields, precision_n); - case start::december: return year_quarter_day_plus_duration_impl(fields, fields_n, precision_fields, precision_n); - } - never_reached("year_quarter_day_plus_duration_cpp"); } // ----------------------------------------------------------------------------- -template +[[cpp11::register]] cpp11::writable::list -as_sys_time_year_quarter_day_impl(cpp11::list_of fields, - const cpp11::integers& precision_int) { +as_sys_time_year_quarter_day_cpp(cpp11::list_of fields, + const cpp11::integers& precision_int, + const cpp11::integers& start_int) { using namespace rclock; + const quarterly::start start = parse_start(start_int); + cpp11::integers year = rquarterly::get_year(fields); cpp11::integers quarter = rquarterly::get_quarter(fields); cpp11::integers day = rquarterly::get_day(fields); @@ -920,15 +710,13 @@ as_sys_time_year_quarter_day_impl(cpp11::list_of fields, cpp11::integers second = rquarterly::get_second(fields); cpp11::integers subsecond = rquarterly::get_subsecond(fields); - rquarterly::y y{year}; - rquarterly::yqn yqn{year, quarter}; - rquarterly::yqnqd yqnqd{year, quarter, day}; - rquarterly::yqnqdh yqnqdh{year, quarter, day, hour}; - rquarterly::yqnqdhm yqnqdhm{year, quarter, day, hour, minute}; - rquarterly::yqnqdhms yqnqdhms{year, quarter, day, hour, minute, second}; - rquarterly::yqnqdhmss yqnqdhmss1{year, quarter, day, hour, minute, second, subsecond}; - rquarterly::yqnqdhmss yqnqdhmss2{year, quarter, day, hour, minute, second, subsecond}; - rquarterly::yqnqdhmss yqnqdhmss3{year, quarter, day, hour, minute, second, subsecond}; + rquarterly::yqnqd yqnqd{year, quarter, day, start}; + rquarterly::yqnqdh yqnqdh{year, quarter, day, hour, start}; + rquarterly::yqnqdhm yqnqdhm{year, quarter, day, hour, minute, start}; + rquarterly::yqnqdhms yqnqdhms{year, quarter, day, hour, minute, second, start}; + rquarterly::yqnqdhmss yqnqdhmss1{year, quarter, day, hour, minute, second, subsecond, start}; + rquarterly::yqnqdhmss yqnqdhmss2{year, quarter, day, hour, minute, second, subsecond, start}; + rquarterly::yqnqdhmss yqnqdhmss3{year, quarter, day, hour, minute, second, subsecond, start}; switch (parse_precision(precision_int)) { case precision::day: return as_sys_time_from_calendar_impl(yqnqd); @@ -950,42 +738,40 @@ as_sys_time_year_quarter_day_impl(cpp11::list_of fields, } } - never_reached("as_sys_time_year_quarter_day_impl"); + never_reached("as_sys_time_year_quarter_day_cpp"); } -[[cpp11::register]] +// ----------------------------------------------------------------------------- + +template cpp11::writable::list -as_sys_time_year_quarter_day_cpp(cpp11::list_of fields, - const cpp11::integers& precision_int, - const cpp11::integers& start_int) { - using namespace quarterly; - - switch (parse_start(start_int)) { - case start::january: return as_sys_time_year_quarter_day_impl(fields, precision_int); - case start::february: return as_sys_time_year_quarter_day_impl(fields, precision_int); - case start::march: return as_sys_time_year_quarter_day_impl(fields, precision_int); - case start::april: return as_sys_time_year_quarter_day_impl(fields, precision_int); - case start::may: return as_sys_time_year_quarter_day_impl(fields, precision_int); - case start::june: return as_sys_time_year_quarter_day_impl(fields, precision_int); - case start::july: return as_sys_time_year_quarter_day_impl(fields, precision_int); - case start::august: return as_sys_time_year_quarter_day_impl(fields, precision_int); - case start::september: return as_sys_time_year_quarter_day_impl(fields, precision_int); - case start::october: return as_sys_time_year_quarter_day_impl(fields, precision_int); - case start::november: return as_sys_time_year_quarter_day_impl(fields, precision_int); - case start::december: return as_sys_time_year_quarter_day_impl(fields, precision_int); +as_year_quarter_day_from_sys_time_impl(const ClockDuration& x, quarterly::start start) { + const r_ssize size = x.size(); + Calendar out(size, start); + using Duration = typename ClockDuration::duration; + + for (r_ssize i = 0; i < size; ++i) { + if (x.is_na(i)) { + out.assign_na(i); + } else { + Duration elt = x[i]; + date::sys_time elt_st{elt}; + out.assign_sys_time(elt_st, i); + } } - never_reached("as_sys_time_year_quarter_day_cpp"); + return out.to_list(); } -// ----------------------------------------------------------------------------- - -template +[[cpp11::register]] cpp11::writable::list -as_year_quarter_day_from_sys_time_impl(cpp11::list_of fields, - const cpp11::integers& precision_int) { +as_year_quarter_day_from_sys_time_cpp(cpp11::list_of fields, + const cpp11::integers& precision_int, + const cpp11::integers& start_int) { using namespace rclock; + const quarterly::start start = parse_start(start_int); + cpp11::integers ticks = duration::get_ticks(fields); cpp11::integers ticks_of_day = duration::get_ticks_of_day(fields); cpp11::integers ticks_of_second = duration::get_ticks_of_second(fields); @@ -999,52 +785,26 @@ as_year_quarter_day_from_sys_time_impl(cpp11::list_of fields, duration::nanoseconds dnano{ticks, ticks_of_day, ticks_of_second}; switch (parse_precision(precision_int)) { - case precision::day: return as_calendar_from_sys_time_impl>(dd); - case precision::hour: return as_calendar_from_sys_time_impl>(dh); - case precision::minute: return as_calendar_from_sys_time_impl>(dmin); - case precision::second: return as_calendar_from_sys_time_impl>(ds); - case precision::millisecond: return as_calendar_from_sys_time_impl>(dmilli); - case precision::microsecond: return as_calendar_from_sys_time_impl>(dmicro); - case precision::nanosecond: return as_calendar_from_sys_time_impl>(dnano); + case precision::day: return as_year_quarter_day_from_sys_time_impl(dd, start); + case precision::hour: return as_year_quarter_day_from_sys_time_impl(dh, start); + case precision::minute: return as_year_quarter_day_from_sys_time_impl(dmin, start); + case precision::second: return as_year_quarter_day_from_sys_time_impl(ds, start); + case precision::millisecond: return as_year_quarter_day_from_sys_time_impl>(dmilli, start); + case precision::microsecond: return as_year_quarter_day_from_sys_time_impl>(dmicro, start); + case precision::nanosecond: return as_year_quarter_day_from_sys_time_impl>(dnano, start); default: clock_abort("Internal error: Invalid precision."); } - never_reached("as_year_quarter_day_from_sys_time_impl"); -} - -[[cpp11::register]] -cpp11::writable::list -as_year_quarter_day_from_sys_time_cpp(cpp11::list_of fields, - const cpp11::integers& precision_int, - const cpp11::integers& start_int) { - using namespace quarterly; - - switch (parse_start(start_int)) { - case start::january: return as_year_quarter_day_from_sys_time_impl(fields, precision_int); - case start::february: return as_year_quarter_day_from_sys_time_impl(fields, precision_int); - case start::march: return as_year_quarter_day_from_sys_time_impl(fields, precision_int); - case start::april: return as_year_quarter_day_from_sys_time_impl(fields, precision_int); - case start::may: return as_year_quarter_day_from_sys_time_impl(fields, precision_int); - case start::june: return as_year_quarter_day_from_sys_time_impl(fields, precision_int); - case start::july: return as_year_quarter_day_from_sys_time_impl(fields, precision_int); - case start::august: return as_year_quarter_day_from_sys_time_impl(fields, precision_int); - case start::september: return as_year_quarter_day_from_sys_time_impl(fields, precision_int); - case start::october: return as_year_quarter_day_from_sys_time_impl(fields, precision_int); - case start::november: return as_year_quarter_day_from_sys_time_impl(fields, precision_int); - case start::december: return as_year_quarter_day_from_sys_time_impl(fields, precision_int); - } - never_reached("as_year_quarter_day_from_sys_time_cpp"); } // ----------------------------------------------------------------------------- -template static inline cpp11::writable::list -year_minus_year_impl(const rclock::rquarterly::y& x, - const rclock::rquarterly::y& y) { +year_minus_year_impl(const rclock::rquarterly::y& x, + const rclock::rquarterly::y& y) { const r_ssize size = x.size(); rclock::duration::years out(size); @@ -1059,12 +819,11 @@ year_minus_year_impl(const rclock::rquarterly::y& x, return out.to_list(); } -template static inline cpp11::writable::list -year_quarter_minus_year_quarter_impl(const rclock::rquarterly::yqn& x, - const rclock::rquarterly::yqn& y) { +year_quarter_minus_year_quarter_impl(const rclock::rquarterly::yqn& x, + const rclock::rquarterly::yqn& y) { const r_ssize size = x.size(); rclock::duration::quarters out(size); @@ -1079,22 +838,25 @@ year_quarter_minus_year_quarter_impl(const rclock::rquarterly::yqn& x, return out.to_list(); } -template +[[cpp11::register]] cpp11::writable::list -year_quarter_day_minus_year_quarter_day_impl(cpp11::list_of x, - cpp11::list_of y, - const cpp11::integers& precision_int) { +year_quarter_day_minus_year_quarter_day_cpp(cpp11::list_of x, + cpp11::list_of y, + const cpp11::integers& precision_int, + const cpp11::integers& start_int) { + quarterly::start start = parse_start(start_int); + const cpp11::integers x_year = rclock::rquarterly::get_year(x); const cpp11::integers x_quarter = rclock::rquarterly::get_quarter(x); const cpp11::integers y_year = rclock::rquarterly::get_year(y); const cpp11::integers y_quarter = rclock::rquarterly::get_quarter(y); - const rclock::rquarterly::y x_y{x_year}; - const rclock::rquarterly::yqn x_yqn{x_year, x_quarter}; + const rclock::rquarterly::y x_y{x_year, start}; + const rclock::rquarterly::yqn x_yqn{x_year, x_quarter, start}; - const rclock::rquarterly::y y_y{y_year}; - const rclock::rquarterly::yqn y_yqn{y_year, y_quarter}; + const rclock::rquarterly::y y_y{y_year, start}; + const rclock::rquarterly::yqn y_yqn{y_year, y_quarter, start}; switch (parse_precision(precision_int)) { case precision::year: return year_minus_year_impl(x_y, y_y); @@ -1102,31 +864,5 @@ year_quarter_day_minus_year_quarter_day_impl(cpp11::list_of x, default: clock_abort("Internal error: Invalid precision."); } - never_reached("year_quarter_day_minus_year_quarter_day_impl"); -} - -[[cpp11::register]] -cpp11::writable::list -year_quarter_day_minus_year_quarter_day_cpp(cpp11::list_of x, - cpp11::list_of y, - const cpp11::integers& precision_int, - const cpp11::integers& start_int) { - using namespace quarterly; - - switch (parse_start(start_int)) { - case start::january: return year_quarter_day_minus_year_quarter_day_impl(x, y, precision_int); - case start::february: return year_quarter_day_minus_year_quarter_day_impl(x, y, precision_int); - case start::march: return year_quarter_day_minus_year_quarter_day_impl(x, y, precision_int); - case start::april: return year_quarter_day_minus_year_quarter_day_impl(x, y, precision_int); - case start::may: return year_quarter_day_minus_year_quarter_day_impl(x, y, precision_int); - case start::june: return year_quarter_day_minus_year_quarter_day_impl(x, y, precision_int); - case start::july: return year_quarter_day_minus_year_quarter_day_impl(x, y, precision_int); - case start::august: return year_quarter_day_minus_year_quarter_day_impl(x, y, precision_int); - case start::september: return year_quarter_day_minus_year_quarter_day_impl(x, y, precision_int); - case start::october: return year_quarter_day_minus_year_quarter_day_impl(x, y, precision_int); - case start::november: return year_quarter_day_minus_year_quarter_day_impl(x, y, precision_int); - case start::december: return year_quarter_day_minus_year_quarter_day_impl(x, y, precision_int); - } - never_reached("year_quarter_day_minus_year_quarter_day_cpp"); } diff --git a/src/quarterly-year-quarter-day.h b/src/quarterly-year-quarter-day.h index 3c1e33ff..d4c785ec 100644 --- a/src/quarterly-year-quarter-day.h +++ b/src/quarterly-year-quarter-day.h @@ -2,6 +2,7 @@ #define CLOCK_QUARTERLY_YEAR_QUARTER_DAY_H #include "clock.h" +#include "quarterly-shim.h" #include "integers.h" #include "enums.h" #include "utils.h" @@ -33,18 +34,21 @@ stream_day(std::ostringstream& os, int day) NOEXCEPT return os; } -template inline -quarterly::year_quarternum_quarterday -resolve_next_day_yqd(const quarterly::year_quarternum_quarterday& x) { +quarterly_shim::year_quarternum_quarterday +resolve_next_day_yqd(const quarterly_shim::year_quarternum_quarterday& x) { return ((x.year() / x.quarternum()) + quarterly::quarters(1)) / quarterly::quarterday{1u}; } -template inline -quarterly::year_quarternum_quarterday -resolve_previous_day_yqd(const quarterly::year_quarternum_quarterday& x) { +quarterly_shim::year_quarternum_quarterday +resolve_previous_day_yqd(const quarterly_shim::year_quarternum_quarterday& x) { return x.year() / x.quarternum() / quarterly::last; } +inline +quarterly_shim::year_quarternum_quarterday +resolve_overflow_day_yqd(const quarterly_shim::year_quarternum_quarterday& x) { + return quarterly_shim::year_quarternum_quarterday{date::sys_days{x}, x.year().start()}; +} template inline void check_range(const int& value, const char* arg) { @@ -89,15 +93,15 @@ inline void check_range(const int& value, const char* arg } // namespace detail -template class y { protected: rclock::integers year_; + quarterly::start start_; public: - y(r_ssize size); - y(const cpp11::integers& year); + y(r_ssize size, quarterly::start start); + y(const cpp11::integers& year, quarterly::start start); bool is_na(r_ssize i) const NOEXCEPT; r_ssize size() const NOEXCEPT; @@ -108,7 +112,7 @@ class y void add(const date::years& x, r_ssize i) NOEXCEPT; - void assign_year(const quarterly::year& x, r_ssize i) NOEXCEPT; + void assign_year(const quarterly_shim::year& x, r_ssize i) NOEXCEPT; void assign_na(r_ssize i) NOEXCEPT; template @@ -116,20 +120,20 @@ class y void resolve(r_ssize i, const enum invalid type); - quarterly::year to_year(r_ssize i) const NOEXCEPT; + quarterly_shim::year to_year(r_ssize i) const NOEXCEPT; cpp11::writable::list to_list() const; }; -template -class yqn : public y +class yqn : public y { protected: rclock::integers quarter_; public: - yqn(r_ssize size); + yqn(r_ssize size, quarterly::start start); yqn(const cpp11::integers& year, - const cpp11::integers& quarter); + const cpp11::integers& quarter, + quarterly::start start); std::ostringstream& stream(std::ostringstream&, r_ssize i) const NOEXCEPT; @@ -138,55 +142,55 @@ class yqn : public y void add(const quarterly::quarters& x, r_ssize i) NOEXCEPT; void assign_quarternum(const quarterly::quarternum& x, r_ssize i) NOEXCEPT; - void assign_year_quarternum(const quarterly::year_quarternum& x, r_ssize i) NOEXCEPT; + void assign_year_quarternum(const quarterly_shim::year_quarternum& x, r_ssize i) NOEXCEPT; void assign_na(r_ssize i) NOEXCEPT; void resolve(r_ssize i, const enum invalid type); - quarterly::year_quarternum to_year_quarternum(r_ssize i) const NOEXCEPT; + quarterly_shim::year_quarternum to_year_quarternum(r_ssize i) const NOEXCEPT; cpp11::writable::list to_list() const; }; -template -class yqnqd : public yqn +class yqnqd : public yqn { protected: rclock::integers day_; public: - yqnqd(r_ssize size); + yqnqd(r_ssize size, quarterly::start start); yqnqd(const cpp11::integers& year, const cpp11::integers& quarter, - const cpp11::integers& day); + const cpp11::integers& day, + quarterly::start start); std::ostringstream& stream(std::ostringstream&, r_ssize i) const NOEXCEPT; bool ok(r_ssize i) const NOEXCEPT; void assign_quarterday(const quarterly::quarterday& x, r_ssize i) NOEXCEPT; - void assign_year_quarternum_quarterday(const quarterly::year_quarternum_quarterday& x, r_ssize i) NOEXCEPT; + void assign_year_quarternum_quarterday(const quarterly_shim::year_quarternum_quarterday& x, r_ssize i) NOEXCEPT; void assign_sys_time(const date::sys_time& x, r_ssize i) NOEXCEPT; void assign_na(r_ssize i) NOEXCEPT; void resolve(r_ssize i, const enum invalid type); date::sys_time to_sys_time(r_ssize i) const NOEXCEPT; - quarterly::year_quarternum_quarterday to_year_quarternum_quarterday(r_ssize i) const NOEXCEPT; + quarterly_shim::year_quarternum_quarterday to_year_quarternum_quarterday(r_ssize i) const NOEXCEPT; cpp11::writable::list to_list() const; }; -template -class yqnqdh : public yqnqd +class yqnqdh : public yqnqd { protected: rclock::integers hour_; public: - yqnqdh(r_ssize size); + yqnqdh(r_ssize size, quarterly::start start); yqnqdh(const cpp11::integers& year, const cpp11::integers& quarter, const cpp11::integers& day, - const cpp11::integers& hour); + const cpp11::integers& hour, + quarterly::start start); std::ostringstream& stream(std::ostringstream&, r_ssize i) const NOEXCEPT; @@ -200,19 +204,19 @@ class yqnqdh : public yqnqd cpp11::writable::list to_list() const; }; -template -class yqnqdhm : public yqnqdh +class yqnqdhm : public yqnqdh { protected: rclock::integers minute_; public: - yqnqdhm(r_ssize size); + yqnqdhm(r_ssize size, quarterly::start start); yqnqdhm(const cpp11::integers& year, const cpp11::integers& quarter, const cpp11::integers& day, const cpp11::integers& hour, - const cpp11::integers& minute); + const cpp11::integers& minute, + quarterly::start start); std::ostringstream& stream(std::ostringstream&, r_ssize i) const NOEXCEPT; @@ -226,20 +230,20 @@ class yqnqdhm : public yqnqdh cpp11::writable::list to_list() const; }; -template -class yqnqdhms : public yqnqdhm +class yqnqdhms : public yqnqdhm { protected: rclock::integers second_; public: - yqnqdhms(r_ssize size); + yqnqdhms(r_ssize size, quarterly::start start); yqnqdhms(const cpp11::integers& year, const cpp11::integers& quarter, const cpp11::integers& day, const cpp11::integers& hour, const cpp11::integers& minute, - const cpp11::integers& second); + const cpp11::integers& second, + quarterly::start start); std::ostringstream& stream(std::ostringstream&, r_ssize i) const NOEXCEPT; @@ -253,21 +257,22 @@ class yqnqdhms : public yqnqdhm cpp11::writable::list to_list() const; }; -template -class yqnqdhmss : public yqnqdhms +template +class yqnqdhmss : public yqnqdhms { protected: rclock::integers subsecond_; public: - yqnqdhmss(r_ssize size); + yqnqdhmss(r_ssize size, quarterly::start start); yqnqdhmss(const cpp11::integers& year, const cpp11::integers& quarter, const cpp11::integers& day, const cpp11::integers& hour, const cpp11::integers& minute, const cpp11::integers& second, - const cpp11::integers& subsecond); + const cpp11::integers& subsecond, + quarterly::start start); std::ostringstream& stream(std::ostringstream&, r_ssize i) const NOEXCEPT; @@ -285,104 +290,93 @@ class yqnqdhmss : public yqnqdhms // y -template inline -y::y(r_ssize size) - : year_(size) +y::y(r_ssize size, quarterly::start start) + : year_(size), + start_(start) {} -template inline -y::y(const cpp11::integers& year) - : year_(rclock::integers(year)) +y::y(const cpp11::integers& year, quarterly::start start) + : year_(rclock::integers(year)), + start_(start) {} -template inline bool -y::is_na(r_ssize i) const NOEXCEPT +y::is_na(r_ssize i) const NOEXCEPT { return year_.is_na(i); } -template inline r_ssize -y::size() const NOEXCEPT +y::size() const NOEXCEPT { return year_.size(); } -template inline std::ostringstream& -y::stream(std::ostringstream& os, r_ssize i) const NOEXCEPT +y::stream(std::ostringstream& os, r_ssize i) const NOEXCEPT { rclock::detail::stream_year(os, year_[i]); return os; } -template inline bool -y::ok(r_ssize i) const NOEXCEPT +y::ok(r_ssize i) const NOEXCEPT { return true; } -template inline void -y::add(const date::years& x, r_ssize i) NOEXCEPT +y::add(const date::years& x, r_ssize i) NOEXCEPT { assign_year(to_year(i) + x, i); } -template inline void -y::assign_year(const quarterly::year& x, r_ssize i) NOEXCEPT +y::assign_year(const quarterly_shim::year& x, r_ssize i) NOEXCEPT { year_.assign(static_cast(x), i); } -template inline void -y::assign_na(r_ssize i) NOEXCEPT +y::assign_na(r_ssize i) NOEXCEPT { year_.assign_na(i); } -template inline void -y::resolve(r_ssize i, const enum invalid type) +y::resolve(r_ssize i, const enum invalid type) { // Never invalid } -template template inline void -y::check_range(const int& value, const char* arg) const +y::check_range(const int& value, const char* arg) const { detail::check_range(value, arg); } -template inline -quarterly::year -y::to_year(r_ssize i) const NOEXCEPT +quarterly_shim::year +y::to_year(r_ssize i) const NOEXCEPT { - return quarterly::year{year_[i]}; + return quarterly_shim::year{year_[i], start_}; } -template inline cpp11::writable::list -y::to_list() const +y::to_list() const { cpp11::writable::list out({year_.sexp()}); out.names() = {"year"}; @@ -391,179 +385,161 @@ y::to_list() const // yqn -template inline -yqn::yqn(r_ssize size) - : y(size), +yqn::yqn(r_ssize size, quarterly::start start) + : y(size, start), quarter_(size) {} -template inline -yqn::yqn(const cpp11::integers& year, - const cpp11::integers& quarter) - : y(year), +yqn::yqn(const cpp11::integers& year, + const cpp11::integers& quarter, + quarterly::start start) + : y(year, start), quarter_(quarter) {} -template inline std::ostringstream& -yqn::stream(std::ostringstream& os, r_ssize i) const NOEXCEPT +yqn::stream(std::ostringstream& os, r_ssize i) const NOEXCEPT { - y::stream(os, i); + y::stream(os, i); os << '-'; detail::stream_quarter(os, quarter_[i]); return os; } -template inline bool -yqn::ok(r_ssize i) const NOEXCEPT +yqn::ok(r_ssize i) const NOEXCEPT { return true; } -template inline void -yqn::add(const quarterly::quarters& x, r_ssize i) NOEXCEPT +yqn::add(const quarterly::quarters& x, r_ssize i) NOEXCEPT { assign_year_quarternum(to_year_quarternum(i) + x, i); } -template inline void -yqn::assign_quarternum(const quarterly::quarternum& x, r_ssize i) NOEXCEPT +yqn::assign_quarternum(const quarterly::quarternum& x, r_ssize i) NOEXCEPT { quarter_.assign(static_cast(static_cast(x)), i); } -template inline void -yqn::assign_year_quarternum(const quarterly::year_quarternum& x, r_ssize i) NOEXCEPT +yqn::assign_year_quarternum(const quarterly_shim::year_quarternum& x, r_ssize i) NOEXCEPT { - y::assign_year(x.year(), i); + y::assign_year(x.year(), i); assign_quarternum(x.quarternum(), i); } -template inline void -yqn::assign_na(r_ssize i) NOEXCEPT +yqn::assign_na(r_ssize i) NOEXCEPT { - y::assign_na(i); + y::assign_na(i); quarter_.assign_na(i); } -template inline void -yqn::resolve(r_ssize i, const enum invalid type) +yqn::resolve(r_ssize i, const enum invalid type) { // Never invalid } -template inline -quarterly::year_quarternum -yqn::to_year_quarternum(r_ssize i) const NOEXCEPT +quarterly_shim::year_quarternum +yqn::to_year_quarternum(r_ssize i) const NOEXCEPT { - return quarterly::year{y::year_[i]} / static_cast(quarter_[i]); + return y::to_year(i) / static_cast(quarter_[i]); } -template inline cpp11::writable::list -yqn::to_list() const +yqn::to_list() const { - cpp11::writable::list out({y::year_.sexp(), quarter_.sexp()}); + cpp11::writable::list out({y::year_.sexp(), quarter_.sexp()}); out.names() = {"year", "quarter"}; return out; } // yqnqd -template inline -yqnqd::yqnqd(r_ssize size) - : yqn(size), +yqnqd::yqnqd(r_ssize size, quarterly::start start) + : yqn(size, start), day_(size) {} -template inline -yqnqd::yqnqd(const cpp11::integers& year, - const cpp11::integers& quarter, - const cpp11::integers& day) - : yqn(year, quarter), +yqnqd::yqnqd(const cpp11::integers& year, + const cpp11::integers& quarter, + const cpp11::integers& day, + quarterly::start start) + : yqn(year, quarter, start), day_(day) {} -template inline std::ostringstream& -yqnqd::stream(std::ostringstream& os, r_ssize i) const NOEXCEPT +yqnqd::stream(std::ostringstream& os, r_ssize i) const NOEXCEPT { - yqn::stream(os, i); + yqn::stream(os, i); os << '-'; detail::stream_day(os, day_[i]); return os; } -template inline bool -yqnqd::ok(r_ssize i) const NOEXCEPT +yqnqd::ok(r_ssize i) const NOEXCEPT { return to_year_quarternum_quarterday(i).ok(); } -template inline void -yqnqd::assign_quarterday(const quarterly::quarterday& x, r_ssize i) NOEXCEPT +yqnqd::assign_quarterday(const quarterly::quarterday& x, r_ssize i) NOEXCEPT { day_.assign(static_cast(static_cast(x)), i); } -template inline void -yqnqd::assign_year_quarternum_quarterday(const quarterly::year_quarternum_quarterday& x, r_ssize i) NOEXCEPT +yqnqd::assign_year_quarternum_quarterday(const quarterly_shim::year_quarternum_quarterday& x, r_ssize i) NOEXCEPT { - yqn::assign_year(x.year(), i); - yqn::assign_quarternum(x.quarternum(), i); + yqn::assign_year(x.year(), i); + yqn::assign_quarternum(x.quarternum(), i); assign_quarterday(x.quarterday(), i); } -template inline void -yqnqd::assign_sys_time(const date::sys_time& x, r_ssize i) NOEXCEPT +yqnqd::assign_sys_time(const date::sys_time& x, r_ssize i) NOEXCEPT { - quarterly::year_quarternum_quarterday yqnqd{x}; + quarterly_shim::year_quarternum_quarterday yqnqd{x, y::start_}; assign_year_quarternum_quarterday(yqnqd, i); } -template inline void -yqnqd::assign_na(r_ssize i) NOEXCEPT +yqnqd::assign_na(r_ssize i) NOEXCEPT { - yqn::assign_na(i); + yqn::assign_na(i); day_.assign_na(i); } -template inline void -yqnqd::resolve(r_ssize i, const enum invalid type) +yqnqd::resolve(r_ssize i, const enum invalid type) { - const quarterly::year_quarternum_quarterday elt = to_year_quarternum_quarterday(i); + const quarterly_shim::year_quarternum_quarterday elt = to_year_quarternum_quarterday(i); if (elt.ok()) { return; @@ -582,7 +558,7 @@ yqnqd::resolve(r_ssize i, const enum invalid type) } case invalid::overflow_day: case invalid::overflow: { - assign_year_quarternum_quarterday(date::sys_days{elt}, i); + assign_year_quarternum_quarterday(detail::resolve_overflow_day_yqd(elt), i); break; } case invalid::na: { @@ -595,97 +571,87 @@ yqnqd::resolve(r_ssize i, const enum invalid type) } } -template inline date::sys_time -yqnqd::to_sys_time(r_ssize i) const NOEXCEPT +yqnqd::to_sys_time(r_ssize i) const NOEXCEPT { return date::sys_time{to_year_quarternum_quarterday(i)}; } -template inline -quarterly::year_quarternum_quarterday -yqnqd::to_year_quarternum_quarterday(r_ssize i) const NOEXCEPT +quarterly_shim::year_quarternum_quarterday +yqnqd::to_year_quarternum_quarterday(r_ssize i) const NOEXCEPT { - return yqn::to_year_quarternum(i) / - static_cast(day_[i]); + return yqn::to_year_quarternum(i) / static_cast(day_[i]); } -template inline cpp11::writable::list -yqnqd::to_list() const +yqnqd::to_list() const { - cpp11::writable::list out({yqn::year_.sexp(), yqn::quarter_.sexp(), day_.sexp()}); + cpp11::writable::list out({yqn::year_.sexp(), yqn::quarter_.sexp(), day_.sexp()}); out.names() = {"year", "quarter", "day"}; return out; } // yqnqdh -template inline -yqnqdh::yqnqdh(r_ssize size) - : yqnqd(size), +yqnqdh::yqnqdh(r_ssize size, quarterly::start start) + : yqnqd(size, start), hour_(size) {} -template inline -yqnqdh::yqnqdh(const cpp11::integers& year, - const cpp11::integers& quarter, - const cpp11::integers& day, - const cpp11::integers& hour) - : yqnqd(year, quarter, day), +yqnqdh::yqnqdh(const cpp11::integers& year, + const cpp11::integers& quarter, + const cpp11::integers& day, + const cpp11::integers& hour, + quarterly::start start) + : yqnqd(year, quarter, day, start), hour_(hour) {} -template inline std::ostringstream& -yqnqdh::stream(std::ostringstream& os, r_ssize i) const NOEXCEPT +yqnqdh::stream(std::ostringstream& os, r_ssize i) const NOEXCEPT { - yqnqd::stream(os, i); + yqnqd::stream(os, i); os << 'T'; rclock::detail::stream_hour(os, hour_[i]); return os; } -template inline void -yqnqdh::assign_hour(const std::chrono::hours& x, r_ssize i) NOEXCEPT +yqnqdh::assign_hour(const std::chrono::hours& x, r_ssize i) NOEXCEPT { hour_.assign(x.count(), i); } -template inline void -yqnqdh::assign_sys_time(const date::sys_time& x, r_ssize i) NOEXCEPT +yqnqdh::assign_sys_time(const date::sys_time& x, r_ssize i) NOEXCEPT { const date::sys_time day_point = date::floor(x); const std::chrono::hours hours = x - day_point; - yqnqd::assign_sys_time(day_point, i); + yqnqd::assign_sys_time(day_point, i); assign_hour(hours, i); } -template inline void -yqnqdh::assign_na(r_ssize i) NOEXCEPT +yqnqdh::assign_na(r_ssize i) NOEXCEPT { - yqnqd::assign_na(i); + yqnqd::assign_na(i); hour_.assign_na(i); } -template inline void -yqnqdh::resolve(r_ssize i, const enum invalid type) +yqnqdh::resolve(r_ssize i, const enum invalid type) { - const quarterly::year_quarternum_quarterday elt = yqnqd::to_year_quarternum_quarterday(i); + const quarterly_shim::year_quarternum_quarterday elt = yqnqd::to_year_quarternum_quarterday(i); if (elt.ok()) { return; @@ -693,26 +659,27 @@ yqnqdh::resolve(r_ssize i, const enum invalid type) switch (type) { case invalid::next_day: - yqnqd::assign_year_quarternum_quarterday(detail::resolve_next_day_yqd(elt), i); + yqnqd::assign_year_quarternum_quarterday(detail::resolve_next_day_yqd(elt), i); break; case invalid::next: { - yqnqd::assign_year_quarternum_quarterday(detail::resolve_next_day_yqd(elt), i); + yqnqd::assign_year_quarternum_quarterday(detail::resolve_next_day_yqd(elt), i); assign_hour(rclock::detail::resolve_next_hour(), i); break; } case invalid::previous_day: - yqnqd::assign_quarterday(detail::resolve_previous_day_yqd(elt).quarterday(), i); + yqnqd::assign_quarterday(detail::resolve_previous_day_yqd(elt).quarterday(), i); break; case invalid::previous: { - yqnqd::assign_quarterday(detail::resolve_previous_day_yqd(elt).quarterday(), i); + yqnqd::assign_quarterday(detail::resolve_previous_day_yqd(elt).quarterday(), i); assign_hour(rclock::detail::resolve_previous_hour(), i); break; } - case invalid::overflow_day: - yqnqd::assign_year_quarternum_quarterday(date::sys_days{elt}, i); + case invalid::overflow_day: { + yqnqd::assign_year_quarternum_quarterday(detail::resolve_overflow_day_yqd(elt), i); break; + } case invalid::overflow: { - yqnqd::assign_year_quarternum_quarterday(date::sys_days{elt}, i); + yqnqd::assign_year_quarternum_quarterday(detail::resolve_overflow_day_yqd(elt), i); assign_hour(rclock::detail::resolve_next_hour(), i); break; } @@ -726,89 +693,81 @@ yqnqdh::resolve(r_ssize i, const enum invalid type) } } -template inline date::sys_time -yqnqdh::to_sys_time(r_ssize i) const NOEXCEPT +yqnqdh::to_sys_time(r_ssize i) const NOEXCEPT { - return yqnqd::to_sys_time(i) + std::chrono::hours{hour_[i]}; + return yqnqd::to_sys_time(i) + std::chrono::hours{hour_[i]}; } -template inline cpp11::writable::list -yqnqdh::to_list() const +yqnqdh::to_list() const { - cpp11::writable::list out({yqnqd::year_.sexp(), yqnqd::quarter_.sexp(), yqnqd::day_.sexp(), hour_.sexp()}); + cpp11::writable::list out({yqnqd::year_.sexp(), yqnqd::quarter_.sexp(), yqnqd::day_.sexp(), hour_.sexp()}); out.names() = {"year", "quarter", "day", "hour"}; return out; } // yqnqdhm -template inline -yqnqdhm::yqnqdhm(r_ssize size) - : yqnqdh(size), +yqnqdhm::yqnqdhm(r_ssize size, quarterly::start start) + : yqnqdh(size, start), minute_(size) {} -template inline -yqnqdhm::yqnqdhm(const cpp11::integers& year, - const cpp11::integers& quarter, - const cpp11::integers& day, - const cpp11::integers& hour, - const cpp11::integers& minute) - : yqnqdh(year, quarter, day, hour), +yqnqdhm::yqnqdhm(const cpp11::integers& year, + const cpp11::integers& quarter, + const cpp11::integers& day, + const cpp11::integers& hour, + const cpp11::integers& minute, + quarterly::start start) + : yqnqdh(year, quarter, day, hour, start), minute_(minute) {} -template inline std::ostringstream& -yqnqdhm::stream(std::ostringstream& os, r_ssize i) const NOEXCEPT +yqnqdhm::stream(std::ostringstream& os, r_ssize i) const NOEXCEPT { - yqnqdh::stream(os, i); + yqnqdh::stream(os, i); os << ':'; rclock::detail::stream_minute(os, minute_[i]); return os; } -template inline void -yqnqdhm::assign_minute(const std::chrono::minutes& x, r_ssize i) NOEXCEPT +yqnqdhm::assign_minute(const std::chrono::minutes& x, r_ssize i) NOEXCEPT { minute_.assign(x.count(), i); } -template inline void -yqnqdhm::assign_sys_time(const date::sys_time& x, r_ssize i) NOEXCEPT +yqnqdhm::assign_sys_time(const date::sys_time& x, r_ssize i) NOEXCEPT { const date::sys_time hour_point = date::floor(x); const std::chrono::minutes minutes = x - hour_point; - yqnqdh::assign_sys_time(hour_point, i); + yqnqdh::assign_sys_time(hour_point, i); assign_minute(minutes, i); } -template inline void -yqnqdhm::assign_na(r_ssize i) NOEXCEPT +yqnqdhm::assign_na(r_ssize i) NOEXCEPT { - yqnqdh::assign_na(i); + yqnqdh::assign_na(i); minute_.assign_na(i); } -template inline void -yqnqdhm::resolve(r_ssize i, const enum invalid type) +yqnqdhm::resolve(r_ssize i, const enum invalid type) { - const quarterly::year_quarternum_quarterday elt = yqnqdh::to_year_quarternum_quarterday(i); + const quarterly_shim::year_quarternum_quarterday elt = yqnqdh::to_year_quarternum_quarterday(i); if (elt.ok()) { return; @@ -816,29 +775,30 @@ yqnqdhm::resolve(r_ssize i, const enum invalid type) switch (type) { case invalid::next_day: - yqnqdh::assign_year_quarternum_quarterday(detail::resolve_next_day_yqd(elt), i); + yqnqdh::assign_year_quarternum_quarterday(detail::resolve_next_day_yqd(elt), i); break; case invalid::next: { - yqnqdh::assign_year_quarternum_quarterday(detail::resolve_next_day_yqd(elt), i); - yqnqdh::assign_hour(rclock::detail::resolve_next_hour(), i); + yqnqdh::assign_year_quarternum_quarterday(detail::resolve_next_day_yqd(elt), i); + yqnqdh::assign_hour(rclock::detail::resolve_next_hour(), i); assign_minute(rclock::detail::resolve_next_minute(), i); break; } case invalid::previous_day: - yqnqdh::assign_quarterday(detail::resolve_previous_day_yqd(elt).quarterday(), i); + yqnqdh::assign_quarterday(detail::resolve_previous_day_yqd(elt).quarterday(), i); break; case invalid::previous: { - yqnqdh::assign_quarterday(detail::resolve_previous_day_yqd(elt).quarterday(), i); - yqnqdh::assign_hour(rclock::detail::resolve_previous_hour(), i); + yqnqdh::assign_quarterday(detail::resolve_previous_day_yqd(elt).quarterday(), i); + yqnqdh::assign_hour(rclock::detail::resolve_previous_hour(), i); assign_minute(rclock::detail::resolve_previous_minute(), i); break; } - case invalid::overflow_day: - yqnqdh::assign_year_quarternum_quarterday(date::sys_days{elt}, i); + case invalid::overflow_day: { + yqnqdh::assign_year_quarternum_quarterday(detail::resolve_overflow_day_yqd(elt), i); break; + } case invalid::overflow: { - yqnqdh::assign_year_quarternum_quarterday(date::sys_days{elt}, i); - yqnqdh::assign_hour(rclock::detail::resolve_next_hour(), i); + yqnqdh::assign_year_quarternum_quarterday(detail::resolve_overflow_day_yqd(elt), i); + yqnqdh::assign_hour(rclock::detail::resolve_next_hour(), i); assign_minute(rclock::detail::resolve_next_minute(), i); break; } @@ -852,90 +812,82 @@ yqnqdhm::resolve(r_ssize i, const enum invalid type) } } -template inline date::sys_time -yqnqdhm::to_sys_time(r_ssize i) const NOEXCEPT +yqnqdhm::to_sys_time(r_ssize i) const NOEXCEPT { - return yqnqdh::to_sys_time(i) + std::chrono::minutes{minute_[i]}; + return yqnqdh::to_sys_time(i) + std::chrono::minutes{minute_[i]}; } -template inline cpp11::writable::list -yqnqdhm::to_list() const +yqnqdhm::to_list() const { - cpp11::writable::list out({yqnqdh::year_.sexp(), yqnqdh::quarter_.sexp(), yqnqdh::day_.sexp(), yqnqdh::hour_.sexp(), minute_.sexp()}); + cpp11::writable::list out({yqnqdh::year_.sexp(), yqnqdh::quarter_.sexp(), yqnqdh::day_.sexp(), yqnqdh::hour_.sexp(), minute_.sexp()}); out.names() = {"year", "quarter", "day", "hour", "minute"}; return out; } // yqnqdhms -template inline -yqnqdhms::yqnqdhms(r_ssize size) - : yqnqdhm(size), +yqnqdhms::yqnqdhms(r_ssize size, quarterly::start start) + : yqnqdhm(size, start), second_(size) {} -template inline -yqnqdhms::yqnqdhms(const cpp11::integers& year, - const cpp11::integers& quarter, - const cpp11::integers& day, - const cpp11::integers& hour, - const cpp11::integers& minute, - const cpp11::integers& second) - : yqnqdhm(year, quarter, day, hour, minute), +yqnqdhms::yqnqdhms(const cpp11::integers& year, + const cpp11::integers& quarter, + const cpp11::integers& day, + const cpp11::integers& hour, + const cpp11::integers& minute, + const cpp11::integers& second, + quarterly::start start) + : yqnqdhm(year, quarter, day, hour, minute, start), second_(second) {} -template inline std::ostringstream& -yqnqdhms::stream(std::ostringstream& os, r_ssize i) const NOEXCEPT +yqnqdhms::stream(std::ostringstream& os, r_ssize i) const NOEXCEPT { - yqnqdhm::stream(os, i); + yqnqdhm::stream(os, i); os << ':'; rclock::detail::stream_second(os, second_[i]); return os; } -template inline void -yqnqdhms::assign_second(const std::chrono::seconds& x, r_ssize i) NOEXCEPT +yqnqdhms::assign_second(const std::chrono::seconds& x, r_ssize i) NOEXCEPT { second_.assign(x.count(), i); } -template inline void -yqnqdhms::assign_sys_time(const date::sys_time& x, r_ssize i) NOEXCEPT +yqnqdhms::assign_sys_time(const date::sys_time& x, r_ssize i) NOEXCEPT { const date::sys_time minute_point = date::floor(x); const std::chrono::seconds seconds = x - minute_point; - yqnqdhm::assign_sys_time(minute_point, i); + yqnqdhm::assign_sys_time(minute_point, i); assign_second(seconds, i); } -template inline void -yqnqdhms::assign_na(r_ssize i) NOEXCEPT +yqnqdhms::assign_na(r_ssize i) NOEXCEPT { - yqnqdhm::assign_na(i); + yqnqdhm::assign_na(i); second_.assign_na(i); } -template inline void -yqnqdhms::resolve(r_ssize i, const enum invalid type) +yqnqdhms::resolve(r_ssize i, const enum invalid type) { - const quarterly::year_quarternum_quarterday elt = yqnqdhms::to_year_quarternum_quarterday(i); + const quarterly_shim::year_quarternum_quarterday elt = yqnqdhms::to_year_quarternum_quarterday(i); if (elt.ok()) { return; @@ -943,32 +895,33 @@ yqnqdhms::resolve(r_ssize i, const enum invalid type) switch (type) { case invalid::next_day: - yqnqdhm::assign_year_quarternum_quarterday(detail::resolve_next_day_yqd(elt), i); + yqnqdhm::assign_year_quarternum_quarterday(detail::resolve_next_day_yqd(elt), i); break; case invalid::next: { - yqnqdhm::assign_year_quarternum_quarterday(detail::resolve_next_day_yqd(elt), i); - yqnqdhm::assign_hour(rclock::detail::resolve_next_hour(), i); - yqnqdhm::assign_minute(rclock::detail::resolve_next_minute(), i); + yqnqdhm::assign_year_quarternum_quarterday(detail::resolve_next_day_yqd(elt), i); + yqnqdhm::assign_hour(rclock::detail::resolve_next_hour(), i); + yqnqdhm::assign_minute(rclock::detail::resolve_next_minute(), i); assign_second(rclock::detail::resolve_next_second(), i); break; } case invalid::previous_day: - yqnqdhm::assign_quarterday(detail::resolve_previous_day_yqd(elt).quarterday(), i); + yqnqdhm::assign_quarterday(detail::resolve_previous_day_yqd(elt).quarterday(), i); break; case invalid::previous: { - yqnqdhm::assign_quarterday(detail::resolve_previous_day_yqd(elt).quarterday(), i); - yqnqdhm::assign_hour(rclock::detail::resolve_previous_hour(), i); - yqnqdhm::assign_minute(rclock::detail::resolve_previous_minute(), i); + yqnqdhm::assign_quarterday(detail::resolve_previous_day_yqd(elt).quarterday(), i); + yqnqdhm::assign_hour(rclock::detail::resolve_previous_hour(), i); + yqnqdhm::assign_minute(rclock::detail::resolve_previous_minute(), i); assign_second(rclock::detail::resolve_previous_second(), i); break; } - case invalid::overflow_day: - yqnqdhm::assign_year_quarternum_quarterday(date::sys_days{elt}, i); + case invalid::overflow_day: { + yqnqdhm::assign_year_quarternum_quarterday(detail::resolve_overflow_day_yqd(elt), i); break; + } case invalid::overflow: { - yqnqdhm::assign_year_quarternum_quarterday(date::sys_days{elt}, i); - yqnqdhm::assign_hour(rclock::detail::resolve_next_hour(), i); - yqnqdhm::assign_minute(rclock::detail::resolve_next_minute(), i); + yqnqdhm::assign_year_quarternum_quarterday(detail::resolve_overflow_day_yqd(elt), i); + yqnqdhm::assign_hour(rclock::detail::resolve_next_hour(), i); + yqnqdhm::assign_minute(rclock::detail::resolve_next_minute(), i); assign_second(rclock::detail::resolve_next_second(), i); break; } @@ -982,91 +935,90 @@ yqnqdhms::resolve(r_ssize i, const enum invalid type) } } -template inline date::sys_time -yqnqdhms::to_sys_time(r_ssize i) const NOEXCEPT +yqnqdhms::to_sys_time(r_ssize i) const NOEXCEPT { - return yqnqdhm::to_sys_time(i) + std::chrono::seconds{second_[i]}; + return yqnqdhm::to_sys_time(i) + std::chrono::seconds{second_[i]}; } -template inline cpp11::writable::list -yqnqdhms::to_list() const +yqnqdhms::to_list() const { - cpp11::writable::list out({yqnqdhms::year_.sexp(), yqnqdhms::quarter_.sexp(), yqnqdhms::day_.sexp(), yqnqdhms::hour_.sexp(), yqnqdhms::minute_.sexp(), second_.sexp()}); + cpp11::writable::list out({yqnqdhms::year_.sexp(), yqnqdhms::quarter_.sexp(), yqnqdhms::day_.sexp(), yqnqdhms::hour_.sexp(), yqnqdhms::minute_.sexp(), second_.sexp()}); out.names() = {"year", "quarter", "day", "hour", "minute", "second"}; return out; } // yqnqdhmss -template +template inline -yqnqdhmss::yqnqdhmss(r_ssize size) - : yqnqdhms(size), +yqnqdhmss::yqnqdhmss(r_ssize size, quarterly::start start) + : yqnqdhms(size, start), subsecond_(size) {} -template -inline -yqnqdhmss::yqnqdhmss(const cpp11::integers& year, - const cpp11::integers& quarter, - const cpp11::integers& day, - const cpp11::integers& hour, - const cpp11::integers& minute, - const cpp11::integers& second, - const cpp11::integers& subsecond) - : yqnqdhms(year, quarter, day, hour, minute, second), +template +inline +yqnqdhmss::yqnqdhmss(const cpp11::integers& year, + const cpp11::integers& quarter, + const cpp11::integers& day, + const cpp11::integers& hour, + const cpp11::integers& minute, + const cpp11::integers& second, + const cpp11::integers& subsecond, + quarterly::start start) + : yqnqdhms(year, quarter, day, hour, minute, second, start), subsecond_(subsecond) {} -template +template inline std::ostringstream& -yqnqdhmss::stream(std::ostringstream& os, r_ssize i) const NOEXCEPT +yqnqdhmss::stream(std::ostringstream& os, r_ssize i) const NOEXCEPT { - yqnqdhm::stream(os, i); + yqnqdhm::stream(os, i); os << ':'; - rclock::detail::stream_second_and_subsecond(os, yqnqdhms::second_[i], subsecond_[i]); + rclock::detail::stream_second_and_subsecond(os, yqnqdhms::second_[i], subsecond_[i]); return os; } -template +template inline void -yqnqdhmss::assign_subsecond(const Duration& x, r_ssize i) NOEXCEPT +yqnqdhmss::assign_subsecond(const Duration& x, r_ssize i) NOEXCEPT { subsecond_.assign(x.count(), i); } -template +template inline void -yqnqdhmss::assign_sys_time(const date::sys_time& x, r_ssize i) NOEXCEPT +yqnqdhmss::assign_sys_time(const date::sys_time& x, r_ssize i) NOEXCEPT { const date::sys_time second_point = date::floor(x); const Duration subseconds = x - second_point; - yqnqdhms::assign_sys_time(second_point, i); + yqnqdhms::assign_sys_time(second_point, i); assign_subsecond(subseconds, i); } -template +template inline void -yqnqdhmss::assign_na(r_ssize i) NOEXCEPT +yqnqdhmss::assign_na(r_ssize i) NOEXCEPT { - yqnqdhms::assign_na(i); + yqnqdhms::assign_na(i); subsecond_.assign_na(i); } -template +template inline void -yqnqdhmss::resolve(r_ssize i, const enum invalid type) +yqnqdhmss::resolve(r_ssize i, const enum invalid type) { - const quarterly::year_quarternum_quarterday elt = yqnqdhms::to_year_quarternum_quarterday(i); + const quarterly_shim::year_quarternum_quarterday elt = yqnqdhms::to_year_quarternum_quarterday(i); if (elt.ok()) { return; @@ -1074,35 +1026,36 @@ yqnqdhmss::resolve(r_ssize i, const enum invalid type) switch (type) { case invalid::next_day: - yqnqdhms::assign_year_quarternum_quarterday(detail::resolve_next_day_yqd(elt), i); + yqnqdhms::assign_year_quarternum_quarterday(detail::resolve_next_day_yqd(elt), i); break; case invalid::next: { - yqnqdhms::assign_year_quarternum_quarterday(detail::resolve_next_day_yqd(elt), i); - yqnqdhms::assign_hour(rclock::detail::resolve_next_hour(), i); - yqnqdhms::assign_minute(rclock::detail::resolve_next_minute(), i); - yqnqdhms::assign_second(rclock::detail::resolve_next_second(), i); + yqnqdhms::assign_year_quarternum_quarterday(detail::resolve_next_day_yqd(elt), i); + yqnqdhms::assign_hour(rclock::detail::resolve_next_hour(), i); + yqnqdhms::assign_minute(rclock::detail::resolve_next_minute(), i); + yqnqdhms::assign_second(rclock::detail::resolve_next_second(), i); assign_subsecond(rclock::detail::resolve_next_subsecond(), i); break; } case invalid::previous_day: - yqnqdhms::assign_quarterday(detail::resolve_previous_day_yqd(elt).quarterday(), i); + yqnqdhms::assign_quarterday(detail::resolve_previous_day_yqd(elt).quarterday(), i); break; case invalid::previous: { - yqnqdhms::assign_quarterday(detail::resolve_previous_day_yqd(elt).quarterday(), i); - yqnqdhms::assign_hour(rclock::detail::resolve_previous_hour(), i); - yqnqdhms::assign_minute(rclock::detail::resolve_previous_minute(), i); - yqnqdhms::assign_second(rclock::detail::resolve_previous_second(), i); + yqnqdhms::assign_quarterday(detail::resolve_previous_day_yqd(elt).quarterday(), i); + yqnqdhms::assign_hour(rclock::detail::resolve_previous_hour(), i); + yqnqdhms::assign_minute(rclock::detail::resolve_previous_minute(), i); + yqnqdhms::assign_second(rclock::detail::resolve_previous_second(), i); assign_subsecond(rclock::detail::resolve_previous_subsecond(), i); break; } - case invalid::overflow_day: - yqnqdhms::assign_year_quarternum_quarterday(date::sys_days{elt}, i); + case invalid::overflow_day: { + yqnqdhms::assign_year_quarternum_quarterday(detail::resolve_overflow_day_yqd(elt), i); break; + } case invalid::overflow: { - yqnqdhms::assign_year_quarternum_quarterday(date::sys_days{elt}, i); - yqnqdhms::assign_hour(rclock::detail::resolve_next_hour(), i); - yqnqdhms::assign_minute(rclock::detail::resolve_next_minute(), i); - yqnqdhms::assign_second(rclock::detail::resolve_next_second(), i); + yqnqdhms::assign_year_quarternum_quarterday(detail::resolve_overflow_day_yqd(elt), i); + yqnqdhms::assign_hour(rclock::detail::resolve_next_hour(), i); + yqnqdhms::assign_minute(rclock::detail::resolve_next_minute(), i); + yqnqdhms::assign_second(rclock::detail::resolve_next_second(), i); assign_subsecond(rclock::detail::resolve_next_subsecond(), i); break; } @@ -1116,20 +1069,20 @@ yqnqdhmss::resolve(r_ssize i, const enum invalid type) } } -template +template inline date::sys_time -yqnqdhmss::to_sys_time(r_ssize i) const NOEXCEPT +yqnqdhmss::to_sys_time(r_ssize i) const NOEXCEPT { - return yqnqdhms::to_sys_time(i) + Duration{subsecond_[i]}; + return yqnqdhms::to_sys_time(i) + Duration{subsecond_[i]}; } -template +template inline cpp11::writable::list -yqnqdhmss::to_list() const +yqnqdhmss::to_list() const { - cpp11::writable::list out({yqnqdhms::year_.sexp(), yqnqdhms::quarter_.sexp(), yqnqdhms::day_.sexp(), yqnqdhms::hour_.sexp(), yqnqdhms::minute_.sexp(), yqnqdhms::second_.sexp(), subsecond_.sexp()}); + cpp11::writable::list out({yqnqdhms::year_.sexp(), yqnqdhms::quarter_.sexp(), yqnqdhms::day_.sexp(), yqnqdhms::hour_.sexp(), yqnqdhms::minute_.sexp(), yqnqdhms::second_.sexp(), subsecond_.sexp()}); out.names() = {"year", "quarter", "day", "hour", "minute", "second", "subsecond"}; return out; }