DateTime.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
//
// Copyright 2026 Caleb Buahin
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

 
#ifndef OPENSWMM_ENGINE_DATETIME_HPP
#define OPENSWMM_ENGINE_DATETIME_HPP
 
#include <cmath>
 
namespace openswmm {
namespace datetime {
 
// ============================================================================
// Constants — matching legacy datetime.c exactly
// ============================================================================
 
static constexpr int    DateDelta  = 693594;  
static constexpr double SecsPerDay = 86400.0; 
static constexpr double OneSecond  = 1.1574074e-5; 
 
// ============================================================================
// Date/time type — same as legacy DateTime (double)
// ============================================================================
 
using DateTime = double;
 
// ============================================================================
// Core functions — numerically identical to legacy datetime.c
// ============================================================================

inline void divMod(int n, int d, int* result, int* remainder) {
    if (d == 0) { *result = 0; *remainder = 0; }
    else { *result = n / d; *remainder = n - d * (*result); }
}

inline bool isLeapYear(int year) {
    return (year % 4 == 0) && ((year % 100 != 0) || (year % 400 == 0));
}

inline DateTime encodeDate(int year, int month, int day) {
    static constexpr int DaysPerMonth[2][12] = {
        {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
        {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}};
    int i = isLeapYear(year) ? 1 : 0;
    if (year >= 1 && year <= 9999 && month >= 1 && month <= 12
        && day >= 1 && day <= DaysPerMonth[i][month - 1]) {
        for (int j = 0; j < month - 1; ++j) day += DaysPerMonth[i][j];
        int y = year - 1;
        return y * 365 + y / 4 - y / 100 + y / 400 + day - DateDelta;
    }
    return -DateDelta;
}

inline DateTime encodeTime(int hour, int minute, int second) {
    if (hour >= 0 && minute >= 0 && second >= 0) {
        int s = hour * 3600 + minute * 60 + second;
        return static_cast<double>(s) / SecsPerDay;
    }
    return 0.0;
}

inline void decodeDate(DateTime date, int& year, int& month, int& day) {
    static constexpr int DaysPerMonth[2][12] = {
        {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
        {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}};
    constexpr int D1 = 365, D4 = 1461, D100 = 36524, D400 = 146097;
 
    int t = static_cast<int>(std::floor(date)) + DateDelta;
    if (t <= 0) { year = 0; month = 1; day = 1; return; }
 
    t--;
    int y = 1, i, d;
    while (t >= D400) { t -= D400; y += 400; }
    divMod(t, D100, &i, &d);
    if (i == 4) { i--; d += D100; }
    y += i * 100;
    divMod(d, D4, &i, &d);
    y += i * 4;
    divMod(d, D1, &i, &d);
    if (i == 4) { i--; d += D1; }
    y += i;
 
    int k = isLeapYear(y) ? 1 : 0;
    int m = 1;
    for (;;) {
        i = DaysPerMonth[k][m - 1];
        if (d < i) break;
        d -= i;
        m++;
    }
    year = y; month = m; day = d + 1;
}

inline void decodeTime(DateTime time, int& h, int& m, int& s) {
    double fracDay = (time - std::floor(time)) * SecsPerDay;
    int secs = static_cast<int>(std::floor(fracDay + 0.5));
    if (secs >= 86400) secs = 86399;
    divMod(secs, 60, &m, &s);  // mins, secs
    int mins = m;
    divMod(mins, 60, &h, &m);  // hours, mins
    if (h > 23) h = 0;
}

inline DateTime addSeconds(DateTime date, double seconds) {
    double d = std::floor(date);
    int h, m, s;
    decodeTime(date, h, m, s);
    return d + (3600.0 * h + 60.0 * m + s + seconds) / SecsPerDay;
}

inline long timeDiff(DateTime date1, DateTime date2) {
    double d1 = std::floor(date1);
    double d2 = std::floor(date2);
    int h, m, s;
    decodeTime(date1, h, m, s);
    long s1 = 3600L * h + 60L * m + s;
    decodeTime(date2, h, m, s);
    long s2 = 3600L * h + 60L * m + s;
    long secs = static_cast<long>(std::floor((d1 - d2) * SecsPerDay + 0.5));
    secs += (s1 - s2);
    return secs;
}

inline int monthOfYear(DateTime date) {
    int y, m, d;
    decodeDate(date, y, m, d);
    return m;
}

inline int dayOfYear(DateTime date) {
    int y, m, d;
    decodeDate(date, y, m, d);
    DateTime startOfYear = encodeDate(y, 1, 1);
    return static_cast<int>(std::floor(date - startOfYear)) + 1;
}
 
} // namespace datetime
} // namespace openswmm
 
#endif // OPENSWMM_ENGINE_DATETIME_HPP