VcstTime.h

Go to the documentation of this file.

/*******************************************************************************
 *
 * NAME:  VcstTime.h
 *
 * DESCRIPTION: This is the header file for the VcstTime object class.
 *
 * Adapted directly from various IDPS files, InfUtil_Tim.h, InfUtil_TimApi.h,
 * etc., published by Raytheon Company.
 *
 *******************************************************************************/
 
#ifndef _VcstTime_h
#define _VcstTime_h
 
#include <map>
#include <set>
#include <string>
#include <exception>
#include <time.h>
 
#define MAX_LEAP 156
#define MAXBUFFER 256
 
/*
 *  The following are all valid error numbers for the time utility
 */
#define TIMERR_ROOT         -1600
 
#define TIMERR_BADDAY       TIMERR_ROOT -  3
#define TIMERR_BADHOUR      TIMERR_ROOT -  4
#define TIMERR_BADMIN       TIMERR_ROOT -  5
#define TIMERR_BADMONTH     TIMERR_ROOT -  6
#define TIMERR_BADMSEC      TIMERR_ROOT -  7
#define TIMERR_BADSEC       TIMERR_ROOT -  8
#define TIMERR_BADYEAR      TIMERR_ROOT -  9
#define TIMERR_LEAPACCESS   TIMERR_ROOT - 10
#define TIMERR_LEAPBADYEAR  TIMERR_ROOT - 11
#define TIMERR_LEAPBADMONTH TIMERR_ROOT - 12
#define TIMERR_LEAPBADDAY   TIMERR_ROOT - 13
#define TIMERR_LEAPBADLEAP  TIMERR_ROOT - 14
#define TIMERR_LEAPOPEN     TIMERR_ROOT - 15
#define TIMERR_MONTHCALC    TIMERR_ROOT - 16
#define TIMERR_BADUTC       TIMERR_ROOT - 17
#define TIMERR_UTCCOLON2    TIMERR_ROOT - 18
#define TIMERR_UTCDASH1     TIMERR_ROOT - 19
#define TIMERR_UTCDOT1      TIMERR_ROOT - 20
#define TIMERR_UTCMONTH     TIMERR_ROOT - 21
#define TIMERR_UTCT         TIMERR_ROOT - 22
#define TIMERR_NOINIT       TIMERR_ROOT - 23
#define TIMERR_BADTAI       TIMERR_ROOT - 24
 
struct TimGdtStruct {
    int year;
    int month;
    int day;
    int hour;
    int min;
    int sec;
    int mill;
    int msec;
    int wkday;
    int numday;
 
};
 
struct LeapStruct {
    int year;
    int month;
    int day;
    double tai;
    int leap;
};
 
struct TimError {
    int errNo;
    char errmsg[MAXBUFFER];
};
 
struct ltGDT {
 
    bool operator()(const TimGdtStruct* gdt1, const TimGdtStruct* gdt2) const {
        if (gdt1 == NULL) {
            if (gdt2 == NULL) {
                return false;
            }
 
            return true; // gdt1 == null && gdt2 !=null
        } else if (gdt2 == NULL) //gdt1 != null && gdt2 == null
        {
            return false;
        } else {
            if (gdt1->year < gdt2->year) {
                return true;
            } else if ((gdt1->year == gdt2->year)
                    && (gdt1->month < gdt2->month)) {
                return true;
            } else if ((gdt1->year == gdt2->year)
                    && (gdt1->month == gdt2->month)
                    && (gdt1->day < gdt2->day)) {
                return true;
            } else if ((gdt1->year == gdt2->year)
                    && (gdt1->month == gdt2->month) && (gdt1->day == gdt2->day)
                    && (gdt1->hour < gdt2->hour)) {
                return true;
            } else if ((gdt1->year == gdt2->year)
                    && (gdt1->month == gdt2->month) && (gdt1->day == gdt2->day)
                    && (gdt1->hour == gdt2->hour) && (gdt1->min < gdt2->min)) {
                return true;
            } else if ((gdt1->year == gdt2->year)
                    && (gdt1->month == gdt2->month) && (gdt1->day == gdt2->day)
                    && (gdt1->hour == gdt2->hour) && (gdt1->min == gdt2->min)
                    && (gdt1->sec < gdt2->sec)) {
                return true;
            } else {
                // We stop at second because we want to see if this GDT is
                // during the same second.  NOT that it is EXACTLY the same.
                return false;
            }
        }
    }
};
 
