date.cpp

贡献一份commoncpp2,有兴趣的可以研究一下

int Time::getHour(void) const
{
	char buf[7];
	fromSeconds(buf);
	ZNumber num(buf, 2);
	return num();
}

int Time::getMinute(void) const
{
	char buf[7];
	fromSeconds(buf);
	ZNumber num(buf + 2, 2);
	return num();
}

int Time::getSecond(void) const
{
	char buf[7];
	fromSeconds(buf);
	ZNumber num(buf + 4, 2);
	return num();
}

void Time::update(void)
{
}

void Time::setTime(char *str, size_t size)
{
	int sec = 00;

	if(!size)
		size = strlen(str);

//00:00
	if (size == 5)
	{
		sec = 00;
	}
//00:00:00	
	else if (size == 8)
	{
		ZNumber nsecond(str + 6, 2);
		sec = nsecond();
	}
#ifdef	CCXX_EXCEPTIONS
	else if(Thread::getException() == Thread::throwObject)
	{
		throw this;
	}
#ifdef	COMMON_STD_EXCEPTION
	else if(Thread::getException() == Thread::throwException)
	{
		throw Exception("Time::setTime(): Invalid time.");
	}
#endif
#endif	    	
	else {
		return;
	}

	ZNumber nhour(str, 2);
	ZNumber nminute(str+3, 2);
	toSeconds(nhour(), nminute(), sec);
}

String Time::operator()() const
{
	char buf[7];

	fromSeconds(buf);
	String strTime(buf);

	return strTime;
}

long Time::getValue(void) const
{
	return seconds;
}

Time& Time::operator++()
{
	++seconds;
	update();
	return *this;
}

Time& Time::operator--()
{
	--seconds;
	update();
	return *this;
}

Time& Time::operator+=(const int val)
{
	seconds += val;
	update();
	return *this;
}

Time& Time::operator-=(const int val)
{
	seconds -= val;
	update();
	return *this;
}

int Time::operator==(const Time &t)
{
	return seconds == t.seconds;
}

int Time::operator!=(const Time &t)
{
	return seconds != t.seconds;
}

int Time::operator<(const Time &t)
{
	return seconds < t.seconds;
}

int Time::operator<=(const Time &t)
{
	return seconds <= t.seconds;
}

int Time::operator>(const Time &t)
{
	return seconds > t.seconds;
}

int Time::operator>=(const Time &t)
{
	return seconds >= t.seconds;
}

void Time::toSeconds(int hour, int minute, int second)
{
	seconds = -1;
	
	if (hour > 23 ||minute > 59 ||second > 59) {
#ifdef	CCXX_EXCEPTIONS
		if(Thread::getException() == Thread::throwObject) {
			throw this;
		}
#ifdef	COMMON_STD_EXCEPTION
		else if(Thread::getException() == Thread::throwException) {
			throw Exception("Time::toSeconds(): Invalid time.");
		}
#endif
#endif
		return;
	}

	seconds = 3600 * hour + 60 * minute + second;
}

void Time::fromSeconds(char *buffer) const
{
	ZNumber hour(buffer, 2);
	ZNumber minute(buffer + 2, 2);
	ZNumber second(buffer + 4, 2);

	hour = seconds / 3600;
	minute = (seconds - (3600 * hour())) / 60;
	second = seconds - (3600 * hour()) - (60 * minute());
	buffer[6] = '\0';
}

Time operator+(const Time &time1, const Time &time2)
{
	Time t;
	t.seconds = time1.seconds + time2.seconds;
	t.update();
	return t;
}

Time operator-(const Time &time1, const Time &time2)
{
	Time t;
	t.seconds = time1.seconds - time2.seconds;
	t.update();
	return t;
}

Time operator+(const Time &time, const int val)
{
	Time t = time;
	t.seconds += val;
	t.update();
	return t;
}

Time operator+(const int val, const Time &time)
{
	Time t = time;
	t.seconds += val;
	t.update();
	return t;
}

Time operator-(const Time &time, const int val)
{
	Time t = time;
	t.seconds -= val;
	t.update();
	return t;
}

Time operator-(const int val, const Time &time)
{
	Time t = time;
	t.seconds -= val;
	t.update();
	return t;
}

Datetime::Datetime(time_t tm)
{
	struct tm dt;
       SysTime::getLocalTime(&tm, &dt);
	toJulian(dt.tm_year + 1900, dt.tm_mon + 1, dt.tm_mday);
	toSeconds(dt.tm_hour, dt.tm_min, dt.tm_sec);
}

Datetime::Datetime(tm *dt) :
Date(dt), Time(dt)
{}

