TDuration CDateTime::operator-(const CDateTime &datetime) const
{
TDuration d = { 0, 0 };
if (!isValid() || !datetime.isValid())
{
return d;
}
int year = datetime.getYear();
// Différence de jours
int n1 = dayOfYear(m_year, m_month, m_day) - 1;
int n2 = dayOfYear(year, datetime.getMonth(), datetime.getDay()) - 1;
d.days = n1 - n2;
// Durée positive
if (year < m_year)
{
for (int a = year; a < m_year; ++a)
{
d.days += (isLeapYear(a) ? 366 : 365);
}
}
// Durée négative
else if (year > m_year)
{
for (int a = m_year; a < year; ++a)
{
d.days -= (isLeapYear(a) ? 366 : 365);
}
}
// Différence de secondes
int s1 = 3600 * m_hour + 60 * m_minute + m_second;
int s2 = 3600 * datetime.getHour() + 60 * datetime.getMinute() + datetime.getSecond();
d.seconds = s1 - s2;
// Le nombre de secondes et le nombre de jours doivent être du même signe
if (d.seconds < 0 && d.days > 0)
{
--d.days;
d.seconds += 86400;
}
else if (d.seconds > 0 && d.days < 0)
{
++d.days;
d.seconds -= 86400;
}
return d;
}
// ISO compliant week numbering, not traditional number, rename in KDE5 to isoWeekNumber()
// JPL still need to fully clean up here
int KCalendarSystem::weekNumber( const QDate &date, int *yearNum ) const
{
if ( isValid( date ) ) {
QDate firstDayWeek1, lastDayOfYear;
int y = year( date );
int week;
int weekDay1, dayOfWeek1InYear;
// let's guess 1st day of 1st week
setDate( firstDayWeek1, y, 1, 1 );
weekDay1 = dayOfWeek( firstDayWeek1 );
// iso 8601: week 1 is the first containing thursday and week starts on monday
if ( weekDay1 > 4 /*Thursday*/ ) {
firstDayWeek1 = addDays( firstDayWeek1 , daysInWeek( date ) - weekDay1 + 1 ); // next monday
}
dayOfWeek1InYear = dayOfYear( firstDayWeek1 );
// our date in prev year's week
if ( dayOfYear( date ) < dayOfWeek1InYear ) {
if ( yearNum ) {
*yearNum = y - 1;
}
return weeksInYear( y - 1 );
}
// let's check if its last week belongs to next year
d->setAnyDate( lastDayOfYear, y + 1, 1, 1 );
lastDayOfYear = addDays( lastDayOfYear, -1 );
// if our date is in last week && 1st week in next year has thursday
if ( ( dayOfYear( date ) >= daysInYear( date ) - dayOfWeek( lastDayOfYear ) + 1 )
&& dayOfWeek( lastDayOfYear ) < 4 ) {
if ( yearNum ) {
* yearNum = y + 1;
}
week = 1;
} else {
// To calculate properly the number of weeks from day a to x let's make a day 1 of week
if( weekDay1 < 5 ) {
firstDayWeek1 = addDays( firstDayWeek1, -( weekDay1 - 1 ) );
}
week = firstDayWeek1.daysTo( date ) / daysInWeek( date ) + 1;
}
return week;
}
return -1;
}
const char *MSMBSDate::format(MSString& aString_,const char *format_) const
{
#ifdef MS_THREAD_SAFE_FUNCTIONS
struct tm tms;
#endif //MS_THREAD_SAFE_FUNCTIONS
MSString aString(0,((format_!=0)?strlen(format_):0)+3);
// __tm_zone, a member of struct tm for the sun architecture
// must be initialized if the strftime format %Z is used. Can
// get this value from localtime.
time_t now=time(0);
struct tm *pCalendarTime=MS_LOCALTIME(&now,&tms);
MSMonth m; MSDay d; MSYear y;
asMonthDayYear(m,d,y);
pCalendarTime->tm_sec=0;
pCalendarTime->tm_min=0;
pCalendarTime->tm_hour=0;
pCalendarTime->tm_mday=d;
pCalendarTime->tm_mon=m-1;
pCalendarTime->tm_year=y-1900;
pCalendarTime->tm_wday=weekDay()==7?0:weekDay();
pCalendarTime->tm_yday=dayOfYear()-1;
pCalendarTime->tm_isdst=-1;
int numberOfChars;
while ((numberOfChars=strftime((char*)aString.string(),aString.length(),format_,pCalendarTime))==0)
{
aString=MSString(0,2*aString.length());
}
// remove the terminating null from strftime. strftime returns the number of characters
// produced not including the terminating null character.
aString=MSString(aString.string(),numberOfChars);
aString_=aString.string();
return aString_;
}
int KCalendarSystemHebrew::weekNumber(const TQDate& date, int * yearNum) const
{
TQDate firstDayWeek1, lastDayOfYear;
int y = year(date);
int week;
int weekDay1, dayOfWeek1InYear;
// let's guess 1st day of 1st week
setYMD(firstDayWeek1, y, 1, 1);
weekDay1 = dayOfWeek(firstDayWeek1);
// iso 8601: week 1 is the first containing thursday and week starts on
// monday
if (weekDay1 > 4 /*Thursday*/)
firstDayWeek1 = addDays(firstDayWeek1 , 7 - weekDay1 + 1); // next monday
dayOfWeek1InYear = dayOfYear(firstDayWeek1);
if ( dayOfYear(date) < dayOfWeek1InYear ) // our date in prev year's week
{
if ( yearNum )
*yearNum = y - 1;
return weeksInYear(y - 1);
}
// let's check if its last week belongs to next year
setYMD(lastDayOfYear, y + 1, 1, 1);
lastDayOfYear = addDays(lastDayOfYear, -1);
if ( (dayOfYear(date) >= daysInYear(date) - dayOfWeek(lastDayOfYear) + 1)
// our date is in last week
&& dayOfWeek(lastDayOfYear) < 4) // 1st week in next year has thursday
{
if ( yearNum )
*yearNum = y + 1;
week = 1;
}
else
{
if( weekDay1 < 5 ) // To calculate properly the number of weeks
// from day a to x let's make a day 1 of week
firstDayWeek1 = addDays( firstDayWeek1, -( weekDay1 - 1));
week = firstDayWeek1.daysTo(date) / 7 + 1;
}
return week;
}
/*
* The number of days elapsed between the Gregorian date 12/31/1 BC and DATE.
* The Gregorian date Sunday, December 31, 1 BC is imaginary.
*/
long int greg2abs( date_t d ) /* "absolute date" */
{
return ((long) dayOfYear (d) /* days this year */
+ 365L * (long) (d.yy - 1) /* + days in prior years */
+ (long) ((d.yy - 1) / 4 /* + Julian Leap years */
- (d.yy - 1) / 100 /* - century years */
+ (d.yy - 1) / 400)); /* + Gregorian leap years */
}
int
yearOfWeek(time_t t, bool beginOnMonday)
{
const struct tm* tms = clocaltime(&t);
int tm_year = tms->tm_year;
int lastDayOfYear = dayOfYear(beginOfYear(sameTimeNextYear(t)) - 1);
if (dayOfYear(t) < 4)
{
if (dayOfWeek(t, beginOnMonday) - dayOfYear(t) >= 3)
return 1900 + tm_year - 1;
}
else if (dayOfYear(t) > lastDayOfYear - 4)
{
if (dayOfYear(t) - dayOfWeek(t, beginOnMonday) > lastDayOfYear - 4)
return 1900 + tm_year + 1;
}
return 1900 + tm_year;
}
void TimeStamp::add( int32 days, int32 hours, int32 mins, int32 secs, int32 msecs )
{
m_day = days + dayOfYear();
m_hour += hours;
m_minute += mins;
m_second += secs;
m_msec += msecs;
rollOver();
}
Month Date::month() const {
Day d = dayOfYear(); // dayOfYear is 1 based
Integer m = d/30 + 1;
bool leap = isLeap(year());
while (d <= monthOffset(Month(m),leap))
--m;
while (d > monthOffset(Month(m+1),leap))
++m;
return Month(m);
}
inline BTime dateTimeToBTime(QDateTime dateTime)
{
auto date = dateTime.date();
auto time = dateTime.time();
BTime btime;
btime.year = date.year();
btime.day = date.dayOfYear();
btime.hour = time.hour();
btime.min = time.minute();
btime.sec = time.second();
btime.fract = time.msec();
return btime;
}
/***********************************************************************
* Function: daysBetween()
* Description: Returns the number of days between two given dates.
***********************************************************************/
int daysBetween( struct date *firstDate, struct date *secondDate )
{
int numOfDays;
int dayNum1, dayNum2;
/*
* Use 'dayOfYear()' function to calculate
* the number of days between the two date arguments.
*/
dayNum1 = dayOfYear( firstDate );
dayNum2 = dayOfYear( secondDate );
/*
* Validate both arguments.
*/
if ((dayNum1 == -1) || (dayNum2 == -1))
numOfDays = -1;
else
numOfDays = abs( dayNum2 - dayNum1 );
return numOfDays;
}
int main(void)
{
while (1)
{
int day=0;
int month = 0;
int year = 0;
scanf("%d", &day);
scanf("%d", &month);
scanf("%d", &year);
printf("Number of Days: %d\n", dayOfYear(day, month, year));
}
}
int DateTime::week(int firstDayOfWeek) const
{
poco_assert (firstDayOfWeek >= 0 && firstDayOfWeek <= 6);
/// find the first firstDayOfWeek.
int baseDay = 1;
while (DateTime(_year, 1, baseDay).dayOfWeek() != firstDayOfWeek) ++baseDay;
int doy = dayOfYear();
int offs = baseDay <= 4 ? 0 : 1;
if (doy < baseDay)
return offs;
else
return (doy - baseDay)/7 + 1 + offs;
}
unsigned int CDateTime::timestamp(int year, unsigned int month, unsigned int day, unsigned int hour, unsigned int minute, unsigned int second)
{
// Date incorrectes
if (year < 1970 || !isValid(year, month, day, hour, minute, second))
{
return static_cast<unsigned int>(-1);
}
unsigned int n = dayOfYear(year, month, day) - 1;
for (int a = 1970 ; a < year ; ++a)
{
n += (isLeapYear(a) ? 366 : 365);
}
return (n * 86400 + 3600 * hour + 60 * minute + second);
}
/** week starting on monday, 0 based. */
int16 TimeStamp::dayOfWeek() const
{
// consider 1700 the epoch
if ( m_year < 1700 )
return -1;
// compute days since epoch.
int32 nyears = m_year - 1700;
int32 nday = nyears * 365;
// add leap years (up to the previous year. This year is computed in dayOfYear()
if( m_year > 1700 )
nday += ((nyears-1) / 4) - ((nyears-1) / 100) + ((nyears-1) / 400);
// add day of the year.
nday += dayOfYear();
// add epoch (1/1/1700 was a Friday)
nday += 4;
nday %= 7;
return nday;
}
unsigned int CDateTime::weekOfYear(int year, unsigned int month, unsigned int day)
{
if (!isValid(year, month, day))
{
return 0;
}
CDateTime d1(year, month, day);
int a = dayOfWeek(year, month, day);
d1.addDays(4 - a); // Jeudi de cette semaine
int y1 = d1.getYear();
CDateTime d2(y1, 1, 4);
int b = dayOfWeek(y1, 1, 4);
d2.addDays(1 - b); // Lundi de cette semaine
int y2 = d2.getYear();
if (y1 < y2)
{
unsigned int a1 = (isLeapYear(y1) ? 366 : 365) - dayOfYear(y1, d1.getMonth(), d1.getDay());
unsigned int a2 = dayOfYear(y2, d2.getMonth(), d2.getDay());
return (1 + (a1 + a2) / 7);
}
else if (y1 > y2)
{
unsigned int a1 = dayOfYear(y1, d1.getMonth(), d1.getDay());
unsigned int a2 = (isLeapYear(y2) ? 366 : 365) - dayOfYear(y2, d2.getMonth(), d2.getDay());
return (1 + (a1 + a2) / 7);
}
else
{
unsigned int a1 = dayOfYear(y1, d1.getMonth(), d1.getDay());
unsigned int a2 = dayOfYear(y2, d2.getMonth(), d2.getDay());
return (1 + (a2 > a1 ? a2 - a1 : a1 - a2) / 7);
}
}
std::string Timestamp::format(const std::string& format) const
{
char buf[20];
uint16_t year, month, day, hour, minute, second, millisecond;
calcFromJulDay(_time, year, month, day, hour, minute, second, millisecond);
FormatContext context(format);
std::stringstream ss;
while(!context.ready()) {
char c = context.nextFormatSpecifier();
switch(c) {
case '%': {
char n = context.nextFormatSpecifier();
switch(n) {
case 'Y':
ss << std::setw(4) << std::setfill('0') << itoa(year, buf);
break;
case 'm':
ss << std::setw(2) << std::setfill('0') << itoa(month, buf);
break;
case 'd':
ss << std::setw(2) << std::setfill('0') << itoa(day, buf);
break;
case 'F': {
if(year > 1000) {
itoa(year, buf);
} else if(year > 100) {
buf[0] = '0';
itoa(year, &buf[1]);
} else if(year > 10) {
buf[0] = '0';
buf[1] = '0';
itoa(year, &buf[2]);
} else {
buf[0] = '0';
buf[1] = '0';
buf[2] = '0';
itoa(year, &buf[3]);
}
buf[4] = '-';
if(month > 9) {
itoa(month, &buf[5]);
} else {
buf[5] = '0';
itoa(month, &buf[6]);
}
buf[7] = '-';
if(day > 9) {
itoa(day, &buf[8]);
} else {
buf[8] = '0';
itoa(day, &buf[9]);
}
buf[10] = 'T';
if(hour > 9) {
itoa(hour, &buf[11]);
} else {
buf[11] = '0';
itoa(hour, &buf[12]);
}
buf[13] = ':';
if(minute > 9) {
itoa(minute, &buf[14]);
} else {
buf[14] = '0';
itoa(minute, &buf[15]);
}
buf[16] = ':';
if(second > 9) {
itoa(second, &buf[17]);
} else {
buf[17] = '0';
itoa(second, &buf[18]);
}
ss << buf;
break;
}
case 'j':
ss << std::setw(3) << std::setfill('0') << itoa(dayOfYear(), buf);
break;
case 'U':
ss << std::setw(2) << std::setfill('0') << itoa(weekOfYear(), buf);
break;
case 'w':
ss << itoa(dayOfWeek(), buf);
break;
case 'H':
ss << std::setw(2) << std::setfill('0') << itoa(hour, buf);
break;
case 'M':
ss << std::setw(2) << std::setfill('0') << itoa(minute, buf);
break;
case 'S':
ss << std::setw(2) << std::setfill('0') << itoa(second, buf);
break;
case 's':
ss << std::setw(3) << std::setfill('0') << itoa(millisecond, buf);
break;
}
break;
}
default:
ss << c;
}
}
return ss.str();
}
inline Day Date::dayOfMonth() const {
return dayOfYear() - monthOffset(month(),isLeap(year()));
}
/***********************************************************************
* Function: calendar()
* Description: Illustrates some general calendar functions.
************************************************************************/
long calendar( long callParm )
{
volatile char *temp;
volatile short days;
volatile int status;
volatile int dayNumber, numOfDays;
struct date firstDate, secondDate; /* Local month date structures */
struct date lclMonthDate;
/*
* Initialize the year1997 structure
*/
year1997.yearName = "1997";
year1997.month = &MONTH[0];
year1997.initId = INITIALIZED;
/*
* Setup 'temp' and 'days', useful to use as watch-window variables while stepping through the
* next set of instructions to illustrate how the structure is arranged.
*/
temp = year1997.yearName;
temp = year1997.month[0].monthName;
days = year1997.month[0].numOfDays;
temp = year1997.month[0].startDay;
temp = year1997.month[4].monthName;
days = year1997.month[4].numOfDays;
temp = year1997.month[4].startDay;
temp = year1997.month[10].monthName;
days = year1997.month[10].numOfDays;
temp = year1997.month[10].startDay;
/*
* Given a specific date, determine the 'day of the year'.
* For example, January 1, is day number one, December 31 is
* day 365 in 1997. If dayOfYear() returns a -1, then the year1997 structure
* was never properly initialized, that is, an error condition.
*/
glbMonthDate.monthName = "January";
glbMonthDate.date = 15;
dayNumber = dayOfYear( &glbMonthDate );
glbMonthDate.monthName = "October";
glbMonthDate.date = 13;
dayNumber = dayOfYear( &glbMonthDate );
glbMonthDate.monthName = "WINDober"; /* error case */
glbMonthDate.date = 30;
dayNumber = dayOfYear( &glbMonthDate );
/*
* Do the inverse operation of the operation above, that is,
* given a specific 'day number', calculate the month and day.
* For example, for day number 16, dateForDayNum returns
* January, 16th. This function returns a 'status' that indicates
* if the date argument is legal. The month information is returned
* via the lclMonthDate argument.
*/
dayNumber = 134; /* getting date for a legal day number */
status = dateForDayNum( dayNumber, &lclMonthDate );
/*
* The locals window view of 'status' shows a valid dayNumber arugmnet.
* Also, either view the contents of lclMonthDate or view
* the temp and days variables below.
*/
temp = lclMonthDate.monthName;
days = lclMonthDate.date;
/*
* Try an invalid day number and check status in the local window.
*/
dayNumber = 366;
status = dateForDayNum( dayNumber, &lclMonthDate );
/*
* Given two dates, calculate the number of days between them,
* excluding the boundary dates. For example, the number of days
* between January 1 and January 3, is one day, excluding the boundary dates.
*/
firstDate.monthName = "June";
firstDate.date = 17;
secondDate.monthName = "September";
secondDate.date = 23;
numOfDays = daysBetween( &firstDate, &secondDate );
return ((long) *temp);
}
unsigned MSMBSDate::weekOfYear(void) const
{ return (dayOfYear()/7)+1; }
void testDayOfYear(int day, int month, int year)
{
printf ("%d/%d/%d => %d\n", day, month, year,
dayOfYear(day, month, year));
}
// Format:
// '%a' : Weekday abbreviated name (Sun, Mon, ..., Sat)
// '%A' : Weekday full name (Sunday, Monday, ..., Saturday)
// '%w' : Numeric representation of the day of the week (0 = Sunday, 6 = Saturday)
// '%d' : Day of the month, 2 digits with leading zeros (01..31)
// '%D' : Day of the month without leading zeros (1..31)
// '%b' : Month abbreviated name (Jan, Feb, ..., Dec)
// '%B' : Month full name (January, February, ..., December)
// '%m' : Numeric representation of a month, with leading zeros (01..12)
// '%y' : Two digits year (99, 00...)
// '%Y' : A full numeric representation of a year, 4 digits (1999, 2000...)
// '%H' : 24-hour format of an hour with leading zeros (00..23)
// '%I' : Hour (12-hour clock) as a zero-padded decimal number (01, 02, ..., 12)
// '%p' : AM or PM
// '%M' : Minutes with leading zeros (00..59)
// '%S' : Seconds, with leading zeros (00..59)
// '%z' : UTC offset in the form +HHMM or -HHMM (+0000, -0400, +1030, ...)
// '%j' : Day of the year as a zero-padded decimal number (001, 002, ..., 366)
// '%c' : Date and time representation (Tue Aug 16 2015 21:30:00 +0000)
// Returns resulting string length without trailing zero.
// Example:
// char str[50];
// datetime.format(str, "%a %b %d %Y %H:%M:%S %z"); // equivalent to "%c"
uint16_t MTD_FLASHMEM DateTime::format(char* outbuf, char const* formatstr)
{
static char const* DAYS[] = {FSTR("Sunday"), FSTR("Monday"), FSTR("Tuesday"), FSTR("Wednesday"), FSTR("Thursday"), FSTR("Friday"), FSTR("Saturday")};
static char const* MONTHS[] = {FSTR("January"), FSTR("February"), FSTR("March"), FSTR("April"), FSTR("May"), FSTR("June"), FSTR("July"), FSTR("August"), FSTR("September"), FSTR("October"), FSTR("November"), FSTR("December")};
char* outbuf_start = outbuf;
for (; getChar(formatstr); ++formatstr)
{
if (getChar(formatstr) == '%')
{
++formatstr;
switch (getChar(formatstr))
{
case '%':
*outbuf++ = '%';
break;
case 'a':
outbuf += sprintf(outbuf, FSTR("%.3s"), DAYS[dayOfWeek()]);
break;
case 'A':
outbuf += sprintf(outbuf, FSTR("%s"), DAYS[dayOfWeek()]);
break;
case 'w':
outbuf += sprintf(outbuf, FSTR("%d"), dayOfWeek());
break;
case 'd':
outbuf += sprintf(outbuf, FSTR("%02d"), day);
break;
case 'D':
outbuf += sprintf(outbuf, FSTR("%d"), day);
break;
case 'b':
outbuf += sprintf(outbuf, FSTR("%.3s"), MONTHS[month - 1]);
break;
case 'B':
outbuf += sprintf(outbuf, FSTR("%s"), MONTHS[month - 1]);
break;
case 'm':
outbuf += sprintf(outbuf, FSTR("%02d"), month);
break;
case 'y':
outbuf += sprintf(outbuf, FSTR("%02d"), year % 100);
break;
case 'Y':
outbuf += sprintf(outbuf, FSTR("%d"), year);
break;
case 'H':
outbuf += sprintf(outbuf, FSTR("%02d"), hours);
break;
case 'I':
outbuf += sprintf(outbuf, FSTR("%02d"), (hours == 0 || hours == 12)? 12 : (hours % 12));
break;
case 'p':
outbuf += sprintf(outbuf, FSTR("%s"), hours > 11? FSTR("PM") : FSTR("AM"));
break;
case 'M':
outbuf += sprintf(outbuf, FSTR("%02d"), minutes);
break;
case 'S':
outbuf += sprintf(outbuf, FSTR("%02d"), seconds);
break;
case 'z':
outbuf += sprintf(outbuf, FSTR("%+03d%02d"), timezoneHours, timezoneMinutes);
break;
case 'j':
outbuf += sprintf(outbuf, FSTR("%03d"), dayOfYear());
break;
case 'c':
outbuf += format(outbuf, FSTR("%a %b %d %Y %H:%M:%S %z"));
break;
}
}
else
*outbuf++ = getChar(formatstr);
}
*outbuf = 0;
return outbuf - outbuf_start;
}
RTCx::time_t RTCx::mktime(struct tm *tm)
{
// Normalise the time
tm->tm_min += (tm->tm_sec / 60);
tm->tm_sec = (tm->tm_sec % 60);
if (tm->tm_sec < 0) {
tm->tm_sec += 60;
--(tm->tm_min);
}
tm->tm_hour += (tm->tm_min / 60);
tm->tm_min = (tm->tm_min % 60);
if (tm->tm_min < 0) {
tm->tm_min += 60;
--(tm->tm_hour);
}
tm->tm_mday += (tm->tm_hour / 24);
tm->tm_hour = (tm->tm_hour % 24);
if (tm->tm_hour < 0) {
tm->tm_hour += 24;
--(tm->tm_mday);
}
if (tm->tm_mon < 0 || tm->tm_mon > 11 || tm->tm_mday < 1)
return -1;
// Normalise the date
while (true) {
uint8_t dim = daysInMonth(tm->tm_year+1900, tm->tm_mon+1);
if (tm->tm_mday > dim) {
tm->tm_mday -= dim;
++(tm->tm_mon);
if (tm->tm_mon == 12) {
tm->tm_mon = 0;
++(tm->tm_year);
}
continue;
}
if (tm->tm_mday < 1) {
--(tm->tm_mon);
if (tm->tm_mon == -1) {
tm->tm_mon = 11;
--(tm->tm_year);
}
uint8_t dim = daysInMonth(tm->tm_year+1900, tm->tm_mon+1);
tm->tm_mday += dim;
continue;
}
break;
}
// Compute day of year
tm->tm_yday = dayOfYear(tm->tm_year+1900, tm->tm_mon+1, tm->tm_mday) - 1;
uint8_t yearsSinceEpoch = tm->tm_year + 1900 - RTCX_EPOCH;
time_t t = (yearsSinceEpoch * 365 * SECS_PER_DAY) // Whole years, leap days excluded
+ ((yearsSinceEpoch / 4) * SECS_PER_DAY) // Leap days in whole 4 year period
// Leap days in partial 4 year period. Count only if in last year
+ ((yearsSinceEpoch % 4) == 3 ? SECS_PER_DAY : 0L)
+ (tm->tm_yday * SECS_PER_DAY) // Whole days in current year
+ (tm->tm_hour * 3600L)
+ (tm->tm_min * (uint16_t)60)
+ tm->tm_sec;
// Compute day of week
uint32_t daysSinceEpoch = (t / SECS_PER_DAY);
tm->tm_wday = (daysSinceEpoch + 4) % 7; // 1970-01-01 was Thursday (day 4)
return t;
}
CString CDateTime::toString(const CString& format) const
{
if (isNull())
{
return CString();
}
CString str;
bool special = false;
const unsigned int len = format.getSize();
for (unsigned int i = 0 ; i < len ; ++i)
{
if (format[i] == CChar('%'))
{
special = true;
}
else if (special)
{
switch (format[i].toLatin1())
{
default:
str += format[i];
break;
case 'a':
str += (m_hour < 12 ? "am" : "pm");
break;
case 'A':
str += (m_hour < 12 ? "AM" : "PM");
break;
case 'd':
if (m_day < 10)
str += '0';
str += CString::fromNumber(m_day);
break;
case 'D':
str += shortDayName(dayOfWeek(m_year, m_month, m_day));
break;
case 'F':
str += longMonthName(m_month);
break;
case 'g':
if (m_hour == 0)
{
str += "12";
}
else if (m_hour < 13)
{
str += CString::fromNumber(m_hour);
}
else
{
str += CString::fromNumber(m_hour - 12);
}
break;
case 'G':
str += CString::fromNumber(m_hour);
break;
case 'h':
if (m_hour == 0)
{
str += "12";
}
else if (m_hour < 13)
{
if (m_hour < 10)
{
str += '0';
}
str += CString::fromNumber(m_hour);
}
else
{
if (m_hour < 22)
{
str += '0';
}
str += CString::fromNumber(m_hour - 12);
}
break;
case 'H':
if (m_hour < 10)
{
str += '0';
}
str += CString::fromNumber(m_hour);
break;
case 'i':
if (m_minute < 10)
{
str += '0';
}
str += CString::fromNumber(m_minute);
break;
case 'j':
str += CString::fromNumber(m_day);
break;
case 'l':
str += longDayName(dayOfWeek(m_year, m_month, m_day));
break;
case 'L':
str += (isLeapYear(m_year) ? '1' : '0');
break;
case 'm':
if (m_month < 10)
{
str += '0';
}
str += CString::fromNumber(m_month);
break;
case 'M':
str += shortMonthName(m_month);
break;
case 'n':
str += CString::fromNumber(m_month);
break;
case 'N':
str += dayOfWeek(m_year, m_month, m_day);
break;
case 's':
if (m_second < 10)
{
str += '0';
}
str += CString::fromNumber(m_second);
break;
case 't':
str += CString::fromNumber(daysInMonth(m_month, m_year));
break;
case 'U':
str += CString::fromNumber(timestamp(m_year, m_month, m_day, m_hour, m_minute, m_second));
break;
case 'W':
str += CString::fromNumber(weekOfYear(m_year, m_month, m_day));
break;
case 'y':
if (m_year < 0)
{
str += CString::fromNumber(m_year);
}
else
{
unsigned int tmp = m_year % 100;
if (tmp < 10)
{
str += "0";
}
str += CString::fromNumber(tmp);
}
break;
case 'Y':
if (m_year < 0)
{
str += CString::fromNumber(m_year);
}
else
{
unsigned int tmp = m_year % 10000;
if (tmp < 10)
str += "000";
if (tmp < 100)
str += "00";
if (tmp < 1000)
str += "000";
str += CString::fromNumber(tmp);
}
break;
case 'z':
str += dayOfYear(m_year, m_month, m_day);
break;
}
special = false;
}
else
{
str += format[i];
}
}
return str;
}
