开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 网格计算 > 查看源码
TimeEx.cpp
资源名称：fmailstable.rar　[点击查看]
上传用户：maryhy001
上传日期：2007-05-02
资源大小：2317k
文件大小：17k
源码类别：

网格计算

开发平台：

Visual C++

TimeEx.cpp：源码内容
  1. #include "stdafx.h"
  2. #include ".TimeEx.h"
  4. #define MIN_DATE (-657434L)  // about year 100
  5. #define MAX_DATE 2958465L    // about year 9999
  8. // Half a second, expressed in days
  9. #define HALF_SECOND (1.0/172800.0)
  11. // One-based array of days in year at month start
  12. static int rgMonthDays[13] = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365};
  15. //get current date
  16. void CDateEx::NowDate()
  17. {
  18. SYSTEMTIME systime;
  19. memset(&systime, 0x0, sizeof(systime));
  20. GetLocalTime(&systime);
  21. this->m_unYear = systime.wYear;
  22. this->m_unMonth = systime.wMonth;
  23. this->m_unDay = systime.wDay;
  24. }
  26. //get the date string text
  27. void CDateEx::AsDString(LPSTR lpzDate, bool bFixedFmt)
  28. {
  29. if(NULL == lpzDate){
  30. throw "param is null, invalid memory!!!";
  31. }
  32. memset(lpzDate, 0x0, MAX_DATE_SIZE);
  33. if(bFixedFmt){
  34. sprintf(lpzDate, "%04d-%02d-%02d", m_unYear, m_unMonth, m_unDay);
  35. }
  36. else{
  37. sprintf(lpzDate, "%d-%d-%d", m_unYear, m_unMonth, m_unDay);
  38. }
  39. return ;
  40. }
  42. //operator "="
  43. CDateEx CDateEx::operator=(CDateEx &dtDate)
  44. {
  45. this->m_unYear = dtDate.Year();
  46. this->m_unMonth = dtDate.Month();
  47. this->m_unDay = dtDate.Day();
  48. return (*this);
  49. }
  51. //operator "=="
  52. bool CDateEx::operator==(CDateEx &dtDate)
  53. {
  54. return (this->m_unYear == dtDate.Year() &&
  55. this->m_unMonth == dtDate.Month() &&
  56. this->m_unDay == dtDate.Day());
  57. }
  59. //operator "!="
  60. bool CDateEx::operator!=(CDateEx &dtDate)
  61. {
  62. return !(*this==dtDate);
  63. }
  65. //operator ">"
  66. bool CDateEx::operator>(CDateEx &dtDate)
  67. {
  68. if( this->m_unYear >= dtDate.Year() &&
  69. this->m_unMonth >= dtDate.Month() &&
  70. this->m_unDay > dtDate.Day())
  71. return true;
  72. else
  73. return false;
  74. }
  76. //operator ">="
  77. bool CDateEx::operator>=(CDateEx &dtDate)
  78. {
  79. if(*this>dtDate || *this==dtDate){
  80. return true;
  81. }
  82. else{
  83. return false;
  84. }
  85. }
  87. //operator "<"
  88. bool CDateEx::operator<(CDateEx &dtDate)
  89. {
  90. return !(*this >= dtDate);
  91. }
  93. //operator "<="
  94. bool CDateEx::operator<=(CDateEx &dtDate)
  95. {
  96. return (*this < dtDate || *this == dtDate);
  97. }
  99. //operator "-"
  100. int CDateEx::operator-(CDateEx &dtDate)
  101. {
  102. if(*this==dtDate){
  103. return 0;
  104. }
  106. //get the begin and end date
  107. CDateEx dtBegin, dtEnd;
  108. if(*this > dtDate){
  109. dtBegin = dtDate;
  110. dtEnd = *this;
  111. }
  112. else{
  113. dtBegin = *this;
  114. dtEnd = dtDate;
  115. }
  116. //get the days
  117. int nret = ( dtEnd.Year() - dtBegin.Year() ) * 365;
  118. for(int i = dtBegin.Month(); i < dtEnd.Month(); ++i){
  119. switch(i) {
  120. case 1: case 3: case 5: case 7:
  121. case 8: case 10: case 12:
  122. nret += 31;
  123. break;
  124. case 2:
  125. nret += this->IsLeapYear()?29:28;
  126. break;
  127. default:
  128. nret += 30;
  129. break;
  130. }
  131. }
  132. nret += (dtEnd.Day() - dtBegin.Day());
  134. return nret;
  135. }
  137. //operator "++"
  138. CDateEx CDateEx::operator++(int)
  139. {
  140. bool bnextMonth = false;
  141. if( IsLeapYear() ){
  142. if(m_unMonth == 2 && 29 == m_unDay){
  143. bnextMonth = true;
  144. }
  145. }
  146. else{
  147. if(m_unMonth == 2 && 28 == m_unDay){
  148. bnextMonth = true;
  149. }
  150. }
  151. if(bnextMonth){
  152. goto NextMonth;
  153. }
  154. else{
  155. if( (IsLargeMonth(m_unMonth) && 31 == m_unDay) ||
  156. (!IsLargeMonth(m_unMonth) && 30 == m_unDay) ){
  157. bnextMonth = true;
  158. }
  159. }
  160. if(bnextMonth){
  161. goto NextMonth;
  162. }
  163. else{
  164. ++m_unDay;
  165. goto Over;
  166. }
  167. NextMonth:
  168. {
  169. //is end of the year
  170. if(12 == m_unMonth){
  171. m_unMonth = 1;
  172. ++m_unYear;
  173. }
  174. else{
  175. ++m_unMonth;
  176. }
  177. m_unDay = 1;
  178. }
  179. Over:
  180. return (*this);
  181. }
  183. //operator "--"
  184. CDateEx CDateEx::operator--(int)
  185. {
  186. bool bpriorMonth = false;
  187. if( IsLeapYear() ){
  188. if(m_unMonth == 3 && 1 == m_unDay){
  189. m_unDay = 29;
  190. bpriorMonth = true;
  191. }
  192. }
  193. else{
  194. if(m_unMonth == 3 && 1 == m_unDay){
  195. m_unDay = 28;
  196. bpriorMonth = true;
  197. }
  198. }
  199. if(bpriorMonth){
  200. goto PriorMonth;
  201. }
  202. else{
  203. if(IsLargeMonth(m_unMonth) && 1 == m_unDay){
  204. m_unDay = 31;
  205. bpriorMonth = true;
  206. }else if(!IsLargeMonth(m_unMonth) && 1 == m_unDay){
  207. m_unDay = 30;
  208. bpriorMonth = true;
  209. }
  210. }
  211. if(bpriorMonth){
  212. goto PriorMonth;
  213. }
  214. else{
  215. --m_unDay;
  216. goto Over;
  217. }
  218. PriorMonth:
  219. {
  220. //is end of the year
  221. if(1 == m_unMonth){
  222. m_unMonth = 12;
  223. --m_unYear;
  224. }
  225. else{
  226. --m_unMonth;
  227. }
  228. }
  229. Over:
  230. return (*this);
  231. }
  233. //#########################################################################
  235. //get current date
  236. void CTimeEx::NowTime()
  237. {
  238. SYSTEMTIME systime;
  239. memset(&systime, 0x0, sizeof(systime));
  240. GetLocalTime(&systime);
  241. this->m_unHour = systime.wHour;
  242. this->m_unMinu = systime.wMinute;
  243. this->m_unSecn = systime.wSecond;
  244. }
  246. //get the time string text
  247. void CTimeEx::AsTString(LPSTR lpzTime, bool bFixedFmt)
  248. {
  249. if(NULL == lpzTime){
  250. throw "param is null, invalid memory!!!";
  251. }
  252. memset(lpzTime, 0x0, MAX_TIME_SIZE);
  253. if(bFixedFmt){
  254. sprintf(lpzTime, "%04d-%02d-%02d", m_unHour, m_unMinu, m_unSecn);
  255. }
  256. else{
  257. sprintf(lpzTime, "%d-%d-%d", m_unHour, m_unMinu, m_unSecn);
  258. }
  259. return ;
  260. }
  262. //operator "="
  263. CTimeEx CTimeEx::operator=(CTimeEx &dtTime)
  264. {
  265. this->m_unHour = dtTime.Hour();
  266. this->m_unMinu = dtTime.Minute();
  267. this->m_unSecn = dtTime.Second();
  269. return (*this);
  270. }
  272. //operator "=="
  273. bool CTimeEx::operator==(CTimeEx &dtTime)
  274. {
  275. if( this->m_unHour == dtTime.Hour() &&
  276. this->m_unMinu == dtTime.Minute() &&
  277. this->m_unSecn == dtTime.Second())
  278. return true;
  279. else
  280. return false;
  281. }
  283. //operator "!="
  284. bool CTimeEx::operator!=(CTimeEx &dtTime)
  285. {
  286. return !(*this==dtTime);
  287. }
  289. //operator ">"
  290. bool CTimeEx::operator>(CTimeEx &dtTime)
  291. {
  292. if( this->m_unHour >= dtTime.Hour() &&
  293. this->m_unMinu >= dtTime.Minute() &&
  294. this->m_unSecn > dtTime.Second())
  295. return true;
  296. else
  297. return false;
  298. }
  300. //operator ">="
  301. bool CTimeEx::operator>=(CTimeEx &dtTime)
  302. {
  303. return (*this == dtTime || *this > dtTime);
  304. }
  306. //operator "<"
  307. bool CTimeEx::operator<(CTimeEx &dtTime)
  308. {
  309. return !(*this >= dtTime);
  310. }
  312. //operator "<="
  313. bool CTimeEx::operator<=(CTimeEx &dtTime)
  314. {
  315. return (*this == dtTime || *this < dtTime);
  316. }
  318. //operator "-"
  319. DWORD CTimeEx::operator-(CTimeEx &dtTime)
  320. {
  321. CTimeEx dtBegin,
  322. dtEnd;
  323. if(*this >= dtTime){
  324. dtBegin = dtTime;
  325. dtEnd = *this;
  326. }
  327. else{
  328. dtBegin = *this;
  329. dtEnd = dtTime;
  330. }
  331. //calc the seconds value
  332. DWORD dwret = (dtEnd.Hour() - dtBegin.Hour()) * 3600 ;
  333. dwret += (dtEnd.Minute() - dtBegin.Minute()) * 60;
  334. dwret += (dtEnd.Second() - dtBegin.Second());
  335. return dwret;
  336. }
  338. //operator "++"(add one second)
  339. CTimeEx CTimeEx::operator++(int)
  340. {
  341. if(59 == m_unSecn){
  342. m_unSecn = 0;
  343. if(59 == m_unMinu){
  344. m_unMinu = 0;
  345. if(23 == m_unHour){
  346. m_unHour = 0;
  347. }
  348. else{
  349. ++m_unHour;
  350. }
  351. }
  352. else{
  353. ++m_unMinu;
  354. }
  355. }
  356. else{
  357. ++m_unSecn;
  358. }
  359. return (*this);
  360. }
  362. //operator "--"(sub one second)
  363. CTimeEx CTimeEx::operator--(int)
  364. {
  365. if(0 == m_unSecn){
  366. m_unSecn = 59;
  367. if(0 == m_unMinu){
  368. m_unMinu = 59;
  369. if(0 == m_unHour){
  370. m_unHour = 23;
  371. }
  372. else{
  373. --m_unHour;
  374. }
  375. }
  376. else{
  377. --m_unMinu;
  378. }
  379. }
  380. else{
  381. --m_unSecn;
  382. }
  383. return (*this);
  384. }
  386. //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
  388. //constructor and destructor
  389. CDateTimeEx::CDateTimeEx()
  390. {
  391. this->Now();
  392. }
  394. //updown inherited static cast change
  395. CDateTimeEx::CDateTimeEx(CDateEx &dtDate)
  396. {
  397. this->m_unYear = dtDate.Year();
  398. this->m_unMonth = dtDate.Month();
  399. this->m_unDay = dtDate.Day();
  400. }
  401. CDateTimeEx::CDateTimeEx(CTimeEx &dtTime)
  402. {
  403. this->m_unHour = dtTime.Hour();
  404. this->m_unMinu = dtTime.Minute();
  405. this->m_unSecn = dtTime.Second();
  406. }
  408. //SYSTEMTIME change to CDateTimeEx
  409. CDateTimeEx::CDateTimeEx(const SYSTEMTIME stTime)
  410. {
  411. equalSysTime(stTime);
  412. }
  413. //FILETIME change to CDateTimeEx
  414. CDateTimeEx::CDateTimeEx(const FILETIME ftTime)
  415. {
  416. try{
  417. equalFileTime(ftTime);
  418. }
  419. catch(std::exception e){
  420. throw e.what();
  421. }
  422. }
  424. //DATE change to CDateTimeEx
  425. CDateTimeEx::CDateTimeEx(const DATE dtSrc)
  426. {
  427. struct tm tmDest;
  428. memset(&tmDest, 0x0, sizeof(tmDest));
  430. if( this->DTFromOleDate(dtSrc, tmDest) ){
  431. this->m_unYear = tmDest.tm_year;
  432. this->m_unMonth = tmDest.tm_mon + 1;
  433. this->m_unDay = tmDest.tm_mday;
  435. this->m_unHour = tmDest.tm_hour;
  436. this->m_unMinu = tmDest.tm_min;
  437. this->m_unSecn = tmDest.tm_sec;
  438. }
  439. }
  441. //"struct tm" change to CDateTimeEx
  442. CDateTimeEx::CDateTimeEx(struct tm &tmDest)
  443. {
  444. this->m_unYear = tmDest.tm_year;
  445. this->m_unMonth = tmDest.tm_mon + 1;
  446. this->m_unDay = tmDest.tm_mday;
  448. this->m_unHour = tmDest.tm_hour;
  449. this->m_unMinu = tmDest.tm_min;
  450. this->m_unSecn = tmDest.tm_sec;
  451. }
  454. //operator "=" --- system time
  455. CDateTimeEx& CDateTimeEx::operator=(const SYSTEMTIME stTime)
  456. {
  457. equalSysTime(stTime);
  458. return (*this);
  459. };
  461. //operator "=" --- file time
  462. CDateTimeEx& CDateTimeEx::operator=(const FILETIME ftTime)
  463. {
  464. try{
  465. equalFileTime(ftTime);
  466. }
  467. catch(std::exception e){
  468. throw e.what();
  469. }
  470. return (*this);
  471. }
  473. //get the now datetime info
  474. void CDateTimeEx::Now()
  475. {
  476. static_cast<CDateEx *>(this)->NowDate();
  477. static_cast<CTimeEx *>(this)->NowTime();
  478. }
  480. //get the datetime string text
  481. void CDateTimeEx::AsDTString(LPSTR lpzDateTime, bool bFixedFmt)
  482. {
  483. if(NULL == lpzDateTime){
  484. throw "param is null, invalid memory!!!";
  485. }
  486. memset(lpzDateTime, 0x0, MAX_DATE_SIZE + MAX_TIME_SIZE);
  487. if(bFixedFmt){
  488. sprintf(lpzDateTime, "%04d-%02d-%02d %02d:%02d:%02d", 
  489. m_unYear, m_unMonth, m_unDay,
  490. m_unHour, m_unMinu, m_unSecn);
  491. }
  492. else{
  493. sprintf(lpzDateTime, "%d-%d-%d %d:%d:%d", 
  494. m_unYear, m_unMonth, m_unDay,
  495. m_unHour, m_unMinu, m_unSecn);
  496. }
  497. return ;
  498. }
  500. void CDateTimeEx::equalSysTime(const SYSTEMTIME stTime)
  501. {
  502. this->m_unYear = stTime.wYear;
  503. this->m_unMonth = stTime.wMonth;
  504. this->m_unDay = stTime.wDay;
  505. this->m_unHour = stTime.wHour;
  506. this->m_unMinu = stTime.wMinute;
  507. this->m_unSecn = stTime.wSecond;
  508. }
  510. void CDateTimeEx::equalFileTime(const FILETIME ftTime)
  511. {
  512. FILETIME lftTime;
  513. if( 0 == FileTimeToLocalFileTime(&ftTime, &lftTime) ){
  514. throw "FileTimeToLocalFileTime function is failed...";
  515. }
  516. //////////////////////////////////////////////////////////
  517. WORD wDate, wTime;
  518. if( 0 == FileTimeToDosDateTime(&lftTime, &wDate, &wTime) ){
  519. throw "FileTimeToDosDateTime function is failed...";
  520. }
  521. SYSTEMTIME stTime;
  522. memset(&stTime, 0x0, sizeof(stTime));
  523. //get the date and time value
  524. stTime.wDay = (wDate & 0x001F);
  525. stTime.wMonth = (wDate & 0x01E0) >> 5;
  526. stTime.wYear = ( (wDate & 0xFE00) >>9 ) + 1980;
  528. stTime.wSecond = (wTime & 0x001E) * 2;
  529. stTime.wMinute = (wTime >> 5) & 0x003F;
  530. stTime.wHour = (wTime >> 11) & 0x001F;
  532. equalSysTime(stTime);
  533. }
  535. //get "struct tm" from DATE structor
  536. bool CDateTimeEx::DTFromOleDate(DATE dtSrc, struct tm& tmDest)
  537. {
  538. // The legal range does not actually span year 0 to 9999.
  539.     if (dtSrc > MAX_DATE || dtSrc < MIN_DATE) // about year 100 to about 9999
  540.         return false;
  541.     
  542.     long nDays; // Number of days since Dec. 30, 1899
  543.     long nDaysAbsolute; // Number of days since 1/1/0
  544.     long nSecsInDay;    // Time in seconds since midnight
  545.     long nMinutesInDay; // Minutes in day
  546.     
  547.     long n400Years;     // Number of 400 year increments since 1/1/0
  548.     long n400Century;   // Century within 400 year block (0,1,2 or 3)
  549.     long n4Years; // Number of 4 year increments since 1/1/0
  550.     long n4Day; // Day within 4 year block
  552.     // (0 is 1/1/yr1, 1460 is 12/31/yr4)
  553.     long n4Yr; // Year within 4 year block (0,1,2 or 3)
  554.     BOOL bLeap4 = TRUE; // TRUE if 4 year block includes leap year
  555.     
  556.     double dblDate = dtSrc; // tempory serial date
  557.     
  558.     // If a valid date, then this conversion should not overflow
  559.     nDays = (long)dblDate;
  560.     
  561.     // Round to the second
  562.     dblDate += ((dtSrc > 0.0) ? HALF_SECOND : -HALF_SECOND);
  563.     
  564.     nDaysAbsolute = (long)dblDate + 693959L; // Add days from 1/1/0 to 12/30/1899
  565.         
  566. dblDate = fabs(dblDate);
  567.     nSecsInDay = (long)((dblDate - floor(dblDate)) * 86400.0);
  568.     
  569.     // Calculate the day of week (sun=1, mon=2...)
  570.     //  -1 because 1/1/0 is Sat. +1 because we want 1-based
  571.     tmDest.tm_wday = (int)((nDaysAbsolute - 1) % 7L) + 1;
  572.     
  573.     // Leap years every 4 yrs except centuries not multiples of 400.
  574.     n400Years = (long)(nDaysAbsolute / 146097L);
  575.     
  576.     // Set nDaysAbsolute to day within 400-year block
  577.     nDaysAbsolute %= 146097L;
  578.     
  579.     // -1 because first century has extra day
  580.     n400Century = (long)((nDaysAbsolute - 1) / 36524L);
  581.     
  582.     // Non-leap century
  583.     if (n400Century != 0)
  584.     {
  585.          // Set nDaysAbsolute to day within century
  586.          nDaysAbsolute = (nDaysAbsolute - 1) % 36524L;
  587.         
  588.          // +1 because 1st 4 year increment has 1460 days
  589.          n4Years = (long)((nDaysAbsolute + 1) / 1461L);
  590.         
  591.          if (n4Years != 0)
  592.               n4Day = (long)((nDaysAbsolute + 1) % 1461L);
  593.          else
  594.          {
  595.               bLeap4 = FALSE;
  596.               n4Day = (long)nDaysAbsolute;
  597.          }
  598.     }
  599.     else
  600.     {
  601.          // Leap century - not special case!
  602.          n4Years = (long)(nDaysAbsolute / 1461L);
  603.          n4Day = (long)(nDaysAbsolute % 1461L);
  604.     }
  605.     
  606.     if (bLeap4)
  607.     {
  608.          // -1 because first year has 366 days
  609.          n4Yr = (n4Day - 1) / 365;
  610.         
  611.          if (n4Yr != 0)
  612.               n4Day = (n4Day - 1) % 365;
  613.     }
  614.     else
  615.     {
  616.          n4Yr = n4Day / 365;
  617.          n4Day %= 365;
  618.     }
  619.     
  620.     // n4Day is now 0-based day of year. Save 1-based day of year, year number
  621. tmDest.tm_yday = (int)n4Day + 1;
  622.     tmDest.tm_year = n400Years * 400 + n400Century * 100 + n4Years * 4 + n4Yr;
  623.     
  624.     // Handle leap year: before, on, and after Feb. 29.
  625.     if (n4Yr == 0 && bLeap4)
  626.     {
  627.          // Leap Year
  628.          if (n4Day == 59)
  629.          {
  630.               /* Feb. 29 */
  631.               tmDest.tm_mon = 2;
  632.               tmDest.tm_mday = 29;
  633.             
  634.               goto DoTime;
  635.          }
  636.         
  637.          // Pretend it's not a leap year for month/day comp.
  638.          if (n4Day >= 60)
  639.               --n4Day;
  640.     }
  641.     
  642.     // Make n4DaY a 1-based day of non-leap year and compute
  643.     // month/day for everything but Feb. 29.
  644.     ++n4Day;
  645.     
  646.     // Month number always >= n/32, so save some loop time */
  647.     for (tmDest.tm_mon = (n4Day >> 5) + 1;
  648. n4Day > rgMonthDays[tmDest.tm_mon]; tmDest.tm_mon++);
  649.     
  650.     tmDest.tm_mday = (int)(n4Day - rgMonthDays[tmDest.tm_mon-1]);
  651.     
  652. DoTime:
  653.     if (nSecsInDay == 0)
  654.          tmDest.tm_hour = tmDest.tm_min = tmDest.tm_sec = 0;
  655.     else
  656.     {
  657.          tmDest.tm_sec = (int)nSecsInDay % 60L;
  658.          nMinutesInDay = nSecsInDay / 60L;
  659.          tmDest.tm_min = (int)nMinutesInDay % 60;
  660.          tmDest.tm_hour = (int)nMinutesInDay / 60;
  661.     }
  662.     
  663.     return true;
  664. }
  665. //######################################################################
  666. bool CDateTimeEx::OleDateFromDT(WORD wYear, WORD wMonth, WORD wDay,
  667.    WORD wHour, WORD wMinute, WORD wSecond, DATE& dtDest)
  668. {
  669. // Validate year and month (ignore day of week and milliseconds)
  670.     if (wYear > 9999 || wMonth < 1 || wMonth > 12)
  671. return false;
  672.     
  673.     //  Check for leap year and set the number of days in the month
  674.     BOOL bLeapYear = ((wYear & 3) == 0) &&
  675. ((wYear % 100) != 0 || (wYear % 400) == 0);
  676.     
  677.     int nDaysInMonth =
  678. rgMonthDays[wMonth] - rgMonthDays[wMonth-1] +
  679. ((bLeapYear && wDay == 29 && wMonth == 2) ? 1 : 0);
  680.     
  681.     // Finish validating the date
  682.     if (wDay < 1 || wDay > nDaysInMonth ||
  683. wHour > 23 || wMinute > 59 ||
  684. wSecond > 59)
  685.     {
  686. return false;
  687.     }
  688.     
  689.     // Cache the date in days and time in fractional days
  690.     long nDate;
  691.     double dblTime;
  692.     
  693.     //It is a valid date; make Jan 1, 1AD be 1
  694.     nDate = wYear*365L + wYear/4 - wYear/100 + wYear/400 +
  695.         
  696. rgMonthDays[wMonth-1] + wDay;
  697.     
  698.     //  If leap year and it's before March, subtract 1:
  699.     if (wMonth <= 2 && bLeapYear)
  700. --nDate;
  701.     
  702.     //  Offset so that 12/30/1899 is 0
  703.     nDate -= 693959L;
  704.     
  705.     dblTime = (((long)wHour * 3600L) +  // hrs in seconds
  706. ((long)wMinute * 60L) +  // mins in seconds
  707. ((long)wSecond)) / 86400.;
  708.     
  709.     dtDest = (double) nDate + ((nDate >= 0) ? dblTime : -dblTime);
  710.     
  711.     return true;
  712. }
  714. //get OleDate
  715. bool CDateTimeEx::getOleDate(struct tm *tmTime)
  716. {
  717. if(NULL==tmTime){
  718. return false;
  719. }
  720. //start conversion
  721. DATE dtDest;
  722. memset(&dtDest, 0x0, sizeof(dtDest));
  723. if( !this->OleDateFromDT(this->Year(), this->Month(), this->Day(),
  724. this->Hour(), this->Minute(), this->Second(), dtDest) ){
  725. return false;
  726. }
  728. memset(tmTime, 0x0, sizeof(struct tm));
  729. if( !this->DTFromOleDate(dtDest, *tmTime) ){
  730. return false;
  731. }
  732. return true;
  733. };
  735. //day of week
  736. WEEKDAY CDateTimeEx::DayOfWeek()
  737. {
  738. struct tm tmTime;
  739. if( !this->getOleDate(&tmTime) ){
  740. return WD_ERROR;
  741. }
  742. else{
  743. switch(tmTime.tm_wday-1) {
  744. case 0:
  745. return WD_SUNDAY;
  746. break;
  748. case 1:
  749. return WD_MONDAY;
  750. break;
  752. case 2:
  753. return WD_TUESDAY;
  754. break;
  756. case 3:
  757. return WD_WEDNESDAY;
  758. break;
  760. case 4:
  761. return WD_THURSDAY;
  762. break;
  764. case 5:
  765. return WD_FRIDAY;
  766. break;
  768. case 6:
  769. return WD_SATURDAY;
  770. break;
  772. default:
  773. return WD_ERROR;
  774. break;
  775. }
  776. }
  777. }