Move time utils to be in one place

We've accumulated several time utility functions in the http classes.
Time isn't a core HTTP primitive, so http is not where those functions
below.

This commit moves all the time functions from the crow::utility
namespace into the redfish::time_utils namespace, as well as moves the
unit tests.

No code changes where made to the individual functions, with the
exception of changing the namespace on the unit tests.

Tested: Unit tests pass.

Signed-off-by: Ed Tanous <edtanous@google.com>
Change-Id: I8493375f60aea31899c84ae703e0f71a17dbdb73

1 files changed, 0 insertions, 184 deletions

diff --git a/http/utility.hpp b/http/utility.hpp
index c9728f5b6d..e08e565b5b 100644
--- a/http/utility.hpp
+++ b/http/utility.hpp
@@ -539,190 +539,6 @@ inline bool base64Decode(const std::string_view input, std::string& output)
     return true;
 }
 
-namespace details
-{
-// Returns year/month/day triple in civil calendar
-// Preconditions:  z is number of days since 1970-01-01 and is in the range:
-//                   [numeric_limits<Int>::min(),
-//                   numeric_limits<Int>::max()-719468].
-// Algorithm sourced from
-// https://howardhinnant.github.io/date_algorithms.html#civil_from_days
-// All constants are explained in the above
-template <class IntType>
-constexpr std::tuple<IntType, unsigned, unsigned>
-    civilFromDays(IntType z) noexcept
-{
-    z += 719468;
-    IntType era = (z >= 0 ? z : z - 146096) / 146097;
-    unsigned doe = static_cast<unsigned>(z - era * 146097); // [0, 146096]
-    unsigned yoe =
-        (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365; // [0, 399]
-    IntType y = static_cast<IntType>(yoe) + era * 400;
-    unsigned doy = doe - (365 * yoe + yoe / 4 - yoe / 100); // [0, 365]
-    unsigned mp = (5 * doy + 2) / 153;                      // [0, 11]
-    unsigned d = doy - (153 * mp + 2) / 5 + 1;              // [1, 31]
-    unsigned m = mp < 10 ? mp + 3 : mp - 9;                 // [1, 12]
-
-    return std::tuple<IntType, unsigned, unsigned>(y + (m <= 2), m, d);
-}
-
-// Creates a string from an integer in the most efficient way possible without
-// using std::locale.  Adds an exact zero pad based on the pad input parameter.
-// Does not handle negative numbers.
-inline std::string padZeros(int value, size_t pad)
-{
-    std::string result(pad, '0');
-    for (int val = value; pad > 0; pad--)
-    {
-        result[pad - 1] = static_cast<char>('0' + val % 10);
-        val /= 10;
-    }
-    return result;
-}
-
-template <typename IntType, typename Period>
-std::string toISO8061ExtendedStr(std::chrono::duration<IntType, Period> t)
-{
-    using seconds = std::chrono::duration<int>;
-    using minutes = std::chrono::duration<int, std::ratio<60>>;
-    using hours = std::chrono::duration<int, std::ratio<3600>>;
-    using days = std::chrono::duration<
-        IntType, std::ratio_multiply<hours::period, std::ratio<24>>>;
-
-    // d is days since 1970-01-01
-    days d = std::chrono::duration_cast<days>(t);
-
-    // t is now time duration since midnight of day d
-    t -= d;
-
-    // break d down into year/month/day
-    int year = 0;
-    int month = 0;
-    int day = 0;
-    std::tie(year, month, day) = details::civilFromDays(d.count());
-    // Check against limits.  Can't go above year 9999, and can't go below epoch
-    // (1970)
-    if (year >= 10000)
-    {
-        year = 9999;
-        month = 12;
-        day = 31;
-        t = days(1) - std::chrono::duration<IntType, Period>(1);
-    }
-    else if (year < 1970)
-    {
-        year = 1970;
-        month = 1;
-        day = 1;
-        t = std::chrono::duration<IntType, Period>::zero();
-    }
-    std::string out;
-    out += details::padZeros(year, 4);
-    out += '-';
-    out += details::padZeros(month, 2);
-    out += '-';
-    out += details::padZeros(day, 2);
-
-    out += 'T';
-    hours hr = duration_cast<hours>(t);
-    out += details::padZeros(hr.count(), 2);
-    t -= hr;
-    out += ':';
-
-    minutes mt = duration_cast<minutes>(t);
-    out += details::padZeros(mt.count(), 2);
-    t -= mt;
-    out += ':';
-
-    seconds se = duration_cast<seconds>(t);
-    out += details::padZeros(se.count(), 2);
-    t -= se;
-
-    if constexpr (std::is_same_v<typename decltype(t)::period, std::milli>)
-    {
-        out += '.';
-        using MilliDuration = std::chrono::duration<int, std::milli>;
-        MilliDuration subsec = duration_cast<MilliDuration>(t);
-        out += details::padZeros(subsec.count(), 3);
-    }
-    else if constexpr (std::is_same_v<typename decltype(t)::period, std::micro>)
-    {
-        out += '.';
-        using MicroDuration = std::chrono::duration<int, std::micro>;
-        MicroDuration subsec = duration_cast<MicroDuration>(t);
-        out += details::padZeros(subsec.count(), 6);
-    }
-
-    out += "+00:00";
-    return out;
-}
-} // namespace details
-
-// Returns the formatted date time string.
-// Note that the maximum supported date is 9999-12-31T23:59:59+00:00, if
-// the given |secondsSinceEpoch| is too large, we return the maximum supported
-// date.
-inline std::string getDateTimeUint(uint64_t secondsSinceEpoch)
-{
-    using DurationType = std::chrono::duration<uint64_t>;
-    DurationType sinceEpoch(secondsSinceEpoch);
-    return details::toISO8061ExtendedStr(sinceEpoch);
-}
-
-// Returns the formatted date time string with millisecond precision
-// Note that the maximum supported date is 9999-12-31T23:59:59+00:00, if
-// the given |secondsSinceEpoch| is too large, we return the maximum supported
-// date.
-inline std::string getDateTimeUintMs(uint64_t milliSecondsSinceEpoch)
-{
-    using DurationType = std::chrono::duration<uint64_t, std::milli>;
-    DurationType sinceEpoch(milliSecondsSinceEpoch);
-    return details::toISO8061ExtendedStr(sinceEpoch);
-}
-
-// Returns the formatted date time string with microsecond precision
-inline std::string getDateTimeUintUs(uint64_t microSecondsSinceEpoch)
-{
-    using DurationType = std::chrono::duration<uint64_t, std::micro>;
-    DurationType sinceEpoch(microSecondsSinceEpoch);
-    return details::toISO8061ExtendedStr(sinceEpoch);
-}
-
-inline std::string getDateTimeStdtime(std::time_t secondsSinceEpoch)
-{
-    using DurationType = std::chrono::duration<std::time_t>;
-    DurationType sinceEpoch(secondsSinceEpoch);
-    return details::toISO8061ExtendedStr(sinceEpoch);
-}
-
-/**
- * Returns the current Date, Time & the local Time Offset
- * infromation in a pair
- *
- * @param[in] None
- *
- * @return std::pair<std::string, std::string>, which consist
- * of current DateTime & the TimeOffset strings respectively.
- */
-inline std::pair<std::string, std::string> getDateTimeOffsetNow()
-{
-    std::time_t time = std::time(nullptr);
-    std::string dateTime = getDateTimeStdtime(time);
-
-    /* extract the local Time Offset value from the
-     * recevied dateTime string.
-     */
-    std::string timeOffset("Z00:00");
-    std::size_t lastPos = dateTime.size();
-    std::size_t len = timeOffset.size();
-    if (lastPos > len)
-    {
-        timeOffset = dateTime.substr(lastPos - len);
-    }
-
-    return std::make_pair(dateTime, timeOffset);
-}
-
 inline bool constantTimeStringCompare(const std::string_view a,
                                       const std::string_view b)
 {