JTime.cpp

Go to the documentation of this file.

/***************************** License **********************************

 Copyright (C) 2008 by Communicative Machines
 http://www.cmlabs.com   All rights reserved.

 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) any later version.

 This library 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
 Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

************************************************************************/
// JTime.cpp: implementation of the JTime class.
//
//////////////////////////////////////////////////////////////////////

#include "JTime.h"
#include "XMLParser.h"


#ifdef CYGWIN
//      #undef __int64
//      #define __int64 Long64_t
#endif

// For Darwin, we need to do quite a lot
#ifdef Darwin

        #include <sys/time.h>

        int ftime(struct timeb *tp) {

                struct timeval tv;
                struct timezone tz;

                gettimeofday(&tv, &tz);

                tp->time = tv.tv_sec;
                tp->millitm = (unsigned short) (tv.tv_usec / 1000);

/*              struct timeval *tv = new struct timeval;
                struct timezone *tz = new struct timezone;

                gettimeofday(tv, tz);

                tp->time = tv->tv_sec;
                tp->millitm = (unsigned short) (tv->tv_usec / 1000);

                delete(tv);
                delete(tz);
*/
                return 0;
        }

#endif

#if defined(WIN32_POCKETPC)

//      #include "wce_time.cpp"

        struct tm staticTM;

        int ftime_gmt(struct timeb *tp) {

                FILETIME ft;
                SYSTEMTIME st;
                GetLocalTime(&st);
                SystemTimeToFileTime(&st, &ft);

                struct timeb t = JTime::filetime2timeb(&ft);

                // GetSystemTimeAsFileTime(&ft); would be faster,
                // but it does not exist on WinCE

                *tp = t;
                return 0;
        }

        int ftime(struct timeb *tp) {

                FILETIME ft;
                SYSTEMTIME st;
                GetSystemTime(&st);
                SystemTimeToFileTime(&st, &ft);

                struct timeb t = JTime::filetime2timeb(&ft);

                // GetSystemTimeAsFileTime(&ft); would be faster,
                // but it does not exist on WinCE

                *tp = t;
                return 0;
        }

        unsigned long time(time_t *t) {
                struct timeb tb;
                ftime(&tb);
                *t = tb.time;
                return 0;
        }

        struct tm* localtime(time_t *t) {

                SYSTEMTIME st;
                FILETIME ft = JTime::time_t2filetime(*t);
                FileTimeToSystemTime(&ft, &st);
        //      GetLocalTime(&st);

                staticTM.tm_sec = st.wSecond;
                staticTM.tm_min = st.wMinute;
                staticTM.tm_hour = st.wHour;
                staticTM.tm_mday = st.wDay;
                staticTM.tm_mon = st.wMonth-1;
                staticTM.tm_year = st.wYear - 1900;
                staticTM.tm_wday = st.wDayOfWeek;
                staticTM.tm_yday = 1;
                //staticTM.tm_isdst = t->dstflag;

                return &staticTM;
        }

        struct tm* gmtime(time_t *t) {

                SYSTEMTIME st;
                FILETIME ft = JTime::time_t2filetime(*t);
                FileTimeToSystemTime(&ft, &st);

                staticTM.tm_sec = st.wSecond;
                staticTM.tm_min = st.wMinute;
                staticTM.tm_hour = st.wHour;
                staticTM.tm_mday = st.wDay;
                staticTM.tm_mon = st.wMonth - 1;
                staticTM.tm_year = st.wYear - 1900;
                staticTM.tm_wday = st.wDayOfWeek;
                staticTM.tm_yday = 1;
                staticTM.tm_isdst = 0;

                return &staticTM;
        }



#endif

