nltime.cpp

一些unix下的c/c++的util包

/**
 * 时间类实现
 * @file NLTime.cpp
 * @date 14-Jul-2005
 * @author 胡春雨
 * @version 1.0.0: 初始版本
 */

#include "nlkit/NLTime.h"
#include <iomanip>

#define BUFFER_SIZE 100							/**< strftime转换时缓冲区大小 */
#define ONE_SEC_IN_USEC 1000000					/**< 1秒钟等于的毫秒数 */

using namespace std;
namespace nlkit
{
string convertIntegerToString(int value)
{
	if (value == 0)
	{
		return string("0");
	}

	char buffer[21];
	char ret[21];
	unsigned int bufferPos = 0;
	unsigned int retPos = 0;

	if (value < 0)
	{
		ret[retPos++] = '-';
	}

	while (value != 0)
	{
		int mod = value % 10;
		value = value / 10;
		buffer[bufferPos++] = '0' + static_cast<char>(mod);
	}

	while (bufferPos > 0)
	{
		ret[retPos++] = buffer[--bufferPos];
	}
	ret[retPos] = 0;

	return string(ret);
}

NLTime::NLTime()
	: tv_sec(0),
	  tv_usec(0)
{
}

NLTime::NLTime(long tv_sec, long tv_usec)
	: tv_sec(tv_sec),
	  tv_usec(tv_usec)
{
}

NLTime::NLTime(time_t time)
	: tv_sec(time),
	  tv_usec(0)
{
}

NLTime::~NLTime()
{
}

NLTime NLTime::gettimeofday()
{
	timeval tp;
	::gettimeofday(&tp, 0);

	return NLTime(tp.tv_sec, tp.tv_usec);
}

int NLTime::setTime(struct tm* t)
{
	time_t time = ::mktime(t);
	if (time != -1)
	{
		tv_sec = time;
	}

	return time;
}

time_t NLTime::getTime() const
{
	return tv_sec;
}

void NLTime::gmtime(struct tm* t) const
{
	time_t clock = tv_sec;
	struct tm* tmp = ::gmtime(&clock);
	*t = *tmp;
}

void NLTime::localtime(struct tm* t) const
{
	time_t clock = tv_sec;
	struct tm* tmp = ::localtime(&clock);
	*t = *tmp;
}

string NLTime::getFormattedTime(const string& fmt, bool use_gmtime) const
{
	char buffer[BUFFER_SIZE];
	struct tm time;

	if (use_gmtime)
	{
		gmtime(&time);
	}
	else
	{
		localtime(&time);
	}

	size_t len = ::strftime(buffer, BUFFER_SIZE, fmt.c_str(), &time);
	buffer[len] = '\0';
	string ret(buffer);

	size_t pos = ret.find("%q");
	if (pos != string::npos)
	{
		string tmp(ret.substr(0, pos));
		string seconds( convertIntegerToString((tv_usec / 1000)) );
		switch (seconds.length())
		{
			case 1: tmp += "00"; break;
			case 2: tmp += "0"; break;
		}
		tmp += seconds;
		tmp += ret.substr(pos + 2);
		ret = tmp;
	}

	pos = ret.find("%Q");
	if (pos != string::npos)
	{
		string tmp(ret.substr(0, pos));
		string seconds( convertIntegerToString((tv_usec / 1000)) );
		switch (seconds.length()) {
			case 1: tmp += "00"; break;
			case 2: tmp += "0"; break;
		}
		tmp += seconds;
		string usecs( convertIntegerToString((tv_usec % 1000)) );
		switch (usecs.length())
		{
			case 1: tmp += ".00"; break;
			case 2: tmp += ".0"; break;
			case 3: tmp += "."; break;
		}
		tmp += usecs;
		tmp += ret.substr(pos + 2);
		ret = tmp;
	}

	return ret;
}

void NLTime::setFormattedTime(const char* timebuf, const char* fmt)
{
	char tmp[BUFFER_SIZE];
	strcpy(tmp, "%Y%m%d%H%M%S");
	if (strcmp(tmp, fmt))
		return;

	struct tm time;
	time.tm_sec = 0;

	memcpy(tmp, timebuf, 4);
	tmp[4] = 0;
	time.tm_year = atoi(tmp) - 1900;

	memcpy(tmp, timebuf+4, 2);
	tmp[2] = 0;
	time.tm_mon = atoi(tmp)-1;

	memcpy(tmp, timebuf+6, 2);
	tmp[2] = 0;
	time.tm_mday = atoi(tmp);

	memcpy(tmp, timebuf+8, 2);
	tmp[2] = 0;
	time.tm_hour = atoi(tmp);

	memcpy(tmp, timebuf+10, 2);
	tmp[2] = 0;
	time.tm_min = atoi(tmp);

	memcpy(tmp, timebuf+12, 2);
	tmp[2] = 0;
	time.tm_sec = atoi(tmp);

	time.tm_isdst = 0;

	setTime(&time);
}

NLTime NLTime::calculateNextRolloverTime(const NLTime& t, NLDailyRollingSchedule schedule, int value)
{
	switch(schedule)
	{
	case MONTHLY:
		{
			struct tm nextMonthTime;
			t.localtime(&nextMonthTime);
			nextMonthTime.tm_mon += value;
			nextMonthTime.tm_isdst = 0;

			NLTime ret;
			if(ret.setTime(&nextMonthTime) == -1)
			{
				ret = (t + NLTime(value*2678400));	// 每个月按31天算
			}

			return ret;
		}

	case WEEKLY:
		return (t + NLTime(value*604800));		// 7 * 24 * 60 * 60 seconds

	case DAILY:
		return (t + NLTime(value*86400));		// 24 * 60 * 60 seconds

	case TWICE_DAILY:
		return (t + NLTime(value*43200));		// 12 * 60 * 60 seconds

	case HOURLY:
		return (t + NLTime(value*3600));		// 60 * 60 seconds

	case MINUTELY:
		return (t + NLTime(value*60));			// 60 seconds
	};

	return (t + NLTime(value*86400));
}

void NLTime::setCalculateBeginTime(NLTime& t, NLDailyRollingSchedule schedule)
{
	t.usec(0);
	struct tm time;
	t.localtime(&time);

	time.tm_sec = 0;
	switch (schedule)
	{
	case MONTHLY:
		time.tm_mday = 1;
		time.tm_hour = 0;
		time.tm_min = 0;
		break;

	case WEEKLY:
		time.tm_mday -= (time.tm_wday % 7);
		time.tm_hour = 0;
		time.tm_min = 0;
		break;

	case DAILY:
		time.tm_hour = 0;
		time.tm_min = 0;
		break;

	case TWICE_DAILY:
		if(time.tm_hour >= 12) {
			time.tm_hour = 12;
		}
		else {
			time.tm_hour = 0;
		}
		time.tm_min = 0;
		break;

	case HOURLY:
		time.tm_min = 0;
		break;

	case MINUTELY:
		break;
	};
	t.setTime(&time);
}

NLTime NLTime::getCalculateBeginTime(const NLTime& t, NLDailyRollingSchedule schedule)
{
	NLTime ret(t.sec(), t.usec());

	setCalculateBeginTime(ret, schedule);

	return ret;
}

NLTime& NLTime::operator+=(const NLTime& rhs)
{
	tv_sec += rhs.tv_sec;
	tv_usec += rhs.tv_usec;

	if(tv_usec >= ONE_SEC_IN_USEC) {
		++tv_sec;
		tv_usec -= ONE_SEC_IN_USEC;
	}

	return *this;
}

NLTime& NLTime::operator-=(const NLTime& rhs)
{
	tv_sec -= rhs.tv_sec;
	tv_usec -= rhs.tv_usec;

	if(tv_usec < 0)
	{
		--tv_sec;
		tv_usec += ONE_SEC_IN_USEC;
	}

	return *this;
}

NLTime& NLTime::operator/=(long rhs)
{
	long rem_secs = tv_sec % rhs;
	tv_sec /= rhs;
	
	tv_usec /= rhs;
	tv_usec += ((rem_secs * ONE_SEC_IN_USEC) / rhs);

	return *this;
}

NLTime& NLTime::operator*=(long rhs)
{
	long new_usec = tv_usec * rhs;
	long overflow_sec = new_usec / ONE_SEC_IN_USEC;
	tv_usec = new_usec % ONE_SEC_IN_USEC;

	tv_sec *= rhs;
	tv_sec += overflow_sec;

	return *this;
}

const NLTime operator+(const NLTime& lhs, const NLTime& rhs)
{
    NLTime temp(lhs);
	return temp += rhs;
}

const NLTime operator-(const NLTime& lhs, const NLTime& rhs)
{
    NLTime temp(lhs);
	return temp -= rhs;
}

const NLTime operator/(const NLTime& lhs, long rhs)
{
    NLTime temp(lhs);    
	return temp /= rhs;
}

const NLTime operator*(const NLTime& lhs, long rhs)
{
    NLTime temp(lhs);
	return temp *= rhs;
}

bool operator<(const NLTime& lhs, const NLTime& rhs)
{
	return (   (lhs.sec() < rhs.sec())
			|| (   (lhs.sec() == rhs.sec()) 
				&& (lhs.usec() < rhs.usec())) );
}

bool operator<=(const NLTime& lhs, const NLTime& rhs)
{
	return ((lhs < rhs) || (lhs == rhs));
}

bool operator>(const NLTime& lhs, const NLTime& rhs)
{
	return (   (lhs.sec() > rhs.sec())
			|| (   (lhs.sec() == rhs.sec()) 
				&& (lhs.usec() > rhs.usec())) );
}

bool operator>=(const NLTime& lhs, const NLTime& rhs)
{
	return ((lhs > rhs) || (lhs == rhs));
}

bool operator==(const NLTime& lhs, const NLTime& rhs)
{
	return (   lhs.sec() == rhs.sec()
			&& lhs.usec() == rhs.usec());
}

bool operator!=(const NLTime& lhs, const NLTime& rhs)
{
	return !(lhs == rhs);
}
}