epicsTime.h

Go to the documentation of this file.

/*************************************************************************\
* Copyright (c) 2009 UChicago Argonne LLC, as Operator of Argonne
* National Laboratory.
* Copyright (c) 2002 The Regents of the University of California, as
* Operator of Los Alamos National Laboratory.
* SPDX-License-Identifier: EPICS
* EPICS BASE is distributed subject to a Software License Agreement found
* in file LICENSE that is included with this distribution.
\*************************************************************************/
#ifndef epicsTimehInclude
#define epicsTimehInclude

#include <time.h>

#include "libComAPI.h"
#include "epicsTypes.h"
#include "osdTime.h"
#include "errMdef.h"

#define POSIX_TIME_AT_EPICS_EPOCH 631152000u

#ifdef __cplusplus

#include <stdexcept>
#include <ostream>

extern "C" {
#endif

typedef struct epicsTimeStamp {
 epicsUInt32 secPastEpoch; 
 epicsUInt32 nsec; 
} epicsTimeStamp;

typedef epicsUInt64 epicsUTag;

#define TS_STAMP epicsTimeStamp


struct timespec; /* POSIX real time */

struct timeval; /* BSD */

#define epicsTimeOK 0

#define S_time_noProvider (M_time| 1) /*No time provider*/

#define S_time_badEvent (M_time| 2) /*Bad event number*/

#define S_time_badArgs (M_time| 3) /*Invalid arguments*/

#define S_time_noMemory (M_time| 4) /*Out of memory*/

#define S_time_unsynchronized (M_time| 5) /*Provider not synchronized*/

#define S_time_timezone (M_time| 6) /*Invalid timezone*/

#define S_time_conversion (M_time| 7) /*Time conversion error*/

#define epicsTimeEventCurrentTime 0
#define epicsTimeEventBestTime -1
#define epicsTimeEventDeviceTime -2

LIBCOM_API int epicsStdCall epicsTimeGetCurrent ( epicsTimeStamp * pDest );
LIBCOM_API int epicsStdCall epicsTimeGetEvent (
 epicsTimeStamp *pDest, int eventNumber);
LIBCOM_API int epicsTimeGetMonotonic ( epicsTimeStamp * pDest );
LIBCOM_API int epicsTimeGetCurrentInt(epicsTimeStamp *pDest);
LIBCOM_API int epicsTimeGetEventInt(epicsTimeStamp *pDest, int eventNumber);
LIBCOM_API int epicsStdCall epicsTimeToTime_t (
 time_t * pDest, const epicsTimeStamp * pSrc );
LIBCOM_API int epicsStdCall epicsTimeFromTime_t (
 epicsTimeStamp * pDest, time_t src );
LIBCOM_API int epicsStdCall epicsTimeToTM (
 struct tm * pDest, unsigned long * pNSecDest, const epicsTimeStamp * pSrc );
LIBCOM_API int epicsStdCall epicsTimeToGMTM (
 struct tm * pDest, unsigned long * pNSecDest, const epicsTimeStamp * pSrc );
LIBCOM_API int epicsStdCall epicsTimeFromTM (
 epicsTimeStamp * pDest, const struct tm * pSrc, unsigned long nSecSrc );
LIBCOM_API int epicsStdCall epicsTimeFromGMTM (
 epicsTimeStamp * pDest, const struct tm * pSrc, unsigned long nSecSrc );
LIBCOM_API int epicsStdCall epicsTimeToTimespec (
 struct timespec * pDest, const epicsTimeStamp * pSrc );
LIBCOM_API int epicsStdCall epicsTimeFromTimespec (
 epicsTimeStamp * pDest, const struct timespec * pSrc );
LIBCOM_API int epicsStdCall epicsTimeToTimeval (
 struct timeval * pDest, const epicsTimeStamp * pSrc );
LIBCOM_API int epicsStdCall epicsTimeFromTimeval (
 epicsTimeStamp * pDest, const struct timeval * pSrc );
LIBCOM_API double epicsStdCall epicsTimeDiffInSeconds (
 const epicsTimeStamp * pLeft, const epicsTimeStamp * pRight );/* left - right */
LIBCOM_API void epicsStdCall epicsTimeAddSeconds (
 epicsTimeStamp * pDest, double secondsToAdd ); /* adds seconds to *pDest */
LIBCOM_API epicsInt64 epicsStdCall epicsTimeDiffInNS (
 const epicsTimeStamp *pLeft, const epicsTimeStamp *pRight);
LIBCOM_API int epicsStdCall epicsTimeEqual (
 const epicsTimeStamp * pLeft, const epicsTimeStamp * pRight);
LIBCOM_API int epicsStdCall epicsTimeNotEqual (
 const epicsTimeStamp * pLeft, const epicsTimeStamp * pRight);
LIBCOM_API int epicsStdCall epicsTimeLessThan (
 const epicsTimeStamp * pLeft, const epicsTimeStamp * pRight);
LIBCOM_API int epicsStdCall epicsTimeLessThanEqual (
 const epicsTimeStamp * pLeft, const epicsTimeStamp * pRight);
LIBCOM_API int epicsStdCall epicsTimeGreaterThan (
 const epicsTimeStamp * pLeft, const epicsTimeStamp * pRight);
LIBCOM_API int epicsStdCall epicsTimeGreaterThanEqual (
 const epicsTimeStamp * pLeft, const epicsTimeStamp * pRight);
LIBCOM_API size_t epicsStdCall epicsTimeToStrftime (
 char * pBuff, size_t bufLength, const char * pFormat, const epicsTimeStamp * pTS );

LIBCOM_API void epicsStdCall epicsTimeShow (
 const epicsTimeStamp *, unsigned interestLevel );

LIBCOM_API int epicsStdCall epicsTime_localtime ( const time_t * clock, struct tm * result );
LIBCOM_API int epicsStdCall epicsTime_gmtime ( const time_t * clock, struct tm * result );
LIBCOM_API epicsUInt64 epicsMonotonicResolution(void);
LIBCOM_API epicsUInt64 epicsMonotonicGet(void);
#ifdef EPICS_EXPOSE_LIBCOM_MONOTONIC_PRIVATE
LIBCOM_API void osdMonotonicInit(void);
#endif

#ifdef __cplusplus
} // extern "C"