namespace cmlabs {

JTime JTime::createInvalid() {
        JTime newTime;
        newTime.setInvalid();
        return newTime;
}


//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

JTime::JTime()
{
        ftime( &timebuffer );
        valid = true;
        atomicOffset = 0;
//      setLocalTimeZoneInformation();

        #ifdef WIN32
                if (QueryPerformanceCounter(&perfCount) == 0) {
                        FILETIME ft;
                        SYSTEMTIME st;
                        GetLocalTime(&st);
                        SystemTimeToFileTime(&st, &ft);
                        perfCount = *(LARGE_INTEGER*)&ft;
                //      perfCount.QuadPart = (ft.dwHighDateTime << 32) + ft.dwLowDateTime;
                //      perfCount.QuadPart = 0;
                }
        #else
                struct timezone tmzone;
                gettimeofday(&perfCount, &tmzone);
        #endif // WIN32

//      cout << "Created time from scratch = " << this->printStamp() << endl;
}

JTime::JTime(const JTime &t) {
        timebuffer = t.timebuffer;
        perfCount = t.perfCount;
        valid = t.valid;
        atomicOffset = t.atomicOffset;
//      setLocalTimeZoneInformation();
}

JTime::JTime(struct timeb tb) {
        timebuffer = tb;
        atomicOffset = 0;

        #ifdef WIN32
                perfCount.QuadPart = 0;
        #else
                perfCount.tv_sec = 0;
        #endif // WIN32
        valid = true;
//      setLocalTimeZoneInformation();
}

JTime::JTime(long ms) {

        ftime( &timebuffer );
        valid = true;
        atomicOffset = 0;

        timebuffer.time = (int)(ms/1000);
        if (timebuffer.time < 0) valid=false;
        timebuffer.millitm = (unsigned short) (ms - (timebuffer.time * 1000));

        #ifdef WIN32
                perfCount.QuadPart = 0;
        #else
                perfCount.tv_sec = 0;
        #endif // WIN32
//      setLocalTimeZoneInformation();
}


JTime::JTime(const JString& text)
{
//      setLocalTimeZoneInformation();
        atomicOffset = 0;
        valid = true;
        ftime( &timebuffer );
        if (text.looksLikeXML()) {
                if (!Object::fromXML(text)) {
                }
        }
        else if ( (text.contains(",")) && (text.contains(":")) ) {
                fromHTTP(text);
        }
        else if (text.length() > 0) {
                JString strTime;
                JString strMs;
                int pos = text.indexOf('.');
                if (pos > 0) {
                        strTime = text.substring(0, pos-3);
                        strMs = text.substring(pos-3, pos);
                        atomicOffset = text.substring(pos+1).toInt();
                }
                else {
                        strTime = text.substring(0, text.length()-3);
                        strMs = text.substring(text.length()-3);
                }

                ftime( &timebuffer );
                timebuffer.time = strTime.toLong();
                if (timebuffer.time < 0)
                        timebuffer.time = timebuffer.time;
                timebuffer.millitm = (unsigned short) strMs.toInt();
        }
        else
                valid = false;

        #ifdef WIN32
                perfCount.QuadPart = 0;
        #else
                perfCount.tv_sec = 0;
        #endif // WIN32
}

JTime::JTime(XMLNode* node) {
//      setLocalTimeZoneInformation();
        atomicOffset = 0;
        valid = true;
        if (!fromXML(node)) {
        }
}

JTime::JTime(long sec, int milli)
{
        ftime( &timebuffer );
        atomicOffset = 0;
        if (sec < 0) sec = 0;
        if (timebuffer.time < 100000000) {
                timebuffer.timezone = 0;
                timebuffer.dstflag = 0;
        }
        timebuffer.time = sec;
        timebuffer.millitm = milli;
        #ifdef WIN32
                perfCount.QuadPart = 0;
        #else
                perfCount.tv_sec = 0;
        #endif // WIN32
        valid = true;
//      setLocalTimeZoneInformation();
}


JTime::~JTime()
{

}


//! Get total size of payload
unsigned long JTime::getPayloadSize() const {
        return sizeof(struct timeb) + tzc.length() + sizeof(perfCount);
}

JString JTime::getLocalTimeZoneInformation() const {

        if (tzc.length() > 0)
                return tzc;

        JString tzName = "";
        long tzOffset = 0;
        int tzDST = 0;

#ifdef WIN32

        TIME_ZONE_INFORMATION tzinfo;
        DWORD res = GetTimeZoneInformation(&tzinfo);

        tzOffset = -1 * tzinfo.StandardBias;
        tzDST = -1 * tzinfo.DaylightBias;

        tzName = tzinfo.StandardName;
        int pos = tzName.indexOf(' ');
        if (pos > 0)
                tzinfo.StandardName[pos] = 0;
        tzName = tzinfo.StandardName;

#else
        #ifndef Darwin
                tzset();
                tzOffset = timezone * 60;
                tzDST = daylight * 60;
                tzName = tzname[0];
        //      if (tzDST != 0)
        //              tzName = tzname[1];
        #endif
#endif

        return JString::format("%s_%d_%d", (char*)tzName, tzOffset, tzDST);
}


bool JTime::setLocalTimeZoneInformation() {
        tzc = getLocalTimeZoneInformation();
        return true;
}

JString JTime::getLocalTimeZoneName() const {
        return getLocalTimeZoneInformation().split("_").get(0);
}
int JTime::getLocalTimeZoneOffset() const {
        return getLocalTimeZoneInformation().split("_").get(1).toInt();
}
int JTime::getLocalTimeZoneDST() const {
        return getLocalTimeZoneInformation().split("_").get(2).toInt();
}
JString JTime::getOriginalTimeZoneName() const {
        return tzc.split("_").get(0);
}
int JTime::getOriginalTimeZoneOffset() const {
        return tzc.split("_").get(1).toInt();
}
int JTime::getOriginalTimeZoneDST() const {
        return tzc.split("_").get(2).toInt();
}

int JTime::getTimeDifference() const {
        return getLocalTimeZoneOffset() - getOriginalTimeZoneOffset() +
                ( getLocalTimeZoneDST() - getOriginalTimeZoneDST() );
}

int JTime::getTimeDifference(const JTime &t) const {
        return t.getOriginalTimeZoneOffset() - getOriginalTimeZoneOffset() +
                ( t.getOriginalTimeZoneDST() - getOriginalTimeZoneDST() );
}

bool JTime::perfCountReset() {
        #ifdef WIN32
                perfCount.QuadPart = 0;
        #else
                perfCount.tv_sec = 0;
        #endif // WIN32
        return true;
}

bool JTime::reset() {
        ftime( &timebuffer );
        atomicOffset = 0;
        valid = true;

        #ifdef WIN32
                if (QueryPerformanceCounter(&perfCount) == 0) {
                        FILETIME ft;
                        SYSTEMTIME st;
                        GetLocalTime(&st);
                        SystemTimeToFileTime(&st, &ft);
                        perfCount = *(LARGE_INTEGER*)&ft;
                }
        #else
                struct timezone tmzone;
                gettimeofday(&perfCount, &tmzone);
        #endif // WIN32
        return true;
}

void JTime::setInvalid() {
        #ifdef WIN32
                perfCount.QuadPart = 0;
        #else
                perfCount.tv_sec = 0;
        #endif // WIN32
        valid = false;
}

bool JTime::isValid() const {
        return valid;
}


Object* JTime::clone() const {
        JTime* t = new JTime(*this);
        return (Object*) t;
}

unsigned long JTime::getHash() const {
        unsigned long key = (unsigned long) this->ms();
        // 32-bit integer hash function
        key += ~(key << 15);
        key ^=  (key >> 10);
        key +=  (key << 3);
        key ^=  (key >> 6);
        key += ~(key << 11);
        key ^=  (key >> 16);
        // 64-bit integer hash function
        //key += ~(key << 32);
        //key ^= (key >>> 22);
        //key += ~(key << 13);
        //key ^= (key >>> 8);
        //key += (key << 3);
        //key ^= (key >>> 15);
        //key += ~(key << 27);
        //key ^= (key >>> 31);
        return key;
}

JString JTime::printTime() const {
        return printTimeMS();
}

JString JTime::printTimeSec() const {
        if (!valid)
                return "n/a";
        struct tm *newtime;
//      time_t* tp = & (timebuffer.time );
        time_t tp = timebuffer.time;
        if (tp < 100000000)
                newtime = gmtime(&tp);
        else
                newtime = localtime(&tp);
        char result[100];
        sprintf(result, "%.2d:%.2d:%.2d", newtime->tm_hour, newtime->tm_min, newtime->tm_sec);
        return JString(result);
}

JString JTime::printTimeMS() const {
        if (!valid)
                return "n/a";
        return JString::format("%s.%.3d", (char*) printTimeSec(), timebuffer.millitm);
}

JString JTime::printDifTime() const {
        if (!valid)
                return "n/a";
        struct tm *newtime;
        time_t tp = timebuffer.time;
        if (tp < 100000000)
                newtime = gmtime(&tp);
        else
                newtime = localtime(&tp);

        int days = (int)(timebuffer.time / (60*60*24));

        JString timestring;
        if (days > 1)
                timestring += JString::format("%d days ", days);
        else if (days == 1)
                timestring += JString::format("%d day ", days);

        if (newtime->tm_hour > 1)
                timestring += JString::format("%d hours ", newtime->tm_hour);
        else if (newtime->tm_hour == 1)
                timestring += JString::format("1 hour ");
        else if (days > 0)
                timestring += JString::format("0 hours ");


        if ((timestring.length() == 0) && (newtime->tm_min > 0))
                timestring += JString::format("%d min ", newtime->tm_min);
        else if (newtime->tm_min > 0)
                timestring += JString::format("%.2d min ", newtime->tm_min);
        else if (timestring.length() > 0)
                timestring += JString::format("0 min ");

        if ((timestring.length() == 0) && (newtime->tm_sec > 0))
                timestring += JString::format("%d", newtime->tm_sec);
        else if (newtime->tm_sec > 0)
                timestring += JString::format("%.2d", newtime->tm_sec);
        else if (timestring.length() > 0)
                timestring += JString::format("00");


        if (timestring.length() == 0)
                timestring += JString::format("%d ms", timebuffer.millitm);
        else
                timestring += JString::format(".%.3d sec", timebuffer.millitm);

        return timestring;
}

JString JTime::printDateShort() const {
        if (!valid)
                return "n/a";
        struct tm *newtime;
        time_t tp = timebuffer.time;
        newtime = localtime(&tp);
        char result[100];
        sprintf(result, "%.2d-%.2d-%.4d", newtime->tm_mday, newtime->tm_mon + 1, newtime->tm_year + 1900);
        return JString(result);
}

JString JTime::printDateSortable() const {
        if (!valid)
                return "n/a";
        struct tm *newtime;
        time_t tp = timebuffer.time;
        newtime = localtime(&tp);
        char result[100];
        sprintf(result, "%.4d-%.2d-%.2d", newtime->tm_year + 1900, newtime->tm_mon + 1, newtime->tm_mday);
        return JString(result);
}

JString JTime::printDateLong() const {
        if (!valid)
                return "n/a";
        struct tm *newtime;
        time_t tp = timebuffer.time;
        newtime = localtime(&tp);
        char result[100];
        sprintf(result, "%.2d.%.2d.%.4d",
                newtime->tm_mday, newtime->tm_mon + 1, newtime->tm_year + 1900);
        return JString(result);
/*
        char *timeline;
        char result[100];
        timeline = ctime( & ( timebuffer.time ) );
        JString tt = timeline;
        sprintf(result, "%.10s %.4s", timeline, &timeline[20]);
        return (JString(result));*/
}


JString JTime::printStamp() const {
        if (!valid)
                return "n/a";
        JString str = printDateSortable();
        str += " ";
        str += printTime();
        return (str);
}

JString JTime::print() {
        if (!valid)
                return "n/a";
        JString str = printDateLong();
        str += " ";
        str += printTime();
        return (str);
}

JString JTime::toHTTP() const {
        // Thu, 01 Dec 1994 16:00:00 GMT

        struct tm *newtime;
        // time_t* tp = & (timebuffer.time );
        time_t tp = timebuffer.time;
//      newtime = localtime(&tp);
        newtime = gmtime(&tp);

        JString str;

        if (newtime->tm_wday == 0)
                str += "Sun";
        else if (newtime->tm_wday == 1)
                str += "Mon";
        else if (newtime->tm_wday == 2)
                str += "Tue";
        else if (newtime->tm_wday == 3)
                str += "Wed";
        else if (newtime->tm_wday == 4)
                str += "Thu";
        else if (newtime->tm_wday == 5)
                str += "Fri";
        else if (newtime->tm_wday == 6)
                str += "Sat";

        str += JString(", ") + JString(newtime->tm_mday, 2) + " ";

        if (newtime->tm_mon == 0)
                str += "Jan";
        else if (newtime->tm_mon == 1)
                str += "Feb";
        else if (newtime->tm_mon == 2)
                str += "Mar";
        else if (newtime->tm_mon == 3)
                str += "Apr";
        else if (newtime->tm_mon == 4)
                str += "May";
        else if (newtime->tm_mon == 5)
                str += "Jun";
        else if (newtime->tm_mon == 6)
                str += "Jul";
        else if (newtime->tm_mon == 7)
                str += "Aug";
        else if (newtime->tm_mon == 8)
                str += "Sep";
        else if (newtime->tm_mon == 9)
                str += "Oct";
        else if (newtime->tm_mon == 10)
                str += "Nov";
        else if (newtime->tm_mon == 11)
                str += "Dec";

        str += JString(" ") + JString(newtime->tm_year+1900) + " ";

        str += JString(newtime->tm_hour, 2) + JString(":") + JString(newtime->tm_min, 2) + JString(":") + JString(newtime->tm_sec, 2) + " GMT";

        return str;
}

bool JTime::fromHTTP(const JString& text) {
        // Sat, 29 Oct 1994 19:43:31 GMT
        int offset = 0;
        if (text.contains("GMT"))
                offset = 0;

        Collection col = text.splitOnWhiteSpaces();
        if (col.getCount() < 6) {
                setInvalid();
                return false;
        }

        Collection tcol = col.get(4).split(";");
        if (tcol.getCount() < 3) {
                setInvalid();
                return false;
        }
        int hour = tcol.get(0).toInt();
        int min = tcol.get(1).toInt();
        int sec = tcol.get(2).toInt();
        int day = col.get(1).toInt();
        int year = col.get(3).toInt();

        int month;
        JString monthName = col.get(2);
        if (monthName.equalsIgnoreCase("jan"))
                month = 1;
        else if (monthName.equalsIgnoreCase("feb"))
                month = 2;
        else if (monthName.equalsIgnoreCase("mar"))
                month = 3;
        else if (monthName.equalsIgnoreCase("apr"))
                month = 4;
        else if (monthName.equalsIgnoreCase("may"))
                month = 5;
        else if (monthName.equalsIgnoreCase("jun"))
                month = 6;
        else if (monthName.equalsIgnoreCase("jul"))
                month = 7;
        else if (monthName.equalsIgnoreCase("aug"))
                month = 8;
        else if (monthName.equalsIgnoreCase("sep"))
                month = 9;
        else if (monthName.equalsIgnoreCase("oct"))
                month = 10;
        else if (monthName.equalsIgnoreCase("nov"))
                month = 11;
        else if (monthName.equalsIgnoreCase("dec"))
                month = 12;
        else {
                setInvalid();
                return false;
        }

        return setTime(year, month, day, hour, min, sec);
}

bool JTime::setTime(int year, int month, int day, int hour, int min, int sec, int ms) {

#ifdef WIN32

        TIME_ZONE_INFORMATION tzi;
        DWORD zone = GetTimeZoneInformation(&tzi);
        bool isDST = false;

        if (zone == TIME_ZONE_ID_DAYLIGHT)
                isDST = true;
                
        //DWORD s1, s2;
        //BOOL s3;
        //GetSystemTimeAdjustment(&s1, &s2, &s3);
        //if ( (s1 != 0) && (s3) )
        //      isDST = true;

        SYSTEMTIME st;
        st.wMilliseconds = ms;
        st.wSecond = sec;
        st.wMinute = min;
        st.wHour = hour;
        st.wDay = day;
        st.wMonth = month;
        st.wYear = year;

        FILETIME ft;
        SystemTimeToFileTime(&st, &ft);
        if (isDST)
                *this = JTime(ft) + (1000*60*(tzi.Bias-60));
        else
                *this = JTime(ft) + (1000*60*tzi.Bias);
        this->timebuffer.millitm = ms;
        perfCount.QuadPart = 0;
#else
        struct tm *newtime;
        ftime( &timebuffer );
        time_t* tp = & (timebuffer.time );
        newtime = localtime(tp);

        if (year > 1900)
                newtime->tm_year = year - 1900;
        else if (year < 30)
                newtime->tm_year = year + 100;
        else
                newtime->tm_year = year;

        newtime->tm_mon = month-1;
        newtime->tm_mday = day;
        newtime->tm_hour = hour;
        newtime->tm_min = min;
        newtime->tm_sec = sec;

        time_t t = mktime(newtime);
        if ((int)t <= 0) {
                setInvalid();
                return false;
        }
        timebuffer.time = t;
        timebuffer.millitm = ms;
        perfCount.tv_sec = 0;
#endif
//      setLocalTimeZoneInformation();
        return true;
}

double JTime::ms() const {
        if (!valid)
                return 0;
        double d = (double) timebuffer.time;
        d = d * 1000;
        return(d + timebuffer.millitm);
}

JString JTime::asText() const {
        if (!valid)
                return "";
        if (atomicOffset > 0)
                return JString::format("%d%.3d.%d", (long)timebuffer.time, (int)timebuffer.millitm, atomicOffset);
        else
                return JString::format("%d%.3d", (long)timebuffer.time, (int)timebuffer.millitm);
/*      JString str = JString((long)timebuffer.time);
        str += JString(timebuffer.millitm, 3);
        return str;*/
}

long JTime::seconds() const {
        if (!valid)
                return 0;
        return (long) timebuffer.time;
}

int JTime::milliseconds() const {
        if (!valid)
                return 0;
        return timebuffer.millitm;
}


long JTime::getAge() const {
        return (long)(getMicroAge()/1000);
}

long long JTime::getMicroAge() const {
        if (!valid)
                return -1;

        struct timeb tb;
        ftime( &tb );

        long long s = (long long)(tb.time - timebuffer.time);
        int ms = tb.millitm - timebuffer.millitm;
//      if ((abs(s) >= 1) || ((s == 0) && (abs(ms) >= 100))) {
        if (abs((long)s) >= 60) {
                return ((s*1000) + ms)*1000;
        }

        #ifdef WIN32
                LARGE_INTEGER newPerfCount;
                if (QueryPerformanceCounter(&newPerfCount) == 0) {
                        FILETIME ft;
                        SYSTEMTIME st;
                        GetLocalTime(&st);
                        SystemTimeToFileTime(&st, &ft);
                        newPerfCount = *(LARGE_INTEGER*)&ft;
                }
        #else
                struct timeval newPerfCount;
                struct timezone tmzone;
                gettimeofday(&newPerfCount, &tmzone);
        #endif // WIN32

        // timebuffer.time;
        // timebuffer.millitm;

        long long micro = 0;

        #ifdef WIN32
                if ( (newPerfCount.QuadPart == 0) || (perfCount.QuadPart == 0) ) {
                        return ((s*1000) + ms)*1000;
                }
                __int64 ticks = (((__int64) newPerfCount.QuadPart) - ((__int64) perfCount.QuadPart));
                LARGE_INTEGER perfFreq;
                QueryPerformanceFrequency(&perfFreq);
                // We want this in microseconds
                ticks = ticks * 1000000;
                micro = (long) (ticks / perfFreq.QuadPart);
        #else
                if ( (newPerfCount.tv_sec == 0) || (perfCount.tv_sec == 0) ) {
                        return ((s*1000) + ms)*1000;
                }
                long long sec = newPerfCount.tv_sec - perfCount.tv_sec;
                micro = (sec*1000000) + (newPerfCount.tv_usec - perfCount.tv_usec);
        //      printf("$$$ PerfCount Good (%d) $$$\n", (int)micro);
        #endif
        return micro;
}

bool JTime::isOlderThan(long ms) const {
        return (getAge() > ms);
}


// Operators

bool JTime::operator>(const JTime &t) const {
        return (this->compare(&t) == 1);
//      if (this->microDifference(t) > 0)
//              return true;
//      if (this->seconds() > t.seconds())
//              return true;
//      else if (this->seconds() == t.seconds())
//              if (this->milliseconds() > t.milliseconds())
//                      return true;

        return false;
}

bool JTime::operator>=(const JTime &t) const {
        int c = this->compare(&t);
        return (c != -1);
//      if (this->microDifference(t) >= 0)
//              return true;
//      if (this->seconds() > t.seconds())
//              return true;
//      else if (this->seconds() == t.seconds())
//              if (this->milliseconds() >= t.milliseconds())
//                      return true;

        return false;
}

bool JTime::operator<(const JTime &t) const {
        return (this->compare(&t) == -1);
//      if (this->microDifference(t) < 0)
//              return true;
//      if (this->seconds() < t.seconds())
//              return true;
//      else if (this->seconds() == t.seconds())
//              if (this->milliseconds() < t.milliseconds())
//                      return true;

        return false;
}

bool JTime::operator<=(const JTime &t) const {
        int c = this->compare(&t);
        return (c != 1);
//      if (this->microDifference(t) <= 0)
//              return true;
//      if (this->seconds() < t.seconds())
//              return true;
//      else if (this->seconds() == t.seconds())
//              if (this->milliseconds() <= t.milliseconds())
//                      return true;

        return false;
}

bool JTime::operator==(const JTime &t) const {
        return (this->compare(&t) == 0);
        //if ((!valid) || (!t.valid))
        //      return false;
        //if (this->seconds() == t.seconds())
        //      if (this->milliseconds() == t.milliseconds())
        //              return true;
        //return false;
}

bool JTime::operator!=(const JTime &t) const {
        return (this->compare(&t) != 0);
        //if ((!valid) || (!t.valid))
        //      return true;
        //if (this->seconds() == t.seconds())
        //      if (this->milliseconds() == t.milliseconds())
        //              return false;
        //return true;
}


long JTime::operator-(const JTime &t) const {
        if ((!valid) || (!t.valid))
                return 0;
        int ms = milliseconds() - t.milliseconds();
        long s = seconds() - t.seconds();
        if (abs(s) < 120)
                return (long)(this->microDifference(t) * 0.001);
        else
                return (s*1000) + ms;
}

//JTime JTime::operator-(long millis) const {
//      JTime t = (*this);
//      if ((!valid) || (!t.valid)) {
//              t.setInvalid();
//              return t;
//      }
//      t.addMilliseconds(0 - millis);
//      return t;
//}

JTime JTime::operator-(long long millis) const {
        JTime t = (*this);
        if ((!valid) || (!t.valid)) {
                t.setInvalid();
                return t;
        }
        t.addMilliseconds(0 - millis);
        return t;
}

//const JTime& JTime::operator-=(long millis) {
//      if (!valid)
//              return *this;
//      addMilliseconds(0 - millis);
//      return *this;
//}

const JTime& JTime::operator-=(long long millis) {
        if (!valid)
                return *this;
        addMilliseconds(0 - millis);
        return *this;
}

//JTime JTime::operator+(long millis) const {
//      JTime t = (*this);
//      if ((!valid) || (!t.valid)) {
//              t.setInvalid();
//              return t;
//      }
//      t.addMilliseconds(millis);
//      return t;
//}

JTime JTime::operator+(long long millis) const {
        JTime t = (*this);
        if ((!valid) || (!t.valid)) {
                t.setInvalid();
                return t;
        }
        t.addMilliseconds(millis);
        return t;
}

//const JTime& JTime::operator+=(long millis) {
//      if (!valid)
//              return *this;
//      addMilliseconds(millis);
//      return *this;
//}

const JTime& JTime::operator+=(long long millis) {
        if (!valid)
                return *this;
        addMilliseconds(millis);
        return *this;
}

bool JTime::equals(const Object* o2) const {
        if (!isSameClass(o2))
                return false;
        return (compare(o2) == 0);
}

int JTime::compare(const Object* o2) const {
        if (!valid)
                return 0;
        if (!isSameClass(o2))
                return 0;

        try {
                long c = this->microDifference(*(JTime*) o2);
                if (c > 0)
                        return 1;
                else if (c == 0) {
                        if (this->atomicOffset > ((JTime*) o2)->atomicOffset)
                                return 1;
                        else if (this->atomicOffset == ((JTime*) o2)->atomicOffset)
                                return 0;
                        else
                                return -1;
                }
        }
        catch(...) {}
        return -1;
}



JString JTime::toXML() {
        return toXML("time");
//      return JString::format("<time sec=\"%d\" msec=\"%d\" />", (int)timebuffer.time, (int) timebuffer.millitm);
//      return JString::format("<time sec=\"%d\" msec=\"%d\" text=\"%s\" />", (int)timebuffer.time, (int) timebuffer.millitm, (char*) this->print());
}

JString JTime::toXML(const JString& tagname, const JString& params) {
        setLocalTimeZoneInformation();
        if (!valid) {
                return JString::format("<%s %s tzc=\"%s\"/>", (char*) tagname.xmlStringEncode(), (char*) params, (char*) tzc);
        }
        if (atomicOffset > 0)
                return JString::format("<%s %s sec=\"%d\" msec=\"%d\" tzc=\"%s\" atomicoffset=\"%d\" />",
                        (char*) tagname.xmlStringEncode(), (char*) params,
                        (int)timebuffer.time, (int) timebuffer.millitm, (char*) tzc, atomicOffset);
        else
                return JString::format("<%s %s sec=\"%d\" msec=\"%d\" tzc=\"%s\" />",
                        (char*) tagname.xmlStringEncode(), (char*) params,
                        (int)timebuffer.time, (int) timebuffer.millitm, (char*) tzc);
}


bool JTime::fromXML(XMLNode* node) {
        if (node == NULL) {
                return false;
        }
//      if (!node->getTag().equalsIgnoreCase("time"))
//              return false;

        if (node->hasAttribute("atomicoffset"))
                atomicOffset = node->getAttribute("atomicoffset").toInt();
        tzc = node->getAttribute("tzc");
//      if (tzc.length() == 0)
//              setLocalTimeZoneInformation();

        if (!node->hasAttribute("sec")) {
                valid = false;
                #ifdef WIN32
                        perfCount.QuadPart = 0;
                #else
                        perfCount.tv_sec = 0;
                #endif // WIN32
                return true;
        }

        struct timeb tb;
        tb.time = (time_t) node->getAttribute("sec").toInt();

        JString msstring = node->getAttribute("msec");
        if (msstring.length() == 0)
                msstring = node->getAttribute("ms");
        if (msstring.length() > 0)
                tb.millitm = (unsigned short) msstring.toInt();
        else
                tb.millitm = 0;

/*      JString str = node->getAttributes().get("text");
        JTime t = JTime(tb.time, tb.millitm);
        if (!str.equalsIgnoreCase(t.print())) {
                printf("### ERROR JTime::fromXML(): '%s' != '%s'\n", (char*) str, (char*) t.print());
        }
*/
        timebuffer = tb;

        #ifdef WIN32
                perfCount.QuadPart = 0;
        #else
                perfCount.tv_sec = 0;
        #endif // WIN32
        
        valid = true;
        return true;
}



//bool JTime::addMilliseconds(long millis) {
//      return addMilliseconds((long long) millis);
//}

bool JTime::addMilliseconds(long long millis) {
        if (!valid)
                return false;

        long long sec = millis/1000;
        int ms = (int) (millis - (sec*1000));

//      ldiv_t div_result = ldiv( labs((long)millis), 1000);
//      long sec2 = div_result.quot;
//      int ms2 = (int) div_result.rem;

        if (millis > 0) {
                if (ms + timebuffer.millitm >= 1000) {
                        ms -= 1000;
                        sec++;
                }
        }
        else {
                if (timebuffer.millitm - ms < 0) {
                        ms += 1000;
                        sec--;
                }
                // ms = (-1) * ms;
                // sec = (-1) * sec;
        }

        timebuffer.time += sec;
        timebuffer.millitm += ms;
        #ifdef WIN32
                perfCount.QuadPart = 0;
        #else
                perfCount.tv_sec = 0;
        #endif // WIN32

        return true;
}


long JTime::microDifference(const JTime& t) const {

        if (!valid)
                return 0;

        long s = seconds() - t.seconds();
        int ms = milliseconds() - t.milliseconds();
        if (abs(s) >= 120) {
                return ((s*1000) + ms)*1000;
        }

        long micro = 0;

        #ifdef WIN32

        //      #if defined(_WIN32_WCE)
        //              return ((s*1000) + ms)*1000;
        //      #else

                        if ( (perfCount.QuadPart == 0) || (t.perfCount.QuadPart == 0) ) {
                        //      ms = milliseconds() - t.milliseconds();
                        //      printf("$$$ PerfCount 0 (%d.%d) $$$\n", (int)s, ms);
                                return ((s*1000) + ms)*1000;
                        }
                        __int64 ticks = (((__int64) perfCount.QuadPart) - ((__int64) t.perfCount.QuadPart));
                        LARGE_INTEGER perfFreq;
                        QueryPerformanceFrequency(&perfFreq);
                        // We want this in microseconds
                        ticks = ticks * 1000000;
                        micro = (long) (ticks / perfFreq.QuadPart);
                        // micro = 10;
        //      #endif
        #else
                if ( (perfCount.tv_sec == 0) || (t.perfCount.tv_sec == 0) ) {
                        return ((s*1000) + ms)*1000;
                }
                long sec = perfCount.tv_sec - t.perfCount.tv_sec;
                micro = (sec*1000000) + (perfCount.tv_usec - t.perfCount.tv_usec);
        //      printf("$$$ PerfCount Good (%d) $$$\n", (int)micro);
        #endif

        return micro;
}

bool JTime::unitTest() {

/*    JTime time;
    time.setTime(2000,12,31,22,30,55,555);

        JString st = time.print();
        if (!st.equals("31.12.2000 22:30:55.555")) {
                addUnitTestLog(JString::format("setTime() failed: 31.12.2000 22:30:55.555 != %s\n", (char*) st));
                return false;
        }
*/
/*      JTime tt;
        for (int n=0; n<100; n++) {
                printf("%2d   %s   %lld   %ld\n", n, (char*) tt.print(), tt.getMicroAge(), tt.getAge());
                tt -= 10000000000;
                Object::wait(10);
        }
*/
        JTime t1 = JTime();
        JTime t2;
        wait(100);
        t2 = JTime();

//      printf("P1: %d    P2: %d\n", (int)t1.perfCount., (int)t2.perfCount);

        long dif = t2 - t1;
        if (dif <= 0) {
                printf("Normal diff failed: %d\n", (int)dif);
                return false;
        }
//      printf("Normal diff success: %d\n", (int)dif);

        dif = t2.microDifference(t1);
        if (dif <= 0) {
                printf("Micro diff failed: %d\n", (int)dif);
                return false;
        }
//      printf("Micro diff success: %d\n", (int)dif);


        t2 = t1 + 10;
        if (t2-t1 != 10)
                return false;

        t2 = t1 - 10;
        if (t2-t1 != -10)
                return false;

        t2 = t1 + 100010;
        if (t2-t1 != 100010)
                return false;

        t2 = t1 - 100010;
        if (t2-t1 != -100010)
                return false;

        return true;
}


















#ifdef WIN32

