Zeit.cpp 35 KB

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