OU
/
CWE-ou-minkata
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git
2
1
Fork 0
Code Releases Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1848 Commits
81 Branches
23 Tags
172 MiB
 
 
 
 
 
Tree: f98222ee59
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'f98222ee59'
${ noResults }
CWE-ou-minkata/Sources/Plasma/PubUtilLib/plUnifiedTime/plUnifiedTime.cpp

1040 lines
28 KiB
Raw Blame History

/*==LICENSE==*
CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011 Cyan Worlds, Inc.
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, either version 3 of the License, or
(at your option) any later version.
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 <http://www.gnu.org/licenses/>.
Additional permissions under GNU GPL version 3 section 7
If you modify this Program, or any covered work, by linking or
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK,
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK
(or a modified version of those libraries),
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA,
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the
licensors of this Program grant you additional
permission to convey the resulting work. Corresponding Source for a
non-source form of such a combination shall include the source code for
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered
work.
You can contact Cyan Worlds, Inc. by email legal@cyan.com
or by snail mail at:
Cyan Worlds, Inc.
14617 N Newport Hwy
Mead, WA 99021
*==LICENSE==*/
#include <cfloat>
#include <cmath>
#include <ctime>
#include "plUnifiedTime.h"
#include "hsWindows.h"
#include "hsStream.h"
#include "plString.h"
#if HS_BUILD_FOR_UNIX
#include <sys/time.h>
#include <unistd.h>
#endif
#if HS_BUILD_FOR_WIN32
#include <sys/timeb.h> // for timeb
#endif
#if HS_BUILD_FOR_WIN32
//
// Converts Windows Time to Unified Time
//
#define MAGICWINDOWSOFFSET ((__int64)11644473600) // magic number, taken from Python Source
//
bool plUnifiedTime::SetFromWinFileTime(const FILETIME ft)
{
// FILETIME resolution seems to be 0.01 sec
__int64 ff,ffsecs;
ff = *(__int64*)(&ft);
ffsecs = ff/(__int64)10000000;
if (ffsecs >= MAGICWINDOWSOFFSET) // make sure we won't end up negatice
{
fSecs = (time_t)(ffsecs-MAGICWINDOWSOFFSET);
fMicros = (uint32_t)(ff % 10000000)/10;
return true;
}
else
// before the UNIX Epoch
return false;
}
//
// Sets the unified time to the current UTC time
//
bool plUnifiedTime::SetToUTC()
{
FILETIME ft;
GetSystemTimeAsFileTime(&ft); /* 100 ns blocks since 01-Jan-1641 */
return SetFromWinFileTime(ft);
}
#elif HS_BUILD_FOR_UNIX
//
// Sets the unified time to the current UTC time
//
bool plUnifiedTime::SetToUTC()
{
struct timeval tv;
// get the secs and micros from Jan 1, 1970
int ret = gettimeofday(&tv, nil);
if (ret == 0)
{
fSecs = tv.tv_sec;
fMicros = tv.tv_usec;
return true;
}
else
{
return false;
}
}
#else
#error "Unified Time Not Implemented on this platform!"
#endif
struct tm * plUnifiedTime::IGetTime(const time_t * timer) const
{
struct tm * tm = nil;
switch (fMode)
{
case kGmt:
tm = gmtime(timer);
break;
default:
tm = localtime(timer);
}
if ( tm )
tm->tm_isdst = -1;
return tm;
}
plUnifiedTime::plUnifiedTime(plUnifiedTime_CtorNow,int mode)
{
SetMode((Mode)mode);
ToCurrentTime();
}
plUnifiedTime::plUnifiedTime(const timeval & tv)
: fMode(kGmt)
{
*this = tv;
}
plUnifiedTime::plUnifiedTime(int mode, const struct tm & src)
: fMode((Mode)mode)
{
*this = src;
}
plUnifiedTime::plUnifiedTime(time_t t)
: fMode(kGmt)
{
*this = t;
}
plUnifiedTime::plUnifiedTime(unsigned long t)
: fMode(kGmt)
{
*this = t;
}
plUnifiedTime::plUnifiedTime(int year, int month, int day, int hour, int min, int sec, unsigned long usec, int dst)
: fMode(kGmt)
{
SetTime(year,month,day,hour,min,sec,usec,dst);
}
plUnifiedTime::plUnifiedTime(int mode, const char * buf, const char * fmt)
: fMode((Mode)mode)
{
FromString(buf,fmt);
}
plUnifiedTime::plUnifiedTime(const plUnifiedTime & src)
: fMode(src.fMode)
{
*this = src;
}
plUnifiedTime::plUnifiedTime(const plUnifiedTime * src)
: fMode(src->fMode)
{
*this = *src;
}
plUnifiedTime plUnifiedTime::GetCurrent(Mode mode)
{
plUnifiedTime t;
t.SetMode(mode);
t.ToCurrentTime();
return t;
}
const plUnifiedTime & plUnifiedTime::operator=(const plUnifiedTime & src)
{
fSecs = src.fSecs;
fMicros = src.fMicros;
fMode = src.fMode;
return *this;
}
const plUnifiedTime & plUnifiedTime::operator=(const plUnifiedTime * src)
{
return operator=(*src);
}
const plUnifiedTime & plUnifiedTime::operator=(time_t src)
{
fSecs = src;
fMicros = 0;
return *this;
}
const plUnifiedTime & plUnifiedTime::operator=(unsigned long src)
{
fSecs = (time_t)src;
fMicros = 0;
return *this;
}
const plUnifiedTime & plUnifiedTime::operator=(const struct timeval & src)
{
fSecs = src.tv_sec;
fMicros = src.tv_usec;
return *this;
}
const plUnifiedTime & plUnifiedTime::operator=(const struct tm & src)
{
struct tm atm = src;
fSecs = mktime(&atm);
return *this;
}
void plUnifiedTime::SetSecsDouble(double secs)
{
hsAssert(secs>=0, "plUnifiedTime::SetSecsDouble negative time");
double x,y;
x = modf(secs,&y);
fSecs = (time_t)y;
fMicros = (uint32_t)(x*1000000);
}
void plUnifiedTime::ToCurrentTime()
{
SetToUTC();
}
bool plUnifiedTime::SetGMTime(short year, short month, short day, short hour, short minute, short second, unsigned long usec)
{
if( !SetTime( year, month, day, hour, minute, second, usec, 0 ) )
return false;
fSecs -= IGetLocalTimeZoneOffset();
fMode = kGmt;
return true;
}
bool plUnifiedTime::SetTime(short year, short month, short day, short hour, short minute, short second, unsigned long usec, int dst)
{
struct tm atm;
atm.tm_sec = second;
atm.tm_min = minute;
atm.tm_hour = hour;
atm.tm_mday = day;
atm.tm_mon = month - 1;
atm.tm_year = year - 1900;
atm.tm_isdst = dst;
fSecs = mktime(&atm);
if (fSecs == -1)
return false;
if (fMicros >= 1000000)
return false;
fMicros = usec;
fMode = kLocal;
return true;
}
bool plUnifiedTime::GetTime(short &year, short &month, short &day, short &hour, short &minute, short &second) const
{
struct tm* time = IGetTime(&fSecs);
if (!time)
return false;
year = time->tm_year+1900;
month = time->tm_mon+1;
day = time->tm_mday;
hour = time->tm_hour;
minute = time->tm_min;
second = time->tm_sec;
return true;
}
const char* plUnifiedTime::Print() const
{
static std::string s;
// short year, month, day, hour, minute, second;
// GetTime(year, month, day, hour, minute, second);
//
// s = plFormat("yr {} mo {} day {} hour {} min {} sec {}",
// year, month, day, hour, minute, second);
s = Format("%c");
return s.c_str();
}
const char* plUnifiedTime::PrintWMillis() const
{
static plString s;
s = plFormat("{},s:{},ms:{}",
Print(), (unsigned long)GetSecs(), GetMillis() );
return s.c_str();
}
struct tm * plUnifiedTime::GetTm(struct tm * ptm) const
{
if (ptm != nil)
{
*ptm = *IGetTime(&fSecs);
return ptm;
}
else
return IGetTime(&fSecs);
}
int plUnifiedTime::GetYear() const
{
return GetTm() ? GetTm()->tm_year + 1900 : 0;
}
int plUnifiedTime::GetMonth() const
{
return GetTm() ? GetTm()->tm_mon + 1 : 0;
}
int plUnifiedTime::GetDay() const
{
return GetTm() ? GetTm()->tm_mday : 0;
}
int plUnifiedTime::GetHour() const
{
return GetTm() ? GetTm()->tm_hour : 0;
}
int plUnifiedTime::GetMinute() const
{
return GetTm() ? GetTm()->tm_min : 0;
}
int plUnifiedTime::GetSecond() const
{
return GetTm() ? GetTm()->tm_sec : 0;
}
int plUnifiedTime::GetDayOfWeek() const
{
return GetTm() ? GetTm()->tm_wday : 0;
}
int plUnifiedTime::GetMillis() const
{
return fMicros/1000;
}
#pragma optimize( "g", off ) // disable global optimizations
double plUnifiedTime::GetSecsDouble() const
{
double ret = GetSecs() + GetMicros() / 1000000.0;
return ret;
}
#pragma optimize( "", on ) // restore optimizations to their defaults
void plUnifiedTime::Read(hsStream* s)
{
s->LogSubStreamStart("UnifiedTime");
uint32_t secs;
s->LogReadLE(&secs,"Seconds");
fSecs = (time_t)secs;
s->LogReadLE(&fMicros,"MicroSeconds");
s->LogSubStreamEnd();
// preserve fMode
}
void plUnifiedTime::Write(hsStream* s) const
{
s->WriteLE((uint32_t)fSecs);
s->WriteLE(fMicros);
// preserve fMode
}
const plUnifiedTime & plUnifiedTime::operator-=(const plUnifiedTime & rhs)
{
// carry if needed
if ((*this).fMicros < rhs.fMicros)
{
(*this).fSecs--;
(*this).fMicros += 1000000;
}
(*this).fMicros -= rhs.fMicros;
(*this).fSecs -= rhs.fSecs;
return *this;
}
const plUnifiedTime & plUnifiedTime::operator+=(const plUnifiedTime & rhs)
{
(*this).fMicros += rhs.fMicros;
// carry if needed
if ((*this).fMicros >= 1000000)
{
(*this).fSecs++;
(*this).fMicros -= 1000000;
}
(*this).fSecs += rhs.fSecs;
return *this;
}
bool plUnifiedTime::operator==(const plUnifiedTime & rhs) const
{
return ((fSecs == rhs.fSecs) && (fMicros == rhs.fMicros));
}
bool plUnifiedTime::operator!=(const plUnifiedTime & rhs) const
{
return ((fSecs != rhs.fSecs) || (fMicros != rhs.fMicros));
}
bool plUnifiedTime::operator <(const plUnifiedTime & rhs) const
{
return ((fSecs < rhs.fSecs) || ((fSecs == rhs.fSecs) && (fMicros < rhs.fMicros)));
}
bool plUnifiedTime::operator >(const plUnifiedTime & rhs) const
{
return ((fSecs > rhs.fSecs) || ((fSecs == rhs.fSecs) && (fMicros > rhs.fMicros)));
}
bool plUnifiedTime::operator<=(const plUnifiedTime & rhs) const
{
return (*this<rhs) || (*this==rhs);
}
bool plUnifiedTime::operator>=(const plUnifiedTime & rhs) const
{
return (*this>rhs) || (*this==rhs);
}
plUnifiedTime::operator timeval() const
{
#if HS_BUILD_FOR_WIN32
// tv_secs should be a time_t, but on Windows it is a long
struct timeval t = {(long)fSecs, (long)fMicros};
#else
struct timeval t = {fSecs, (suseconds_t)fMicros};
#endif
return t;
}
plUnifiedTime::operator struct tm() const
{
return *GetTm();
}
std::string plUnifiedTime::Format(const char * fmt) const
{
char buf[128];
struct tm * t = IGetTime(&fSecs);
if (t == nil ||
!strftime(buf, sizeof(buf), fmt, t))
buf[0] = '\0';
return std::string(buf);
}
plUnifiedTime operator -(const plUnifiedTime & left, const plUnifiedTime & right)
{
plUnifiedTime ans = left;
ans -= right;
return ans;
}
plUnifiedTime operator +(const plUnifiedTime & left, const plUnifiedTime & right)
{
plUnifiedTime ans = left;
ans += right;
return ans;
}
bool operator <(const plUnifiedTime & time, int secs)
{
return (time.GetSecs()<secs);
}
////////////////////////////////////////////////////////////////////
// FromString
#if !defined(HS_BUILD_FOR_UNIX)
namespace pvt_strptime
{
//
// based on glibc's strptime
//
#define __isleap(year) \
((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
#define match_char(ch1, ch2) if (ch1 != ch2) return NULL
#define match_string(cs1, s2) \
(strnicmp((cs1), (s2), strlen (cs1)) ? 0 : ((s2) += strlen (cs1), 1))
#define get_number(from, to, n) \
do { \
int __n = n; \
val = 0; \
while (*rp == ' ') \
++rp; \
if (*rp < '0' || *rp > '9') \
return NULL; \
do { \
val *= 10; \
val += *rp++ - '0'; \
} while (--__n > 0 && val * 10 <= to && *rp >= '0' && *rp <= '9'); \
if (val < from || val > to) \
return NULL; \
} while (0)
#define recursive(new_fmt) \
(*(new_fmt) != '\0' \
&& (rp = strptime_internal (rp, (new_fmt), tm, mode)) != NULL)
static char const weekday_name[][10] =
{
"Sunday", "Monday", "Tuesday", "Wednesday",
"Thursday", "Friday", "Saturday"
};
static char const ab_weekday_name[][4] =
{
"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
};
static char const month_name[][10] =
{
"January", "February", "March", "April", "May", "June",
"July", "August", "September", "October", "November", "December"
};
static char const ab_month_name[][4] =
{
"Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
};
#define HERE_D_T_FMT "%m/%d/%y %H:%M:%S"
#define HERE_D_FMT "%m/%d/%y"
#define HERE_AM_STR "AM"
#define HERE_PM_STR "PM"
#define HERE_T_FMT_AMPM "%I:%M:%S %p"
#define HERE_T_FMT "%H:%M:%S"
const unsigned short int __mon_yday[2][13] =
{
/* Normal years. */
{ 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 },
/* Leap years. */
{ 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }
};
static struct tm *
time_r(
const time_t *t,
struct tm *tp,
int mode)
{
struct tm *l = 0;
switch (mode)
{
case plUnifiedTime::kGmt:
l = gmtime(t);
break;
default:
l = localtime(t);
}
if (! l)
return 0;
*tp = *l;
tp->tm_isdst = -1;
return tp;
}
/* Compute the day of the week. */
static void
day_of_the_week (struct tm *tm)
{
/* We know that January 1st 1970 was a Thursday (= 4). Compute the
the difference between this data in the one on TM and so determine
the weekday. */
int corr_year = 1900 + tm->tm_year - (tm->tm_mon < 2);
int wday = (-473
+ (365 * (tm->tm_year - 70))
+ (corr_year / 4)
- ((corr_year / 4) / 25) + ((corr_year / 4) % 25 < 0)
+ (((corr_year / 4) / 25) / 4)
+ __mon_yday[0][tm->tm_mon]
+ tm->tm_mday - 1);
tm->tm_wday = ((wday % 7) + 7) % 7;
}
/* Compute the day of the year. */
static void
day_of_the_year (struct tm *tm)
{
tm->tm_yday = (__mon_yday[__isleap (1900 + tm->tm_year)][tm->tm_mon]
+ (tm->tm_mday - 1));
}
static char * strptime_internal(
const char * rp,
const char * fmt,
struct tm * tm,
int mode)
{
const char *rp_backup;
int cnt;
size_t val;
int have_I, is_pm;
int century, want_century;
int have_wday, want_xday;
int have_yday;
int have_mon, have_mday;
have_I = is_pm = 0;
century = -1;
want_century = 0;
have_wday = want_xday = have_yday = have_mon = have_mday = 0;
while (*fmt != '\0')
{
/* A white space in the format string matches 0 more or white
space in the input string. */
if (isspace (*fmt))
{
while (isspace (*rp))
++rp;
++fmt;
continue;
}
/* Any character but `%' must be matched by the same character
in the iput string. */
if (*fmt != '%')
{
match_char (*fmt++, *rp++);
continue;
}
++fmt;
/* We need this for handling the `E' modifier. */
start_over:
/* Make back up of current processing pointer. */
rp_backup = rp;
switch (*fmt++)
{
case '%':
/* Match the `%' character itself. */
match_char ('%', *rp++);
break;
case 'a':
case 'A':
/* Match day of week. */
for (cnt = 0; cnt < 7; ++cnt)
{
if (match_string (weekday_name[cnt], rp)
|| match_string (ab_weekday_name[cnt], rp))
{
break;
}
}
if (cnt == 7)
/* Does not match a weekday name. */
return NULL;
tm->tm_wday = cnt;
have_wday = 1;
break;
case 'b':
case 'B':
case 'h':
/* Match month name. */
for (cnt = 0; cnt < 12; ++cnt)
{
if (match_string (month_name[cnt], rp)
|| match_string (ab_month_name[cnt], rp))
{
break;
}
}
if (cnt == 12)
/* Does not match a month name. */
return NULL;
tm->tm_mon = cnt;
want_xday = 1;
break;
case 'c':
/* Match locale's date and time format. */
if (!recursive (HERE_D_T_FMT))
return NULL;
want_xday = 1;
break;
case 'C':
/* Match century number. */
get_number (0, 99, 2);
century = val;
want_xday = 1;
break;
case 'd':
case 'e':
/* Match day of month. */
get_number (1, 31, 2);
tm->tm_mday = val;
have_mday = 1;
want_xday = 1;
break;
case 'F':
if (!recursive ("%Y-%m-%d"))
return NULL;
want_xday = 1;
break;
case 'x':
/* Fall through. */
case 'D':
/* Match standard day format. */
if (!recursive (HERE_D_FMT))
return NULL;
want_xday = 1;
break;
case 'k':
case 'H':
/* Match hour in 24-hour clock. */
get_number (0, 23, 2);
tm->tm_hour = val;
have_I = 0;
break;
case 'I':
/* Match hour in 12-hour clock. */
get_number (1, 12, 2);
tm->tm_hour = val % 12;
have_I = 1;
break;
case 'j':
/* Match day number of year. */
get_number (1, 366, 3);
tm->tm_yday = val - 1;
have_yday = 1;
break;
case 'm':
/* Match number of month. */
get_number (1, 12, 2);
tm->tm_mon = val - 1;
have_mon = 1;
want_xday = 1;
break;
case 'M':
/* Match minute. */
get_number (0, 59, 2);
tm->tm_min = val;
break;
case 'n':
case 't':
/* Match any white space. */
while (isspace (*rp))
++rp;
break;
case 'p':
/* Match locale's equivalent of AM/PM. */
if (!match_string (HERE_AM_STR, rp))
if (match_string (HERE_PM_STR, rp))
is_pm = 1;
else
return NULL;
break;
case 'r':
if (!recursive (HERE_T_FMT_AMPM))
return NULL;
break;
case 'R':
if (!recursive ("%H:%M"))
return NULL;
break;
case 's':
{
/* The number of seconds may be very high so we cannot use
the `get_number' macro. Instead read the number
character for character and construct the result while
doing this. */
time_t secs = 0;
if (*rp < '0' || *rp > '9')
/* We need at least one digit. */
return NULL;
do
{
secs *= 10;
secs += *rp++ - '0';
}
while (*rp >= '0' && *rp <= '9');
if (time_r (&secs, tm, mode) == NULL)
/* Error in function. */
return NULL;
}
break;
case 'S':
get_number (0, 61, 2);
tm->tm_sec = val;
break;
case 'X':
/* Fall through. */
case 'T':
if (!recursive (HERE_T_FMT))
return NULL;
break;
case 'u':
get_number (1, 7, 1);
tm->tm_wday = val % 7;
have_wday = 1;
break;
case 'g':
get_number (0, 99, 2);
/* XXX This cannot determine any field in TM. */
break;
case 'G':
if (*rp < '0' || *rp > '9')
return NULL;
/* XXX Ignore the number since we would need some more
information to compute a real date. */
do
++rp;
while (*rp >= '0' && *rp <= '9');
break;
case 'U':
case 'V':
case 'W':
get_number (0, 53, 2);
/* XXX This cannot determine any field in TM without some
information. */
break;
case 'w':
/* Match number of weekday. */
get_number (0, 6, 1);
tm->tm_wday = val;
have_wday = 1;
break;
case 'y':
/* Match year within century. */
get_number (0, 99, 2);
/* The "Year 2000: The Millennium Rollover" paper suggests that
values in the range 69-99 refer to the twentieth century. */
tm->tm_year = val >= 69 ? val : val + 100;
/* Indicate that we want to use the century, if specified. */
want_century = 1;
want_xday = 1;
break;
case 'Y':
/* Match year including century number. */
get_number (0, 9999, 4);
tm->tm_year = val - 1900;
want_century = 0;
want_xday = 1;
break;
goto start_over;
case 'O':
switch (*fmt++)
{
case 'd':
case 'e':
/* Match day of month using alternate numeric symbols. */
get_number (1, 31, 2);
tm->tm_mday = val;
have_mday = 1;
want_xday = 1;
break;
case 'H':
/* Match hour in 24-hour clock using alternate numeric
symbols. */
get_number (0, 23, 2);
tm->tm_hour = val;
have_I = 0;
break;
case 'I':
/* Match hour in 12-hour clock using alternate numeric
symbols. */
get_number (1, 12, 2);
tm->tm_hour = val - 1;
have_I = 1;
break;
case 'm':
/* Match month using alternate numeric symbols. */
get_number (1, 12, 2);
tm->tm_mon = val - 1;
have_mon = 1;
want_xday = 1;
break;
case 'M':
/* Match minutes using alternate numeric symbols. */
get_number (0, 59, 2);
tm->tm_min = val;
break;
case 'S':
/* Match seconds using alternate numeric symbols. */
get_number (0, 61, 2);
tm->tm_sec = val;
break;
case 'U':
case 'V':
case 'W':
get_number (0, 53, 2);
/* XXX This cannot determine any field in TM without
further information. */
break;
case 'w':
/* Match number of weekday using alternate numeric symbols. */
get_number (0, 6, 1);
tm->tm_wday = val;
have_wday = 1;
break;
case 'y':
/* Match year within century using alternate numeric symbols. */
get_number (0, 99, 2);
tm->tm_year = val >= 69 ? val : val + 100;
want_xday = 1;
break;
default:
return NULL;
}
break;
default:
return NULL;
}
}
if (have_I && is_pm)
tm->tm_hour += 12;
if (century != -1)
{
if (want_century)
tm->tm_year = tm->tm_year % 100 + (century - 19) * 100;
else
/* Only the century, but not the year. Strange, but so be it. */
tm->tm_year = (century - 19) * 100;
}
if (want_xday && !have_wday)
{
if ( !(have_mon && have_mday) && have_yday)
{
/* We don't have tm_mon and/or tm_mday, compute them. */
int t_mon = 0;
while (__mon_yday[__isleap(1900 + tm->tm_year)][t_mon] <= tm->tm_yday)
t_mon++;
if (!have_mon)
tm->tm_mon = t_mon - 1;
if (!have_mday)
tm->tm_mday =
(tm->tm_yday
- __mon_yday[__isleap(1900 + tm->tm_year)][t_mon - 1] + 1);
}
day_of_the_week (tm);
}
if (want_xday && !have_yday)
day_of_the_year (tm);
return (char *) rp;
}
} // namespace pvt_strptime
#endif
bool plUnifiedTime::FromString(const char * buf, const char * fmt)
{
struct tm tm;
tm.tm_isdst = -1;
#if !defined(HS_BUILD_FOR_UNIX)
bool result = (pvt_strptime::strptime_internal(buf, fmt, &tm, fMode)!=nil);
#else
bool result = (strptime(buf, fmt, &tm)!=nil);
#endif
if (result)
*this = tm;
return result;
}
/// Local time zone offset stuff
int32_t plUnifiedTime::fLocalTimeZoneOffset = -1;
int32_t plUnifiedTime::IGetLocalTimeZoneOffset( void )
{
static bool inited = false;
if( !inited )
{
inited = true;
// Calculate the difference between local time and GMT for this system currently
// Taken from devx.com from an article written by Danny Kalev
// http://gethelp.devx.com/techtips/cpp_pro/10min/2001/10min1200-3.asp
time_t currLocalTime = time( 0 ); // current local time
struct tm local = *gmtime( &currLocalTime ); // convert curr to GMT, store as tm
time_t utc = mktime( &local ); // convert GMT tm to GMT time_t
double diffInSecs = difftime( utc, currLocalTime );
fLocalTimeZoneOffset = (int32_t)diffInSecs;
}
return fLocalTimeZoneOffset;
}
//
// static helper, return difference timeA-timeB, may be negative
//
double plUnifiedTime::GetTimeDifference(const plUnifiedTime& timeA, const plUnifiedTime& timeB)
{
bool neg = (timeB > timeA);
plUnifiedTime timeDiff = neg ? (timeB - timeA) : (timeA - timeB); // always positive
double t = (float)(neg ? timeDiff.GetSecsDouble() * -1. : timeDiff.GetSecsDouble());
return t;
}