timeUtils.cpp

Go to the documentation of this file.

/** \file timeUtils.cpp
 * \brief Definitions for utilities for working with time
 *
 * \author Jared R. Males (jaredmales@gmail.com)
 *
 * \ingroup utils_files
 *
 */
 
//***********************************************************************//
// Copyright 2020 Jared R. Males (jaredmales@gmail.com)
//
// This file is part of mxlib.
//
// mxlib 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, either version 3 of the License, or
// (at your option) any later version.
//
// mxlib 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 mxlib.  If not, see <http://www.gnu.org/licenses/>.
//***********************************************************************//
 
#include "sys/timeUtils.hpp"
 
namespace mx
{
namespace sys
{
 
namespace timeUtilsDetail
{
 
operations &operationsInstance()
{
    static operations ops = { ::gmtime_r, sofa::iauDat, sofa::iauCal2jd };
    return ops;
}
 
void resetOperations()
{
    operationsInstance() = { ::gmtime_r, sofa::iauDat, sofa::iauCal2jd };
}
 
} // namespace timeUtilsDetail
 
template <>
double get_curr_time<double, CLOCK_REALTIME>( timespec &tsp )
{
    clock_gettime( CLOCK_REALTIME, &tsp );
 
    return ( (double)tsp.tv_sec ) + ( (double)tsp.tv_nsec ) / 1e9;
}
 
template <>
double get_curr_time<double, CLOCK_REALTIME>()
{
    struct timespec tsp;
    return get_curr_time<double, CLOCK_REALTIME>( tsp );
}
 
void sleep( unsigned sec )
{
    std::this_thread::sleep_for( std::chrono::seconds( sec ) );
}
 
void milliSleep( unsigned msec )
{
    std::this_thread::sleep_for( std::chrono::milliseconds( msec ) );
}
 
void microSleep( unsigned usec )
{
    std::this_thread::sleep_for( std::chrono::microseconds( usec ) );
}
 
void nanoSleep( unsigned nsec )
{
    std::this_thread::sleep_for( std::chrono::nanoseconds( nsec ) );
}
 
void timespecAddNsec( timespec &ts, unsigned nsec )
{
    ts.tv_nsec += nsec % 1000000000;
    ts.tv_sec += nsec / 1000000000;
 
    if( ts.tv_nsec > 999999999 )
    {
        ts.tv_nsec -= 1000000000;
        ts.tv_sec += 1;
    }
}
 
double Cal2mjd( int yr, int mon, int day, int hr, int min, double sec )
{
    double djm0;
    double djm;
 
    int rv = timeUtilsDetail::operationsInstance().iauCal2jd( yr, mon, day, &djm0, &djm );
 
    if( rv < 0 )
        return (double)rv;
 
    djm0 = djm + ( ( (double)hr ) / ( 24.0 ) + ( (double)min ) / ( 60.0 * 24.0 ) + sec / ( 3600.0 * 24.0 ) );
 
    return djm0;
}
 
int ISO8601dateBreakdown( int &yr, int &mon, int &day, int &hr, int &min, double &sec, const std::string &fdate )
{
    if( fdate.length() < 19 )
        return -4;
 
    yr = atoi( fdate.substr( 0, 4 ).c_str() );
    mon = atoi( fdate.substr( 5, 2 ).c_str() );
    day = atoi( fdate.substr( 8, 2 ).c_str() );
 
    double _hr, _min;
    parse_hms( _hr, _min, sec, fdate.substr( 11 ) );
 
    hr = floor( _hr );
    min = floor( _min );
 
    return 0;
}
 
double ISO8601date2mjd( const std::string &fdate )
{
    if( fdate.length() < 19 )
        return -4;
 
    int yr, mon, day, hr, min;
    // double hr, min, sec;
    double sec;
 
    ISO8601dateBreakdown( yr, mon, day, hr, min, sec, fdate );
 
    return Cal2mjd( yr, mon, day, hr, min, sec );
}
 
template <>
std::string ISO8601DateTimeStr<time_t>( const time_t &timeIn, int timeZone )
{
    tm bdt;
    if( timeUtilsDetail::operationsInstance().gmtimeR( &timeIn, &bdt ) == nullptr )
    {
        return {};
    }
 
    char tstr[25];
 
    strftime( tstr, 25, "%FT%H:%M:%S", &bdt );
 
    std::string result = tstr;
 
    if( timeZone == 1 )
        result += "Z";
    if( timeZone == 2 )
        result += "+00:00";
 
    return result;
}
 
template <>
std::string ISO8601DateTimeStr<timespec>( const timespec &timeIn, int timeZone )
{
    std::string result = ISO8601DateTimeStr<time_t>( timeIn.tv_sec, 0 );
    if( result.empty() )
    {
        return result;
    }
 
    char tstr[20];
 
    snprintf( tstr, 20, ".%09ld", timeIn.tv_nsec );
 
    result += tstr;
 
    if( timeZone == 1 )
        result += "Z";
    if( timeZone == 2 )
        result += "+00:00";
 
    return result;
} // LCOV_EXCL_LINE
 
std::string ISO8601DateTimeStr( int timeZone )
{
    return ISO8601DateTimeStr<time_t>( ::time( 0 ), timeZone );
}
 
std::string ISO8601DateTimeStrMJD( const double &timeIn, int timeZone )
{
    int iy, im, id;
    double fd;
 
    sofa::iauJd2cal( DJM0, timeIn, &iy, &im, &id, &fd );
 
    int hr, mn;
 
    hr = floor( fd * 24.0 );
    fd = ( fd - hr / 24.0 ) * 24.0;
 
    mn = floor( fd * 60. );
 
    fd = ( fd - mn / 60.0 ) * 3600.0;
 
    char tstr[32];
 
    snprintf( tstr, 32, "%04d-%02d-%02dT%02d:%02d:%012.9f", iy, im, id, hr, mn, fd );
 
    std::string result = tstr;
 
    if( timeZone == 1 )
        result += "Z";
    if( timeZone == 2 )
        result += "+00:00";
 
    return result;
} // LCOV_EXCL_LINE
 
int timeStamp( std::string &tstamp, timespec &ts )
{
    tm uttime; // The broken down time.
 
    time_t t0 = ts.tv_sec;
 
    if( timeUtilsDetail::operationsInstance().gmtimeR( &t0, &uttime ) == nullptr )
    {
        std::cerr << "Error getting UT time (gmtime_r returned 0). At: " << __FILE__ << " " << __LINE__ << "\n";
        return -1;
    }
 
    char buffer[48];
 
    snprintf( buffer,
              sizeof( buffer ),
              "%04i%02i%02i%02i%02i%02i%09i",
              uttime.tm_year + 1900,
              uttime.tm_mon + 1,
              uttime.tm_mday,
              uttime.tm_hour,
              uttime.tm_min,
              uttime.tm_sec,
              static_cast<int>( ts.tv_nsec ) ); // casting in case we switch type of time_ns.
 
    tstamp = buffer;
 
    return 0;
}
 
int timespecUTC2TAIMJD( double &djm, double &djmf, const timespec &tsp, tm *tm0 )
{
    double dat, djm0;
    tm localTm;
    tm *tmrv;
    int rv1, rv2;
 
    if( tm0 == nullptr )
    {
        tm0 = &localTm;
    }
 
    // Get the broken down time corresponding to tsp0
    tmrv = timeUtilsDetail::operationsInstance().gmtimeR( &tsp.tv_sec, tm0 );
    if( tmrv == 0 )
        return -10;
 
    // Then determine deltaAT = TAI-UTC
    rv1 = timeUtilsDetail::operationsInstance().iauDat( 1900 + tm0->tm_year, 1 + tm0->tm_mon, tm0->tm_mday, 0.0, &dat );
    if( rv1 < 0 )
        return rv1;
 
    // And get the MJD
    rv2 = timeUtilsDetail::operationsInstance().iauCal2jd( 1900 + tm0->tm_year,
                                                           1 + tm0->tm_mon,
                                                           tm0->tm_mday,
                                                           &djm0,
                                                           &djm );
    if( rv2 < 0 )
        return rv2;
 
    // Finally calculate the day fraction
    djmf = ( (double)tm0->tm_hour ) / 24.0 + ( (double)tm0->tm_min ) / ( 24.0 * 60. ) +
           ( ( (double)tm0->tm_sec ) + ( (double)tsp.tv_nsec / 1e9 ) + dat ) / ( 24.0 * 3600.0 );
 
    if( djmf >= 1.0 )
    {
        djmf -= 1.0;
        djm += 1.0;
    }
 
    if( rv1 )
        return rv1;
    return 0;
}
 
timespec meanTimespec( timespec ts1, timespec ts2 )
{
    double means = ( ts1.tv_sec + ts2.tv_sec ) / 2.0;
    double meanns = ( ts1.tv_nsec + ts2.tv_nsec ) / 2.0;
 
    ts1.tv_sec = floor( means );
    ts1.tv_nsec = round( meanns );
 
    if( means != floor( means ) )
    {
        ts1.tv_nsec += 5e8;
 
        if( ts1.tv_nsec >= 1e9 )
        {
            ts1.tv_sec += 1;
            ts1.tv_nsec -= 1e9;
        }
    }
 
    return ts1;
}
 
namespace tscomp
{
 
bool operator<( timespec const &tsL, timespec const &tsR )
{
    return ( ( ( tsL.tv_sec == tsR.tv_sec ) && ( tsL.tv_nsec < tsR.tv_nsec ) ) || ( tsL.tv_sec < tsR.tv_sec ) );
}
 
bool operator>( timespec const &tsL, timespec const &tsR )
{
    return ( ( ( tsL.tv_sec == tsR.tv_sec ) && ( tsL.tv_nsec > tsR.tv_nsec ) ) || ( tsL.tv_sec > tsR.tv_sec ) );
}
 
bool operator==( timespec const &tsL, timespec const &tsR )
{
    return ( ( tsL.tv_sec == tsR.tv_sec ) && ( tsL.tv_nsec == tsR.tv_nsec ) );
}
 
bool operator<=( timespec const &tsL, timespec const &tsR )
{
    return ( tsL < tsR || tsL == tsR );
}
 
bool operator>=( timespec const &tsL, timespec const &tsR )
{
    return ( tsL > tsR || tsL == tsR );
}
 
} // namespace tscomp
 
} // namespace sys
} // namespace mx