Zeit.h 41 KB

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