diff options
Diffstat (limited to '')
-rw-r--r-- | src/VBox/Runtime/common/time/RTTimeFormatDurationEx.cpp | 267 |
1 files changed, 267 insertions, 0 deletions
diff --git a/src/VBox/Runtime/common/time/RTTimeFormatDurationEx.cpp b/src/VBox/Runtime/common/time/RTTimeFormatDurationEx.cpp new file mode 100644 index 00000000..1b017816 --- /dev/null +++ b/src/VBox/Runtime/common/time/RTTimeFormatDurationEx.cpp @@ -0,0 +1,267 @@ +/* $Id: RTTimeFormatDurationEx.cpp $ */ +/** @file + * IPRT - RTTimeFormatInterval. + */ + +/* + * Copyright (C) 2022-2023 Oracle and/or its affiliates. + * + * This file is part of VirtualBox base platform packages, as + * available from https://www.virtualbox.org. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, in version 3 of the + * License. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <https://www.gnu.org/licenses>. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included + * in the VirtualBox distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + * + * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0 + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include "internal/iprt.h" +#include <iprt/time.h> + +#include <iprt/assert.h> +#include <iprt/errcore.h> +#include <iprt/string.h> + + +static size_t rtTimeFormatDurationNumberEx(char *psz, uint32_t uValue, size_t cchValue) +{ + switch (cchValue) + { + case 10: + *psz++ = (uint8_t)(uValue / 1000000000) + '0'; + uValue %= 1000000000; + RT_FALL_THROUGH(); + case 9: + *psz++ = (uint8_t)(uValue / 100000000) + '0'; + uValue %= 100000000; + RT_FALL_THROUGH(); + case 8: + *psz++ = (uint8_t)(uValue / 10000000) + '0'; + uValue %= 10000000; + RT_FALL_THROUGH(); + case 7: + *psz++ = (uint8_t)(uValue / 1000000) + '0'; + uValue %= 1000000; + RT_FALL_THROUGH(); + case 6: + *psz++ = (uint8_t)(uValue / 100000) + '0'; + uValue %= 100000; + RT_FALL_THROUGH(); + case 5: + *psz++ = (uint8_t)(uValue / 10000) + '0'; + uValue %= 10000; + RT_FALL_THROUGH(); + case 4: + *psz++ = (uint8_t)(uValue / 1000) + '0'; + uValue %= 1000; + RT_FALL_THROUGH(); + case 3: + *psz++ = (uint8_t)(uValue / 100) + '0'; + uValue %= 100; + RT_FALL_THROUGH(); + case 2: + *psz++ = (uint8_t)(uValue / 10) + '0'; + uValue %= 10; + RT_FALL_THROUGH(); + case 1: + *psz++ = (uint8_t)uValue + '0'; + break; + } + return cchValue; +} + + +static size_t rtTimeFormatDurationNumber(char *psz, uint32_t uValue) +{ + size_t cchValue; + if (uValue < 10) + cchValue = 1; + else if (uValue < 100) + cchValue = 2; + else if (uValue < 1000) + cchValue = 3; + else if (uValue < 10000) + cchValue = 4; + else if (uValue < 100000) + cchValue = 5; + else if (uValue < 1000000) + cchValue = 6; + else if (uValue < 10000000) + cchValue = 7; + else if (uValue < 100000000) + cchValue = 8; + else if (uValue < 1000000000) + cchValue = 9; + else + cchValue = 10; + return rtTimeFormatDurationNumberEx(psz, uValue, cchValue); +} + + +static ssize_t rtTimeFormatDurationCopyOutResult(char *pszDst, size_t cbDst, const char *pszValue, size_t cchValue) +{ + if (cbDst > cchValue) + { + memcpy(pszDst, pszValue, cchValue); + pszDst[cchValue] = '\0'; + return cchValue; + } + if (cbDst) + { + memcpy(pszDst, pszValue, cbDst); + pszDst[cbDst - 1] = '\0'; + } + return VERR_BUFFER_OVERFLOW; +} + + +/** + * Formats duration as best we can according to ISO-8601. + * + * The returned value is on the form "[-]PnnnnnWnDTnnHnnMnn.fffffffffS", where a + * sequence of 'n' can be between 1 and the given lenght, and all but the + * "nn.fffffffffS" part is optional and will only be outputted when the duration + * is sufficiently large. The code currently does not omit any inbetween + * elements other than the day count (D), so an exactly 7 day duration is + * formatted as "P1WT0H0M0.000000000S" when @a cFractionDigits is 9. + * + * @returns Number of characters in the output on success. VERR_BUFFER_OVEFLOW + * on failure. + * @retval VERR_OUT_OF_RANGE if @a cFractionDigits is too large. + * @param pszDst Pointer to the output buffer. In case of overflow, + * the max number of characters will be written and + * zero terminated, provided @a cbDst isn't zero. + * @param cbDst The size of the output buffer. + * @param pDuration The duration to format. + * @param cFractionDigits Number of digits in the second fraction part. Zero + * for whole no fraction. Max is 9 (nano seconds). + */ +RTDECL(ssize_t) RTTimeFormatDurationEx(char *pszDst, size_t cbDst, PCRTTIMESPEC pDuration, uint32_t cFractionDigits) +{ + AssertReturn(cFractionDigits <= 9, VERR_OUT_OF_RANGE); + AssertReturn(cbDst != 0, VERR_BUFFER_OVERFLOW); + + /* + * Get the seconds and . + */ + int64_t cNanoSecsSigned = RTTimeSpecGetNano(pDuration); + + /* Special case: zero interval */ + if (cNanoSecsSigned == 0) + return rtTimeFormatDurationCopyOutResult(pszDst, cbDst, RT_STR_TUPLE("PT0S")); + + char szTmp[64]; + size_t offTmp = 0; + + /* Negative intervals aren't really allowed by the standard, but we slap a + minus in from of the 'P' and get on with it. */ + if (cNanoSecsSigned < 0) + { + szTmp[offTmp++] = '-'; + cNanoSecsSigned = -cNanoSecsSigned; + } + uint64_t cNanoSecs = (uint64_t)cNanoSecsSigned; + + /* Emit the duration indicator: */ + szTmp[offTmp++] = 'P'; + size_t const offPostP = offTmp; + + /* Any full weeks? */ + if (cNanoSecs >= RT_NS_1WEEK) + { + uint64_t const cWeeks = cNanoSecs / RT_NS_1WEEK; /* (the max value here is 15250) */ + cNanoSecs %= RT_NS_1WEEK; + offTmp += rtTimeFormatDurationNumber(&szTmp[offTmp], (uint32_t)cWeeks); + szTmp[offTmp++] = 'W'; + } + + /* Any full days?*/ + if (cNanoSecs >= RT_NS_1DAY) + { + uint8_t const cDays = (uint8_t)(cNanoSecs / RT_NS_1DAY); + cNanoSecs %= RT_NS_1DAY; + szTmp[offTmp++] = '0' + cDays; + szTmp[offTmp++] = 'D'; + } + + szTmp[offTmp++] = 'T'; + + /* Hours: */ + if (cNanoSecs >= RT_NS_1HOUR || offTmp > offPostP + 1) + { + uint8_t const cHours = (uint8_t)(cNanoSecs / RT_NS_1HOUR); + cNanoSecs %= RT_NS_1HOUR; + offTmp += rtTimeFormatDurationNumber(&szTmp[offTmp], cHours); + szTmp[offTmp++] = 'H'; + } + + /* Minutes: */ + if (cNanoSecs >= RT_NS_1MIN || offTmp > offPostP + 1) + { + uint8_t const cMins = (uint8_t)(cNanoSecs / RT_NS_1MIN); + cNanoSecs %= RT_NS_1MIN; + offTmp += rtTimeFormatDurationNumber(&szTmp[offTmp], cMins); + szTmp[offTmp++] = 'M'; + } + + /* Seconds: */ + uint8_t const cSecs = (uint8_t)(cNanoSecs / RT_NS_1SEC); + cNanoSecs %= RT_NS_1SEC; + offTmp += rtTimeFormatDurationNumber(&szTmp[offTmp], cSecs); + if (cFractionDigits > 0) + { + szTmp[offTmp++] = '.'; + static uint32_t const s_auFactors[9] = { 100000000, 10000000, 1000000, 100000, 10000, 1000, 100, 10, 1 }; + offTmp += rtTimeFormatDurationNumberEx(&szTmp[offTmp], (uint32_t)(cNanoSecs / s_auFactors[cFractionDigits - 1]), + cFractionDigits); + } + szTmp[offTmp++] = 'S'; + szTmp[offTmp] = '\0'; + + return rtTimeFormatDurationCopyOutResult(pszDst, cbDst, szTmp, offTmp); +} +RT_EXPORT_SYMBOL(RTTimeFormatDurationEx); + + +/** + * Formats duration as best we can according to ISO-8601, with no fraction. + * + * See RTTimeFormatDurationEx for details. + * + * @returns Number of characters in the output on success. VERR_BUFFER_OVEFLOW + * on failure. + * @param pszDst Pointer to the output buffer. In case of overflow, + * the max number of characters will be written and + * zero terminated, provided @a cbDst isn't zero. + * @param cbDst The size of the output buffer. + * @param pDuration The duration to format. + */ +RTDECL(int) RTTimeFormatDuration(char *pszDst, size_t cbDst, PCRTTIMESPEC pDuration) +{ + return RTTimeFormatDurationEx(pszDst, cbDst, pDuration, 0); +} +RT_EXPORT_SYMBOL(RTTimeFormatDuration); + |