SUMOTime.cpp

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2026 German Aerospace Center (DLR) and others.
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License 2.0 which is available at
// https://www.eclipse.org/legal/epl-2.0/
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License 2.0 are satisfied: GNU General Public License, version 2
// or later which is available at
// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
/****************************************************************************/
// Variables, methods, and tools for internal time representation
/****************************************************************************/
#include <config.h>
 
#include <iostream>
#ifdef HAVE_FMT
#include <fmt/format.h>
#endif
#include "SUMOTime.h"
#include "StringTokenizer.h"
#include "StringUtils.h"
#include "StdDefs.h"
#include "MsgHandler.h"
 
 
// ===========================================================================
// type definitions
// ===========================================================================
SUMOTime DELTA_T = 1000;
 
 
// ===========================================================================
// method definitions
// ===========================================================================
 
SUMOTime
string2time(const std::string& r) {
    if (r.find(":") == std::string::npos) {
        const double time = StringUtils::toDouble(r);
        if (time > STEPS2TIME(SUMOTime_MAX)) {
            throw TimeFormatException("Input string '" + r + "' exceeds the time value range.");
        }
        return TIME2STEPS(time);
    } else {
        // try to parse dd:hh:mm:ss.s
        std::vector<std::string> hrt = StringTokenizer(r, ":").getVector();
        if (hrt.size() == 3) {
            //std::cout << "parsed '" << r << "' as " << (3600 * string2time(hrt[0]) + 60 * string2time(hrt[1]) + string2time(hrt[2])) << "\n";
            return 3600 * string2time(hrt[0]) + 60 * string2time(hrt[1]) + string2time(hrt[2]);
        } else if (hrt.size() == 4) {
            //std::cout << "parsed '" << r << "' as " << (24 * 3600 * string2time(hrt[0]) + 3600 * string2time(hrt[1]) + 60 * string2time(hrt[2]) + string2time(hrt[3])) << "\n";
            return 24 * 3600 * string2time(hrt[0]) + 3600 * string2time(hrt[1]) + 60 * string2time(hrt[2]) + string2time(hrt[3]);
        }
        throw TimeFormatException("Input string '" + r + "' is not a valid time format (jj:HH:MM:SS.S).");
    }
}
 
 
bool
isTime(const std::string& r) {
    if (r.find(":") == std::string::npos) {
        if (StringUtils::isDouble(r)) {
            return (StringUtils::toDouble(r) <= STEPS2TIME(SUMOTime_MAX));
        } else {
            return false;
        }
    } else {
        // try to parse dd:hh:mm:ss.s
        const std::vector<std::string> hrt = StringTokenizer(r, ":").getVector();
        if (hrt.size() == 3) {
            return StringUtils::isInt(hrt[0]) && StringUtils::isInt(hrt[1]) && StringUtils::isInt(hrt[2]);
        } else if (hrt.size() == 4) {
            return StringUtils::isInt(hrt[0]) && StringUtils::isInt(hrt[1]) && StringUtils::isInt(hrt[2]) && StringUtils::isDouble(hrt[3]);
        } else {
            return false;
        }
    }
}
 
 
// append the digits of value, padded with leading zeros to the given width
static void
appendPadded(std::string& result, SUMOTime value, int width) {
#ifdef HAVE_FMT
    const fmt::format_int digits(value);
#else
    const std::string digits = std::to_string(value);
#endif
    if ((int)digits.size() < width) {
        result.append(width - (int)digits.size(), '0');
    }
    result.append(digits.data(), digits.size());
}
 
 
std::string
time2string(SUMOTime t, bool humanReadable) {
    const bool negative = t < 0;
    // needed for signed zero errors, see #5926
    // llabs(SUMOTime_MIN) would create overflow and must be handleed separately
    t = t == SUMOTime_MIN ? SUMOTime_MAX : (SUMOTime)llabs(t);
    SUMOTime scale = (SUMOTime)pow(10, MAX2(0, 3 - gPrecision));
    if (scale > 1) {
        if (t != SUMOTime_MAX) {
            t = (t + scale / 2) / scale;
        } else {
            scale = 1;
        }
    }
    const SUMOTime second = TIME2STEPS(1) / scale;
    std::string result = negative ? "-" : "";
    if (humanReadable) {
        const SUMOTime minute = 60 * second;
        const SUMOTime hour = 60 * minute;
        const SUMOTime day = 24 * hour;
        // 123456 -> "00:00:12.34"
        if (t > day) {
            appendPadded(result, t / day, 0);
            result += ':';
            t %= day;
        }
        appendPadded(result, t / hour, 2);
        result += ':';
        t %= hour;
        appendPadded(result, t / minute, 2);
        result += ':';
        t %= minute;
        appendPadded(result, t / second, 2);
        t %= second;
        if (t != 0 || TS < 1.) {
            result += '.';
            appendPadded(result, t, MIN2(3, gPrecision));
        }
        return result;
    }
    appendPadded(result, t / second, 0);
    result += '.';
    appendPadded(result, t % second, MIN2(3, gPrecision));
    return result;
}
 
 
std::string
time2string(SUMOTime t) {
    return time2string(t, gHumanReadableTime);
}
 
 
std::string
elapsedMs2string(long long int t) {
    if (gHumanReadableTime) {
        if (STEPS2TIME(t) > 60) {
            // round to seconds
            return time2string((t / 1000) * 1000);
        } else {
            return toString((double)t / 1000.0) + "s";
        }
    } else {
        return time2string(t) + "s";
    }
}
 
bool checkStepLengthMultiple(const SUMOTime t, const std::string& error, SUMOTime deltaT, SUMOTime begin) {
    if (begin % deltaT == 0) {
        if (t % deltaT != 0) {
            WRITE_WARNING("The given time value " + time2string(t) + " is not a multiple of the step length " + time2string(deltaT) + error + ".")
        }
    } else {
        if ((t - begin) % deltaT != 0) {
            WRITE_WARNING("The given time value " + time2string(t) + " is not reached with step length " + time2string(deltaT)
                          + " and begin time " + time2string(begin) + error + ".")
        }
    }
    // next line used to fix build
    return false;
}
 
void checkTimeBounds(const double time) {
    if (time > STEPS2TIME(SUMOTime_MAX)) {
        throw TimeFormatException("Input time " + toString(time) + "s exceeds the time value range.");
    }
}
 
 
/****************************************************************************/