struct ltLeap {
 
    bool operator()(const LeapStruct* leap1, const LeapStruct* leap2) const {
        if (leap1 == NULL) {
            if (leap2 == NULL) {
                return false;
            }
            return true; // leap1 == null && leap2 !=null
        } else if (leap2 == NULL) //leap1 != null && leap2 == null
        {
            return false;
        } else {
            if (leap1->tai < leap2->tai) {
                // If the TAI is the same ALL other values should be the same
                // in a consistent CDS Struct.
                return true;
            }
            return false;
        }
    }
};
 
struct lsCDS {
 
    bool operator()(const long long l1, const long long l2) const {
        return l1 < l2;
    }
};
 
typedef std::set<const TimGdtStruct*, ltGDT> GDTSet;
typedef std::set<unsigned long long, lsCDS> CDSSet;
 
class VcstTime {
public:
 
    static VcstTime* getInstance(void);
 
    int initialize(void);
 
    int initialize(const char* inLeapFile);
 
    double taiNow(void);
 
    void tai2Unix(double inTai, timespec*);
 
    double unix2Tai(timespec *tspec);
 
    int taiAddDelta(double *ioTai, double inDelta);
 
    int taiSubtractDelta(double *ioTai, double inDelta);
 
    int cds2Tai(unsigned long long inCds, double *outTai);
 
    int tai2Cds(double inTai, unsigned long long *outCds);
 
    int dispCds(unsigned long long inCds);
 
    int tai2Gdt(double inTai, TimGdtStruct *outGdt);
 
    int gdt2Tai(TimGdtStruct *inGdt, double *outTai);
 
    int tai2String(double inTai, char* outString, int inFormat = 1);
 
    int string2Tai(std::string inString, double *outTai);
 
    void printInfo();
 
    timespec getSystemTime();
 
    static std::string errorMessage(int errNo = 1);
 
private:
 
 
    enum tokenType {
        NONE, INT, FLOAT, STRING, EOS
    };
 
    // Constant memebers
    static const char *TOKEN_SEPARATORS;
 
    // Constant memebers
    static const char *TOKEN_SEPARATORS_UTC;
 
 
    struct TokenStruct {
        tokenType type;
 
        union tokenVal {
            char *s;
            int i;
            float f;
            long long l;
            double d;
        } val;
    };
 
    VcstTime(void);
 
    void calcTai(TimGdtStruct *inGdt, double *outTai);
 
    int adjustLeapDay(int inYear);
 
    int calcLeapDays(int inYear);
 
    int getTaiLeapSecond(double inTai, int withLeap);
 
    int isExactLeapSecond(double inTai);
 
    int getLeapSecond(int inYear, int inMonth, int inDay);
 
    int readLeapSecondFile(const char * inFilename);
 
    int parseLeapFileLine(char *inBuffer, int *outYear, int *outMonth,
            int *outDay, int *outLeap);
 
    TimGdtStruct utcParse(std::string inString);
 
    void displayLeap(void);
 
    void displayGdt(char *inPrompt, TimGdtStruct *inGdt);
 
    char *nextField(char *inBuffer, char delin, char *outSub);
 
    TokenStruct getNextToken(const char* tokens);
 
    TokenStruct getNextToken(char * parseString, const char* tokens);
 
    bool isNegativeLeapSecond(TimGdtStruct *inGdt);
 
    bool isNegativeLeapSecondCDS(long long inCDS);
 
    void initNegativeLeaps(void);
 
private:
    // Members
 
    struct LeapStruct myLeapList[MAX_LEAP + 1];
 
    int myNleap;
 
    // The pointer to the string currently being parsed.
    char *myBuffer;
 
    static char myMonthStr[13][13];
 
    static int myDayInMonth[13];
 
    bool myInit;
 
    // A Set of TimGdtStructs representing negative Leaps
    GDTSet* myGDTNegativeLeaps;
 
    // A Set of long long (CDS representations) Leaps representing negative Leaps
    CDSSet* myCDSNegativeLeaps;
 
