Zeit.cpp 43 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964
  1. #include "Zeit.h"
  2. #include <ctime>
  3. #include <time.h>
  4. #include "Text.h"
  5. #ifdef WIN32
  6. # include "Fenster.h"
  7. #else
  8. # include <string.h>
  9. # include <sys/time.h>
  10. #endif
  11. #ifdef WIN32
  12. # if defined(_MSC_VER) || defined(_MSC_EXTENSIONS)
  13. # define DELTA_EPOCH_IN_MICROSECS 11644473600000000Ui64
  14. # else
  15. # define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL
  16. # endif
  17. struct timeval
  18. {
  19. long tv_sec; // Sekunden seit dem 1.1.1970
  20. long tv_usec; // und Mikrosekunden
  21. };
  22. struct timezone
  23. {
  24. int tz_minuteswest; // minutes W of Greenwich
  25. int tz_dsttime; // type of dst correction
  26. };
  27. int gettimeofday(struct timeval* tv, struct timezone* tz)
  28. {
  29. FILETIME ft;
  30. unsigned __int64 tmpres = 0;
  31. static int tzflag;
  32. if (NULL != tv)
  33. {
  34. GetSystemTimeAsFileTime(&ft);
  35. tmpres |= ft.dwHighDateTime;
  36. tmpres <<= 32;
  37. tmpres |= ft.dwLowDateTime;
  38. // converting file time to unix epoch
  39. tmpres -= DELTA_EPOCH_IN_MICROSECS;
  40. tmpres /= 10; // convert into microseconds
  41. tv->tv_sec = (long)(tmpres / 1000000UL);
  42. tv->tv_usec = (long)(tmpres % 1000000UL);
  43. }
  44. if (NULL != tz)
  45. {
  46. if (!tzflag)
  47. {
  48. _tzset();
  49. ++tzflag;
  50. }
  51. _get_timezone((long*)&(tz->tz_minuteswest));
  52. tz->tz_minuteswest /= 60;
  53. _get_daylight(&(tz->tz_dsttime));
  54. }
  55. return 0;
  56. }
  57. #endif
  58. using namespace Framework;
  59. // Inhalt der Uhrzeit Klasse aus Zeit.h
  60. // Privat
  61. int Uhrzeit::update() // berechnet die neue Zeit
  62. {
  63. __int64 mins = sekunde / 60;
  64. minute = minute + mins;
  65. __int64 hours = (minute) / 60;
  66. stunde = stunde + hours;
  67. int days = (int)((stunde) / 24);
  68. sekunde = sekunde - (mins * 60);
  69. minute = minute - (hours * 60);
  70. stunde = stunde - (days * 24);
  71. while (sekunde < 0)
  72. {
  73. sekunde += 60;
  74. --minute;
  75. }
  76. while (minute < 0)
  77. {
  78. minute += 60;
  79. --stunde;
  80. }
  81. while (stunde < 0)
  82. {
  83. stunde += 24;
  84. --days;
  85. }
  86. return days;
  87. }
  88. Uhrzeit::Uhrzeit()
  89. : ReferenceCounter(),
  90. stunde(0),
  91. minute(0),
  92. sekunde(0)
  93. {}
  94. int Uhrzeit::setUhrzeit(Uhrzeit* zeit) // setzt die Uhrzeit
  95. {
  96. stunde = zeit->getStunde();
  97. minute = zeit->getMinute();
  98. sekunde = zeit->getSekunde();
  99. zeit->release();
  100. return update();
  101. }
  102. int Uhrzeit::setUhrzeit(int stunde, int minute, int sekunde)
  103. {
  104. this->stunde = stunde;
  105. this->minute = minute;
  106. this->sekunde = sekunde;
  107. return update();
  108. }
  109. int Uhrzeit::setUhrzeit(
  110. const char* format, const char* zeit) // format Beispiele: "H:i:s", "H-i-s"
  111. // (H=stunde,i=minute,s=sekunde)
  112. {
  113. int flen = textLength(format);
  114. char* ende = 0;
  115. for (const char* f = format; f < format + flen; ++f)
  116. {
  117. switch (*f)
  118. {
  119. case 'h':
  120. stunde = TextZuInt(zeit, &ende, 10);
  121. zeit = ende;
  122. ende = 0;
  123. break;
  124. case 'i':
  125. minute = TextZuInt(zeit, &ende, 10);
  126. zeit = ende;
  127. ende = 0;
  128. break;
  129. case 's':
  130. sekunde = TextZuInt(zeit, &ende, 10);
  131. zeit = ende;
  132. ende = 0;
  133. break;
  134. default:
  135. ++zeit;
  136. break;
  137. }
  138. }
  139. return update();
  140. }
  141. int Uhrzeit::setUhrzeit(const char* format, Text* zeit)
  142. {
  143. int ret = setUhrzeit(format, zeit->getText());
  144. zeit->release();
  145. return ret;
  146. }
  147. int Uhrzeit::setStunde(int stunde) // setzt die Stunde
  148. {
  149. this->stunde = stunde;
  150. return update();
  151. }
  152. int Uhrzeit::setMinute(int minute) // setzt die Minute
  153. {
  154. this->minute = minute;
  155. return update();
  156. }
  157. int Uhrzeit::setSekunde(int sekunde) // setzt die Sekunde
  158. {
  159. this->sekunde = sekunde;
  160. return update();
  161. }
  162. int Uhrzeit::plusUhrzeit(Uhrzeit* zeit) // addiert die zeiten
  163. {
  164. stunde += zeit->getStunde();
  165. minute += zeit->getMinute();
  166. sekunde += zeit->getSekunde();
  167. return update();
  168. }
  169. int Uhrzeit::plusUhrzeit(int stunde, int minute, int sekunde)
  170. {
  171. this->stunde += stunde;
  172. this->minute += minute;
  173. this->sekunde += sekunde;
  174. return update();
  175. }
  176. int Uhrzeit::plusUhrzeit(const char* format, const char* zeit)
  177. {
  178. int flen = textLength(format);
  179. char* ende = 0;
  180. for (const char* f = format; f < format + flen; ++f)
  181. {
  182. switch (*f)
  183. {
  184. case 'h':
  185. stunde += TextZuInt(zeit, &ende, 10);
  186. zeit = ende;
  187. ende = 0;
  188. break;
  189. case 'i':
  190. minute += TextZuInt(zeit, &ende, 10);
  191. zeit = ende;
  192. ende = 0;
  193. break;
  194. case 's':
  195. sekunde += TextZuInt(zeit, &ende, 10);
  196. zeit = ende;
  197. ende = 0;
  198. break;
  199. default:
  200. ++zeit;
  201. break;
  202. }
  203. }
  204. return update();
  205. }
  206. int Uhrzeit::plusUhrzeit(const char* format, Text* zeit)
  207. {
  208. int ret = plusUhrzeit(format, zeit->getText());
  209. zeit->release();
  210. return ret;
  211. }
  212. int Uhrzeit::plusStunde(__int64 stunde) // addiert stunde Stunden
  213. {
  214. this->stunde += stunde;
  215. return update();
  216. }
  217. int Uhrzeit::plusMinute(__int64 minute) // addiert minute Minuten
  218. {
  219. this->minute += minute;
  220. return update();
  221. }
  222. int Uhrzeit::plusSekunde(__int64 sekunde) // addiert sekunde Sekunden
  223. {
  224. this->sekunde += sekunde;
  225. return update();
  226. }
  227. int Uhrzeit::minusUhrzeit(Uhrzeit* zeit) // subtrahiert die zeiten
  228. {
  229. stunde -= zeit->getStunde();
  230. minute -= zeit->getMinute();
  231. sekunde -= zeit->getSekunde();
  232. zeit->release();
  233. return update();
  234. }
  235. int Uhrzeit::minusUhrzeit(int stunde, int minute, int sekunde)
  236. {
  237. this->stunde -= stunde;
  238. this->minute -= minute;
  239. this->sekunde -= sekunde;
  240. return update();
  241. }
  242. int Uhrzeit::minusUhrzeit(const char* format, const char* zeit)
  243. {
  244. int flen = textLength(format);
  245. char* ende = 0;
  246. for (const char* f = format; f < format + flen; ++f)
  247. {
  248. switch (*f)
  249. {
  250. case 'h':
  251. stunde -= TextZuInt(zeit, &ende, 10);
  252. zeit = ende;
  253. ende = 0;
  254. break;
  255. case 'i':
  256. minute -= TextZuInt(zeit, &ende, 10);
  257. zeit = ende;
  258. ende = 0;
  259. break;
  260. case 's':
  261. sekunde -= TextZuInt(zeit, &ende, 10);
  262. zeit = ende;
  263. ende = 0;
  264. break;
  265. default:
  266. ++zeit;
  267. break;
  268. }
  269. }
  270. return update();
  271. }
  272. int Uhrzeit::minusUhrzeit(const char* format, Text* zeit)
  273. {
  274. int ret = plusUhrzeit(format, zeit->getText());
  275. zeit->release();
  276. return ret;
  277. }
  278. int Uhrzeit::minusStunde(__int64 stunde) // subtrahiert stunde Stunden
  279. {
  280. this->stunde -= stunde;
  281. return update();
  282. }
  283. int Uhrzeit::minusMinute(__int64 minute) // subtrahiert minute Minuten
  284. {
  285. this->minute -= minute;
  286. return update();
  287. }
  288. int Uhrzeit::minusSekunde(__int64 sekunde) // subtrahiert sekunde Sekunden
  289. {
  290. this->sekunde -= sekunde;
  291. return update();
  292. }
  293. // constant
  294. int Uhrzeit::getStunde() const // gibt die Stunde zurück
  295. {
  296. return (int)stunde;
  297. }
  298. int Uhrzeit::getMinute() const // gibt die Minute zurück
  299. {
  300. return (int)minute;
  301. }
  302. int Uhrzeit::getSekunde() const // gibt die Sekunde zurück
  303. {
  304. return (int)sekunde;
  305. }
  306. Text* Uhrzeit::getUhrzeit(
  307. const char* format) const // gibt die Uhrzeit als Text formatiert zurück
  308. {
  309. Text* ret = new Text("");
  310. int flen = textLength(format);
  311. for (const char* f = format; f < format + flen; ++f)
  312. {
  313. switch (*f)
  314. {
  315. case 'h':
  316. ret->append(stunde);
  317. break;
  318. case 'i':
  319. ret->append(minute);
  320. break;
  321. case 's':
  322. ret->append(sekunde);
  323. break;
  324. default:
  325. ret->append(f, 1);
  326. break;
  327. }
  328. }
  329. return ret;
  330. }
  331. bool Uhrzeit::istGleich(
  332. Uhrzeit* zeit) const // prüft, ob die Uhrzeit gleich zeit ist
  333. {
  334. bool ret = stunde == zeit->getStunde() && minute == zeit->getMinute()
  335. && sekunde == zeit->getSekunde();
  336. zeit->release();
  337. return ret;
  338. }
  339. bool Uhrzeit::istGleich(const char* format, const char* zeit) const
  340. {
  341. int st = (int)stunde, min = (int)minute, sek = (int)sekunde;
  342. int flen = textLength(format);
  343. char* ende = 0;
  344. for (const char* f = format; f < format + flen; ++f)
  345. {
  346. switch (*f)
  347. {
  348. case 'h':
  349. st = TextZuInt(zeit, &ende, 10);
  350. zeit = ende;
  351. ende = 0;
  352. break;
  353. case 'i':
  354. min = TextZuInt(zeit, &ende, 10);
  355. zeit = ende;
  356. ende = 0;
  357. break;
  358. case 's':
  359. sek = TextZuInt(zeit, &ende, 10);
  360. zeit = ende;
  361. ende = 0;
  362. break;
  363. default:
  364. ++zeit;
  365. break;
  366. }
  367. }
  368. bool ret = stunde == st && minute == min && sekunde == sek;
  369. return ret;
  370. }
  371. bool Uhrzeit::istGleich(const char* format, Text* zeit) const
  372. {
  373. bool ret = istGleich(format, zeit->getText());
  374. zeit->release();
  375. return ret;
  376. }
  377. bool Uhrzeit::istGleich(int stunde, int minute, int sekunde) const
  378. {
  379. return this->stunde == stunde && this->minute == minute
  380. && this->sekunde == sekunde;
  381. }
  382. bool Uhrzeit::stundeGleich(
  383. int stunde) const // prüft, ob die Stunde gleich stunde ist
  384. {
  385. return this->stunde == stunde;
  386. }
  387. bool Uhrzeit::minuteGleich(
  388. int minute) const // prüft, ob die Minute gleich minute ist
  389. {
  390. return this->minute == minute;
  391. }
  392. bool Uhrzeit::sekundeGleich(
  393. int sekunde) const // prüft, ob die Sekunde gleich sekunde ist
  394. {
  395. return this->sekunde == sekunde;
  396. }
  397. bool Uhrzeit::istKleiner(
  398. Uhrzeit* zeit) const // prüft, ob die Zeit kleiner als zeit ist
  399. {
  400. bool ret
  401. = istKleiner(zeit->getStunde(), zeit->getMinute(), zeit->getSekunde());
  402. zeit->release();
  403. return ret;
  404. }
  405. bool Uhrzeit::istKleiner(int stunde, int minute, int sekunde) const
  406. {
  407. if (this->stunde < stunde)
  408. return 1;
  409. else if (this->stunde == stunde)
  410. {
  411. if (this->minute < minute)
  412. return 1;
  413. else if (this->minute == minute)
  414. {
  415. if (this->sekunde < sekunde)
  416. return 1;
  417. else if (this->sekunde == sekunde)
  418. return 0;
  419. else
  420. return 0;
  421. }
  422. else
  423. return 0;
  424. }
  425. else
  426. return 0;
  427. }
  428. bool Uhrzeit::istKleiner(const char* format, const char* zeit) const
  429. {
  430. int st = (int)stunde, min = (int)minute, sek = (int)sekunde;
  431. int flen = textLength(format);
  432. char* ende = 0;
  433. for (const char* f = format; f < format + flen; ++f)
  434. {
  435. switch (*f)
  436. {
  437. case 'h':
  438. st = TextZuInt(zeit, &ende, 10);
  439. zeit = ende;
  440. ende = 0;
  441. break;
  442. case 'i':
  443. min = TextZuInt(zeit, &ende, 10);
  444. zeit = ende;
  445. ende = 0;
  446. break;
  447. case 's':
  448. sek = TextZuInt(zeit, &ende, 10);
  449. zeit = ende;
  450. ende = 0;
  451. break;
  452. default:
  453. ++zeit;
  454. break;
  455. }
  456. }
  457. return istKleiner(st, min, sek);
  458. }
  459. bool Uhrzeit::istKleiner(const char* format, Text* zeit) const
  460. {
  461. bool ret = istKleiner(format, zeit->getText());
  462. zeit->release();
  463. return ret;
  464. }
  465. bool Uhrzeit::istLater(
  466. Uhrzeit* zeit) const // prüft, ob die Zeit größer als zeit ist
  467. {
  468. bool ret
  469. = istLater(zeit->getStunde(), zeit->getMinute(), zeit->getSekunde());
  470. zeit->release();
  471. return ret;
  472. }
  473. bool Uhrzeit::istLater(int stunde, int minute, int sekunde) const
  474. {
  475. if (this->stunde > stunde)
  476. return 1;
  477. else if (this->stunde == stunde)
  478. {
  479. if (this->minute > minute)
  480. return 1;
  481. else if (this->minute == minute)
  482. {
  483. if (this->sekunde > sekunde)
  484. return 1;
  485. else if (this->sekunde == sekunde)
  486. return 0;
  487. else
  488. return 0;
  489. }
  490. else
  491. return 0;
  492. }
  493. else
  494. return 0;
  495. }
  496. bool Uhrzeit::istLater(const char* format, const char* zeit) const
  497. {
  498. int st = (int)stunde, min = (int)minute, sek = (int)sekunde;
  499. int flen = textLength(format);
  500. char* ende = 0;
  501. for (const char* f = format; f < format + flen; ++f)
  502. {
  503. switch (*f)
  504. {
  505. case 'h':
  506. st = TextZuInt(zeit, &ende, 10);
  507. zeit = ende;
  508. ende = 0;
  509. break;
  510. case 'i':
  511. min = TextZuInt(zeit, &ende, 10);
  512. zeit = ende;
  513. ende = 0;
  514. break;
  515. case 's':
  516. sek = TextZuInt(zeit, &ende, 10);
  517. zeit = ende;
  518. ende = 0;
  519. break;
  520. default:
  521. ++zeit;
  522. break;
  523. }
  524. }
  525. return istLater(st, min, sek);
  526. }
  527. bool Uhrzeit::istLater(const char* format, Text* zeit) const
  528. {
  529. bool ret = istLater(format, zeit->getText());
  530. zeit->release();
  531. return ret;
  532. }
  533. // Inhalt der Datum Klasse aus Zeit.h
  534. // Privat
  535. void Datum::update() // berechnet die neue Zeit
  536. {
  537. while (monat > 12)
  538. {
  539. monat -= 12;
  540. ++jahr;
  541. }
  542. while (monat <= 0)
  543. {
  544. monat += 12;
  545. --jahr;
  546. }
  547. if (istSchaltjahr(jahr))
  548. maxTage[1] = 29;
  549. else
  550. maxTage[1] = 28;
  551. while (tag > maxTage[monat - 1])
  552. {
  553. tag -= maxTage[monat - 1];
  554. ++monat;
  555. if (monat > 12)
  556. {
  557. monat -= 12;
  558. ++jahr;
  559. if (istSchaltjahr(jahr))
  560. maxTage[1] = 29;
  561. else
  562. maxTage[1] = 28;
  563. }
  564. }
  565. while (tag <= 0)
  566. {
  567. tag += maxTage[(monat - 2 > 0 ? monat - 2 : 11)];
  568. --monat;
  569. if (monat <= 0)
  570. {
  571. monat += 12;
  572. --jahr;
  573. if (istSchaltjahr(jahr))
  574. maxTage[1] = 29;
  575. else
  576. maxTage[1] = 28;
  577. }
  578. }
  579. }
  580. // Konstruktor
  581. Datum::Datum()
  582. : ReferenceCounter(),
  583. jahr(0),
  584. monat(0),
  585. tag(0)
  586. {
  587. int maxT[] = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
  588. maxTage = new int[12];
  589. memcpy(maxTage, maxT, 12 * sizeof(int));
  590. }
  591. // Destruktor
  592. Datum::~Datum()
  593. {
  594. delete[] maxTage;
  595. }
  596. // nicht constant
  597. void Datum::setDatum(Datum* datum) // setzt das Datum
  598. {
  599. jahr = datum->getJahr();
  600. monat = datum->getMonat();
  601. tag = datum->getTag();
  602. datum->release();
  603. update();
  604. }
  605. void Datum::setDatum(int jahr, int monat, int tag)
  606. {
  607. this->jahr = jahr;
  608. this->monat = monat;
  609. this->tag = tag;
  610. update();
  611. }
  612. void Datum::setDatum(const char* format,
  613. const char*
  614. datum) // format Beispiele: "Y:m:d", "Y-m-d" (Y=Jahr,m=Monat,d=tag)
  615. {
  616. int flen = textLength(format);
  617. char* ende = 0;
  618. for (const char* f = format; f < format + flen; ++f)
  619. {
  620. switch (*f)
  621. {
  622. case 'y':
  623. jahr = TextZuInt(datum, &ende, 10);
  624. datum = ende;
  625. ende = 0;
  626. break;
  627. case 'm':
  628. monat = TextZuInt(datum, &ende, 10);
  629. datum = ende;
  630. ende = 0;
  631. break;
  632. case 'd':
  633. tag = TextZuInt(datum, &ende, 10);
  634. datum = ende;
  635. ende = 0;
  636. break;
  637. default:
  638. ++datum;
  639. break;
  640. }
  641. }
  642. update();
  643. }
  644. void Datum::setDatum(const char* format, Text* datum)
  645. {
  646. setDatum(format, datum->getText());
  647. datum->release();
  648. }
  649. void Datum::setJahr(int jahr) // setzt das Jahr
  650. {
  651. this->jahr = jahr;
  652. update();
  653. }
  654. void Datum::setMonat(int monat) // setzt den Monat
  655. {
  656. this->monat = monat;
  657. update();
  658. }
  659. void Datum::setTag(int tag) // setzt den Tag
  660. {
  661. this->tag = tag;
  662. update();
  663. }
  664. void Datum::plusDatum(Datum* datum) // addiert das datum
  665. {
  666. this->jahr += datum->getJahr();
  667. this->monat += datum->getMonat();
  668. this->tag += datum->getTag();
  669. datum->release();
  670. update();
  671. }
  672. void Datum::plusDatum(int jahr, int monat, int tag)
  673. {
  674. this->jahr += jahr;
  675. this->monat += monat;
  676. this->tag += tag;
  677. update();
  678. }
  679. void Datum::plusDatum(const char* format, const char* datum)
  680. {
  681. int flen = textLength(format);
  682. char* ende = 0;
  683. for (const char* f = format; f < format + flen; ++f)
  684. {
  685. switch (*f)
  686. {
  687. case 'y':
  688. jahr += TextZuInt(datum, &ende, 10);
  689. datum = ende;
  690. ende = 0;
  691. break;
  692. case 'm':
  693. monat += TextZuInt(datum, &ende, 10);
  694. datum = ende;
  695. ende = 0;
  696. break;
  697. case 'd':
  698. tag += TextZuInt(datum, &ende, 10);
  699. datum = ende;
  700. ende = 0;
  701. break;
  702. default:
  703. ++datum;
  704. break;
  705. }
  706. }
  707. update();
  708. }
  709. void Datum::plusDatum(const char* format, Text* datum)
  710. {
  711. plusDatum(format, datum->getText());
  712. datum->release();
  713. }
  714. void Datum::plusJahr(int jahr) // addiert jahr Jahre
  715. {
  716. this->jahr += jahr;
  717. update();
  718. }
  719. void Datum::plusMonat(int monat) // addiert monat Monate
  720. {
  721. this->monat = monat;
  722. update();
  723. }
  724. void Datum::plusTag(int tag) // addiert tag Tage
  725. {
  726. this->tag += tag;
  727. update();
  728. }
  729. void Datum::minusDatum(Datum* datum) // subtrahiert das datum
  730. {
  731. jahr -= datum->getJahr();
  732. monat -= datum->getMonat();
  733. tag -= datum->getTag();
  734. datum->release();
  735. update();
  736. }
  737. void Datum::minusDatum(int jahr, int monat, int tag)
  738. {
  739. this->jahr -= jahr;
  740. this->monat -= monat;
  741. this->tag -= tag;
  742. update();
  743. }
  744. void Datum::minusDatum(const char* format, const char* datum)
  745. {
  746. int flen = textLength(format);
  747. char* ende = 0;
  748. for (const char* f = format; f < format + flen; ++f)
  749. {
  750. switch (*f)
  751. {
  752. case 'y':
  753. jahr -= TextZuInt(datum, &ende, 10);
  754. datum = ende;
  755. ende = 0;
  756. break;
  757. case 'm':
  758. monat -= TextZuInt(datum, &ende, 10);
  759. datum = ende;
  760. ende = 0;
  761. break;
  762. case 'd':
  763. tag -= TextZuInt(datum, &ende, 10);
  764. datum = ende;
  765. ende = 0;
  766. break;
  767. default:
  768. ++datum;
  769. break;
  770. }
  771. }
  772. update();
  773. }
  774. void Datum::minusDatum(const char* format, Text* datum)
  775. {
  776. minusDatum(format, datum->getText());
  777. datum->release();
  778. }
  779. void Datum::minusJahr(int jahr) // subtrahiert jahr Jahre
  780. {
  781. this->jahr -= jahr;
  782. update();
  783. }
  784. void Datum::minusMonat(int monat) // subtrahiert monat Monate
  785. {
  786. this->monat -= monat;
  787. update();
  788. }
  789. void Datum::minusTag(int tag) // subtrahiert tag Tage
  790. {
  791. this->tag -= tag;
  792. update();
  793. }
  794. // constant
  795. int Datum::getJahr() const // gibt das Jahr zurück
  796. {
  797. return jahr;
  798. }
  799. int Datum::getMonat() const // gibt der Monat zurück
  800. {
  801. return monat;
  802. }
  803. int Datum::getTag() const // gibt der Tag zurück
  804. {
  805. return tag;
  806. }
  807. Text* Datum::getDatum(
  808. const char* format) const // gibt das Datum als Text formatiert zurück
  809. {
  810. Text* ret = new Text("");
  811. int flen = textLength(format);
  812. for (const char* f = format; f < format + flen; ++f)
  813. {
  814. switch (*f)
  815. {
  816. case 'y':
  817. ret->append(jahr);
  818. break;
  819. case 'm':
  820. ret->append(monat);
  821. break;
  822. case 'd':
  823. ret->append(tag);
  824. break;
  825. default:
  826. ret->append(f, 1);
  827. break;
  828. }
  829. }
  830. return ret;
  831. }
  832. bool Datum::istGleich(
  833. Datum* datum) const // prüft, ob das Datum gleich datum ist
  834. {
  835. bool ret = jahr == datum->getJahr() && monat == datum->getMonat()
  836. && tag == datum->getTag();
  837. datum->release();
  838. return ret;
  839. }
  840. bool Datum::istGleich(const char* format, const char* datum) const
  841. {
  842. int j = jahr, m = monat, t = tag;
  843. int flen = textLength(format);
  844. char* ende = 0;
  845. for (const char* f = format; f < format + flen; ++f)
  846. {
  847. switch (*f)
  848. {
  849. case 'y':
  850. j = TextZuInt(datum, &ende, 10);
  851. datum = ende;
  852. ende = 0;
  853. break;
  854. case 'm':
  855. m = TextZuInt(datum, &ende, 10);
  856. datum = ende;
  857. ende = 0;
  858. break;
  859. case 'd':
  860. t = TextZuInt(datum, &ende, 10);
  861. datum = ende;
  862. ende = 0;
  863. break;
  864. default:
  865. ++datum;
  866. break;
  867. }
  868. }
  869. bool ret = jahr == j && monat == m && tag == t;
  870. return ret;
  871. }
  872. bool Datum::istGleich(const char* format, Text* datum) const
  873. {
  874. bool ret = istGleich(format, datum->getText());
  875. datum->release();
  876. return ret;
  877. }
  878. bool Datum::istGleich(int jahr, int monat, int tag) const
  879. {
  880. return this->jahr == jahr && this->monat == monat && this->tag == tag;
  881. }
  882. bool Datum::jahrGleich(int jahr) const // prüft, ob das Jahr gleich jahr ist
  883. {
  884. return this->jahr == jahr;
  885. }
  886. bool Datum::monatGleich(int monat) const // prüft, ob der Monat gleich monat ist
  887. {
  888. return this->monat == monat;
  889. }
  890. bool Datum::tagGleich(int tag) const // prüft, ob der Tag gleich tag ist
  891. {
  892. return this->tag == tag;
  893. }
  894. bool Datum::istKleiner(
  895. Datum* datum) const // prüft, ob die Datum kleiner als datum ist
  896. {
  897. bool ret = istKleiner(datum->getJahr(), datum->getMonat(), datum->getTag());
  898. datum->release();
  899. return ret;
  900. }
  901. bool Datum::istKleiner(int jahr, int monat, int tag) const
  902. {
  903. if (this->jahr < jahr)
  904. return 1;
  905. else if (this->jahr == jahr)
  906. {
  907. if (this->monat < monat)
  908. return 1;
  909. else if (this->monat == monat)
  910. {
  911. if (this->tag < tag)
  912. return 1;
  913. else if (this->tag == tag)
  914. return 0;
  915. else
  916. return 0;
  917. }
  918. else
  919. return 0;
  920. }
  921. else
  922. return 0;
  923. }
  924. bool Datum::istKleiner(const char* format, const char* datum) const
  925. {
  926. int j = jahr, m = monat, t = tag;
  927. int flen = textLength(format);
  928. char* ende = 0;
  929. for (const char* f = format; f < format + flen; ++f)
  930. {
  931. switch (*f)
  932. {
  933. case 'y':
  934. j = TextZuInt(datum, &ende, 10);
  935. datum = ende;
  936. ende = 0;
  937. break;
  938. case 'm':
  939. m = TextZuInt(datum, &ende, 10);
  940. datum = ende;
  941. ende = 0;
  942. break;
  943. case 'd':
  944. t = TextZuInt(datum, &ende, 10);
  945. datum = ende;
  946. ende = 0;
  947. break;
  948. default:
  949. ++datum;
  950. break;
  951. }
  952. }
  953. return istKleiner(j, m, t);
  954. }
  955. bool Datum::istKleiner(const char* format, Text* datum) const
  956. {
  957. bool ret = istKleiner(format, datum->getText());
  958. datum->release();
  959. return ret;
  960. }
  961. bool Datum::istLater(
  962. Datum* datum) const // prüft, ob die Datum größer als datum ist
  963. {
  964. bool ret = istLater(datum->getJahr(), datum->getMonat(), datum->getTag());
  965. datum->release();
  966. return ret;
  967. }
  968. bool Datum::istLater(int jahr, int monat, int tag) const
  969. {
  970. if (this->jahr > jahr)
  971. return 1;
  972. else if (this->jahr == jahr)
  973. {
  974. if (this->monat > monat)
  975. return 1;
  976. else if (this->monat == monat)
  977. {
  978. if (this->tag > tag)
  979. return 1;
  980. else if (this->tag == tag)
  981. return 0;
  982. else
  983. return 0;
  984. }
  985. else
  986. return 0;
  987. }
  988. else
  989. return 0;
  990. }
  991. bool Datum::istLater(const char* format, const char* datum) const
  992. {
  993. int j = jahr, m = monat, t = tag;
  994. int flen = textLength(format);
  995. char* ende = 0;
  996. for (const char* f = format; f < format + flen; ++f)
  997. {
  998. switch (*f)
  999. {
  1000. case 'y':
  1001. j = TextZuInt(datum, &ende, 10);
  1002. datum = ende;
  1003. ende = 0;
  1004. break;
  1005. case 'm':
  1006. m = TextZuInt(datum, &ende, 10);
  1007. datum = ende;
  1008. ende = 0;
  1009. break;
  1010. case 'd':
  1011. t = TextZuInt(datum, &ende, 10);
  1012. datum = ende;
  1013. ende = 0;
  1014. break;
  1015. default:
  1016. ++datum;
  1017. break;
  1018. }
  1019. }
  1020. return istLater(j, m, t);
  1021. }
  1022. bool Datum::istLater(const char* format, Text* datum) const
  1023. {
  1024. bool ret = istLater(format, datum->getText());
  1025. datum->release();
  1026. return ret;
  1027. }
  1028. // Inhalt der Zeit Klasse aus Zeit.h
  1029. // Konstruktor
  1030. Zeit::Zeit()
  1031. : ReferenceCounter(),
  1032. datum(new Datum()),
  1033. uhrzeit(new Uhrzeit())
  1034. {}
  1035. //! Erzeugt eine neue Zeit mit den vergangenen sekunden seit 1970.
  1036. Zeit::Zeit(__int64 timestamp)
  1037. : ReferenceCounter(),
  1038. datum(new Datum()),
  1039. uhrzeit(new Uhrzeit())
  1040. {
  1041. datum->setDatum(1970, 1, 1);
  1042. plusSekunde(timestamp);
  1043. }
  1044. // Destruktor
  1045. Zeit::~Zeit()
  1046. {
  1047. datum->release();
  1048. uhrzeit->release();
  1049. }
  1050. // nicht constant
  1051. void Zeit::setZeit(Zeit* zeit) // setzt die Zeit
  1052. {
  1053. datum->setDatum(zeit->getDatum());
  1054. datum->plusTag(uhrzeit->setUhrzeit(zeit->getUhrzeit()));
  1055. zeit->release();
  1056. }
  1057. void Zeit::setZeit(
  1058. int jahr, int monat, int tag, int stunde, int minute, int sekunde)
  1059. {
  1060. datum->setDatum(jahr, monat, tag);
  1061. datum->plusTag(uhrzeit->setUhrzeit(stunde, minute, sekunde));
  1062. }
  1063. void Zeit::setZeit(const char* format,
  1064. const char* zeit) // format Beispiele: "Y:m:d H-i-s", "Y-m-d H:i:s"
  1065. // (Y=Jahr,m=Monat,d=tag,H=stunde,i=minute,s=sekunde)
  1066. {
  1067. int y = datum->getJahr();
  1068. int m = datum->getMonat();
  1069. int d = datum->getTag();
  1070. int h = uhrzeit->getStunde();
  1071. int i = uhrzeit->getMinute();
  1072. int s = uhrzeit->getSekunde();
  1073. int flen = textLength(format);
  1074. char* ende = 0;
  1075. for (const char* f = format; f < format + flen; ++f)
  1076. {
  1077. switch (*f)
  1078. {
  1079. case 'y':
  1080. y = TextZuInt(zeit, &ende, 10);
  1081. zeit = ende;
  1082. ende = 0;
  1083. break;
  1084. case 'm':
  1085. m = TextZuInt(zeit, &ende, 10);
  1086. zeit = ende;
  1087. ende = 0;
  1088. break;
  1089. case 'd':
  1090. d = TextZuInt(zeit, &ende, 10);
  1091. zeit = ende;
  1092. ende = 0;
  1093. break;
  1094. case 'h':
  1095. h = TextZuInt(zeit, &ende, 10);
  1096. zeit = ende;
  1097. ende = 0;
  1098. break;
  1099. case 'i':
  1100. i = TextZuInt(zeit, &ende, 10);
  1101. zeit = ende;
  1102. ende = 0;
  1103. break;
  1104. case 's':
  1105. s = TextZuInt(zeit, &ende, 10);
  1106. zeit = ende;
  1107. ende = 0;
  1108. break;
  1109. default:
  1110. ++zeit;
  1111. break;
  1112. }
  1113. }
  1114. datum->setDatum(y, m, d);
  1115. datum->plusTag(uhrzeit->setUhrzeit(h, i, s));
  1116. }
  1117. void Zeit::setZeit(const char* format, Text* zeit)
  1118. {
  1119. setZeit(format, zeit->getText());
  1120. zeit->release();
  1121. }
  1122. void Zeit::setJahr(int jahr) // setzt das Jahr
  1123. {
  1124. datum->setJahr(jahr);
  1125. }
  1126. void Zeit::setMonat(int monat) // setzt den Monat
  1127. {
  1128. datum->setMonat(monat);
  1129. }
  1130. void Zeit::setTag(int tag) // setzt den Tag
  1131. {
  1132. datum->setTag(tag);
  1133. }
  1134. void Zeit::setStunde(int stunde) // setzt die Stunde
  1135. {
  1136. datum->plusTag(uhrzeit->setStunde(stunde));
  1137. }
  1138. void Zeit::setMinute(int minute) // setzt die Minute
  1139. {
  1140. datum->plusTag(uhrzeit->setMinute(minute));
  1141. }
  1142. void Zeit::setSekunde(int sekunde) // setzt die Sekunde
  1143. {
  1144. datum->plusTag(uhrzeit->setSekunde(sekunde));
  1145. }
  1146. void Zeit::plusZeit(Zeit* zeit) // addiert die zeit
  1147. {
  1148. datum->plusDatum(zeit->getDatum());
  1149. datum->plusTag(uhrzeit->plusUhrzeit(zeit->getUhrzeit()));
  1150. zeit->release();
  1151. }
  1152. void Zeit::plusZeit(
  1153. int jahr, int monat, int tag, int stunde, int minute, int sekunde)
  1154. {
  1155. datum->plusDatum(jahr, monat, tag);
  1156. datum->plusTag(uhrzeit->plusUhrzeit(stunde, minute, sekunde));
  1157. }
  1158. void Zeit::plusZeit(const char* format, const char* zeit)
  1159. {
  1160. int y = datum->getJahr();
  1161. int m = datum->getMonat();
  1162. int d = datum->getTag();
  1163. int h = uhrzeit->getStunde();
  1164. int i = uhrzeit->getMinute();
  1165. int s = uhrzeit->getSekunde();
  1166. int flen = textLength(format);
  1167. char* ende = 0;
  1168. for (const char* f = format; f < format + flen; ++f)
  1169. {
  1170. switch (*f)
  1171. {
  1172. case 'y':
  1173. y += TextZuInt(zeit, &ende, 10);
  1174. zeit = ende;
  1175. ende = 0;
  1176. break;
  1177. case 'm':
  1178. m += TextZuInt(zeit, &ende, 10);
  1179. zeit = ende;
  1180. ende = 0;
  1181. break;
  1182. case 'd':
  1183. d += TextZuInt(zeit, &ende, 10);
  1184. zeit = ende;
  1185. ende = 0;
  1186. break;
  1187. case 'h':
  1188. h += TextZuInt(zeit, &ende, 10);
  1189. zeit = ende;
  1190. ende = 0;
  1191. break;
  1192. case 'i':
  1193. i += TextZuInt(zeit, &ende, 10);
  1194. zeit = ende;
  1195. ende = 0;
  1196. break;
  1197. case 's':
  1198. s += TextZuInt(zeit, &ende, 10);
  1199. zeit = ende;
  1200. ende = 0;
  1201. break;
  1202. default:
  1203. ++zeit;
  1204. break;
  1205. }
  1206. }
  1207. datum->setDatum(y, m, d);
  1208. datum->plusTag(uhrzeit->setUhrzeit(h, i, s));
  1209. }
  1210. void Zeit::plusZeit(const char* format, Text* zeit)
  1211. {
  1212. plusZeit(format, zeit->getText());
  1213. zeit->release();
  1214. }
  1215. void Zeit::plusJahr(int jahr) // addiert jahr Jahre
  1216. {
  1217. datum->plusJahr(jahr);
  1218. }
  1219. void Zeit::plusMonat(int monat) // addiert monat Monate
  1220. {
  1221. datum->plusMonat(monat);
  1222. }
  1223. void Zeit::plusTag(int tag) // addiert tag Tage
  1224. {
  1225. datum->plusTag(tag);
  1226. }
  1227. void Zeit::plusStunde(__int64 stunde) // addiert stunde Stunden
  1228. {
  1229. datum->plusTag(uhrzeit->plusStunde(stunde));
  1230. }
  1231. void Zeit::plusMinute(__int64 minute) // addiert minute Minuten
  1232. {
  1233. datum->plusTag(uhrzeit->plusMinute(minute));
  1234. }
  1235. void Zeit::plusSekunde(__int64 sekunde) // addiert sekunde Sekunden
  1236. {
  1237. datum->plusTag(uhrzeit->plusSekunde(sekunde));
  1238. }
  1239. void Zeit::minusZeit(Zeit* zeit) // subtrahiert die zeit
  1240. {
  1241. datum->minusDatum(zeit->getDatum());
  1242. datum->plusTag(uhrzeit->minusUhrzeit(zeit->getUhrzeit()));
  1243. zeit->release();
  1244. }
  1245. void Zeit::minusZeit(
  1246. int jahr, int monat, int tag, int stunde, int minute, int sekunde)
  1247. {
  1248. datum->minusDatum(jahr, monat, tag);
  1249. datum->plusTag(uhrzeit->plusUhrzeit(stunde, minute, sekunde));
  1250. }
  1251. void Zeit::minusZeit(const char* format, const char* zeit)
  1252. {
  1253. int y = datum->getJahr();
  1254. int m = datum->getMonat();
  1255. int d = datum->getTag();
  1256. int h = uhrzeit->getStunde();
  1257. int i = uhrzeit->getMinute();
  1258. int s = uhrzeit->getSekunde();
  1259. int flen = textLength(format);
  1260. char* ende = 0;
  1261. for (const char* f = format; f < format + flen; ++f)
  1262. {
  1263. switch (*f)
  1264. {
  1265. case 'y':
  1266. y -= TextZuInt(zeit, &ende, 10);
  1267. zeit = ende;
  1268. ende = 0;
  1269. break;
  1270. case 'm':
  1271. m -= TextZuInt(zeit, &ende, 10);
  1272. zeit = ende;
  1273. ende = 0;
  1274. break;
  1275. case 'd':
  1276. d -= TextZuInt(zeit, &ende, 10);
  1277. zeit = ende;
  1278. ende = 0;
  1279. break;
  1280. case 'h':
  1281. h += TextZuInt(zeit, &ende, 10);
  1282. zeit = ende;
  1283. ende = 0;
  1284. break;
  1285. case 'i':
  1286. i -= TextZuInt(zeit, &ende, 10);
  1287. zeit = ende;
  1288. ende = 0;
  1289. break;
  1290. case 's':
  1291. s -= TextZuInt(zeit, &ende, 10);
  1292. zeit = ende;
  1293. ende = 0;
  1294. break;
  1295. default:
  1296. ++zeit;
  1297. break;
  1298. }
  1299. }
  1300. datum->setDatum(y, m, d);
  1301. datum->plusTag(uhrzeit->setUhrzeit(h, i, s));
  1302. }
  1303. void Zeit::minusZeit(const char* format, Text* zeit)
  1304. {
  1305. minusZeit(format, zeit->getText());
  1306. zeit->release();
  1307. }
  1308. void Zeit::minusJahr(int jahr) // subtrahiert jahr Jahre
  1309. {
  1310. datum->minusJahr(jahr);
  1311. }
  1312. void Zeit::minusMonat(int monat) // subtrahiert monat Monate
  1313. {
  1314. datum->minusMonat(monat);
  1315. }
  1316. void Zeit::minusTag(int tag) // subtrahiert tag Tage
  1317. {
  1318. datum->minusTag(tag);
  1319. }
  1320. void Zeit::minusStunde(__int64 stunde) // subtrahiert stunde Stunden
  1321. {
  1322. datum->plusTag(uhrzeit->minusStunde(stunde));
  1323. }
  1324. void Zeit::minusMinute(__int64 minute) // subtrahiert minute Minuten
  1325. {
  1326. datum->plusTag(uhrzeit->minusMinute(minute));
  1327. }
  1328. void Zeit::minusSekunde(__int64 sekunde) // subtrahiert sekunde Sekunden
  1329. {
  1330. datum->plusTag(uhrzeit->minusSekunde(sekunde));
  1331. }
  1332. // constant
  1333. Text* Zeit::getZeit(
  1334. const char* format) const // gibt die Zeit als Text formatiert zurück
  1335. {
  1336. Text* ret = new Text("");
  1337. int flen = textLength(format);
  1338. for (const char* f = format; f < format + flen; ++f)
  1339. {
  1340. switch (*f)
  1341. {
  1342. case 'y':
  1343. ret->append(datum->getJahr());
  1344. break;
  1345. case 'm':
  1346. if (datum->getMonat() < 10) ret->append("0");
  1347. ret->append(datum->getMonat());
  1348. break;
  1349. case 'd':
  1350. if (datum->getTag() < 10) ret->append("0");
  1351. ret->append(datum->getTag());
  1352. break;
  1353. case 'h':
  1354. if (uhrzeit->getStunde() < 10) ret->append("0");
  1355. ret->append(uhrzeit->getStunde());
  1356. break;
  1357. case 'i':
  1358. if (uhrzeit->getMinute() < 10) ret->append("0");
  1359. ret->append(uhrzeit->getMinute());
  1360. break;
  1361. case 's':
  1362. if (uhrzeit->getSekunde() < 10) ret->append("0");
  1363. ret->append(uhrzeit->getSekunde());
  1364. break;
  1365. default:
  1366. ret->append(f, 1);
  1367. }
  1368. }
  1369. return ret;
  1370. }
  1371. bool Zeit::istGleich(Zeit* zeit) const // prüft, ob die Uhrzeit gleich zeit ist
  1372. {
  1373. bool ret = datum->istGleich(zeit->getDatum())
  1374. && uhrzeit->istGleich(zeit->getUhrzeit());
  1375. zeit->release();
  1376. return ret;
  1377. }
  1378. bool Zeit::istGleich(const char* format, const char* zeit) const
  1379. {
  1380. int y = datum->getJahr();
  1381. int m = datum->getMonat();
  1382. int d = datum->getTag();
  1383. int h = uhrzeit->getStunde();
  1384. int i = uhrzeit->getMinute();
  1385. int s = uhrzeit->getSekunde();
  1386. int flen = textLength(format);
  1387. char* ende = 0;
  1388. for (const char* f = format; f < format + flen; ++f)
  1389. {
  1390. switch (*f)
  1391. {
  1392. case 'y':
  1393. y = TextZuInt(zeit, &ende, 10);
  1394. zeit = ende;
  1395. ende = 0;
  1396. break;
  1397. case 'm':
  1398. m = TextZuInt(zeit, &ende, 10);
  1399. zeit = ende;
  1400. ende = 0;
  1401. break;
  1402. case 'd':
  1403. d = TextZuInt(zeit, &ende, 10);
  1404. zeit = ende;
  1405. ende = 0;
  1406. break;
  1407. case 'h':
  1408. h = TextZuInt(zeit, &ende, 10);
  1409. zeit = ende;
  1410. ende = 0;
  1411. break;
  1412. case 'i':
  1413. i = TextZuInt(zeit, &ende, 10);
  1414. zeit = ende;
  1415. ende = 0;
  1416. break;
  1417. case 's':
  1418. s = TextZuInt(zeit, &ende, 10);
  1419. zeit = ende;
  1420. ende = 0;
  1421. break;
  1422. default:
  1423. ++zeit;
  1424. break;
  1425. }
  1426. }
  1427. return datum->istGleich(y, m, d) && uhrzeit->istGleich(h, i, s);
  1428. }
  1429. bool Zeit::istGleich(const char* format, Text* zeit) const
  1430. {
  1431. bool ret = istGleich(format, zeit->getText());
  1432. zeit->release();
  1433. return ret;
  1434. }
  1435. bool Zeit::istGleich(
  1436. int jahr, int monat, int tag, int stunde, int minute, int sekunde) const
  1437. {
  1438. return datum->istGleich(jahr, monat, tag)
  1439. && uhrzeit->istGleich(stunde, minute, sekunde);
  1440. }
  1441. Datum* Zeit::getDatum() const // gibt das Datum zurück
  1442. {
  1443. return dynamic_cast<Datum*>(datum->getThis());
  1444. }
  1445. Datum* Zeit::zDatum() const
  1446. {
  1447. return datum;
  1448. }
  1449. Uhrzeit* Zeit::getUhrzeit() const // gibt die Uhrzeit zurück
  1450. {
  1451. return dynamic_cast<Uhrzeit*>(uhrzeit->getThis());
  1452. }
  1453. Uhrzeit* Zeit::zUhrzeit() const
  1454. {
  1455. return uhrzeit;
  1456. }
  1457. bool Zeit::istKleiner(
  1458. Zeit* zeit) const // prüft, ob die Zeit kleiner als zeit ist
  1459. {
  1460. if (datum->istKleiner(zeit->getDatum()))
  1461. {
  1462. zeit->release();
  1463. return 1;
  1464. }
  1465. else if (datum->istGleich(zeit->getDatum()))
  1466. {
  1467. if (uhrzeit->istKleiner(zeit->getUhrzeit()))
  1468. {
  1469. zeit->release();
  1470. return 1;
  1471. }
  1472. else
  1473. {
  1474. zeit->release();
  1475. return 0;
  1476. }
  1477. }
  1478. else
  1479. {
  1480. zeit->release();
  1481. return 0;
  1482. }
  1483. }
  1484. bool Zeit::istKleiner(
  1485. int jahr, int monat, int tag, int stunde, int minute, int sekunde) const
  1486. {
  1487. if (datum->istKleiner(jahr, monat, tag))
  1488. return 1;
  1489. else if (datum->istGleich(jahr, monat, tag))
  1490. {
  1491. if (uhrzeit->istKleiner(stunde, minute, sekunde))
  1492. return 1;
  1493. else
  1494. return 0;
  1495. }
  1496. else
  1497. return 0;
  1498. }
  1499. bool Zeit::istKleiner(const char* format, const char* zeit) const
  1500. {
  1501. int y = datum->getJahr();
  1502. int m = datum->getMonat();
  1503. int d = datum->getTag();
  1504. int h = uhrzeit->getStunde();
  1505. int i = uhrzeit->getMinute();
  1506. int s = uhrzeit->getSekunde();
  1507. int flen = textLength(format);
  1508. char* ende = 0;
  1509. for (const char* f = format; f < format + flen; ++f)
  1510. {
  1511. switch (*f)
  1512. {
  1513. case 'y':
  1514. y = TextZuInt(zeit, &ende, 10);
  1515. zeit = ende;
  1516. ende = 0;
  1517. break;
  1518. case 'm':
  1519. m = TextZuInt(zeit, &ende, 10);
  1520. zeit = ende;
  1521. ende = 0;
  1522. break;
  1523. case 'd':
  1524. d = TextZuInt(zeit, &ende, 10);
  1525. zeit = ende;
  1526. ende = 0;
  1527. break;
  1528. case 'h':
  1529. h = TextZuInt(zeit, &ende, 10);
  1530. zeit = ende;
  1531. ende = 0;
  1532. break;
  1533. case 'i':
  1534. i = TextZuInt(zeit, &ende, 10);
  1535. zeit = ende;
  1536. ende = 0;
  1537. break;
  1538. case 's':
  1539. s = TextZuInt(zeit, &ende, 10);
  1540. zeit = ende;
  1541. ende = 0;
  1542. break;
  1543. default:
  1544. ++zeit;
  1545. break;
  1546. }
  1547. }
  1548. if (datum->istKleiner(y, m, d))
  1549. return 1;
  1550. else if (datum->istGleich(y, m, d))
  1551. {
  1552. if (uhrzeit->istKleiner(h, i, s))
  1553. return 1;
  1554. else
  1555. return 0;
  1556. }
  1557. else
  1558. return 0;
  1559. }
  1560. bool Zeit::istKleiner(const char* format, Text* zeit) const
  1561. {
  1562. bool ret = istKleiner(format, zeit->getText());
  1563. zeit->release();
  1564. return ret;
  1565. }
  1566. bool Zeit::istLater(Zeit* zeit) const // prüft, ob die Zeit größer als zeit ist
  1567. {
  1568. if (datum->istLater(zeit->getDatum()))
  1569. {
  1570. zeit->release();
  1571. return 1;
  1572. }
  1573. else if (datum->istGleich(zeit->getDatum()))
  1574. {
  1575. if (uhrzeit->istLater(zeit->getUhrzeit()))
  1576. {
  1577. zeit->release();
  1578. return 1;
  1579. }
  1580. else
  1581. {
  1582. zeit->release();
  1583. return 0;
  1584. }
  1585. }
  1586. else
  1587. {
  1588. zeit->release();
  1589. return 0;
  1590. }
  1591. }
  1592. bool Zeit::istLater(
  1593. int jahr, int monat, int tag, int stunde, int minute, int sekunde) const
  1594. {
  1595. if (datum->istLater(jahr, monat, tag))
  1596. return 1;
  1597. else if (datum->istGleich(jahr, monat, tag))
  1598. {
  1599. if (uhrzeit->istLater(stunde, minute, sekunde))
  1600. return 1;
  1601. else
  1602. return 0;
  1603. }
  1604. else
  1605. return 0;
  1606. }
  1607. bool Zeit::istLater(const char* format, const char* zeit) const
  1608. {
  1609. int y = datum->getJahr();
  1610. int m = datum->getMonat();
  1611. int d = datum->getTag();
  1612. int h = uhrzeit->getStunde();
  1613. int i = uhrzeit->getMinute();
  1614. int s = uhrzeit->getSekunde();
  1615. int flen = textLength(format);
  1616. char* ende = 0;
  1617. for (const char* f = format; f < format + flen; ++f)
  1618. {
  1619. switch (*f)
  1620. {
  1621. case 'y':
  1622. y = TextZuInt(zeit, &ende, 10);
  1623. zeit = ende;
  1624. ende = 0;
  1625. break;
  1626. case 'm':
  1627. m = TextZuInt(zeit, &ende, 10);
  1628. zeit = ende;
  1629. ende = 0;
  1630. break;
  1631. case 'd':
  1632. d = TextZuInt(zeit, &ende, 10);
  1633. zeit = ende;
  1634. ende = 0;
  1635. break;
  1636. case 'h':
  1637. h = TextZuInt(zeit, &ende, 10);
  1638. zeit = ende;
  1639. ende = 0;
  1640. break;
  1641. case 'i':
  1642. i = TextZuInt(zeit, &ende, 10);
  1643. zeit = ende;
  1644. ende = 0;
  1645. break;
  1646. case 's':
  1647. s = TextZuInt(zeit, &ende, 10);
  1648. zeit = ende;
  1649. ende = 0;
  1650. break;
  1651. default:
  1652. ++zeit;
  1653. break;
  1654. }
  1655. }
  1656. if (datum->istLater(y, m, d))
  1657. return 1;
  1658. else if (datum->istGleich(y, m, d))
  1659. {
  1660. if (uhrzeit->istLater(h, i, s))
  1661. return 1;
  1662. else
  1663. return 0;
  1664. }
  1665. else
  1666. return 0;
  1667. }
  1668. bool Zeit::istLater(const char* format, Text* zeit) const
  1669. {
  1670. bool ret = istLater(format, zeit->getText());
  1671. zeit->release();
  1672. return ret;
  1673. }
  1674. // Inhalt der ZeitMesser Klasse aus Zeit.h
  1675. // Konstruktor
  1676. ZeitMesser::ZeitMesser()
  1677. : ReferenceCounter(),
  1678. start(0),
  1679. ende(0),
  1680. messung(0)
  1681. {}
  1682. // Destruktor
  1683. ZeitMesser::~ZeitMesser() {}
  1684. // nicht constant
  1685. void ZeitMesser::messungStart() // legt des Startpunkt der Zeitmessung fest
  1686. {
  1687. timeval tv;
  1688. gettimeofday(&tv, 0);
  1689. start = (double)tv.tv_sec + (double)tv.tv_usec / 1000000.0;
  1690. }
  1691. void ZeitMesser::messungEnde() // legt des Endpunkt der Zeitmessung fest
  1692. {
  1693. timeval tv;
  1694. gettimeofday(&tv, 0);
  1695. ende = (double)tv.tv_sec + (double)tv.tv_usec / 1000000.0;
  1696. messung = ende - start;
  1697. }
  1698. // constant
  1699. double ZeitMesser::getSekunden()
  1700. const // gibt den sekundenabstand zwischen start und ende der Messung zurück
  1701. {
  1702. return messung;
  1703. }
  1704. double ZeitMesser::getMinuten()
  1705. const // gibt den minutenabstand zwischen start und ende der Messung zurück
  1706. {
  1707. return messung / 60;
  1708. }
  1709. double ZeitMesser::getStunden()
  1710. const // gibt den stundenabstand zwischen start und ende der Messung zurück
  1711. {
  1712. return messung / 3600;
  1713. }
  1714. //! gibt true zurück, wenn aktuell eine MEssung läuft
  1715. DLLEXPORT bool ZeitMesser::isMeasuring() const
  1716. {
  1717. return start != 0;
  1718. }
  1719. // Globale Funktionen
  1720. Uhrzeit* Framework::getUhrzeit() // gibt die aktuelle Uhrzeit zurück
  1721. {
  1722. #ifdef WIN32
  1723. Uhrzeit* ret = new Uhrzeit();
  1724. time_t Zeitstempel = time(0);
  1725. tm now;
  1726. localtime_s(&now, &Zeitstempel);
  1727. ret->setUhrzeit(now.tm_hour, now.tm_min, now.tm_sec);
  1728. return ret;
  1729. #else
  1730. Uhrzeit* ret = new Uhrzeit();
  1731. time_t Zeitstempel = time(0);
  1732. tm* now = localtime(&Zeitstempel);
  1733. ret->setUhrzeit(now->tm_hour, now->tm_min, now->tm_sec);
  1734. return ret;
  1735. #endif
  1736. }
  1737. Datum* Framework::getDatum() // gibt das aktuelle Datum zurück
  1738. {
  1739. #ifdef WIN32
  1740. Datum* ret = new Datum();
  1741. time_t Zeitstempel = time(0);
  1742. tm now;
  1743. localtime_s(&now, &Zeitstempel);
  1744. ret->setDatum(now.tm_year + 1900, now.tm_mon + 1, now.tm_mday);
  1745. return ret;
  1746. #else
  1747. Datum* ret = new Datum();
  1748. time_t Zeitstempel = time(0);
  1749. tm* now = localtime(&Zeitstempel);
  1750. ret->setDatum(now->tm_year + 1900, now->tm_mon + 1, now->tm_mday);
  1751. return ret;
  1752. #endif
  1753. }
  1754. Zeit* Framework::getZeit() // gibt die aktuelle Zeit( Datum und Uhrzeit ) zurück
  1755. {
  1756. #ifdef WIN32
  1757. Zeit* ret = new Zeit();
  1758. time_t Zeitstempel = time(0);
  1759. tm now;
  1760. localtime_s(&now, &Zeitstempel);
  1761. ret->setZeit(now.tm_year + 1900,
  1762. now.tm_mon + 1,
  1763. now.tm_mday,
  1764. now.tm_hour,
  1765. now.tm_min,
  1766. now.tm_sec);
  1767. return ret;
  1768. #else
  1769. Zeit* ret = new Zeit();
  1770. time_t Zeitstempel = time(0);
  1771. tm* now = localtime(&Zeitstempel);
  1772. ret->setZeit(now->tm_year + 1900,
  1773. now->tm_mon + 1,
  1774. now->tm_mday,
  1775. now->tm_hour,
  1776. now->tm_min,
  1777. now->tm_sec);
  1778. return ret;
  1779. #endif
  1780. }
  1781. bool Framework::istSchaltjahr(int jahr) // prüft, ob jahr ein Schaltjahr ist
  1782. {
  1783. if (jahr % 4 == 0)
  1784. {
  1785. if (jahr % 100 == 0)
  1786. {
  1787. if (jahr % 400 == 0)
  1788. return true;
  1789. else
  1790. return false;
  1791. }
  1792. else
  1793. return true;
  1794. }
  1795. else
  1796. return false;
  1797. }