struct local_tm_nano_sec {
 struct tm ansi_tm; 
 unsigned long nSec; 
};

struct gm_tm_nano_sec {
 struct tm ansi_tm; 
 unsigned long nSec; 
};

struct time_t_wrapper {
 time_t ts;
};

class LIBCOM_API epicsTimeEvent
{
public:
 epicsTimeEvent (const int &number) :eventNumber(number) {}
 operator int () const { return eventNumber; }
private:
 int eventNumber;
};

class LIBCOM_API epicsTime
{
 // translate S_time_* code to exception
 static void throwError(int code);
public:
 typedef std::runtime_error unableToFetchCurrentTime;
 typedef std::logic_error formatProblemWithStructTM;

#if __cplusplus>=201103L
 constexpr epicsTime() :ts{} {}
#else
 epicsTime () {
 ts.secPastEpoch = ts.nsec = 0u;
 }
#endif

 static inline epicsTime getEvent ( const epicsTimeEvent & evt) ;
 static epicsTime getCurrent ();
 static epicsTime getMonotonic () {
 epicsTime ret;
 epicsTimeGetMonotonic(&ret.ts); // can't fail
 return ret;
 }

 operator const epicsTimeStamp& () const { return ts; }
 epicsTime ( const epicsTimeStamp & replace );
 epicsTime & operator = ( const epicsTimeStamp & replace) {
 ts = replace;
 return *this;
 }
 operator time_t_wrapper () const {
 time_t_wrapper ret;
 throwError(epicsTimeToTime_t(&ret.ts, &ts));
 return ret;
 }
 epicsTime ( const time_t_wrapper & replace ) {
 throwError(epicsTimeFromTime_t(&ts, replace.ts));
 }
 epicsTime & operator = ( const time_t_wrapper & replace) {
 throwError(epicsTimeFromTime_t(&ts, replace.ts));
 return *this;
 }
 operator local_tm_nano_sec () const {
 local_tm_nano_sec ret;
 throwError(epicsTimeToTM(&ret.ansi_tm, 0, &ts));
 ret.nSec = ts.nsec;
 return ret;
 }
 epicsTime ( const local_tm_nano_sec & replace) {
 throwError(epicsTimeFromTM(&ts, &replace.ansi_tm, replace.nSec));
 }
 epicsTime & operator = ( const local_tm_nano_sec & replace) {
 throwError(epicsTimeFromTM(&ts, &replace.ansi_tm, replace.nSec));
 return *this;
 }
 operator gm_tm_nano_sec () const {
 gm_tm_nano_sec ret;
 throwError(epicsTimeToGMTM(&ret.ansi_tm, 0, &ts));
 ret.nSec = ts.nsec;
 return ret;
 }
 epicsTime ( const gm_tm_nano_sec & replace) {
 throwError(epicsTimeFromGMTM(&ts, &replace.ansi_tm, replace.nSec));
 }
 epicsTime & operator = ( const gm_tm_nano_sec & replace) {
 throwError(epicsTimeFromGMTM(&ts, &replace.ansi_tm, replace.nSec));
 return *this;
 }
 operator struct timespec () const {
 timespec ret;
 epicsTimeToTimespec(&ret, &ts);
 return ret;
 }
 epicsTime ( const struct timespec & replace) {
 throwError(epicsTimeFromTimespec(&ts, &replace));
 }
 epicsTime & operator = ( const struct timespec & replace ) {
 throwError(epicsTimeFromTimespec(&ts, &replace));
 return *this;
 }
 operator struct timeval () const ;
 epicsTime ( const struct timeval & replace);
 epicsTime & operator = ( const struct timeval & replace);
#ifdef _WIN32