    // The hash map of month to integer conversion.
    std::map<std::string, int> myMonthMap;
};
 
extern const std::string EXCEPTION_STRING;
 
extern const std::string ERR_BADDAY_MSG;
 
extern const std::string ERR_BADHOUR_MSG;
 
extern const std::string ERR_BADMIN_MSG;
 
extern const std::string ERR_BADMONTH_MSG;
 
extern const std::string ERR_BADMSEC_MSG;
 
extern const std::string ERR_BADSEC_MSG;
 
extern const std::string ERR_BADYEAR_MSG;
 
extern const std::string ERR_LEAPACCESS_MSG;
 
extern const std::string ERR_LEAPREAD_MSG;
 
extern const std::string ERR_LEAPBADDAY_MSG;
 
extern const std::string ERR_LEAPBADLEAP_MSG;
 
extern const std::string ERR_LEAPBADMONTH_MSG;
 
extern const std::string ERR_LEAPBADYEAR_MSG;
 
extern const std::string ERR_LEAPOPEN_MSG;
 
extern const std::string ERR_MONTHCALC_MSG;
 
extern const std::string ERR_BADUTC_MSG;
 
extern const std::string ERR_UTCCOLON2_MSG;
 
extern const std::string ERR_UTCDASH1_MSG;
 
extern const std::string ERR_UTCDOT1_MSG;
 
extern const std::string ERR_UTCMONTH_MSG;
 
extern const std::string ERR_UTCT_MSG;
 
extern const std::string ERR_NOINIT_MSG;
 
extern const std::string ERR_BADTAI_MSG;
 
extern const std::string MAX_TAI_VALUE_EXCEEDED_MSG;
 
extern const std::string IOEXCEPTION_Msg;
 
class TimException : public std::exception {
public:
 
    static const int EXCEPTION_CODE;
 
    static const int NAME_NOT_FOUND;
 
    static const int ERR_BADDAY;
 
    static const int ERR_BADHOUR;
 
    static const int ERR_BADMIN;
 
    static const int ERR_BADMONTH;
 
    static const int ERR_BADMSEC;
 
    static const int ERR_BADSEC;
 
    static const int ERR_BADYEAR;
 
    static const int ERR_LEAPACCESS;
 
    static const int ERR_LEAPREAD;
 
    static const int ERR_LEAPBADYEAR;
 
    static const int ERR_LEAPBADMONTH;
 
    static const int ERR_LEAPBADDAY;
 
    static const int ERR_LEAPBADLEAP;
 
    static const int ERR_LEAPOPEN;
 
    static const int ERR_MONTHCALC;
 
    static const int ERR_BADUTC;
 
    static const int ERR_UTCCOLON2;
 
    static const int ERR_UTCDASH1;
 
    static const int ERR_UTCDOT1;
 
    static const int ERR_UTCMONTH;
 
    static const int ERR_UTCT;
 
    static const int ERR_NOINIT;
 
    static const int ERR_BADTAI;
 
    static const int MAX_TAI_VALUE_EXCEEDED;
 
    static const int IOEXCEPTION;
 
    TimException(void);
 
    TimException(const std::string& errorString, int errorCode);
 
    ~TimException(void) throw () {
        if (myCause) {
            delete myCause;
            myCause = 0;
        }
    }
    ;
 
    inline int getErrorCode() const {
        return myErrorCode;
    }
 
    inline std::string getErrorString() const {
        return myErrorString;
    }
 
private:
 
    int myErrorCode;
 
    std::string myErrorString;
 
    std::exception* myCause;
};
 
union TimCDS {
public:
    unsigned long long ll;
    unsigned char uc[8];
 
    //getters
    unsigned short getDays();
    unsigned int getMillis();
    unsigned short getMicros();
 
    // Setters
    void setDays(unsigned short);
    void setMillis(unsigned int);
    void setMicros(unsigned short);
 
    static int makeCds(unsigned int inDay, unsigned long long inMsec,
            unsigned long long *outCds);
 
    static int parseCds(unsigned long long inCds, unsigned int *outDay,
            unsigned long long *outMsec);
 
    static int displayCds(unsigned long long inCds);
 
};
 
#endif