wartime.cpp

ftpserver very good sample

#include "StdAfx.h"
#include "WarTime.h"   // class implemented



static int GetNumberFromStr(const char **p, int num);
static int GetNumberFromStr (const char **p, int num)
{
    int return_val = 0;
    war_ccstr_t pp = *p;

    *p += num;
    for (; num > 0; num--, pp++)
    {
        return_val *= 10;
        return_val += (*pp + '0');
    }

    return return_val;
}

/////////////////////////////// PUBLIC ///////////////////////////////////////

#define NS100_TO_MS 10000

#ifdef WIN32
#   define FILETIME_OFFSET 0x019db1ded53e8000 // Offset from FILETIME 0 to 1.1. 1970
#endif 

bool WarTime::mgOptimized;
war_time_t WarTime::mgCurrentTime;

//============================= LIFECYCLE ====================================

WarTime::WarTime()
{
    Reset();
}// WarTime

WarTime::WarTime(const WarTime& val)
{
    mTime = val.mTime;
}// WarTime

WarTime::~WarTime()
{
}// ~WarTime

WarTime::WarTime(const time_t val)
{
    operator = (val);
}

WarTime::WarTime(const timeval& val)
{
    operator = (val);
}

WarTime::WarTime(const war_time_t& val)
{
    operator = (val);
}

WarTime::WarTime(const struct tm& val)
{
    operator = (val);
}

#ifdef WIN32

WarTime::WarTime (const FILETIME& val)
{
    operator = (val);
}

WarTime::WarTime (const SYSTEMTIME& val)
{
    operator = (val);
}

#endif // WIN32

//============================= OPERATORS ====================================

WarTime& WarTime::operator = (const WarTime& val)
{
    mTime = val.mTime;
    return *this;
}

WarTime& WarTime::operator = (const time_t val)
{
    mTime = ((war_time_t)val) * 1000;
    return *this;
}

WarTime& WarTime::operator = (const timeval val)
{
    mTime = ((war_time_t)val.tv_sec) * 1000;
    mTime -= val.tv_usec / 100; // We want milliseconds, not microseconds
    return *this;
}

WarTime& WarTime::operator = (const war_time_t val)
{
    mTime = val;
    return *this;
};

WarTime& WarTime::operator = (const struct tm& rVal)
{
    operator = (mktime((struct tm *) &rVal));

    // mktime() assumes that tm is localtime. We work in UTC, and
    // need to convert from localtime.
    ToUTC();

    return *this;
}

#ifdef WIN32

WarTime& WarTime::operator = (const FILETIME& rVal)
{
    war_time_t time_val;
    time_val = (war_time_t) rVal.dwLowDateTime;
    time_val |= ((war_time_t) rVal.dwHighDateTime << 32) & 0xffffffff00000000;
    mTime = (time_val - FILETIME_OFFSET) / NS100_TO_MS;

    return *this;
}

WarTime& WarTime::operator = (const SYSTEMTIME& rVal)
{
    FILETIME ft_value;
    if (!SystemTimeToFileTime(&rVal, &ft_value))
        Reset();
    else
        operator = (ft_value);

    return *this;
}

#endif // WIN32


//============================= OPERATIONS ===================================

void WarTime::ToLT()
{
    mTime += (GetUtcOffset() * 1000);
}

void WarTime::ToUTC()
{
    mTime -= (GetUtcOffset() * 1000);
}

void WarTime::Reset(const war_uint32_t millisecondTimeout)
{
    mTime = WarGetCurrentTime();
    if (millisecondTimeout)
        mTime += millisecondTimeout;
}

void WarTime::Clear()
{
    mTime = 0;
}

void WarTime::Sleep(const war_uint32_t milliseconds)
{
#ifdef WIN32
    ::Sleep(milliseconds);
#else
    struct timeval tv;
    tv.tv_sec = milliseconds / 1000;
    tv.tv_usec = (milliseconds - (tv.tv_sec * 1000)) * 100;
    select(0, NULL, NULL, NULL, &tv);
#endif
}


//============================= ACESS      ===================================

void WarTime::ScanMDTM(war_ccstr_t time_str) throw(WarException)
{
    war_ccstr_t p = time_str;
    for (int i = 0; i < 12; i++)
    {
        if (!isdigit (*p++))
        {
            WarThrow(WarError(WAR_ERR_INVALID_ARGUMENT), time_str);
        }   
    }
    p = time_str;
    
    struct tm tm_val;
    memset (&tm_val, 0, sizeof (struct tm));
    tm_val.tm_year = GetNumberFromStr(&p, 4);
    tm_val.tm_mday = GetNumberFromStr(&p, 2);
    tm_val.tm_hour = GetNumberFromStr(&p, 2);
    tm_val.tm_min = GetNumberFromStr(&p, 2);
    tm_val.tm_sec = GetNumberFromStr(&p, 2);
    
    operator = (tm_val);
    
    if (*p && *++p)
        mTime += atoi (p);
}