Datetime::Datetime(const char *a_str, size_t size)
{
	char *timestr;

	if (!size)
		size = strlen(a_str);

	char *str = new char[size+1];
	strncpy(str, a_str, size);
	str[size]=0;

// 00/00 00:00
	if (size ==  11)
	{
		timestr = str + 6;
		setDate(str, 5);
		setTime(timestr, 5);
	}
// 00/00/00 00:00
	else if (size == 14)
	{
		timestr = str + 9;
		setDate(str, 8);
		setTime(timestr,5);
	}
// 00/00/00 00:00:00
	else if (size == 17)
	{
		timestr = str + 9;
		setDate(str, 8);
		setTime(timestr,8);
	}
// 0000/00/00 00:00:00
	else if (size == 19)
	{
		timestr = str + 11;
		setDate(str, 10);
		setTime(timestr,8);
	}
#ifdef	CCXX_EXCEPTIONS
	else if(Thread::getException() == Thread::throwObject)
	{
		delete str;
		throw this;
	}
#ifdef	COMMON_STD_EXCEPTION
	else if(Thread::getException() == Thread::throwException)
	{
		delete str;
		throw Exception("Datetime::Datetime(): Invalid time.");
	}	    	
#endif
#endif
	delete str;
}

Datetime::Datetime(int year, unsigned month, unsigned day,
		   int hour, int minute, int second) :
  Date(year, month, day), Time(hour, minute, second)
{}

Datetime::Datetime() : Date(), Time()
{
	time_t now = SysTime::getTime();
	struct tm dt;
       SysTime::getLocalTime(&now, &dt);

	toSeconds(dt.tm_hour, dt.tm_min, dt.tm_sec);
	toJulian(dt.tm_year + 1900, dt.tm_mon + 1, dt.tm_mday);
}

bool Datetime::isValid(void) const
{
	return Date::isValid() && Time::isValid();
}

char *Datetime::getDatetime(char *buf) const
{
	fromJulian(buf);
	buf[10] = ' ';
	fromSeconds(buf+11);
	return buf;
}

time_t Datetime::getDatetime(void) const
{
	char buf[11];
	struct tm dt;
	memset(&dt, 0, sizeof(dt));

	fromJulian(buf);
	ZNumber nyear(buf, 4);
	ZNumber nmonth(buf + 5, 2);
	ZNumber nday(buf + 8, 2);
	dt.tm_year = nyear() - 1900;
	dt.tm_mon = nmonth() - 1;
	dt.tm_mday = nday();

	fromSeconds(buf);
	ZNumber nhour(buf, 2);
	ZNumber nminute(buf + 2, 2);
	ZNumber nsecond(buf + 4, 2);
	dt.tm_hour = nhour();
	dt.tm_min = nminute();
	dt.tm_sec = nsecond();
	dt.tm_isdst = -1;
	
	return mktime(&dt);
}

Datetime& Datetime::operator=(const Datetime datetime)
{
	julian = datetime.julian;
	seconds = datetime.seconds;
	
	return *this;	
}

Datetime& Datetime::operator+=(const Datetime &datetime)
{
	seconds += datetime.seconds;
	julian += datetime.julian; 
	Date::update();
	Time::update();
	return *this;
}

Datetime& Datetime::operator-=(const Datetime &datetime)
{
	seconds -= datetime.seconds;
	julian -= datetime.julian; 
	Date::update();
	Time::update();
	return *this;
}

Datetime& Datetime::operator+=(const Time &time)
{
	seconds += time.getValue();
	Date::update();
	Time::update();
	return *this;
}

Datetime& Datetime::operator-=(const Time &time)
{
	seconds -= time.getValue();
	Date::update();
	Time::update();
	return *this;
}


int Datetime::operator==(const Datetime &d)
{
	return (julian == d.julian) && (seconds == d.seconds);
}

int Datetime::operator!=(const Datetime &d)
{
	return (julian != d.julian) || (seconds != d.seconds);
}

int Datetime::operator<(const Datetime &d)
{
	if (julian != d.julian) {
		return (julian < d.julian);
	}
	else {
		return (seconds < d.seconds);
	}
}

int Datetime::operator<=(const Datetime &d)
{
	if (julian != d.julian) {
		return (julian < d.julian);
	}
	else {
		return (seconds <= d.seconds);
	}
}

int Datetime::operator>(const Datetime &d)
{
	if (julian != d.julian) {
		return (julian > d.julian);
	}
	else {
		return (seconds > d.seconds);
	}
}

int Datetime::operator>=(const Datetime &d)
{
	if (julian != d.julian) {
		return (julian > d.julian);
	}
	else {
		return (seconds >= d.seconds);
	}
}

bool Datetime::operator!() const
{
	return !(Date::isValid() && Time::isValid());
}


String Datetime::strftime(const char *format) const
{
	char buffer[64];
	size_t last;
	time_t t;
	tm tbp;
	String retval;

	t = getDatetime();
       SysTime::getLocalTime(&t, &tbp);
#ifdef	WIN32
	last = ::strftime(buffer, 64, format, &tbp);
#else
	last = std::strftime(buffer, 64, format, &tbp);
#endif

	buffer[last] = '\0';
	retval = buffer;
	return retval;
}

DateNumber::DateNumber(char *str) :
Number(str, 10), Date(str, 10)
{}

#ifdef	CCXX_NAMESPACES
}
#endif