/**
* @see clock.h
* @private
* Mock a clock on the PC
* @param clockParam the clock
*/
ClockData* _readPcClock(Clock* clockParam) {
time_t rawtime;
struct tm timeinfo;
time(&rawtime);
localtime_s(&timeinfo, &rawtime);
ClockData* data = &(clockParam->clockData);
data->year = timeinfo.tm_year - 100; // we store the date after 2000 (100 = 2000 - 1900)
data->month = timeinfo.tm_mon;
data->day = timeinfo.tm_mday;
data->dayofweek = timeinfo.tm_wday;
data->hour = timeinfo.tm_hour;
data->minute = timeinfo.tm_min;
data->second = timeinfo.tm_sec;
return &(clockParam->clockData);
}
////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////// PRIVATE FUNCTIONS ////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////
void getLocalTime(std::wstring ×tamp)
{
time_t rawtime;
struct tm timeinfo;
wchar_t buffer [20];
time ( &rawtime );
#ifdef WIN32
localtime_s( &timeinfo, &rawtime );
#else
timeinfo = *(localtime(&rawtime));
#endif
wcsftime (buffer,20,L"%Y-%m-%d %H:%M:%S",&timeinfo);
timestamp.assign(buffer);
}
void getLocalTime(const time_t* localTime, struct tm* localTM)
{
#if PLATFORM(QT)
#if USE(MULTIPLE_THREADS)
#error Mulitple threads are currently not supported in the Qt/mingw build
#endif
*localTM = *localtime(localTime);
#elif PLATFORM(WIN_OS)
#if COMPILER(MSVC7)
*localTM = *localtime(localTime);
#else
localtime_s(localTM, localTime);
#endif
#else
localtime_r(localTime, localTM);
#endif
}
void SessionServer::TeardownFileLogger()
{
time_t curTime = time(NULL);
tm curTM;
localtime_s(&curTM, &curTime);
m_logger->ClearWriter();
std::string curTimeString = GetCurrentDateTimeString(curTM);
LogInfo(" ** Logging Session Ended at %s", curTimeString.c_str());
if (m_logWriter)
{
delete m_logWriter;
m_logWriter = NULL;
}
}
void SimpleDate::now()
{
std::chrono::system_clock::time_point p = std::chrono::system_clock::now();
time_t t = std::chrono::system_clock::to_time_t(p);
#ifdef _WIN32
tm timeinfo;
localtime_s(&timeinfo, &t);
year = 1900 + timeinfo.tm_year;
month = 1 + timeinfo.tm_mon;
day = timeinfo.tm_mday;
#else
tm *timeinfo = localtime(&t);
year = std::to_string(1900 + timeinfo->tm_year);
month = std::to_string(1 + timeinfo->tm_mon);
day = std::to_string(timeinfo->tm_mday);
#endif
}
void GetDefaultFiles(const char *logBaseName, string &capture_filename, string &logging_filename,
string &target)
{
wchar_t temp_filename[MAX_PATH];
GetTempPathW(MAX_PATH, temp_filename);
wchar_t curFile[512];
GetModuleFileNameW(NULL, curFile, 512);
wchar_t fn[MAX_PATH];
wcscpy_s(fn, MAX_PATH, curFile);
wchar_t *mod = wcsrchr(fn, L'.');
if(mod)
*mod = 0;
mod = wcsrchr(fn, L'/');
if(!mod)
mod = fn;
mod = wcsrchr(mod, L'\\');
mod++; // now points to base filename without extension
target = StringFormat::Wide2UTF8(wstring(mod));
time_t t = time(NULL);
tm now;
localtime_s(&now, &t);
wchar_t *filename_start = temp_filename + wcslen(temp_filename);
wsprintf(filename_start, L"%ls_%04d.%02d.%02d_%02d.%02d.rdc", mod, 1900 + now.tm_year,
now.tm_mon + 1, now.tm_mday, now.tm_hour, now.tm_min);
capture_filename = StringFormat::Wide2UTF8(wstring(temp_filename));
*filename_start = 0;
wstring wbase = StringFormat::UTF82Wide(string(logBaseName));
wsprintf(filename_start, L"%ls_%04d.%02d.%02d_%02d.%02d.%02d.log", wbase.c_str(),
1900 + now.tm_year, now.tm_mon + 1, now.tm_mday, now.tm_hour, now.tm_min, now.tm_sec);
logging_filename = StringFormat::Wide2UTF8(wstring(temp_filename));
}
int main(void)
{
const char *day[7] = {
"Sunday" , "Monday", "Tuesday", "Wednesday",
"Thursday", "Friday", "Saturday"
};
const char *month[12] = {
"January", "February", "March", "April",
"May", "June", "July", "August",
"September", "October", "November", "December"
};
const char *suffix[] = { "st", "nd", "rd", "th" };
enum sufindex { st, nd, rd, th } sufsel = th; // Suffix selector
struct tm ourT; // The time structure
time_t tVal = time(NULL); // Calendar time
if(!localtime_s(&tVal, &ourT)) // Populate time structure
{
fprintf_s(stderr, "Failed to populate tm struct.\n");
return -1;
}
switch(ourT.tm_mday)
{
case 1: case 21: case 31:
sufsel= st;
break;
case 2: case 22:
sufsel= nd;
break;
case 3: case 23:
sufsel= rd;
break;
default:
sufsel= th;
break;
}
printf_s("Today is %s the %d%s %s %d. ", day[ourT.tm_wday],
ourT.tm_mday, suffix[sufsel], month[ourT.tm_mon], 1900 + ourT.tm_year);
printf_s("The time is %d : %d : %d.\n",
ourT.tm_hour, ourT.tm_min, ourT.tm_sec );
return 0;
}
int getCurrentDateTimeStringWithSeparator(char *dateString, char dateSeparator, char *timeString, char timeSeparator)
{
static const char *wday[] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
time_t t;
struct tm tmobj;
time(&t);
localtime_s(&tmobj, &t);
if (dateString)
{
if (dateSeparator == '\0')
{
sprintf_s(dateString, TIMESTRING_BUFFER_SIZE, "%04d%02d%02d",
(1900 + tmobj.tm_year),
(1 + tmobj.tm_mon),
tmobj.tm_mday);
}
else {
sprintf_s(dateString, TIMESTRING_BUFFER_SIZE, "%04d%c%02d%c%02d",
(1900 + tmobj.tm_year), dateSeparator,
(1 + tmobj.tm_mon), dateSeparator,
tmobj.tm_mday);
}
}
if (timeString)
{
if (timeSeparator == '\0')
{
sprintf_s(timeString, TIMESTRING_BUFFER_SIZE, "%02d%02d%02d",
tmobj.tm_hour,
tmobj.tm_min,
tmobj.tm_sec);
}
else {
sprintf_s(timeString, TIMESTRING_BUFFER_SIZE, "%02d%c%02d%c%02d",
tmobj.tm_hour, timeSeparator,
tmobj.tm_min, timeSeparator,
tmobj.tm_sec);
}
}
return 1;
}
void RichEditEventLogger::AddToLog(LogLevel level, uint8_t * data, int32_t length, const TCHAR * msg, ...)
{
if (level < m_LogLevel)
{
return;
}
TCHAR * pLogMsg = logMsgBuffer;
time_t rawtime;
struct tm timeinfo;
time(&rawtime);
localtime_s(&timeinfo, &rawtime);
_tcsftime(pLogMsg, MAX_LOG_MSG_LENGTH, _T("%d-%m-%Y %I:%M:%S: "), &timeinfo);
pLogMsg += _tcslen(logMsgBuffer);
va_list argptr;
va_start(argptr, msg);
_vstprintf_s(pLogMsg, MAX_LOG_MSG_LENGTH - _tcslen(logMsgBuffer), msg, argptr);
va_end(argptr);
int32_t logMsgLength = sizeof(logMsgBuffer) / sizeof(TCHAR);
int32_t currentLength = _tcslen(logMsgBuffer);
TCHAR hexStr[16];
for (int32_t i = 0; i < length; i++)
{
if ((i % 16) == 0)
{
_tcscat_s(logMsgBuffer, logMsgLength - currentLength, _T("\n"));
currentLength = _tcslen(logMsgBuffer);
pLogMsg = logMsgBuffer + currentLength;
}
_stprintf_s(hexStr, sizeof(hexStr) / sizeof(TCHAR), _T(" %02X"), data[i]);
_tcscat_s(pLogMsg, logMsgLength - currentLength, hexStr);
currentLength += _tcslen(hexStr);
pLogMsg = logMsgBuffer + currentLength;
}
_tcscat_s(pLogMsg, logMsgLength - currentLength, _T("\n"));
m_Logger->SetSel(-1, -1);
m_Logger->ReplaceSel(logMsgBuffer);
m_Logger->PostMessage(WM_VSCROLL, SB_BOTTOM, NULL);
}
///////////////////////////////////////////////////////////////////////////////
// Debugger - Constructor for debugger class
Debug::Debugger::Debugger(Bool bLogging)
{
m_bLogging = bLogging;
#if defined ( WIN32 ) || defined ( WIN64 )
// Create critical section
m_CsFileWrite = new CRITICAL_SECTION;
InitializeCriticalSection( m_CsFileWrite );
#else
ASSERT( False ); // Only Windows critical sections are supported
#endif
if(m_bLogging)
{
// Copy the s_LogFiles into the instance
memcpy( m_LogFiles, s_LogFiles, sizeof( s_LogFiles ) );
// Create a directory with the current timestamp
// ( Format: Month_Day_HourMinute )
time_t Time;
time( &Time );
tm Date;
localtime_s( &Date, &Time );
char FolderName[ MAX_STRING_LENGTH ];
sprintf_s( FolderName, MAX_STRING_LENGTH, "..\\Logs\\%.2d%.2d%.2d%.2d\\", (Date.tm_mon + 1), Date.tm_mday, Date.tm_hour, Date.tm_min );
int Result = _mkdir( FolderName );
ASSERT( Result == 0 );
if( Result == 0 )
{
// Open all the log files
for( u8 Index = 0; Index < LogType::e_LogTypeCount; Index++ )
{
char FileName[ MAX_STRING_LENGTH ];
strncpy_s( FileName, MAX_STRING_LENGTH, FolderName, MAX_STRING_LENGTH - strlen( m_LogFiles[ Index ].FileName ) );
strcat_s( FileName, MAX_STRING_LENGTH, m_LogFiles[ Index ].FileName );
fopen_s( &m_LogFiles[ Index ].FileHandle, FileName, "w" );
}
}
}
}
void side::makeLine(const _finddata_t &finfo, string &str) const
{
str.clear();
str += char(179);
/*name*/
if (strlen(finfo.name) > 19)
str += string(finfo.name, 19);
else
str += finfo.name + string(19 - strlen(finfo.name), ' ');
str += char(179);
/*size*/
string size;
if (finfo.size >= 1000 * 1000 * 1000) // > 1 gb
size = std::to_string(finfo.size / (1024 * 1024 * 1024)) + ',' + std::to_string(finfo.size % (1024 * 1024 * 1024) / 1024 / 1024 *100 / 1024) + 'G';
else if (finfo.size >= 1000 * 1000) // > 1 mb < 1 gb
size = std::to_string(finfo.size / (1024 * 1024)) + ',' + std::to_string(finfo.size % (1024 * 1024) * 100 / (1024 * 1024)) + 'M';
else if (finfo.size >= 1000) // > 1 kb < 1 mb
size = std::to_string(finfo.size / 1024) + ',' + std::to_string(finfo.size % 1024 * 100 / 1024) + 'K';
else // < 1 kb
size = std::to_string(finfo.size) + 'B';
if (size.size() > 7)
throw string("lenght of str:size > 7 : ") + size;
if (size.size() < 7)
size.insert(0, 7 - size.size(), ' ');
str += size + char(179);
/*date*/
tm t;
localtime_s(&t, &finfo.time_write);
if (t.tm_mday < 10)
str += '0';
str += std::to_string(t.tm_mday) + '.';
if (t.tm_mon < 9)
str += '0';
str += std::to_string(t.tm_mon + 1) + '.' + std::to_string(t.tm_year + 1900);
str += char(179);
}
void _formatTime(std::ostringstream &ss, time_t t)
{
struct tm tm1;
char szTime[24];
#ifdef _WIN32
localtime_s(&tm1, &t);
sprintf_s(szTime, 24, "%04d-%02d-%02d %02d:%02d:%02d",
tm1.tm_year + 1900, tm1.tm_mon + 1, tm1.tm_mday,
tm1.tm_hour, tm1.tm_min, tm1.tm_sec);
#else
localtime_r(&t, &tm1);
snprintf(szTime, 24, "%04d-%02d-%02d %02d:%02d:%02d",
tm1.tm_year + 1900, tm1.tm_mon + 1, tm1.tm_mday,
tm1.tm_hour, tm1.tm_min, tm1.tm_sec);
#endif
ss << szTime;
}
void OnTimer(void* vp)
{
time_t t;
CClock* p = (CClock*)vp;
// 시계를 멈추기전까지 계속 현재시간을 구한다.
while (p->bStop != FALSE)
{
Sleep(1000);
t = time(NULL);
//p->now = *localtime(&t);
localtime_s(&(p->now), &t);
// 매1분마다 콜백함수호출
if (p->now.tm_sec == 0)
{
if (p->m_cb) p->m_cb();
}
}
}
const char* CFileListView::ConvertTime( const time_t* pFileTime )
{
static char szBuffer[1024];
tm localTime;
assert(pFileTime != NULL);
localtime_s(&localTime, pFileTime);
sprintf_s(szBuffer, 1024, "%d/%d/%d %.2d:%.2d",
localTime.tm_year + 1900,
localTime.tm_mon + 1,
localTime.tm_mday,
localTime.tm_hour,
localTime.tm_min);
return szBuffer;
}
STLWriter::STLWriter() : filename_(""),
filedir_(""),
isBinaryMode_(false)
{
time_t t = time(0);
struct tm* n = new tm();
localtime_s(n, &t);
// Use the time of construction
// for a unique filename
filename_ = (n->tm_year + 1900) +
(n->tm_mon + 1) +
n->tm_mday +
"_" +
n->tm_hour +
n->tm_min +
n->tm_sec;
}
bool ClockTime::checkOverdueTime() {
bool hasElapsed;
struct tm today;
time_t currentTime = time(ZERO); // get local time
int hr = _time / TIME_DIVISOR,
min = _time % TIME_DIVISOR;
localtime_s( &today, ¤tTime); // update tm struct to be local date and time
if( hr < today.tm_hour ) {
hasElapsed = true;
} else if ( hr == today.tm_hour && min <= today.tm_min) {
hasElapsed = true;
} else{
hasElapsed = false;
}
return hasElapsed;
}
static int logBase(LogLevel level, const char * format, va_list ap)
{
struct _timeb timebuffer;
struct tm tm;
char strTmp[60];
if (level > logLevel)
{
return 0;
}
_ftime_s(&timebuffer);
localtime_s(&tm, &timebuffer.time);
strftime(strTmp, 60, "%Y-%m-%d %H:%M:%S", &tm);
fprintf(stderr, "%s %s,%3.3d [%s] ", logLevels[level], strTmp, timebuffer.millitm, progName);
return vfprintf(stderr, format, ap);
}
void RaceStandingsPlugin::Log(const char *msg)
{
FILE *fo;
time_t curtime;
struct tm localtime;
char timestamp[26];
fo = fopen( RACE_STANDINGS_LOG_FILENAME, "a" );
if( fo != NULL )
{
curtime = time(NULL);
localtime_s(&localtime, &curtime);
asctime_s(timestamp, 26, &localtime);
timestamp[24] = 0;
fprintf( fo, "[%s] %s\n", timestamp, msg );
fclose( fo );
}
}
static void FormatAt(char* buffer, int32_t len, time_t now)
{
#if 0
struct tm timinfo;
if (now == 0)
{
now = time(0);
}
#endif
#if defined(linux) || defined(__linux) || defined(__linux__)
strftime(buffer, len, "%F %T", localtime_r(&now, &timinfo));
#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
localtime_s(&timinfo, &now);
strftime(buffer, len, "%F %T", &timinfo);
#endif
}
bool MsgLogger::Init(const char* prefix, const char* logPath) {
m_prefix = prefix;
m_logPath = logPath;
m_logFileName = m_logPath + "/" + m_prefix + ".log";
m_historyFileNamePattern = m_logPath + "/" + m_prefix + "_%Y%m%d%H%M%S.log";
time_t ttNow = time(NULL);
time_t ttNowAdj = ttNow + TZ_ADJUST;
m_ttLogDay = ttNowAdj / (24 * 3600);
tm tmNow;
localtime_s(&tmNow, &ttNow);
char strLogDay[256];
strftime(strLogDay, 256, "%Y-%m-%d", &tmNow);
m_strLogDay = strLogDay;
return DoDivide();
}
void FSTimeLimiter(int iYear, int iMonth, int iDay)
{
time_t secs=time(0);
#if defined (WIN32)
tm now_s;
localtime_s(&now_s, &secs);
const tm *now=&now_s;
#else
tm *now=localtime(&secs);
#endif
if (now->tm_year+1900 > iYear) throw CFSException();
if (now->tm_year+1900 == iYear) {
if (now->tm_mon+1 > iMonth) throw CFSException();
if (now->tm_mon+1 == iMonth) {
if (now->tm_mday >= iDay) throw CFSException();
}
}
}
void Logger::saveSession(FILE* session){
fprintf(session,"## Session ID \n");
fprintf(session,"%d \n",m_Session_id);
fprintf(session,"# Session Date and Time \n");
struct tm Today;
time_t now;
time(&now);
localtime_s(&Today, &now);
saveTimeDate(session, &Today);
fprintf(session,"\n");
}
int main(void)
{
struct tm ptm;
time_t t = time(NULL);
ptm = *gmtime(&t);
printf("UTC: %s", asctime(&ptm));
ptm = *localtime(&t);
printf("local: %s", asctime(&ptm));
#ifdef __STDC_LIB_EXT1__
struct tm buf;
char str[26];
asctime_s(str, sizeof str, gmtime_s(&t, &buf));
printf("UTC: %s", str);
asctime_s(str, sizeof str, localtime_s(&t, &buf));
printf("local: %s", str);
#endif
}
const std::string toDate(const uint64 tt)
{
if (0 == tt)
{
DateTime dt;
return dt.toDate();
}
char buf[64] = { 0 };
struct tm tm_;
#if defined(_WINDOWS) || defined(_WIN32)
localtime_s(&tm_, (time_t*)&tt);
#else
tm_ = localtime_r(&tt);
#endif
strftime(buf, 64, "%Y-%m-%d", &tm_);
return buf;
}
void DateTime::_setTime(const uint64 tt)
{
_millis = (time_t)tt;
struct tm tm_;
#if defined(_WINDOWS) || defined(_WIN32)
localtime_s(&tm_, &_millis);
#else
tm_ = localtime_r(&tt);
#endif
_year = tm_.tm_year + 1900;
_mon = tm_.tm_mon + 1;
_day = tm_.tm_mday;
_hour = tm_.tm_hour;
_min = tm_.tm_min;
_sec = tm_.tm_sec;
_wday = tm_.tm_wday;
}
/**
* Description: SetRangeField(). 设置Range头域
* @param [in] ulStartTime 起始时间
* @param [in] bRelativeTime 是否为相对时间
* @param [io] strRange 设置后的字符串
* @return long. 返回码
*/
long CRtspPacket::SetRangeField
(
IN unsigned long ulStartTime,
IN BOOL bRelativeTime,
IO string& strRange
)const
{
//开始时间转换为字符串，最大长度不会超过32字节
char szStartTime[32] = {0};
if (bRelativeTime)
{
(void)snprintf(szStartTime, sizeof(szStartTime) - 1, "%u-", ulStartTime);
//Range使用npt相对时间
strRange += "Range:npt=";
}
else
{
time_t tStartTime = ulStartTime;
//localtime返回NULL的条件: Before midnight, January 1, 1970. After 03:14:07, January 19, 2038,
struct tm _tm;
memset(&_tm, 0, sizeof(tm));
localtime_s(&_tm, &tStartTime);
(void)snprintf(szStartTime, sizeof(szStartTime) - 1,
"%04d%02d%02dT%02d%02d%02dZ-",
_tm.tm_year + 1900,
_tm.tm_mon + 1,
_tm.tm_mday,
_tm.tm_hour,
_tm.tm_min,
_tm.tm_sec);
//Range使用clock绝对时间
strRange += "Range:clock=";
}
strRange += szStartTime;
strRange += RTSP::CRLF;
return RTSP::RET_CODE_OK;
}
size_t zLog::print(const string& status, const string& classname, const list<string>& buf) const
{
#if defined(_WIN32)
return write(buf);
#else
#if defined(__GNUG__) || defined(__CYGWIN__) || defined(__linux__)
if(buf.size() == 0) return 0;
string q;
time_t ltime = ::time(NULL);
struct tm tmtime;
#if defined(_WIN32)
localtime_s(&tmtime,<ime);
#else
#if defined(__GNUG__) || defined(__CYGWIN__) || defined(__linux__)
localtime_r(<ime, &tmtime);
#endif // _WIN32
#endif // __GNUG__
q+='[';
if(tmtime.tm_mday < 10) q+='0';
q+=ZNSTR::toString(static_cast<int>(tmtime.tm_mday));
q+='/';
if(tmtime.tm_mon < 10) q+='0';
q+=ZNSTR::toString(static_cast<int>(tmtime.tm_mon));
q+='/';
// if(tmtime.tm_year < 10) q+='0';
q+=ZNSTR::toString(static_cast<int>(tmtime.tm_year));
q+=' ';
if(tmtime.tm_hour < 10) q+='0';
q+=ZNSTR::toString(static_cast<int>(tmtime.tm_hour));
q+=':';
if(tmtime.tm_min < 10) q+='0';
q+=ZNSTR::toString(static_cast<int>(tmtime.tm_min));
q+=':';
if(tmtime.tm_sec < 10) q+='0';
q+=ZNSTR::toString(static_cast<int>(tmtime.tm_sec));
q+="] "+status+' '+classname+' ';
string s;
for(list<string>::const_iterator k=buf.begin(); k != buf.end(); ++k) { s+=(q+*k); }
return write(s);
#endif // _WIN32
#endif // __GNUG__
};
const char * timeStamp::TimeStamp(char * const buffer, int bufsize, bool useColons)
{
const char* const format = useColons ? "%F %T." : "%F %H-%M-%S.";
const int millisize = 5;
char millibuf[millisize];
struct _timeb timebuffer;
_ftime64_s(&timebuffer);
unsigned short millitime = timebuffer.millitm;
sprintf_s(millibuf, millisize, "%03d.", millitime);
time_t rawTime;
time(&rawTime);
struct tm timeInfo;
localtime_s(&timeInfo, &rawTime);
strftime(buffer, bufsize, format, &timeInfo);
strcat_s(buffer, bufsize, millibuf);
return buffer;
}
CTime::operator FILETIME() const
{
FILETIME ft;
FILETIME localTime;
SYSTEMTIME st;
struct tm Time;
localtime_s(&Time,&m_time);
st.wYear=Time.tm_year+1900;
st.wMonth=Time.tm_mon+1;
st.wDayOfWeek=Time.tm_wday;
st.wDay=Time.tm_mday;
st.wHour=Time.tm_hour;
st.wMinute=Time.tm_min;
st.wSecond=Time.tm_sec;
st.wMilliseconds=msec;
SystemTimeToFileTime(&st,&localTime);
LocalFileTimeToFileTime(&localTime,&ft);
return ft;
}
string Store::currentYear() {
time_t rawtime;
time(&rawtime);
tm now;
localtime_s(&now, &rawtime);
int nowYear = 1900 + (&now)->tm_year;
ostringstream convert; // stream used for the conversion
convert << nowYear;
string nowYearstr = convert.str();
return nowYearstr;
}