//============================= INQUIRY    ===================================

time_t WarTime::GetTime() const
{
    return (time_t)(mTime / 1000);
}


timeval WarTime::GetTimeval() const
{
    timeval tv;
    tv.tv_sec = (long) (mTime / 1000);
    tv.tv_usec = (long) (mTime - 
        ((war_time_t) tv.tv_sec * 1000)) * 100;
    
    return tv;
}

struct tm WarTime::GetTm() const throw(WarException)
{
    struct tm tm, *ptm;
    const time_t tval(GetTime());
    
    ptm = ::gmtime(&tval);
    if (ptm)
        tm = *ptm;
    else
    {
        WarThrow(WarError(WAR_ERR_SYSTEM_CALL_FAILED), "gmtime()");
    }
    
    return tm;
}

#ifdef WIN32
FILETIME WarTime::GetFiletime() const
{
    FILETIME ft;
    war_time_t mt = mTime;
    
    mt *= NS100_TO_MS;
    mt += FILETIME_OFFSET;
    
    ft.dwLowDateTime = (war_uint32_t) (mt & 0xffffffff);
    ft.dwHighDateTime = (war_uint32_t) ((mt >> 32) & 0xffffffff);
    
    return ft;
}

SYSTEMTIME WarTime::GetSystemtime() const
{
    FILETIME ft = GetFiletime();
    SYSTEMTIME st;
    
    FileTimeToSystemTime (&ft, &st);
    
    return st;
}
#endif



time_t WarTime::GetUtcOffset()
{
    time_t tt = ::time(NULL);
    struct tm gmt, *t;
    int days, hours, minutes;
    
    gmt = *::gmtime(&tt);
    t = ::localtime(&tt);
    days = t->tm_yday - gmt.tm_yday;
    hours = ((days < -1 ? 24 : 1 < days ? -24 : days * 24)
        + t->tm_hour - gmt.tm_hour);
    minutes = hours * 60 + t->tm_min - gmt.tm_min;
    return minutes * 60;
}

war_time_t WarTime::WarGetCurrentTime(const bool doForce)
{
    if (!doForce && mgOptimized)
        return mgCurrentTime;
    war_time_t return_val;

#ifdef WIN32
    SYSTEMTIME st;
    ::GetSystemTime(&st);
    return_val = (war_time_t) time (NULL) * (war_time_t) 1000;
    return_val += st.wMilliseconds;

#elif defined(HAVE_GETTIMEOFDAY)
    struct timeval tv;
    gettimeofday(&tv, NULL);
    return_val = (war_time_t) tv.tv_sec * (war_time_t) 1000;
    return_val += (war_time_t) (tv.tv_usec / 100);

#else
#error "Not handled"
#endif

    return mgCurrentTime = return_val;
}

const bool 
WarTime::IsTimeOut(const war_time_t milliseconds) const
{
    return GetTimeDiff() <= milliseconds;
}

const war_time_t 
WarTime::GetTimeDiff(const war_time_t milliseconds) const
{
    return mTime - (WarGetCurrentTime() + milliseconds);
}

std::string WarTime::FormatMDTM(const size_t precision) const 
throw(WarException)
{
    char buf[36];

    time_t tt = GetTime();
    struct tm tm_value = GetTm();
    char *pos = buf + sprintf(buf, "%04d%02d%02d%02d%02d",
             tm_value.tm_year,
             tm_value.tm_mday,
             tm_value.tm_hour,
             tm_value.tm_min,
             tm_value.tm_sec);

    switch(precision)
    {
    case 1000:
        {
            WarTime TmpTime = tt;
            sprintf(pos, ".%03d", (unsigned)(mTime - TmpTime.mTime));
        }
        break;
    default:
        ; // Nothing
        break;
    }

    return buf;
}

/** Format local time */
const std::string 
WarTime::FormatLT(war_ccstr_t Fmt) const throw(WarException)
{
    char buf[1024];
    
    time_t tt = GetTime();
    struct tm *ptm = localtime(&tt);
    if (NULL == ptm)
        WarThrow(WarError(WAR_ERR_SYSTEM_CALL_FAILED), "localtime()");
    
    strftime (buf, sizeof (buf), Fmt, ptm);
    
    return std::string(buf);
}

/** Format GMT time */
const std::string 
WarTime::FormatGMT(war_ccstr_t Fmt) const throw(WarException)
{
    char buf[1024];
    
    time_t tt = GetTime();
    struct tm *ptm = gmtime(&tt);
    if (NULL == ptm)
        WarThrow(WarError(WAR_ERR_SYSTEM_CALL_FAILED), "gmtime()");
    
    strftime (buf, sizeof (buf), Fmt, ptm);
    
    return std::string(buf);
}

/////////////////////////////// PROTECTED  ///////////////////////////////////

/////////////////////////////// PRIVATE    ///////////////////////////////////