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

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

网格计算

开发平台：

Visual C++

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