        JTime::JTime(FILETIME filetime) {
                timebuffer = JTime::filetime2timeb(&filetime);
                perfCount.QuadPart = 0;
        }

        #ifdef CYGWIN
                #define FACTOR (0x19db1ded53ea710LL)
        #else
                #define FACTOR (0x19db1ded53ea710)
        #endif
        #define NSPERSEC 10000000
        #define NSPERMS 10000

        long JTime::filetime2time_t(FILETIME * ptr) {
                struct timeb t = filetime2timeb(ptr);
                return (long)t.time;
        }

        FILETIME JTime::time_t2filetime(time_t t)
        {
                struct timeb tb;
                tb.time = t;
                tb.millitm = 0;
                return timeb2filetime(tb);
        }

        struct timeb JTime::filetime2timeb(FILETIME * ptr)
        {
                /* A file time is the number of 100ns since jan 1 1601
                stuffed into two long words.
                A time_t is the number of seconds since jan 1 1970.  */

                long rem;
                __int64 x = ((__int64) ptr->dwHighDateTime << 32) + ((unsigned) ptr->dwLowDateTime);
                x -= FACTOR;                    /* number of 100ns between 1601 and 1970 */
                rem = (long) (x % ((__int64) NSPERMS));
                rem += (NSPERMS / 2);
                x /= (__int64) NSPERMS; /* number of 100ns in a millisecond */
                x += (__int64) (rem / NSPERMS);

