Zeit.h 46 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817
  1. #ifndef Zeit_H
  2. #define Zeit_H
  3. #include <time.h>
  4. #include "Betriebssystem.h"
  5. #include "ReferenceCounter.h"
  6. namespace Framework
  7. {
  8. class Text; //! Text.h
  9. class Uhrzeit; //! Aus dieser Datei
  10. class Datum; //! Aus dieser Datei
  11. class Zeit; //! Aus dieser Datei
  12. class ZeitMesser; //! Aus dieser Datei
  13. //! Diese Klasse speichert eine Uhrzeit in form von Stunden, Minuten und
  14. //! Sekunden
  15. class Uhrzeit : public virtual ReferenceCounter
  16. {
  17. private:
  18. __int64 stunde, minute, sekunde;
  19. int update();
  20. public:
  21. //! Erzeugt ein neues Uhrzeit Zeichnung mit den Standartwerten 00:00:00
  22. DLLEXPORT Uhrzeit();
  23. //! Setzt die Uhrzeit durch kopieren.
  24. //! \param zeit Aus diesem Zeichnung werden die Werte für Stunde, Minute
  25. //! und Sekunde kopiert.
  26. DLLEXPORT int setUhrzeit(Uhrzeit* zeit);
  27. //! Setzt die Uhrzeit.
  28. //! \param stunde Die Stunde der neuen Uhrzeit.
  29. //! \param minute Die Minute der neuen Uhrzeit.
  30. //! \param sekunde Die Sekunde der neuen Uhrzeit.
  31. //! \return Die Anzahl übriger Tage.
  32. //! Beispiel: setUhrzeit( 30, 30, 30 ); return: 1, gespeichert: 6:30:30
  33. DLLEXPORT int setUhrzeit(int stunde, int minute, int sekunde);
  34. //! Setzt die Uhrzeit.
  35. //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die
  36. //! Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde. \param
  37. //! zeit Eine Zeichenfolge die die neue Uhrzeit enthält. \return Die
  38. //! Anzahl übriger Tage. Beispiel: setUhrzeit( "h:i:s", "05:30:00" );
  39. //! Beispiel: setUhrzeit( "h:i:s", "30:30:00" ); return: 1, gespeichert:
  40. //! 6:30:00
  41. DLLEXPORT int setUhrzeit(const char* format, const char* zeit);
  42. //! Setzt die Uhrzeit.
  43. //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die
  44. //! Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde. \param
  45. //! zeit Ein Text Zeichnung, dass die neue Uhrzeit enthält. \return Die
  46. //! Anzahl übriger Tage. Beispiel: setUhrzeit( "h:i:s", new Text(
  47. //! "05:30:00" ) ); Beispiel: setUhrzeit( "h:i:s", new Text( "30:30:00"
  48. //! ) ); return: 1, gespeichert: 6:30:00
  49. DLLEXPORT int setUhrzeit(const char* format, Text* zeit);
  50. //! setzt die Stunde.
  51. //! \param stunde Die Stunde, die gespeichert werden soll.
  52. //! \return Die Anzahl übriger Tage.
  53. //! Beispiel: setStunde( 30 ); return: 1 Tag, gespeicherte Stunden: 6
  54. DLLEXPORT int setStunde(int stunde);
  55. //! setzt die Minute.
  56. //! \param minute Die Minute, die gespeichert werden soll.
  57. //! \return Die Anzahl übriger Tage.
  58. //! Beispiel: Alte Zeit: 23:50:10, setMinute( 80 ); return: 1,
  59. //! gespeicherte Zeit: 01:10:10
  60. DLLEXPORT int setMinute(int minute);
  61. //! setzt die Sekunde.
  62. //! \param minute Die Sekunde, die gespeichert werden soll.
  63. //! \return Die Anzahl übriger Tage.
  64. //! Beispiel: Alte Zeit: 23:59:10, setSekunde( 80 ); return: 1,
  65. //! gespeicherte Zeit: 00:00:30
  66. DLLEXPORT int setSekunde(int sekunde);
  67. //! errechnet die Summe von dieser und einer anderen Uhrzeit und
  68. //! speichert diese. \param zeit Die Uhrzeit, deren Werte addiert werden
  69. //! sollen. \return Die Anzahl übriger Tage. Beispiel: Alte Zeit:
  70. //! 19:40:18, plusZeit( (10:05:30) ); return 1, gespeicherte Zeit:
  71. //! 05:45:48
  72. DLLEXPORT int plusUhrzeit(Uhrzeit* zeit);
  73. //! errechnet die Summe von dieser und einer anderen Uhrzeit und
  74. //! speichert diese. \param stunde Die Stunden die Werte addiert werden
  75. //! sollen. \param minute Die Minute die Werte addiert werden sollen.
  76. //! \param sekunde Die Sekunde die Werte addiert werden sollen.
  77. //! \return Die Anzahl übriger Tage.
  78. //! Beispiel: Alte Zeit: 19:40:18, plusZeit( 10, 5, 30 ); return 1,
  79. //! gespeicherte Zeit: 05:45:48
  80. DLLEXPORT int plusUhrzeit(int stunde, int minute, int sekunde);
  81. //! errechnet die Summe von dieser und einer anderen Uhrzeit und
  82. //! speichert diese. \param format Eine Zeichenfolge, die bestimmt in
  83. //! welcher Form die Uhrzeit in (zeit) vorliegt. h=Stunde,
  84. //! i=Minute,s=Sekunde. \param zeit Eine Zeichenfolge die die neue
  85. //! Uhrzeit enthält. \return Die Anzahl übriger Tage. Beispiel:
  86. //! plusUhrzeit( "h:i:s", "05:20:00" ); Beispiel: Alte Zeit: 19:40:18,
  87. //! plusZeit( "h:i:s", "10:05:30" ); return 1, gespeicherte Zeit:
  88. //! 05:45:48
  89. DLLEXPORT int plusUhrzeit(const char* format, const char* zeit);
  90. //! errechnet die Summe von dieser und einer anderen Uhrzeit und
  91. //! speichert diese. \param format Eine Zeichenfolge, die bestimmt in
  92. //! welcher Form die Uhrzeit in (zeit) vorliegt. h=Stunde,
  93. //! i=Minute,s=Sekunde. \param zeit Ein Text Zeichnung, welches die neue
  94. //! Uhrzeit enthält. \return Die Anzahl übriger Tage. Beispiel:
  95. //! plusUhrzeit( "h:i:s", new Text( "05:20:00" ) ); Beispiel: Alte Zeit:
  96. //! 19:40:18, plusZeit( "h:i:s", new Text( "10:05:30" ) ); return 1,
  97. //! gespeicherte Zeit: 05:45:48
  98. DLLEXPORT int plusUhrzeit(const char* format, Text* zeit);
  99. //! errechnet die Summe von dieser und einer anderen Uhrzeit und
  100. //! speichert diese. \param stunde die draufzurechnenden Stunden.
  101. //! \return Die Anzahl übriger Tage.
  102. //! Beispiel: Alte Zeit: 20:50:30, plusStunde( 10 ); return 1,
  103. //! gespeicherte Zeit: 6:50:30
  104. DLLEXPORT int plusStunde(__int64 stunde);
  105. //! errechnet die Summe von dieser und einer anderen Uhrzeit und
  106. //! speichert diese. \param minute die draufzurechnenden Minuten.
  107. //! \return Die Anzahl übriger Tage.
  108. //! Beispiel: Alte Zeit: 23:50:30, plusMinute( 11 ); return 1,
  109. //! gespeicherte Zeit: 00:01:30
  110. DLLEXPORT int plusMinute(__int64 minute);
  111. //! errechnet die Summe von dieser und einer anderen Uhrzeit und
  112. //! speichert diese. \param sekunde die draufzurechnenden Sekunden.
  113. //! \return Die Anzahl übriger Tage.
  114. //! Beispiel: Alte Zeit: 23:59:30, plusSekunde( 40 ); return 1,
  115. //! gespeicherte Zeit: 00:00:10
  116. DLLEXPORT int plusSekunde(__int64 sekunde);
  117. //! zieht eine gegebene Uhrzeit von dieser ab und speichert das
  118. //! Ergebnis. \param zeit Die Uhrzeit, die von dieser abgezogen werden
  119. //! soll. \return Die Anzahl übriger Tage. Beispiel Alte Zeit: 10:40:18,
  120. //! minusUhrzeit( (19:05:30) ); return -1, gespeicherte Zeit: 15:34:48
  121. DLLEXPORT int minusUhrzeit(Uhrzeit* zeit);
  122. //! zieht eine gegebene Uhrzeit von dieser ab und speichert das
  123. //! Ergebnis. \param stunde Die Stunden, die von dieser Uhrzeit
  124. //! abgezogen werden sollen. \param minute Die Minuten, die von dieser
  125. //! Uhrzeit abgezogen werden sollen. \param sekunde Die Sekunden, die
  126. //! von dieser Uhrzeit abgezogen werden sollen. \return Die Anzahl
  127. //! übriger Tage. Beispiel Alte Zeit: 10:40:18, minusUhrzeit( 19, 05, 30
  128. //! ); return -1, gespeicherte Zeit: 15:34:48
  129. DLLEXPORT int minusUhrzeit(int stunde, int minute, int sekunde);
  130. //! zieht eine gegebene Uhrzeit von dieser ab und speichert das
  131. //! Ergebnis. \param format Eine Zeichenfolge, die bestimmt in welcher
  132. //! Form die Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde.
  133. //! \param zeit Eine Zeichenfolge die die neue Uhrzeit enthält.
  134. //! \return Die Anzahl übriger Tage.
  135. //! Beispiel Alte Zeit: 10:40:18, minusUhrzeit( "h:i:s", "19:05:30" );
  136. //! return -1, gespeicherte Zeit: 15:34:48
  137. DLLEXPORT int minusUhrzeit(const char* format, const char* zeit);
  138. //! zieht eine gegebene Uhrzeit von dieser ab und speichert das
  139. //! Ergebnis. \param format Eine Zeichenfolge, die bestimmt in welcher
  140. //! Form die Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde.
  141. //! \param zeit Ein Text Zeichnung, welches die neue Uhrzeit enthält.
  142. //! \return Die Anzahl übriger Tage.
  143. //! Beispiel Alte Zeit: 10:40:18, minusUhrzeit( "h:i:s", new Text(
  144. //! "19:05:30" ) ); return -1, gespeicherte Zeit: 15:34:48
  145. DLLEXPORT int minusUhrzeit(const char* format, Text* zeit);
  146. //! zieht eine gegebene Zeit von dieser ab und speichert das Ergebnis.
  147. //! \param stunde Die abzuziehenden Stunden.
  148. //! \return Die Anzahl übriger Tage.
  149. //! Beispiel Alte Zeit: 10:40:18, minusStunde( 19 ); return -1,
  150. //! gespeicherte Zeit: 15:40:18
  151. DLLEXPORT int minusStunde(__int64 stunde);
  152. //! zieht eine gegebene Zeit von dieser ab und speichert das Ergebnis.
  153. //! \param minute Die abzuziehenden Minuten.
  154. //! \return Die Anzahl übriger Tage.
  155. //! Beispiel Alte Zeit: 00:40:18, minusStunde( 50 ); return -1,
  156. //! gespeicherte Zeit: 23:50:18
  157. DLLEXPORT int minusMinute(__int64 minute);
  158. //! zieht eine gegebene Zeit von dieser ab und speichert das Ergebnis.
  159. //! \param sekunde Die abzuziehenden Sekunden.
  160. //! \return Die Anzahl übriger Tage.
  161. //! Beispiel Alte Zeit: 00:00:20, minusStunde( 50 ); return -1,
  162. //! gespeicherte Zeit: 23:59:30
  163. DLLEXPORT int minusSekunde(__int64 sekunde);
  164. //! gibt die Stunde zurück.
  165. DLLEXPORT int getStunde() const;
  166. //! gibt die Minute zurück.
  167. DLLEXPORT int getMinute() const;
  168. //! gibt die Sekunde zurück.
  169. DLLEXPORT int getSekunde() const;
  170. //! gibt die Uhrzeit als Text formatiert zurück.
  171. //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die
  172. //! Uhrzeit zurückgegeben werden soll. h=Stunde, i=Minute,s=Sekunde.
  173. //! Beispiel: Zeit: 5:40:39, getUhrzeit( "h:i:s" ); return: "5:40:39"
  174. DLLEXPORT Text* getUhrzeit(const char* format) const;
  175. //! prüft, ob die Uhrzeit gleich zeit ist.
  176. //! \param zeit Die Uhrzeit, mit der diese verglichen werden soll.
  177. //! \return (true), wenn die beiden Zeiten geich sind. (false), wenn die
  178. //! Zeiten nicht gleich sind.
  179. DLLEXPORT bool istGleich(Uhrzeit* zeit) const;
  180. //! prüft, ob die Uhrzeit gleich zeit ist.
  181. //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die
  182. //! Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde. \param
  183. //! zeit Eine Zeichenfolge die die andere Uhrzeit enthält. \return
  184. //! (true), wenn die beiden Zeiten geich sind. (false), wenn die Zeiten
  185. //! nicht gleich sind.
  186. DLLEXPORT bool istGleich(const char* format, const char* zeit) const;
  187. //! prüft, ob die Uhrzeit gleich zeit ist.
  188. //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die
  189. //! Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde. \param
  190. //! zeit Ein Text Zeichnung, welches die andere Uhrzeit enthält. \return
  191. //! (true), wenn die beiden Zeiten geich sind. (false), wenn die Zeiten
  192. //! nicht gleich sind.
  193. DLLEXPORT bool istGleich(const char* format, Text* zeit) const;
  194. //! prüft, ob die Uhrzeit gleich der übergebenen Zeit ist. Hier wird
  195. //! nicht beachtet, ob die gegebene Zeit eine gültige Uhrzeit ist.
  196. //! \param stunde Die Stunden der zu überprüfenden Uhrzeit
  197. //! \param minute Die Minuten der zu überprüfenden Uhrzeit
  198. //! \param sekunde Die Sekunden der zu überprüfenden Uhrzeit
  199. //! \return (true), wenn die beiden Zeiten geich sind. (false), wenn die
  200. //! Zeiten nicht gleich sind.
  201. DLLEXPORT bool istGleich(int stunde, int minute, int sekunde) const;
  202. //! prüft, ob die Stunde gleich der gegebenen Stunde ist.
  203. //! \param stunde die zu prüfende Stunde.
  204. //! \return (true), wenn die Stunden gleich sind. (false), wenn sie
  205. //! nicht gleich sind.
  206. DLLEXPORT bool stundeGleich(int stunde) const;
  207. //! prüft, ob die Minute gleich der gegebenen Minute ist.
  208. //! \param minute die zu prüfende Minute.
  209. //! \return (true), wenn die Minuten gleich sind. (false), wenn sie
  210. //! nicht gleich sind.
  211. DLLEXPORT bool minuteGleich(int minute) const;
  212. //! prüft, ob die Sekunde gleich der gegebenen Sekunde ist.
  213. //! \param sekunde die zu prüfende Sekunde.
  214. //! \return (true), wenn die Sekunden gleich sind. (false), wenn sie
  215. //! nicht gleich sind.
  216. DLLEXPORT bool sekundeGleich(int sekunde) const;
  217. //! prüft, ob die Uhrzeit kleiner als zeit ist.
  218. //! \param zeit Die zu prüfende Uhrzeit.
  219. //! \return (true), wenn die gespeicherte Zeit kleiner als die
  220. //! übergebene Zeit ist. (false) sonst. Beispiel: (5:30:00).istKleiner(
  221. //! (10:40:29) ); return true
  222. DLLEXPORT bool istKleiner(Uhrzeit* zeit) const;
  223. //! prüft, ob die Uhrzeit kleiner als die übergebene Zeit ist.
  224. //! \param stunde Die Stunden der zu prüfenden Zeit.
  225. //! \param minute Die Minute der zu prüfenden Zeit.
  226. //! \param sekunde Die Sekunde der zu prüfenden Zeit.
  227. //! \return (true), wenn die gespeicherte Zeit kleiner als die
  228. //! übergebene Zeit ist. (false) sonst. Beispiel: (5:30:00).istKleiner(
  229. //! 10, 40, 29 ); return true
  230. DLLEXPORT bool istKleiner(int stunde, int minute, int sekunde) const;
  231. //! prüft, ob die Uhrzeit kleiner als die übergebene Zeit ist.
  232. //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die
  233. //! Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde. \param
  234. //! zeit Eine Zeichenfolge die die andere Uhrzeit enthält. \return
  235. //! (true), wenn die gespeicherte Zeit kleiner als die übergebene Zeit
  236. //! ist. (false) sonst. Beispiel: (5:30:00).istKleiner( "h:i:s",
  237. //! "10:40:29" ); return true
  238. DLLEXPORT bool istKleiner(const char* format, const char* zeit) const;
  239. //! prüft, ob die Uhrzeit kleiner als die übergebene Zeit ist.
  240. //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die
  241. //! Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde. \param
  242. //! zeit Ein Text Zeichnung, welches die andere Uhrzeit enthält. \return
  243. //! (true), wenn die gespeicherte Zeit kleiner als die übergebene Zeit
  244. //! ist. (false) sonst. Beispiel: (5:30:00).istKleiner( "h:i:s",
  245. //! "10:40:29" ); return true
  246. DLLEXPORT bool istKleiner(const char* format, Text* zeit) const;
  247. //! prüft, ob die Uhrzeit größer als zeit ist.
  248. //! \param zeit Die zu prüfende Uhrzeit.
  249. //! \return (true), wenn die gespeicherte Zeit größer als die übergebene
  250. //! Zeit ist. (false) sonst. Beispiel: (5:30:00).istGrößer( (10:40:29)
  251. //! ); return false
  252. DLLEXPORT bool istLater(Uhrzeit* zeit) const;
  253. //! prüft, ob die Uhrzeit größer als die übergebene Zeit ist.
  254. //! \param stunde Die Stunden der zu prüfenden Zeit.
  255. //! \param minute Die Minute der zu prüfenden Zeit.
  256. //! \param sekunde Die Sekunde der zu prüfenden Zeit.
  257. //! \return (true), wenn die gespeicherte Zeit größer als die übergebene
  258. //! Zeit ist. (false) sonst. Beispiel: (5:30:00).istGrößer( 10, 40, 29
  259. //! ); return false
  260. DLLEXPORT bool istLater(int stunde, int minute, int sekunde) const;
  261. //! prüft, ob die Uhrzeit größer als die übergebene Zeit ist.
  262. //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die
  263. //! Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde. \param
  264. //! zeit Eine Zeichenfolge die die andere Uhrzeit enthält. \return
  265. //! (true), wenn die gespeicherte Zeit größer als die übergebene Zeit
  266. //! ist. (false) sonst. Beispiel: (5:30:00).istGrößer( "h:i:s",
  267. //! "10:40:29" ); return false
  268. DLLEXPORT bool istLater(const char* format, const char* zeit) const;
  269. //! prüft, ob die Uhrzeit größer als die übergebene Zeit ist.
  270. //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die
  271. //! Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde. \param
  272. //! zeit Ein Text Zeichnung, welches die andere Uhrzeit enthält. \return
  273. //! (true), wenn die gespeicherte Zeit größer als die übergebene Zeit
  274. //! ist. (false) sonst. Beispiel: (5:30:00).istGrößer( "h:i:s",
  275. //! "10:40:29" ); return false
  276. DLLEXPORT bool istLater(const char* format, Text* zeit) const;
  277. };
  278. //! Diese Klasse speichert ein Datum in Form von Jahr, Monat und Tagen
  279. class Datum : public virtual ReferenceCounter
  280. {
  281. private:
  282. int jahr, monat, tag;
  283. int* maxTage;
  284. void update();
  285. public:
  286. //! Erzeugt ein neues Datum Zeichnung mit den Standartwerten 0.0.0.
  287. DLLEXPORT Datum();
  288. //! Löscht das Datum.
  289. DLLEXPORT ~Datum();
  290. //! Setzt das Datum durch kopieren.
  291. //! \param datum Das zu speichernde Datum.
  292. DLLEXPORT void setDatum(Datum* datum);
  293. //! Setzt das Datum zu den übergebenen Werten.
  294. //! \param jahr Das Jahr des neuen Datums.
  295. //! \param monat Der Monat des neuen Datums.
  296. //! \param tag Der Tag des neuen Datums.
  297. DLLEXPORT void setDatum(int jahr, int monat, int tag);
  298. //! Setzt das Datum zu dem übergebenen Wert.
  299. //! \param format Eine Zeichenkette, die angibt in welcher Form das
  300. //! Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag. \param datum
  301. //! Eine Zeichenkette, die das neue Datum enthält. Beispiel: setDatum(
  302. //! "y-m-d", "2016-01-25" );
  303. DLLEXPORT void setDatum(const char* format, const char* datum);
  304. //! Setzt das Datum zu dem übergebenen Wert.
  305. //! \param format Eine Zeichenkette, die angibt in welcher Form das
  306. //! Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag. \param datum
  307. //! Ein Text Zeichnung, welches das neue Datum enthält. Beispiel:
  308. //! setDatum( "y-m-d", new Text( "2016-01-25" ) );
  309. DLLEXPORT void setDatum(const char* format, Text* datum);
  310. //! Ändert das Jahr des Datums.
  311. //! \param jahr Das neue Jahr.
  312. DLLEXPORT void setJahr(int jahr);
  313. //! Ändert den Monat des Datums.
  314. //! \param monat Der neue Monat.
  315. DLLEXPORT void setMonat(int monat);
  316. //! Ändert den Tag des Datums.
  317. //! \param tag Der neue Tag.
  318. DLLEXPORT void setTag(int tag);
  319. //! Addiert zum aktuellen Datum das übergebene Datum dazu und speichert
  320. //! das Ergebnis. \param datum Das zu addierende Datum. Beispiel:
  321. //! ( 1.11.1995 ).plusDatum( ( 5.2.7 ) ); neues Datum: 6.1.2003
  322. DLLEXPORT void plusDatum(Datum* datum);
  323. //! Addiert zum aktuellen Datum das übergebene Datum dazu und speichert
  324. //! das Ergebnis. \param jahr Das zu addierende Jahr. \param monat Der
  325. //! zu addierende Monat. \param tag Der zu addierende Tag. Beispiel:
  326. //! ( 1.11.1995 ).plusDatum( ( 7, 2, 5 ) ); neues Datum: 6.1.2003
  327. DLLEXPORT void plusDatum(int jahr, int monat, int tag);
  328. //! Addiert zum aktuellen Datum das übergebene Datum dazu und speichert
  329. //! das Ergebnis. \param format Eine Zeichenkette, die angibt in welcher
  330. //! Form das Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag.
  331. //! \param datum Eine Zeichenkette, die das zu addierende Datum enthält.
  332. //! Beispiel: ( 1.11.1995 ).plusDatum( "d.m.y", "5.2.7" ); neues
  333. //! Datum: 6.1.2003
  334. DLLEXPORT void plusDatum(const char* format, const char* datum);
  335. //! Addiert zum aktuellen Datum das übergebene Datum dazu und speichert
  336. //! das Ergebnis. \param format Eine Zeichenkette, die angibt in welcher
  337. //! Form das Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag.
  338. //! \param datum Ein Text Zeichnung, welches das zu addierende Datum
  339. //! enthält. Beispiel: ( 1.11.1995 ).plusDatum( "d.m.y", new Text(
  340. //! "5.2.7" ) ); neues Datum: 6.1.2003
  341. DLLEXPORT void plusDatum(const char* format, Text* datum);
  342. //! Addiert zum aktuellen Datum das übergebene Jahr dazu und speichert
  343. //! das Ergebnis. \param jahr Das zu addierende Jahr. Beispiel:
  344. //! ( 1.11.1995 ).plusJahr( 21 ); neues Datum: 1.11.2016
  345. DLLEXPORT void plusJahr(int jahr);
  346. //! Addiert zum aktuellen Datum den übergebenen Monat dazu und speichert
  347. //! das Ergebnis. \param monat Der zu addierende Monat. Beispiel:
  348. //! ( 1.11.1995 ).plusMonat( 13 ); neues Datum: 1.12.1996
  349. DLLEXPORT void plusMonat(int monat);
  350. //! Addiert zum aktuellen Datum den übergebenen Tag dazu und speichert
  351. //! das Ergebnis. \param tag Der zu addierende Tag. Beispiel: ( 1.1.2000
  352. //! ).plusTag( 32 ); neues Datum: 2.2.2000
  353. DLLEXPORT void plusTag(int tag);
  354. //! Zieht vom aktuellen Datum das übergebene Datum ab und speichert das
  355. //! Ergebnis. \param datum Das abzuzuehende Datum. Beispiel: ( 2.12.1996
  356. //! ).minusDatum( ( 1.1.1 ) ); neues Datum: 1.11.1995
  357. DLLEXPORT void minusDatum(Datum* datum);
  358. //! Zieht vom aktuellen Datum das übergebene Datum ab und speichert das
  359. //! Ergebnis. \param jahr Das abzuzuehende Jahr. \param monat Der
  360. //! abzuzuehende Monat. \param tag Der abzuzuehende Tag. Beispiel:
  361. //! ( 2.12.1996 ).minusDatum( 1, 1, 1 ); neues Datum: 1.11.1995
  362. DLLEXPORT void minusDatum(int jahr, int monat, int tag);
  363. //! Zieht vom aktuellen Datum das übergebene Datum ab und speichert das
  364. //! Ergebnis. \param format Eine Zeichenkette, die angibt in welcher
  365. //! Form das Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag.
  366. //! \param datum Eine Zeichenkette, die das abzuziehende Datum enthält.
  367. //! Beispiel: ( 2.12.1996 ).minusDatum( "d.m.y", "1.1.1" ); neues
  368. //! Datum: 1.11.1995
  369. DLLEXPORT void minusDatum(const char* format, const char* datum);
  370. //! Zieht vom aktuellen Datum das übergebene Datum ab und speichert das
  371. //! Ergebnis. \param format Eine Zeichenkette, die angibt in welcher
  372. //! Form das Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag.
  373. //! \param datum Ein Text Zeichnung, welches das abzuziehende Datum
  374. //! enthält. Beispiel: ( 2.12.1996 ).minusDatum( "d.m.y", new Text(
  375. //! "1.1.1" ) ); neues Datum: 1.11.1995
  376. DLLEXPORT void minusDatum(const char* format, Text* datum);
  377. //! Zieht vom aktuellen Datum das übergebene Jahr ab und speichert das
  378. //! Ergebnis. \param jahr Das abzuzuehende Jahr. Beispiel: ( 1.11.1996
  379. //! ).minusJahr( 1 ); neues Datum: 1.11.1995
  380. DLLEXPORT void minusJahr(int jahr);
  381. //! Zieht vom aktuellen Datum den übergebenen Monat ab und speichert das
  382. //! Ergebnis. \param monat Der abzuzuehende Monat. Beispiel: ( 1.12.1996
  383. //! ).minusMonat( 13 ); neues Datum: 1.11.1995
  384. DLLEXPORT void minusMonat(int monat);
  385. //! Zieht vom aktuellen Datum den übergebenen Tag ab und speichert das
  386. //! Ergebnis. \param monat Der abzuzuehende Tag. Beispiel: ( 5.2.2016
  387. //! ).minusMonat( 11 ); neues Datum: 25.1.2016
  388. DLLEXPORT void minusTag(int tag);
  389. //! gibt das Jahr zurück.
  390. DLLEXPORT int getJahr() const;
  391. //! gibt der Monat zurück.
  392. DLLEXPORT int getMonat() const;
  393. //! gibt der Tag zurück.
  394. DLLEXPORT int getTag() const;
  395. //! Gibt das Datum als Text Zeichnung zurück.
  396. //! \param format Eine Zeichenkette, die angibt in welcher Form das
  397. //! Datum zurückgegeben werden soll. y=Jahr, m=Monat, d=Tag. Beispiel:
  398. //! ( 1.11.1995 ).getDatum( "y-m-d" ); return: "1995-11-1"
  399. DLLEXPORT Text* getDatum(const char* format) const;
  400. //! Prüft, ob das Datum gleich dem übergebenen Datum ist.
  401. //! \param datum das zu prüfende Datum.
  402. //! \return (true), wenn das übergebene Datum dem gespeicherten
  403. //! entspricht. (false) sonnst.
  404. DLLEXPORT bool istGleich(Datum* datum) const;
  405. //! Prüft, ob das Datum gleich dem übergebenen Datum ist.
  406. //! \param format Eine Zeichenkette, die angibt in welcher Form das
  407. //! Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag. \param datum
  408. //! Eine Zeichenkette, die das zu überprüfende Datum enthält. \return
  409. //! (true), wenn das übergebene Datum dem gespeicherten entspricht.
  410. //! (false) sonnst. Beispiel: ( 1.11.1995 ).istGleich( "y-m-d",
  411. //! "1995-11-1" ); return: true
  412. DLLEXPORT bool istGleich(const char* format, const char* datum) const;
  413. //! Prüft, ob das Datum gleich dem übergebenen Datum ist.
  414. //! \param format Eine Zeichenkette, die angibt in welcher Form das
  415. //! Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag. \param datum
  416. //! Ein Text Zeichnung, welches das zu überprüfende Datum enthält.
  417. //! \return (true), wenn das übergebene Datum dem gespeicherten
  418. //! entspricht. (false) sonnst. Beispiel: ( 1.11.1995 ).istGleich(
  419. //! "y-m-d", new Text( "1995-11-1" ) ); return: true
  420. DLLEXPORT bool istGleich(const char* format, Text* datum) const;
  421. //! Prüft, ob das Datum gleich dem übergebenen Datum ist.
  422. //! \param jahr Das Jahr des zu überprüfenden Datums.
  423. //! \param monat Der Monat des zu überprüfenden Datums.
  424. //! \param tag Der Tag des zu überprüfenden Datums.
  425. //! \return (true), wenn das übergebene Datum dem gespeicherten
  426. //! entspricht. (false) sonnst. Beispiel: ( 1.11.1995 ).istGleich( 1995,
  427. //! 11, 1 ); return: true
  428. DLLEXPORT bool istGleich(int jahr, int monat, int tag) const;
  429. //! Prüft, ob das Jahr gleich dem übergebenen Jahr ist.
  430. //! \param jahr Das zu prüfende Jahr.
  431. //! \return (true), wenn das übergebene Jahr dem gespeicherten
  432. //! entspricht. (false) sonnst.
  433. DLLEXPORT bool jahrGleich(int jahr) const;
  434. //! Prüft, ob der Monat gleich dem übergebenen Monat ist.
  435. //! \param monat Der zu prüfende Monat.
  436. //! \return (true), wenn der übergebene Monat dem gespeicherten
  437. //! entspricht. (false) sonnst.
  438. DLLEXPORT bool monatGleich(int monat) const;
  439. //! Prüft, ob der Tag gleich dem übergebenen Tag ist.
  440. //! \param tag Der zu prüfende Tag.
  441. //! \return (true), wenn der übergebene Tag dem gespeicherten
  442. //! entspricht. (false) sonnst.
  443. DLLEXPORT bool tagGleich(int tag) const;
  444. //! Prüft, ob das gespeicherte Datum kleiner als das übergebene ist.
  445. //! \param datum Das zu prüfende Datum.
  446. //! \return (true), wenn das gespeicherte Datum vor dem übergebenen
  447. //! liegt. (false) sonnst. Beispiel: ( 1.11.1995 ).istKleiner(
  448. //! ( 23.1.2016 ) ); return true
  449. DLLEXPORT bool istKleiner(Datum* datum) const;
  450. //! Prüft, ob das gespeicherte Datum kleiner als das übergebene ist.
  451. //! \param jahr Das Jahr des zu prüfenden Datums.
  452. //! \param monat Der Monat des zu prüfenden Datums.
  453. //! \param tag Der Tag des zu prüfenden Datums.
  454. //! \return (true), wenn das gespeicherte Datum vor dem übergebenen
  455. //! liegt. (false) sonnst. Beispiel: ( 1.11.1995 ).istKleiner( 2016, 1,
  456. //! 23 ); return true
  457. DLLEXPORT bool istKleiner(int jahr, int monat, int tag) const;
  458. //! Prüft, ob das gespeicherte Datum kleiner als das übergebene ist.
  459. //! \param format Eine Zeichenkette, die angibt in welcher Form das
  460. //! Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag. \param datum
  461. //! Eine Zeichenkette, die das zu überprüfende Datum enthält. \return
  462. //! (true), wenn das gespeicherte Datum vor dem übergebenen liegt.
  463. //! (false) sonnst. Beispiel: ( 1.11.1995 ).istKleiner( "y, m, d",
  464. //! "2016, 1, 23" ); return true
  465. DLLEXPORT bool istKleiner(const char* format, const char* datum) const;
  466. //! Prüft, ob das gespeicherte Datum kleiner als das übergebene ist.
  467. //! \param format Eine Zeichenkette, die angibt in welcher Form das
  468. //! Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag. \param datum
  469. //! Ein Text Zeichnung, welches das zu überprüfende Datum enthält.
  470. //! \return (true), wenn das gespeicherte Datum vor dem übergebenen
  471. //! liegt. (false) sonnst. Beispiel: ( 1.11.1995 ).istKleiner( "y, m,
  472. //! d", new Text( "2016, 1, 23" ) ); return true
  473. DLLEXPORT bool istKleiner(const char* format, Text* datum) const;
  474. //! Prüft, ob das gespeicherte Datum größer als das übergebene ist.
  475. //! \param datum Das zu prüfende Datum.
  476. //! \return (true), wenn das gespeicherte Datum hinter dem übergebenen
  477. //! liegt. (false) sonnst. Beispiel: ( 1.11.1995 ).istGrößer(
  478. //! ( 23.1.2016 ) ); return false
  479. DLLEXPORT bool istLater(Datum* datum) const;
  480. //! Prüft, ob das gespeicherte Datum größer als das übergebene ist.
  481. //! \param jahr Das Jahr des zu prüfenden Datums.
  482. //! \param monat Der Monat des zu prüfenden Datums.
  483. //! \param tag Der Tag des zu prüfenden Datums.
  484. //! \return (true), wenn das gespeicherte Datum hinter dem übergebenen
  485. //! liegt. (false) sonnst. Beispiel: ( 1.11.1995 ).istGrößer( 2016, 1,
  486. //! 23 ); return false
  487. DLLEXPORT bool istLater(int jahr, int monat, int tag) const;
  488. //! Prüft, ob das gespeicherte Datum größer als das übergebene ist.
  489. //! \param format Eine Zeichenkette, die angibt in welcher Form das
  490. //! Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag. \param datum
  491. //! Eine Zeichenkette, die das zu überprüfende Datum enthält. \return
  492. //! (true), wenn das gespeicherte Datum hinter dem übergebenen liegt.
  493. //! (false) sonnst. Beispiel: ( 1.11.1995 ).istGrößer( "y, m, d", "2016,
  494. //! 1, 23" ); return false
  495. DLLEXPORT bool istLater(const char* format, const char* datum) const;
  496. //! Prüft, ob das gespeicherte Datum größer als das übergebene ist.
  497. //! \param format Eine Zeichenkette, die angibt in welcher Form das
  498. //! Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag. \param datum
  499. //! Ein Text Zeichnung, welches das zu überprüfende Datum enthält.
  500. //! \return (true), wenn das gespeicherte Datum hinter dem übergebenen
  501. //! liegt. (false) sonnst. Beispiel: ( 1.11.1995 ).istGrößer( "y, m, d",
  502. //! new Text( "2016, 1, 23" ) ) ); return true
  503. DLLEXPORT bool istLater(const char* format, Text* datum) const;
  504. };
  505. //! Diese Klasse vereint die beiden Klassen Datum und Uhrzeit und speichert
  506. //! somit einen Zeitstempel mit Jahr, Monat, Tag, Stunde, Minute und Sekunde
  507. class Zeit : public virtual ReferenceCounter
  508. {
  509. private:
  510. Datum* datum;
  511. Uhrzeit* uhrzeit;
  512. public:
  513. //! Erzeugt eine neue Zeit mit den Standartwerten 0.0.0 0:0:0.
  514. DLLEXPORT Zeit();
  515. //! Erzeugt eine neue Zeit mit den vergangenen sekunden seit 1970.
  516. DLLEXPORT Zeit(__int64 timestamp);
  517. //! Löscht das aktuelle Zeichnung.
  518. DLLEXPORT ~Zeit();
  519. //! Ändert die gespeicherte Zeit durch kopieren der Werte aus (zeit).
  520. //! \param zeit Die neue Zeit.
  521. DLLEXPORT void setZeit(Zeit* zeit);
  522. //! Ändert die gespeicherte Zeit.
  523. //! \param jahr Das neue Jahr.
  524. //! \param monat Der neue Monat.
  525. //! \param tag Det neue Tag.
  526. //! \param stunde Die neue Stunde.
  527. //! \param minute Die neue Minute.
  528. //! \param sekunde Die neue Sekunde.
  529. DLLEXPORT void setZeit(
  530. int jahr, int monat, int tag, int stunde, int minute, int sekunde);
  531. //! Ändert die gespeicherte Zeit.
  532. //! \param format Eine Zeichenkette, die angibt in welcher Form die neue
  533. //! Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde,
  534. //! i=Minute, s=Sekunde. \param zeit Eine Zeichenkette, die die neue
  535. //! Zeit enthält. Beispiel: setZeit( "y-m-d h:i:s", "2016-1-25 21:59:30"
  536. //! );
  537. DLLEXPORT void setZeit(const char* format, const char* zeit);
  538. //! Ändert die gespeicherte Zeit.
  539. //! \param format Eine Zeichenkette, die angibt in welcher Form die neue
  540. //! Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde,
  541. //! i=Minute, s=Sekunde. \param zeit Ein Text Zeichnung, welches die
  542. //! neue Zeit enthält. Beispiel: setZeit( "y-m-d h:i:s", new Text(
  543. //! "2016-1-25 21:59:30" ) );
  544. DLLEXPORT void setZeit(const char* format, Text* zeit);
  545. //! Ändert das gespeicherte Jahr.
  546. //! \param jahr Das neue Jahr.
  547. DLLEXPORT void setJahr(int jahr);
  548. //! Ändert den gespeicherten Monat.
  549. //! \param monat Der neue Monat.
  550. DLLEXPORT void setMonat(int monat);
  551. //! Ändert den gespeicherten Tag.
  552. //! \param tag Der neue Tag.
  553. DLLEXPORT void setTag(int tag);
  554. //! Ändert die gespeicherte Stunde.
  555. //! \param stunde Die neue Stunde.
  556. DLLEXPORT void setStunde(int stunde);
  557. //! Ändert die gespeicherte Minute.
  558. //! \param minute Die neue Minute.
  559. DLLEXPORT void setMinute(int minute);
  560. //! Ändert die gespeicherte Sekunde.
  561. //! \param sekunde Die neue Sekunde.
  562. DLLEXPORT void setSekunde(int sekunde);
  563. //! Addiert die übergebene Zeit und speichert das Ergebnis.
  564. //! \param zeit Die zu Addierende Zeit.
  565. DLLEXPORT void plusZeit(Zeit* zeit);
  566. //! Addiert die übergebene Zeit und speichert das Ergebnis.
  567. //! \param jahr Das zu addierende Jahr.
  568. //! \param monat Der zu addierende Monat.
  569. //! \param tag Der zu addierende Tag.
  570. //! \param stunde Die zu addierende Stunde.
  571. //! \param minute Die zu addierende Minute.
  572. //! \param sekunde Die zu addierende Sekunde.
  573. DLLEXPORT void plusZeit(
  574. int jahr, int monat, int tag, int stunde, int minute, int sekunde);
  575. //! Addiert die übergebene Zeit und speichert das Ergebnis.
  576. //! \param format Eine Zeichenkette, die angibt in welcher Form die neue
  577. //! Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde,
  578. //! i=Minute, s=Sekunde. \param zeit Eine Zeichenkette, die die zu
  579. //! addierende Zeit enthält.
  580. DLLEXPORT void plusZeit(const char* format, const char* zeit);
  581. //! Addiert die übergebene Zeit und speichert das Ergebnis.
  582. //! \param format Eine Zeichenkette, die angibt in welcher Form die neue
  583. //! Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde,
  584. //! i=Minute, s=Sekunde. \param zeit Ein Text Zeichnung, welches die zu
  585. //! addierende Zeit enthält.
  586. DLLEXPORT void plusZeit(const char* format, Text* zeit);
  587. //! Addiert die übergebene Zeit und speichert das Ergebnis.
  588. //! \param jahr Das zu addierende Jahr.
  589. DLLEXPORT void plusJahr(int jahr);
  590. //! Addiert die übergebene Zeit und speichert das Ergebnis.
  591. //! \param monat Der zu addierende Monat.
  592. DLLEXPORT void plusMonat(int monat);
  593. //! Addiert die übergebene Zeit und speichert das Ergebnis.
  594. //! \param tag Der zu addierende Tag.
  595. DLLEXPORT void plusTag(int tag);
  596. //! Addiert die übergebene Zeit und speichert das Ergebnis.
  597. //! \param stunde Die zu addierende Stunde.
  598. DLLEXPORT void plusStunde(__int64 stunde);
  599. //! Addiert die übergebene Zeit und speichert das Ergebnis.
  600. //! \param minute Die zu addierende Minute.
  601. DLLEXPORT void plusMinute(__int64 minute);
  602. //! Addiert die übergebene Zeit und speichert das Ergebnis.
  603. //! \param sekunde Die zu addierende Sekunde.
  604. DLLEXPORT void plusSekunde(__int64 sekunde);
  605. //! Zieht die übergebene Zeit ab und speichert das Ergebnis.
  606. //! \param zeit Die abzuziehende Zeit.
  607. DLLEXPORT void minusZeit(Zeit* zeit);
  608. //! Zieht die übergebene Zeit ab und speichert das Ergebnis.
  609. //! \param jahr Das abzuziehende Jahr.
  610. //! \param monat Der abzuziehende Monat.
  611. //! \param tag Der abzuziehende Tag.
  612. //! \param stunde Die abzuziehende Stunde.
  613. //! \param minute Die abzuziehende Minute.
  614. //! \param sekunde Die abzuziehende Sekunde.
  615. DLLEXPORT void minusZeit(
  616. int jahr, int monat, int tag, int stunde, int minute, int sekunde);
  617. //! Zieht die übergebene Zeit ab und speichert das Ergebnis.
  618. //! \param format Eine Zeichenkette, die angibt in welcher Form die neue
  619. //! Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde,
  620. //! i=Minute, s=Sekunde. \param zeit Eine Zeichenkette, die die
  621. //! abzuziehende Zeit enthält.
  622. DLLEXPORT void minusZeit(const char* format, const char* zeit);
  623. //! Zieht die übergebene Zeit ab und speichert das Ergebnis.
  624. //! \param format Eine Zeichenkette, die angibt in welcher Form die neue
  625. //! Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde,
  626. //! i=Minute, s=Sekunde. \param zeit Ein Text Zeichnung, welches die
  627. //! abzuziehende Zeit enthält.
  628. DLLEXPORT void minusZeit(const char* format, Text* zeit);
  629. //! Zieht die übergebene Zeit ab und speichert das Ergebnis.
  630. //! \param jahr Das abzuziehende Jahr.
  631. DLLEXPORT void minusJahr(int jahr);
  632. //! Zieht die übergebene Zeit ab und speichert das Ergebnis.
  633. //! \param monat Der abzuziehende Monat.
  634. DLLEXPORT void minusMonat(int monat);
  635. //! Zieht die übergebene Zeit ab und speichert das Ergebnis.
  636. //! \param tag Der abzuziehende Tag.
  637. DLLEXPORT void minusTag(int tag);
  638. //! Zieht die übergebene Zeit ab und speichert das Ergebnis.
  639. //! \param stunde Die abzuziehende Stunde.
  640. DLLEXPORT void minusStunde(__int64 stunde);
  641. //! Zieht die übergebene Zeit ab und speichert das Ergebnis.
  642. //! \param minute Die abzuziehende Minute.
  643. DLLEXPORT void minusMinute(__int64 minute);
  644. //! Zieht die übergebene Zeit ab und speichert das Ergebnis.
  645. //! \param sekunde Die abzuziehende Sekunde.
  646. DLLEXPORT void minusSekunde(__int64 sekunde);
  647. //! Gibt die gespeicherte Zeit als Text zurück.
  648. //! \param format Eine Zeichenkette, die angibt in welcher Form die neue
  649. //! Zeit zurückgegeben werden soll. y=Jahr, m=Monat, d=Tag, h=Stunde,
  650. //! i=Minute, s=Sekunde.
  651. DLLEXPORT Text* getZeit(const char* format) const;
  652. //! Überprüft, ob die Zeit gleich der übergebenen Zeit ist.
  653. //! \param zeit die zu überprüfende Zeit.
  654. //! \return (true), wenn die Zeiten gleich sind. (false) sonst.
  655. DLLEXPORT bool istGleich(Zeit* zeit) const;
  656. //! Überprüft, ob die Zeit gleich der übergebenen Zeit ist.
  657. //! \param format Eine Zeichenkette, die angibt in welcher Form die neue
  658. //! Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde,
  659. //! i=Minute, s=Sekunde. \param zeit Eine Zeichenkette, die die zu
  660. //! überprüfende Zeit enthält. \return (true), wenn die Zeiten gleich
  661. //! sind. (false) sonst.
  662. DLLEXPORT bool istGleich(const char* format, const char* zeit) const;
  663. //! Überprüft, ob die Zeit gleich der übergebenen Zeit ist.
  664. //! \param format Eine Zeichenkette, die angibt in welcher Form die neue
  665. //! Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde,
  666. //! i=Minute, s=Sekunde. \param zeit Eine Text Zeichnung, welches die zu
  667. //! überprüfende Zeit enthält. \return (true), wenn die Zeiten gleich
  668. //! sind. (false) sonst.
  669. DLLEXPORT bool istGleich(const char* format, Text* zeit) const;
  670. //! Überprüft, ob die Zeit gleich der übergebenen Zeit ist.
  671. //! \param jahr Das zu überprüfende Jahr.
  672. //! \param monat Der zu überprüfende Monat.
  673. //! \param tag Der zu überprüfende Tag.
  674. //! \param stunde Die zu überprüfende Stunde.
  675. //! \param minute Die zu überprüfende Minute.
  676. //! \param sekunde Die zu überprüfende Sekunde.
  677. //! \return (true), wenn die Zeiten gleich sind. (false) sonst.
  678. DLLEXPORT bool istGleich(int jahr,
  679. int monat,
  680. int tag,
  681. int stunde,
  682. int minute,
  683. int sekunde) const;
  684. //! Gibt das Zeichnung zurück, in dem das Datum gespeichert wird mit
  685. //! erhöhtem Reference Counter.
  686. DLLEXPORT Datum* getDatum() const;
  687. //! Gibt das Zeichnung zurück, in dem das Datum gespeichert wird ohne
  688. //! erhöhten Reference Counter.
  689. DLLEXPORT Datum* zDatum() const;
  690. //! Gibt das Zeichnung zurück, in dem die Uhrzeit gespeichert wird mit
  691. //! erhöhtem Reference Counter.
  692. DLLEXPORT Uhrzeit* getUhrzeit() const;
  693. //! Gibt das Zeichnung zurück, in dem die uhrzeit gespeichert wird ohne
  694. //! erhöhten Reference Counter.
  695. DLLEXPORT Uhrzeit* zUhrzeit() const;
  696. //! Überprüft, ob die gespeicherte Zeit kleiner als die übergebene Zeit
  697. //! ist. \param zeit Die zu überprüfende Zeit. \return (true) wenn die
  698. //! gespeicherte Zeit vor der übergebenen Zeit liegt. (false) sonnst.
  699. DLLEXPORT bool istKleiner(Zeit* zeit) const;
  700. //! Überprüft, ob die gespeicherte Zeit kleiner als die übergebene Zeit
  701. //! ist. \param jahr Das zu überprüfende Jahr. \param monat Der zu
  702. //! überprüfende Monat. \param tag Der zu überprüfende Tag. \param
  703. //! stunde Die zu überprüfende Stunde. \param minute Die zu überprüfende
  704. //! Minute. \param sekunde Die zu überprüfende Sekunde. \return (true)
  705. //! wenn die gespeicherte Zeit vor der übergebenen Zeit liegt. (false)
  706. //! sonnst.
  707. DLLEXPORT bool istKleiner(int jahr,
  708. int monat,
  709. int tag,
  710. int stunde,
  711. int minute,
  712. int sekunde) const;
  713. //! Überprüft, ob die gespeicherte Zeit kleiner als die übergebene Zeit
  714. //! ist. \param format Eine Zeichenkette, die angibt in welcher Form die
  715. //! neue Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde,
  716. //! i=Minute, s=Sekunde. \param zeit Eine Zeichenkette, die die zu
  717. //! überprüfende Zeit enthält. \return (true) wenn die gespeicherte Zeit
  718. //! vor der übergebenen Zeit liegt. (false) sonnst.
  719. DLLEXPORT bool istKleiner(const char* format, const char* zeit) const;
  720. //! Überprüft, ob die gespeicherte Zeit kleiner als die übergebene Zeit
  721. //! ist. \param format Eine Zeichenkette, die angibt in welcher Form die
  722. //! neue Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde,
  723. //! i=Minute, s=Sekunde. \param zeit Eine Text Zeichnung, welches die zu
  724. //! überprüfende Zeit enthält. \return (true) wenn die gespeicherte Zeit
  725. //! vor der übergebenen Zeit liegt. (false) sonnst.
  726. DLLEXPORT bool istKleiner(const char* format, Text* zeit) const;
  727. //! Überprüft, ob die gespeicherte Zeit größer als die übergebene Zeit
  728. //! ist. \param zeit Die zu überprüfende Zeit. \return (true) wenn die
  729. //! gespeicherte Zeit nach der übergebenen Zeit liegt. (false) sonnst.
  730. DLLEXPORT bool istLater(Zeit* zeit) const;
  731. //! Überprüft, ob die gespeicherte Zeit größer als die übergebene Zeit
  732. //! ist. \param jahr Das zu überprüfende Jahr. \param monat Der zu
  733. //! überprüfende Monat. \param tag Der zu überprüfende Tag. \param
  734. //! stunde Die zu überprüfende Stunde. \param minute Die zu überprüfende
  735. //! Minute. \param sekunde Die zu überprüfende Sekunde. \return (true)
  736. //! wenn die gespeicherte Zeit nach der übergebenen Zeit liegt. (false)
  737. //! sonnst.
  738. DLLEXPORT bool istLater(int jahr,
  739. int monat,
  740. int tag,
  741. int stunde,
  742. int minute,
  743. int sekunde) const;
  744. //! Überprüft, ob die gespeicherte Zeit größer als die übergebene Zeit
  745. //! ist. \param format Eine Zeichenkette, die angibt in welcher Form die
  746. //! neue Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde,
  747. //! i=Minute, s=Sekunde. \param zeit Eine Zeichenkette, die die zu
  748. //! überprüfende Zeit enthält. \return (true) wenn die gespeicherte Zeit
  749. //! nach der übergebenen Zeit liegt. (false) sonnst.
  750. DLLEXPORT bool istLater(const char* format, const char* zeit) const;
  751. //! Überprüft, ob die gespeicherte Zeit größer als die übergebene Zeit
  752. //! ist. \param format Eine Zeichenkette, die angibt in welcher Form die
  753. //! neue Zeit in (zeit) vorhanden ist. y=Jahr, m=Monat, d=Tag, h=Stunde,
  754. //! i=Minute, s=Sekunde. \param zeit Eine Text Zeichnung, welches die zu
  755. //! überprüfende Zeit enthält. \return (true) wenn die gespeicherte Zeit
  756. //! nach der übergebenen Zeit liegt. (false) sonnst.
  757. DLLEXPORT bool istLater(const char* format, Text* zeit) const;
  758. };
  759. //! Diese Klasse kann messen, wie viel Zeit zwischen zwei Zeitpunkten
  760. //! verstrichen ist
  761. class ZeitMesser : public virtual ReferenceCounter
  762. {
  763. private:
  764. double start;
  765. double ende;
  766. double messung;
  767. public:
  768. //! Erzeugt ein neues ZeitMesser Zeichnung
  769. DLLEXPORT ZeitMesser();
  770. //! Löscht das aktuelle Zeichnung
  771. DLLEXPORT ~ZeitMesser();
  772. //! legt den Startpunkt des zeitstoppens fest
  773. DLLEXPORT void messungStart();
  774. //! legt des Endpunkt der Zeitmessung fest
  775. DLLEXPORT void messungEnde();
  776. //! gibt den Abstand zwischen start und ende der Messung in Sekunden
  777. //! zurück
  778. DLLEXPORT double getSekunden() const;
  779. //! gibt den Abstand zwischen start und ende der Messung in Minuten
  780. //! zurück
  781. DLLEXPORT double getMinuten() const;
  782. //! gibt den Abstand zwischen start und ende der Messung in Stunden
  783. //! zurück
  784. DLLEXPORT double getStunden() const;
  785. //! gibt true zurück, wenn aktuell eine MEssung läuft
  786. DLLEXPORT bool isMeasuring() const;
  787. };
  788. //! gibt die aktuelle Uhrzeit zurück.
  789. DLLEXPORT Uhrzeit* getUhrzeit();
  790. //! gibt das aktuelle Datum zurück.
  791. DLLEXPORT Datum* getDatum();
  792. //! gibt die aktuelle Zeit( Datum und Uhrzeit ) zurück.
  793. DLLEXPORT Zeit* getZeit();
  794. //! prüft, ob jahr ein Schaltjahr ist.
  795. //! \param jahr Das zu überprüfende Jahr.
  796. //! \return (true), wenn das übergebene jahr ein Schaltjahr ist. (false)
  797. //! sonst.
  798. DLLEXPORT bool istSchaltjahr(int jahr);
  799. } // namespace Framework
  800. #endif