 operator struct _FILETIME () const;
 epicsTime ( const struct _FILETIME & );
 epicsTime & operator = ( const struct _FILETIME & );
#endif /* _WIN32 */

 double operator- ( const epicsTime & other) const {
 return epicsTimeDiffInSeconds(&ts, &other.ts);
 }
 epicsTime operator+ (double delta) const {
 epicsTime ret(*this);
 epicsTimeAddSeconds(&ret.ts, delta);
 return ret;
 }
 epicsTime operator- (double delta ) const {
 return (*this)+(-delta);
 }
 epicsTime operator+= (double delta) {
 epicsTimeAddSeconds(&ts, delta);
 return *this;
 }
 epicsTime operator-= ( double delta ) {
 return (*this) += (-delta);
 }
 bool operator == ( const epicsTime & other) const {
 return epicsTimeEqual(&ts, &other.ts);
 }
 bool operator != ( const epicsTime & other) const {
 return epicsTimeNotEqual(&ts, &other.ts);
 }
 bool operator <= ( const epicsTime & other) const {
 return epicsTimeLessThanEqual(&ts, &other.ts);
 }
 bool operator < ( const epicsTime & other) const {
 return epicsTimeLessThan(&ts, &other.ts);
 }
 bool operator >= ( const epicsTime & other) const {
 return epicsTimeGreaterThanEqual(&ts, &other.ts);
 }
 bool operator > ( const epicsTime & other) const {
 return epicsTimeGreaterThan(&ts, &other.ts);
 }
 size_t strftime ( char * pBuff, size_t bufLength, const char * pFormat ) const {
 return epicsTimeToStrftime(pBuff, bufLength, pFormat, &ts);
 }

 void show ( unsigned interestLevel ) const {
 epicsTimeShow(&ts, interestLevel);
 }

private:
 epicsTimeStamp ts;
};

LIBCOM_API
std::ostream& operator<<(std::ostream& strm, const epicsTime& ts);

#endif /* __cplusplus */
 

#endif /* epicsTimehInclude */