                // Now x contains ms, convert to timeb
                struct timeb t;
                t.dstflag = 0;
                t.timezone = 0;
                t.millitm = (unsigned short) x % 1000;
                t.time = (int) (x / 1000);

                return t;
        }

        FILETIME JTime::timeb2filetime(struct timeb tb)
        {
                /* A file time is the number of 100ns since jan 1 1601
                 stuffed into two long words.
                 A time_t is the number of seconds since jan 1 1970.  */

                // First get number of 100ns since 1970
                __int64 val = (__int64)((__int64)tb.time*1000 + (__int64)tb.millitm)*10000;
                // Now get number of 100ns since 1601
                val += FACTOR;
                
                FILETIME ptr;
                ptr.dwHighDateTime = (unsigned long) (val >> 32);
                ptr.dwLowDateTime = (unsigned long) val;

                return ptr;
        }

#endif

















StopWatch::StopWatch() {
        reset();
}

StopWatch::~StopWatch() {
}

Object* StopWatch::clone() const {
        StopWatch* sw = new StopWatch();
        sw->timeStarted = timeStarted;
        sw->timeStopped = timeStopped;
        sw->marks.copyAll(marks);
        return sw;
}

bool StopWatch::reset() {
        timeStarted.setInvalid();
        timeStopped.setInvalid();
        return marks.removeAll();
}

bool StopWatch::start() {
        timeStarted = JTime();
        return true;
}

bool StopWatch::stop() {
        if (!timeStarted.isValid())
                return false;
        timeStopped = JTime();
        return true;
}

bool StopWatch::setMark() {
        return marks.put(this->createUniqueID("NoLabel_"), new JTime());
}

bool StopWatch::setMark(const JString& label) {

        JString newlabel = label;

        if (marks.contains(label)) {
                int count = 1;
                JString origlabel = label;
                while (marks.contains(newlabel))
                        newlabel = JString::format("%s(%d)", (char*) origlabel, count);
        }

        return marks.put(newlabel, new JTime());
}

JString StopWatch::print() {
        int n, l;
        int maxwidth = 0;
        for (n=0; n<marks.getCount(); n++) {
                if ( (l = marks.getKey(n).length()) > maxwidth )
                        maxwidth = l;
        }
        JString formatString = JString::format("   %%%ds:  %%10.3f\n", maxwidth);
        JString markString;

        StatSample statSample = getStatSample();

        JString key;
        if (marks.getCount() > 0) {
                for (n=0; n<statSample.getCount(); n++) {
                        key = marks.getKey(n);
                        if (key.startsWith("NoLabel_"))
                                key = "";
                        else if (n == statSample.getCount()-1)
                                key = "End";
                        markString += JString::format(formatString, (char*) key, statSample.values.get(n).toDouble()/1000.0);
                }
                markString += JString::format(formatString, "Total", ((double)getTotalTime())/1000.0);
                return JString::format("Started: %s - Stopped: %s - Mean: %.3f - STD: %.3f \n%s",
                        (char*) timeStarted.printTimeMS(), (char*) timeStopped.printTimeMS(),
                        statSample.getMean()/1000.0, statSample.getStandardDeviation()/1000.0, (char*) markString);
        }
        else {
                return JString::format("Started: %s - Stopped: %s - Total: %.3f - Mean: %.3f - STD: %.3f",
                        (char*) timeStarted.printTimeMS(), (char*) timeStopped.printTimeMS(), ((double)getTotalTime())/1000.0,
                        statSample.getMean()/1000.0, statSample.getStandardDeviation()/1000.0);
        }
}

JString StopWatch::printNoLabels() {
        int n, l;
        int maxwidth = 0;
        for (n=0; n<marks.getCount(); n++) {
                if ( (l = marks.getKey(n).length()) > maxwidth )
                        maxwidth = l;
        }
        JString formatString = JString::format("   %%10.3f\n", maxwidth);
        JString markString;

        StatSample statSample = getStatSample();

        for (n=0; n<statSample.getCount(); n++) {
                markString += JString::format(formatString, statSample.values.get(n).toDouble()/1000.0);
        }

        return JString::format("Started: %s - Stopped: %s - Mean: %.3f - STD: %.3f \n%s",
                (char*) timeStarted.printTimeMS(), (char*) timeStopped.printTimeMS(),
                statSample.getMean()/1000.0, statSample.getStandardDeviation()/1000.0, (char*) markString);
}

JString StopWatch::printDetails() {

        int n, l;
        int maxwidth = 0;
        for (n=0; n<marks.getCount(); n++) {
                if ( (l = marks.getKey(n).length()) > maxwidth )
                        maxwidth = l;
        }
        JString formatString = JString::format("   %%%ds:  %%10.3f\n", maxwidth);
        JString markString;

        StatSample statSample = getStatSample();

        JString key;
        if (marks.getCount() > 0) {
                for (n=0; n<statSample.getCount(); n++) {
                        key = marks.getKey(n);
                        if (key.startsWith("NoLabel_"))
                                key = "";
                        else if (n == statSample.getCount()-1)
                                key = "End";
                        markString += JString::format(formatString, (char*) key, statSample.values.get(n).toDouble()/1000.0);
                }
                markString += JString::format(formatString, "Total", ((double)getTotalTime())/1000.0);
                return JString::format("Started: %s - Stopped: %s - Mean: %.3f - STD: %.3f \n%s\nTimes:\n   %s\n",
                        (char*) timeStarted.printTimeMS(), (char*) timeStopped.printTimeMS(),
                        statSample.getMean()/1000.0, statSample.getStandardDeviation()/1000.0, (char*) markString,
                        (char*) marks.printListLine("\n   "));
        }
        else {
                return JString::format("Started: %s - Stopped: %s - Total: %.3f - Mean: %.3f - STD: %.3f",
                        (char*) timeStarted.printTimeMS(), (char*) timeStopped.printTimeMS(), ((double)getTotalTime())/1000.0,
                        statSample.getMean()/1000.0, statSample.getStandardDeviation()/1000.0);
        }
}

long StopWatch::getTotalTime() {
        if (!timeStarted.isValid())
                return -1;
        if (!timeStopped.isValid())
                return -1;
        return timeStopped.microDifference(timeStarted);
}

long StopWatch::getMarkCount() {
        return marks.getCount();
}

long StopWatch::getAverageDistance() {
        StatSample statSample = getStatSample();
        return (long) statSample.getMean();
}

long StopWatch::getStandardDeviationDistance() {
        StatSample statSample = getStatSample();
        return (long) statSample.getStandardDeviation();
}

StatSample StopWatch::getStatSample() {
        StatSample statSample;
        if (!timeStarted.isValid())
                return statSample;
        if (!timeStopped.isValid())
                return statSample;
        
        if (marks.getCount() == 0) {
                statSample.add(timeStopped.microDifference(timeStarted));
                return statSample;
        }

        statSample.add(((JTime*)marks.getFirst())->microDifference(timeStarted));
        for (int n=1; n<marks.getCount(); n++) {
                statSample.add(((JTime*)marks.get(n))->microDifference(*(JTime*)marks.get(n-1)));
        }
        statSample.add(timeStopped.microDifference(*(JTime*)marks.getLast()));
        return statSample;
}








} // namespace cmlabs

---