KSG-Framework/Zeit.h

#ifndef Zeit_H
#define Zeit_H

#include <time.h>

#include "Betriebssystem.h"
#include "ReferenceCounter.h"

namespace Framework
{
    class Text;       //! Text.h
    class Uhrzeit;    //! Aus dieser Datei
    class Datum;      //! Aus dieser Datei
    class Zeit;       //! Aus dieser Datei
    class ZeitMesser; //! Aus dieser Datei

    //! Diese Klasse speichert eine Uhrzeit in form von Stunden, Minuten und
    //! Sekunden
    class Uhrzeit : public virtual ReferenceCounter
    {
    private:
        int stunde, minute, sekunde;
        int update();

    public:
        // Erzeugt ein neues Uhrzeit Zeichnung mit den Standartwerten 00:00:00
        DLLEXPORT Uhrzeit();

        // Setzt die Uhrzeit durch kopieren.
        //! \param zeit Aus diesem Zeichnung werden die Werte für Stunde, Minute
        //! und Sekunde kopiert.
        DLLEXPORT int setUhrzeit(Uhrzeit* zeit);
        // Setzt die Uhrzeit.
        //! \param stunde Die Stunde der neuen Uhrzeit.
        //! \param minute Die Minute der neuen Uhrzeit.
        //! \param sekunde Die Sekunde der neuen Uhrzeit.
        //! \return Die Anzahl übriger Tage.
        //! Beispiel: setUhrzeit( 30, 30, 30 ); return: 1, gespeichert: 6:30:30
        DLLEXPORT int setUhrzeit(int stunde, int minute, int sekunde);
        // Setzt die Uhrzeit.
        //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die
        //! Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde. \param
        //! zeit Eine Zeichenfolge die die neue Uhrzeit enthält. \return Die
        //! Anzahl übriger Tage. Beispiel: setUhrzeit( "h:i:s", "05:30:00" );
        //! Beispiel: setUhrzeit( "h:i:s", "30:30:00" ); return: 1, gespeichert:
        //! 6:30:00
        DLLEXPORT int setUhrzeit(const char* format, const char* zeit);
        // Setzt die Uhrzeit.
        //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die
        //! Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde. \param
        //! zeit Ein Text Zeichnung, dass die neue Uhrzeit enthält. \return Die
        //! Anzahl übriger Tage. Beispiel: setUhrzeit( "h:i:s", new Text(
        //! "05:30:00" ) ); Beispiel: setUhrzeit( "h:i:s", new Text( "30:30:00"
        //! ) ); return: 1, gespeichert: 6:30:00
        DLLEXPORT int setUhrzeit(const char* format, Text* zeit);
        //! setzt die Stunde.
        //! \param stunde Die Stunde, die gespeichert werden soll.
        //! \return Die Anzahl übriger Tage.
        //! Beispiel: setStunde( 30 ); return: 1 Tag, gespeicherte Stunden: 6
        DLLEXPORT int setStunde(int stunde);
        //! setzt die Minute.
        //! \param minute Die Minute, die gespeichert werden soll.
        //! \return Die Anzahl übriger Tage.
        //! Beispiel: Alte Zeit: 23:50:10, setMinute( 80 ); return: 1,
        //! gespeicherte Zeit: 01:10:10
        DLLEXPORT int setMinute(int minute);
        //! setzt die Sekunde.
        //! \param minute Die Sekunde, die gespeichert werden soll.
        //! \return Die Anzahl übriger Tage.
        //! Beispiel: Alte Zeit: 23:59:10, setSekunde( 80 ); return: 1,
        //! gespeicherte Zeit: 00:00:30
        DLLEXPORT int setSekunde(int sekunde);
        //! errechnet die Summe von dieser und einer anderen Uhrzeit und
        //! speichert diese. \param zeit Die Uhrzeit, deren Werte addiert werden
        //! sollen. \return Die Anzahl übriger Tage. Beispiel: Alte Zeit:
        //! 19:40:18, plusZeit( (10:05:30) ); return 1, gespeicherte Zeit:
        //! 05:45:48
        DLLEXPORT int plusUhrzeit(Uhrzeit* zeit);
        //! errechnet die Summe von dieser und einer anderen Uhrzeit und
        //! speichert diese. \param stunde Die Stunden die Werte addiert werden
        //! sollen. \param minute Die Minute die Werte addiert werden sollen.
        //! \param sekunde Die Sekunde die Werte addiert werden sollen.
        //! \return Die Anzahl übriger Tage.
        //! Beispiel: Alte Zeit: 19:40:18, plusZeit( 10, 5, 30 ); return 1,
        //! gespeicherte Zeit: 05:45:48
        DLLEXPORT int plusUhrzeit(int stunde, int minute, int sekunde);
        //! errechnet die Summe von dieser und einer anderen Uhrzeit und
        //! speichert diese. \param format Eine Zeichenfolge, die bestimmt in
        //! welcher Form die Uhrzeit in (zeit) vorliegt. h=Stunde,
        //! i=Minute,s=Sekunde. \param zeit Eine Zeichenfolge die die neue
        //! Uhrzeit enthält. \return Die Anzahl übriger Tage. Beispiel:
        //! plusUhrzeit( "h:i:s", "05:20:00" ); Beispiel: Alte Zeit: 19:40:18,
        //! plusZeit( "h:i:s", "10:05:30" ); return 1, gespeicherte Zeit:
        //! 05:45:48
        DLLEXPORT int plusUhrzeit(const char* format, const char* zeit);
        //! errechnet die Summe von dieser und einer anderen Uhrzeit und
        //! speichert diese. \param format Eine Zeichenfolge, die bestimmt in
        //! welcher Form die Uhrzeit in (zeit) vorliegt. h=Stunde,
        //! i=Minute,s=Sekunde. \param zeit Ein Text Zeichnung, welches die neue
        //! Uhrzeit enthält. \return Die Anzahl übriger Tage. Beispiel:
        //! plusUhrzeit( "h:i:s", new Text( "05:20:00" ) ); Beispiel: Alte Zeit:
        //! 19:40:18, plusZeit( "h:i:s", new Text( "10:05:30" ) ); return 1,
        //! gespeicherte Zeit: 05:45:48
        DLLEXPORT int plusUhrzeit(const char* format, Text* zeit);
        //! errechnet die Summe von dieser und einer anderen Uhrzeit und
        //! speichert diese. \param stunde die draufzurechnenden Stunden.
        //! \return Die Anzahl übriger Tage.
        //! Beispiel: Alte Zeit: 20:50:30, plusStunde( 10 ); return 1,
        //! gespeicherte Zeit: 6:50:30
        DLLEXPORT int plusStunde(int stunde);
        //! errechnet die Summe von dieser und einer anderen Uhrzeit und
        //! speichert diese. \param minute die draufzurechnenden Minuten.
        //! \return Die Anzahl übriger Tage.
        //! Beispiel: Alte Zeit: 23:50:30, plusMinute( 11 ); return 1,
        //! gespeicherte Zeit: 00:01:30
        DLLEXPORT int plusMinute(int minute);
        //! errechnet die Summe von dieser und einer anderen Uhrzeit und
        //! speichert diese. \param sekunde die draufzurechnenden Sekunden.
        //! \return Die Anzahl übriger Tage.
        //! Beispiel: Alte Zeit: 23:59:30, plusSekunde( 40 ); return 1,
        //! gespeicherte Zeit: 00:00:10
        DLLEXPORT int plusSekunde(int sekunde);
        //! zieht eine gegebene Uhrzeit von dieser ab und speichert das
        //! Ergebnis. \param zeit Die Uhrzeit, die von dieser abgezogen werden
        //! soll. \return Die Anzahl übriger Tage. Beispiel Alte Zeit: 10:40:18,
        //! minusUhrzeit( (19:05:30) ); return -1, gespeicherte Zeit: 15:34:48
        DLLEXPORT int minusUhrzeit(Uhrzeit* zeit);
        //! zieht eine gegebene Uhrzeit von dieser ab und speichert das
        //! Ergebnis. \param stunde Die Stunden, die von dieser Uhrzeit
        //! abgezogen werden sollen. \param minute Die Minuten, die von dieser
        //! Uhrzeit abgezogen werden sollen. \param sekunde Die Sekunden, die
        //! von dieser Uhrzeit abgezogen werden sollen. \return Die Anzahl
        //! übriger Tage. Beispiel Alte Zeit: 10:40:18, minusUhrzeit( 19, 05, 30
        //! ); return -1, gespeicherte Zeit: 15:34:48
        DLLEXPORT int minusUhrzeit(int stunde, int minute, int sekunde);
        //! zieht eine gegebene Uhrzeit von dieser ab und speichert das
        //! Ergebnis. \param format Eine Zeichenfolge, die bestimmt in welcher
        //! Form die Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde.
        //! \param zeit Eine Zeichenfolge die die neue Uhrzeit enthält.
        //! \return Die Anzahl übriger Tage.
        //! Beispiel Alte Zeit: 10:40:18, minusUhrzeit( "h:i:s", "19:05:30" );
        //! return -1, gespeicherte Zeit: 15:34:48
        DLLEXPORT int minusUhrzeit(const char* format, const char* zeit);
        //! zieht eine gegebene Uhrzeit von dieser ab und speichert das
        //! Ergebnis. \param format Eine Zeichenfolge, die bestimmt in welcher
        //! Form die Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde.
        //! \param zeit Ein Text Zeichnung, welches die neue Uhrzeit enthält.
        //! \return Die Anzahl übriger Tage.
        //! Beispiel Alte Zeit: 10:40:18, minusUhrzeit( "h:i:s", new Text(
        //! "19:05:30" ) ); return -1, gespeicherte Zeit: 15:34:48
        DLLEXPORT int minusUhrzeit(const char* format, Text* zeit);
        //! zieht eine gegebene Zeit von dieser ab und speichert das Ergebnis.
        //! \param stunde Die abzuziehenden Stunden.
        //! \return Die Anzahl übriger Tage.
        //! Beispiel Alte Zeit: 10:40:18, minusStunde( 19 ); return -1,
        //! gespeicherte Zeit: 15:40:18
        DLLEXPORT int minusStunde(int stunde);
        //! zieht eine gegebene Zeit von dieser ab und speichert das Ergebnis.
        //! \param minute Die abzuziehenden Minuten.
        //! \return Die Anzahl übriger Tage.
        //! Beispiel Alte Zeit: 00:40:18, minusStunde( 50 ); return -1,
        //! gespeicherte Zeit: 23:50:18
        DLLEXPORT int minusMinute(int minute);
        //! zieht eine gegebene Zeit von dieser ab und speichert das Ergebnis.
        //! \param sekunde Die abzuziehenden Sekunden.
        //! \return Die Anzahl übriger Tage.
        //! Beispiel Alte Zeit: 00:00:20, minusStunde( 50 ); return -1,
        //! gespeicherte Zeit: 23:59:30
        DLLEXPORT int minusSekunde(int sekunde);

        //! gibt die Stunde zurück.
        DLLEXPORT int getStunde() const;
        //! gibt die Minute zurück.
        DLLEXPORT int getMinute() const;
        //! gibt die Sekunde zurück.
        DLLEXPORT int getSekunde() const;
        //! gibt die Uhrzeit als Text formatiert zurück.
        //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die
        //! Uhrzeit zurückgegeben werden soll. h=Stunde, i=Minute,s=Sekunde.
        //! Beispiel: Zeit: 5:40:39, getUhrzeit( "h:i:s" ); return: "5:40:39"
        DLLEXPORT Text* getUhrzeit(const char* format) const;
        //! prüft, ob die Uhrzeit gleich zeit ist.
        //! \param zeit Die Uhrzeit, mit der diese verglichen werden soll.
        //! \return (true), wenn die beiden Zeiten geich sind. (false), wenn die
        //! Zeiten nicht gleich sind.
        DLLEXPORT bool istGleich(Uhrzeit* zeit) const;
        //! prüft, ob die Uhrzeit gleich zeit ist.
        //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die
        //! Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde. \param
        //! zeit Eine Zeichenfolge die die andere Uhrzeit enthält. \return
        //! (true), wenn die beiden Zeiten geich sind. (false), wenn die Zeiten
        //! nicht gleich sind.
        DLLEXPORT bool istGleich(const char* format, const char* zeit) const;
        //! prüft, ob die Uhrzeit gleich zeit ist.
        //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die
        //! Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde. \param
        //! zeit Ein Text Zeichnung, welches die andere Uhrzeit enthält. \return
        //! (true), wenn die beiden Zeiten geich sind. (false), wenn die Zeiten
        //! nicht gleich sind.
        DLLEXPORT bool istGleich(const char* format, Text* zeit) const;
        //! prüft, ob die Uhrzeit gleich der übergebenen Zeit ist. Hier wird
        //! nicht beachtet, ob die gegebene Zeit eine gültige Uhrzeit ist.
        //! \param stunde Die Stunden der zu überprüfenden Uhrzeit
        //! \param minute Die Minuten der zu überprüfenden Uhrzeit
        //! \param sekunde Die Sekunden der zu überprüfenden Uhrzeit
        //! \return (true), wenn die beiden Zeiten geich sind. (false), wenn die
        //! Zeiten nicht gleich sind.
        DLLEXPORT bool istGleich(int stunde, int minute, int sekunde) const;
        //! prüft, ob die Stunde gleich der gegebenen Stunde ist.
        //! \param stunde die zu prüfende Stunde.
        //! \return (true), wenn die Stunden gleich sind. (false), wenn sie
        //! nicht gleich sind.
        DLLEXPORT bool stundeGleich(int stunde) const;
        //! prüft, ob die Minute gleich der gegebenen Minute ist.
        //! \param minute die zu prüfende Minute.
        //! \return (true), wenn die Minuten gleich sind. (false), wenn sie
        //! nicht gleich sind.
        DLLEXPORT bool minuteGleich(int minute) const;
        //! prüft, ob die Sekunde gleich der gegebenen Sekunde ist.
        //! \param sekunde die zu prüfende Sekunde.
        //! \return (true), wenn die Sekunden gleich sind. (false), wenn sie
        //! nicht gleich sind.
        DLLEXPORT bool sekundeGleich(int sekunde) const;
        //! prüft, ob die Uhrzeit kleiner als zeit ist.
        //! \param zeit Die zu prüfende Uhrzeit.
        //! \return (true), wenn die gespeicherte Zeit kleiner als die
        //! übergebene Zeit ist. (false) sonst. Beispiel: (5:30:00).istKleiner(
        //! (10:40:29) ); return true
        DLLEXPORT bool istKleiner(Uhrzeit* zeit) const;
        //! prüft, ob die Uhrzeit kleiner als die übergebene Zeit ist.
        //! \param stunde Die Stunden der zu prüfenden Zeit.
        //! \param minute Die Minute der zu prüfenden Zeit.
        //! \param sekunde Die Sekunde der zu prüfenden Zeit.
        //! \return (true), wenn die gespeicherte Zeit kleiner als die
        //! übergebene Zeit ist. (false) sonst. Beispiel: (5:30:00).istKleiner(
        //! 10, 40, 29 ); return true
        DLLEXPORT bool istKleiner(int stunde, int minute, int sekunde) const;
        //! prüft, ob die Uhrzeit kleiner als die übergebene Zeit ist.
        //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die
        //! Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde. \param
        //! zeit Eine Zeichenfolge die die andere Uhrzeit enthält. \return
        //! (true), wenn die gespeicherte Zeit kleiner als die übergebene Zeit
        //! ist. (false) sonst. Beispiel: (5:30:00).istKleiner( "h:i:s",
        //! "10:40:29" ); return true
        DLLEXPORT bool istKleiner(const char* format, const char* zeit) const;
        //! prüft, ob die Uhrzeit kleiner als die übergebene Zeit ist.
        //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die
        //! Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde. \param
        //! zeit Ein Text Zeichnung, welches die andere Uhrzeit enthält. \return
        //! (true), wenn die gespeicherte Zeit kleiner als die übergebene Zeit
        //! ist. (false) sonst. Beispiel: (5:30:00).istKleiner( "h:i:s",
        //! "10:40:29" ); return true
        DLLEXPORT bool istKleiner(const char* format, Text* zeit) const;
        //! prüft, ob die Uhrzeit größer als zeit ist.
        //! \param zeit Die zu prüfende Uhrzeit.
        //! \return (true), wenn die gespeicherte Zeit größer als die übergebene
        //! Zeit ist. (false) sonst. Beispiel: (5:30:00).istGrößer( (10:40:29)
        //! ); return false
        DLLEXPORT bool istLater(Uhrzeit* zeit) const;
        //! prüft, ob die Uhrzeit größer als die übergebene Zeit ist.
        //! \param stunde Die Stunden der zu prüfenden Zeit.
        //! \param minute Die Minute der zu prüfenden Zeit.
        //! \param sekunde Die Sekunde der zu prüfenden Zeit.
        //! \return (true), wenn die gespeicherte Zeit größer als die übergebene
        //! Zeit ist. (false) sonst. Beispiel: (5:30:00).istGrößer( 10, 40, 29
        //! ); return false
        DLLEXPORT bool istLater(int stunde, int minute, int sekunde) const;
        //! prüft, ob die Uhrzeit größer als die übergebene Zeit ist.
        //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die
        //! Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde. \param
        //! zeit Eine Zeichenfolge die die andere Uhrzeit enthält. \return
        //! (true), wenn die gespeicherte Zeit größer als die übergebene Zeit
        //! ist. (false) sonst. Beispiel: (5:30:00).istGrößer( "h:i:s",
        //! "10:40:29" ); return false
        DLLEXPORT bool istLater(const char* format, const char* zeit) const;
        //! prüft, ob die Uhrzeit größer als die übergebene Zeit ist.
        //! \param format Eine Zeichenfolge, die bestimmt in welcher Form die
        //! Uhrzeit in (zeit) vorliegt. h=Stunde, i=Minute,s=Sekunde. \param
        //! zeit Ein Text Zeichnung, welches die andere Uhrzeit enthält. \return
        //! (true), wenn die gespeicherte Zeit größer als die übergebene Zeit
        //! ist. (false) sonst. Beispiel: (5:30:00).istGrößer( "h:i:s",
        //! "10:40:29" ); return false
        DLLEXPORT bool istLater(const char* format, Text* zeit) const;
    };

    //! Diese Klasse speichert ein Datum in Form von Jahr, Monat und Tagen
    class Datum : public virtual ReferenceCounter
    {
    private:
        int jahr, monat, tag;
        int* maxTage;
        void update();

    public:
        //! Erzeugt ein neues Datum Zeichnung mit den Standartwerten 0.0.0.
        DLLEXPORT Datum();
        //! Löscht das Datum.
        DLLEXPORT ~Datum();

        //! Setzt das Datum durch kopieren.
        //! \param datum Das zu speichernde Datum.
        DLLEXPORT void setDatum(Datum* datum);
        //! Setzt das Datum zu den übergebenen Werten.
        //! \param jahr Das Jahr des neuen Datums.
        //! \param monat Der Monat des neuen Datums.
        //! \param tag Der Tag des neuen Datums.
        DLLEXPORT void setDatum(int jahr, int monat, int tag);
        //! Setzt das Datum zu dem übergebenen Wert.
        //! \param format Eine Zeichenkette, die angibt in welcher Form das
        //! Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag. \param datum
        //! Eine Zeichenkette, die das neue Datum enthält. Beispiel: setDatum(
        //! "y-m-d", "2016-01-25" );
        DLLEXPORT void setDatum(const char* format, const char* datum);
        //! Setzt das Datum zu dem übergebenen Wert.
        //! \param format Eine Zeichenkette, die angibt in welcher Form das
        //! Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag. \param datum
        //! Ein Text Zeichnung, welches das neue Datum enthält. Beispiel:
        //! setDatum( "y-m-d", new Text(  "2016-01-25" ) );
        DLLEXPORT void setDatum(const char* format, Text* datum);
        //! Ändert das Jahr des Datums.
        //! \param jahr Das neue Jahr.
        DLLEXPORT void setJahr(int jahr);
        //! Ändert den Monat des Datums.
        //! \param monat Der neue Monat.
        DLLEXPORT void setMonat(int monat);
        //! Ändert den Tag des Datums.
        //! \param tag Der neue Tag.
        DLLEXPORT void setTag(int tag);
        //! Addiert zum aktuellen Datum das übergebene Datum dazu und speichert
        //! das Ergebnis. \param datum Das zu addierende Datum. Beispiel:
        //! ( 1.11.1995 ).plusDatum( ( 5.2.7 ) ); neues Datum: 6.1.2003
        DLLEXPORT void plusDatum(Datum* datum);
        //! Addiert zum aktuellen Datum das übergebene Datum dazu und speichert
        //! das Ergebnis. \param jahr Das zu addierende Jahr. \param monat Der
        //! zu addierende Monat. \param tag Der zu addierende Tag. Beispiel:
        //! ( 1.11.1995 ).plusDatum( ( 7, 2, 5 ) ); neues Datum: 6.1.2003
        DLLEXPORT void plusDatum(int jahr, int monat, int tag);
        //! Addiert zum aktuellen Datum das übergebene Datum dazu und speichert
        //! das Ergebnis. \param format Eine Zeichenkette, die angibt in welcher
        //! Form das Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag.
        //! \param datum Eine Zeichenkette, die das zu addierende Datum enthält.
        //! Beispiel: ( 1.11.1995 ).plusDatum( "d.m.y", "5.2.7" ); neues
        //! Datum: 6.1.2003
        DLLEXPORT void plusDatum(const char* format, const char* datum);
        //! Addiert zum aktuellen Datum das übergebene Datum dazu und speichert
        //! das Ergebnis. \param format Eine Zeichenkette, die angibt in welcher
        //! Form das Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag.
        //! \param datum Ein Text Zeichnung, welches das zu addierende Datum
        //! enthält. Beispiel: ( 1.11.1995 ).plusDatum( "d.m.y", new Text(
        //! "5.2.7" ) ); neues Datum: 6.1.2003
        DLLEXPORT void plusDatum(const char* format, Text* datum);
        //! Addiert zum aktuellen Datum das übergebene Jahr dazu und speichert
        //! das Ergebnis. \param jahr Das zu addierende Jahr. Beispiel:
        //! ( 1.11.1995 ).plusJahr( 21 ); neues Datum: 1.11.2016
        DLLEXPORT void plusJahr(int jahr);
        //! Addiert zum aktuellen Datum den übergebenen Monat dazu und speichert
        //! das Ergebnis. \param monat Der zu addierende Monat. Beispiel:
        //! ( 1.11.1995 ).plusMonat( 13 ); neues Datum: 1.12.1996
        DLLEXPORT void plusMonat(int monat);
        //! Addiert zum aktuellen Datum den übergebenen Tag dazu und speichert
        //! das Ergebnis. \param tag Der zu addierende Tag. Beispiel: ( 1.1.2000
        //! ).plusTag( 32 ); neues Datum: 2.2.2000
        DLLEXPORT void plusTag(int tag);
        //! Zieht vom aktuellen Datum das übergebene Datum ab und speichert das
        //! Ergebnis. \param datum Das abzuzuehende Datum. Beispiel: ( 2.12.1996
        //! ).minusDatum( ( 1.1.1 ) ); neues Datum: 1.11.1995
        DLLEXPORT void minusDatum(Datum* datum);
        //! Zieht vom aktuellen Datum das übergebene Datum ab und speichert das
        //! Ergebnis. \param jahr Das abzuzuehende Jahr. \param monat Der
        //! abzuzuehende Monat. \param tag Der abzuzuehende Tag. Beispiel:
        //! ( 2.12.1996 ).minusDatum( 1, 1, 1 ); neues Datum: 1.11.1995
        DLLEXPORT void minusDatum(int jahr, int monat, int tag);
        //! Zieht vom aktuellen Datum das übergebene Datum ab und speichert das
        //! Ergebnis. \param format Eine Zeichenkette, die angibt in welcher
        //! Form das Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag.
        //! \param datum Eine Zeichenkette, die das abzuziehende Datum enthält.
        //! Beispiel: ( 2.12.1996 ).minusDatum( "d.m.y", "1.1.1" ); neues
        //! Datum: 1.11.1995
        DLLEXPORT void minusDatum(const char* format, const char* datum);
        //! Zieht vom aktuellen Datum das übergebene Datum ab und speichert das
        //! Ergebnis. \param format Eine Zeichenkette, die angibt in welcher
        //! Form das Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag.
        //! \param datum Ein Text Zeichnung, welches das abzuziehende Datum
        //! enthält. Beispiel: ( 2.12.1996 ).minusDatum( "d.m.y", new Text(
        //! "1.1.1" ) ); neues Datum: 1.11.1995
        DLLEXPORT void minusDatum(const char* format, Text* datum);
        //! Zieht vom aktuellen Datum das übergebene Jahr ab und speichert das
        //! Ergebnis. \param jahr Das abzuzuehende Jahr. Beispiel: ( 1.11.1996
        //! ).minusJahr( 1 ); neues Datum: 1.11.1995
        DLLEXPORT void minusJahr(int jahr);
        //! Zieht vom aktuellen Datum den übergebenen Monat ab und speichert das
        //! Ergebnis. \param monat Der abzuzuehende Monat. Beispiel: ( 1.12.1996
        //! ).minusMonat( 13 ); neues Datum: 1.11.1995
        DLLEXPORT void minusMonat(int monat);
        //! Zieht vom aktuellen Datum den übergebenen Tag ab und speichert das
        //! Ergebnis. \param monat Der abzuzuehende Tag. Beispiel: ( 5.2.2016
        //! ).minusMonat( 11 ); neues Datum: 25.1.2016
        DLLEXPORT void minusTag(int tag);

        //! gibt das Jahr zurück.
        DLLEXPORT int getJahr() const;
        //! gibt der Monat zurück.
        DLLEXPORT int getMonat() const;
        //! gibt der Tag zurück.
        DLLEXPORT int getTag() const;
        //! Gibt das Datum als Text Zeichnung zurück.
        //! \param format Eine Zeichenkette, die angibt in welcher Form das
        //! Datum zurückgegeben werden soll. y=Jahr, m=Monat, d=Tag. Beispiel:
        //! ( 1.11.1995 ).getDatum( "y-m-d" ); return: "1995-11-1"
        DLLEXPORT Text* getDatum(const char* format) const;
        //! Prüft, ob das Datum gleich dem übergebenen Datum ist.
        //! \param datum das zu prüfende Datum.
        //! \return (true), wenn das übergebene Datum dem gespeicherten
        //! entspricht. (false) sonnst.
        DLLEXPORT bool istGleich(Datum* datum) const;
        //! Prüft, ob das Datum gleich dem übergebenen Datum ist.
        //! \param format Eine Zeichenkette, die angibt in welcher Form das
        //! Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag. \param datum
        //! Eine Zeichenkette, die das zu überprüfende Datum enthält. \return
        //! (true), wenn das übergebene Datum dem gespeicherten entspricht.
        //! (false) sonnst. Beispiel: ( 1.11.1995 ).istGleich( "y-m-d",
        //! "1995-11-1" ); return: true
        DLLEXPORT bool istGleich(const char* format, const char* datum) const;
        //! Prüft, ob das Datum gleich dem übergebenen Datum ist.
        //! \param format Eine Zeichenkette, die angibt in welcher Form das
        //! Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag. \param datum
        //! Ein Text Zeichnung, welches das zu überprüfende Datum enthält.
        //! \return (true), wenn das übergebene Datum dem gespeicherten
        //! entspricht. (false) sonnst. Beispiel: ( 1.11.1995 ).istGleich(
        //! "y-m-d", new Text( "1995-11-1" ) ); return: true
        DLLEXPORT bool istGleich(const char* format, Text* datum) const;
        //! Prüft, ob das Datum gleich dem übergebenen Datum ist.
        //! \param jahr Das Jahr des zu überprüfenden Datums.
        //! \param monat Der Monat des zu überprüfenden Datums.
        //! \param tag Der Tag des zu überprüfenden Datums.
        //! \return (true), wenn das übergebene Datum dem gespeicherten
        //! entspricht. (false) sonnst. Beispiel: ( 1.11.1995 ).istGleich( 1995,
        //! 11, 1 ); return: true
        DLLEXPORT bool istGleich(int jahr, int monat, int tag) const;
        //! Prüft, ob das Jahr gleich dem übergebenen Jahr ist.
        //! \param jahr Das zu prüfende Jahr.
        //! \return (true), wenn das übergebene Jahr dem gespeicherten
        //! entspricht. (false) sonnst.
        DLLEXPORT bool jahrGleich(int jahr) const;
        //! Prüft, ob der Monat gleich dem übergebenen Monat ist.
        //! \param monat Der zu prüfende Monat.
        //! \return (true), wenn der übergebene Monat dem gespeicherten
        //! entspricht. (false) sonnst.
        DLLEXPORT bool monatGleich(int monat) const;
        //! Prüft, ob der Tag gleich dem übergebenen Tag ist.
        //! \param tag Der zu prüfende Tag.
        //! \return (true), wenn der übergebene Tag dem gespeicherten
        //! entspricht. (false) sonnst.
        DLLEXPORT bool tagGleich(int tag) const;
        //! Prüft, ob das gespeicherte Datum kleiner als das übergebene ist.
        //! \param datum Das zu prüfende Datum.
        //! \return (true), wenn das gespeicherte Datum vor dem übergebenen
        //! liegt. (false) sonnst. Beispiel: ( 1.11.1995 ).istKleiner(
        //! ( 23.1.2016 ) ); return true
        DLLEXPORT bool istKleiner(Datum* datum) const;
        //! Prüft, ob das gespeicherte Datum kleiner als das übergebene ist.
        //! \param jahr Das Jahr des zu prüfenden Datums.
        //! \param monat Der Monat des zu prüfenden Datums.
        //! \param tag Der Tag des zu prüfenden Datums.
        //! \return (true), wenn das gespeicherte Datum vor dem übergebenen
        //! liegt. (false) sonnst. Beispiel: ( 1.11.1995 ).istKleiner( 2016, 1,
        //! 23 ); return true
        DLLEXPORT bool istKleiner(int jahr, int monat, int tag) const;
        //! Prüft, ob das gespeicherte Datum kleiner als das übergebene ist.
        //! \param format Eine Zeichenkette, die angibt in welcher Form das
        //! Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag. \param datum
        //! Eine Zeichenkette, die das zu überprüfende Datum enthält. \return
        //! (true), wenn das gespeicherte Datum vor dem übergebenen liegt.
        //! (false) sonnst. Beispiel: ( 1.11.1995 ).istKleiner( "y, m, d",
        //! "2016, 1, 23" ); return true
        DLLEXPORT bool istKleiner(const char* format, const char* datum) const;
        //! Prüft, ob das gespeicherte Datum kleiner als das übergebene ist.
        //! \param format Eine Zeichenkette, die angibt in welcher Form das
        //! Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag. \param datum
        //! Ein Text Zeichnung, welches das zu überprüfende Datum enthält.
        //! \return (true), wenn das gespeicherte Datum vor dem übergebenen
        //! liegt. (false) sonnst. Beispiel: ( 1.11.1995 ).istKleiner( "y, m,
        //! d", new Text( "2016, 1, 23" ) ); return true
        DLLEXPORT bool istKleiner(const char* format, Text* datum) const;
        //! Prüft, ob das gespeicherte Datum größer als das übergebene ist.
        //! \param datum Das zu prüfende Datum.
        //! \return (true), wenn das gespeicherte Datum hinter dem übergebenen
        //! liegt. (false) sonnst. Beispiel: ( 1.11.1995 ).istGrößer(
        //! ( 23.1.2016 ) ); return false
        DLLEXPORT bool istLater(Datum* datum) const;
        //! Prüft, ob das gespeicherte Datum größer als das übergebene ist.
        //! \param jahr Das Jahr des zu prüfenden Datums.
        //! \param monat Der Monat des zu prüfenden Datums.
        //! \param tag Der Tag des zu prüfenden Datums.
        //! \return (true), wenn das gespeicherte Datum hinter dem übergebenen
        //! liegt. (false) sonnst. Beispiel: ( 1.11.1995 ).istGrößer( 2016, 1,
        //! 23 ); return false
        DLLEXPORT bool istLater(int jahr, int monat, int tag) const;
        //! Prüft, ob das gespeicherte Datum größer als das übergebene ist.
        //! \param format Eine Zeichenkette, die angibt in welcher Form das
        //! Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag. \param datum
        //! Eine Zeichenkette, die das zu überprüfende Datum enthält. \return
        //! (true), wenn das gespeicherte Datum hinter dem übergebenen liegt.
        //! (false) sonnst. Beispiel: ( 1.11.1995 ).istGrößer( "y, m, d", "2016,
        //! 1, 23" ); return false
        DLLEXPORT bool istLater(const char* format, const char* datum) const;
        //! Prüft, ob das gespeicherte Datum größer als das übergebene ist.
        //! \param format Eine Zeichenkette, die angibt in welcher Form das
        //! Datum in (datum) vorhanden ist. y=Jahr, m=Monat, d=Tag. \param datum
        //! Ein Text Zeichnung, welches das zu überprüfende Datum enthält.
        //! \return (true), wenn das gespeicherte Datum hinter dem übergebenen
        //! liegt. (false) sonnst. Beispiel: ( 1.11.1995 ).istGrößer( "y, m, d",
        //! new Text( "2016, 1, 23" ) ) ); return true
        DLLEXPORT bool istLater(const char* format, Text* datum) const;
    };

    //! Diese Klasse vereint die beiden Klassen Datum und Uhrzeit und speichert
    //! somit einen Zeitstempel mit Jahr, Monat, Tag, Stunde, Minute und Sekunde
    class Zeit : public virtual ReferenceCounter
    {
    private:
        Datum* datum;
        Uhrzeit* uhrzeit;

    public:
        //! Erzeugt ein neues Zeichnung mit den Standartwerten 0.0.0 0:0:0.
        DLLEXPORT Zeit();
        //! Löscht das aktuelle Zeichnung.
        DLLEXPORT ~Zeit();
        //! Ändert die gespeicherte Zeit durch kopieren der Werte aus (zeit).
        //! \param zeit Die neue Zeit.
        DLLEXPORT void setZeit(Zeit* zeit);
        //! Ändert die gespeicherte Zeit.
        //! \param jahr Das neue Jahr.
        //! \param monat Der neue Monat.
        //! \param tag Det neue Tag.
        //! \param stunde Die neue Stunde.
        //! \param minute Die neue Minute.
        //! \param sekunde Die neue Sekunde.
        DLLEXPORT void setZeit(
            int jahr, int monat, int tag, int stunde, int minute, int sekunde);
        //! Ändert die gespeicherte Zeit.
        //! \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. \param zeit Eine Zeichenkette, die die neue
        //! Zeit enthält. Beispiel: setZeit( "y-m-d h:i:s", "2016-1-25 21:59:30"
        //! );
        DLLEXPORT void setZeit(const char* format, const char* zeit);
        //! Ändert die gespeicherte Zeit.
        //! \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. \param zeit Ein Text Zeichnung, welches die
        //! neue Zeit enthält. Beispiel: setZeit( "y-m-d h:i:s", new Text(
        //! "2016-1-25 21:59:30" ) );
        DLLEXPORT void setZeit(const char* format, Text* zeit);
        //! Ändert das gespeicherte Jahr.
        //! \param jahr Das neue Jahr.
        DLLEXPORT void setJahr(int jahr);
        //! Ändert den gespeicherten Monat.
        //! \param monat Der neue Monat.
        DLLEXPORT void setMonat(int monat);
        //! Ändert den gespeicherten Tag.
        //! \param tag Der neue Tag.
        DLLEXPORT void setTag(int tag);
        //! Ändert die gespeicherte Stunde.
        //! \param stunde Die neue Stunde.
        DLLEXPORT void setStunde(int stunde);
        //! Ändert die gespeicherte Minute.
        //! \param minute Die neue Minute.
        DLLEXPORT void setMinute(int minute);
        //! Ändert die gespeicherte Sekunde.
        //! \param sekunde Die neue Sekunde.
        DLLEXPORT void setSekunde(int sekunde);
        //! Addiert die übergebene Zeit und speichert das Ergebnis.
        //! \param zeit Die zu Addierende Zeit.
        DLLEXPORT void plusZeit(Zeit* zeit);
        //! Addiert die übergebene Zeit und speichert das Ergebnis.
        //! \param jahr Das zu addierende Jahr.
        //! \param monat Der zu addierende Monat.
        //! \param tag Der zu addierende Tag.
        //! \param stunde Die zu addierende Stunde.
        //! \param minute Die zu addierende Minute.
        //! \param sekunde Die zu addierende Sekunde.
        DLLEXPORT void plusZeit(
            int jahr, int monat, int tag, int stunde, int minute, int sekunde);
        //! Addiert die übergebene Zeit und speichert das Ergebnis.
        //! \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. \param zeit Eine Zeichenkette, die die zu
        //! addierende Zeit enthält.
        DLLEXPORT void plusZeit(const char* format, const char* zeit);
        //! Addiert die übergebene Zeit und speichert das Ergebnis.
        //! \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. \param zeit Ein Text Zeichnung, welches die zu
        //! addierende Zeit enthält.
        DLLEXPORT void plusZeit(const char* format, Text* zeit);
        //! Addiert die übergebene Zeit und speichert das Ergebnis.
        //! \param jahr Das zu addierende Jahr.
        DLLEXPORT void plusJahr(int jahr);
        //! Addiert die übergebene Zeit und speichert das Ergebnis.
        //! \param monat Der zu addierende Monat.
        DLLEXPORT void plusMonat(int monat);
        //! Addiert die übergebene Zeit und speichert das Ergebnis.
        //! \param tag Der zu addierende Tag.
        DLLEXPORT void plusTag(int tag);
        //! Addiert die übergebene Zeit und speichert das Ergebnis.
        //! \param stunde Die zu addierende Stunde.
        DLLEXPORT void plusStunde(int stunde);
        //! Addiert die übergebene Zeit und speichert das Ergebnis.
        //! \param minute Die zu addierende Minute.
        DLLEXPORT void plusMinute(int minute);
        //! Addiert die übergebene Zeit und speichert das Ergebnis.
        //! \param sekunde Die zu addierende Sekunde.
        DLLEXPORT void plusSekunde(int sekunde);
        //! Zieht die übergebene Zeit ab und speichert das Ergebnis.
        //! \param zeit Die abzuziehende Zeit.
        DLLEXPORT void minusZeit(Zeit* zeit);
        //! Zieht die übergebene Zeit ab und speichert das Ergebnis.
        //! \param jahr Das abzuziehende Jahr.
        //! \param monat Der abzuziehende Monat.
        //! \param tag Der abzuziehende Tag.
        //! \param stunde Die abzuziehende Stunde.
        //! \param minute Die abzuziehende Minute.
        //! \param sekunde Die abzuziehende Sekunde.
        DLLEXPORT void minusZeit(
            int jahr, int monat, int tag, int stunde, int minute, int sekunde);
        //! Zieht die übergebene Zeit ab und speichert das Ergebnis.
        //! \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. \param zeit Eine Zeichenkette, die die
        //! abzuziehende Zeit enthält.
        DLLEXPORT void minusZeit(const char* format, const char* zeit);
        //! Zieht die übergebene Zeit ab und speichert das Ergebnis.
        //! \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. \param zeit Ein Text Zeichnung, welches die
        //! abzuziehende Zeit enthält.
        DLLEXPORT void minusZeit(const char* format, Text* zeit);
        //! Zieht die übergebene Zeit ab und speichert das Ergebnis.
        //! \param jahr Das abzuziehende Jahr.
        DLLEXPORT void minusJahr(int jahr);
        //! Zieht die übergebene Zeit ab und speichert das Ergebnis.
        //! \param monat Der abzuziehende Monat.
        DLLEXPORT void minusMonat(int monat);
        //! Zieht die übergebene Zeit ab und speichert das Ergebnis.
        //! \param tag Der abzuziehende Tag.
        DLLEXPORT void minusTag(int tag);
        //! Zieht die übergebene Zeit ab und speichert das Ergebnis.
        //! \param stunde Die abzuziehende Stunde.
        DLLEXPORT void minusStunde(int stunde);
        //! Zieht die übergebene Zeit ab und speichert das Ergebnis.
        //! \param minute Die abzuziehende Minute.
        DLLEXPORT void minusMinute(int minute);
        //! Zieht die übergebene Zeit ab und speichert das Ergebnis.
        //! \param sekunde Die abzuziehende Sekunde.
        DLLEXPORT void minusSekunde(int sekunde);
        //! Gibt die gespeicherte Zeit als Text zurück.
        //! \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.
        DLLEXPORT Text* getZeit(const char* format) const;
        //! Überprüft, ob die Zeit gleich der übergebenen Zeit ist.
        //! \param zeit die zu überprüfende Zeit.
        //! \return (true), wenn die Zeiten gleich sind. (false) sonst.
        DLLEXPORT bool istGleich(Zeit* zeit) const;
        //! Überprüft, ob die Zeit gleich der übergebenen Zeit ist.
        //! \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. \param zeit Eine Zeichenkette, die die zu
        //! überprüfende Zeit enthält. \return (true), wenn die Zeiten gleich
        //! sind. (false) sonst.
        DLLEXPORT bool istGleich(const char* format, const char* zeit) const;
        //! Überprüft, ob die Zeit gleich der übergebenen Zeit ist.
        //! \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. \param zeit Eine Text Zeichnung, welches die zu
        //! überprüfende Zeit enthält. \return (true), wenn die Zeiten gleich
        //! sind. (false) sonst.
        DLLEXPORT bool istGleich(const char* format, Text* zeit) const;
        //! Überprüft, ob die Zeit gleich der übergebenen Zeit ist.
        //! \param jahr Das zu überprüfende Jahr.
        //! \param monat Der zu überprüfende Monat.
        //! \param tag Der zu überprüfende Tag.
        //! \param stunde Die zu überprüfende Stunde.
        //! \param minute Die zu überprüfende Minute.
        //! \param sekunde Die zu überprüfende Sekunde.
        //! \return (true), wenn die Zeiten gleich sind. (false) sonst.
        DLLEXPORT bool istGleich(int jahr,
            int monat,
            int tag,
            int stunde,
            int minute,
            int sekunde) const;
        //! Gibt das Zeichnung zurück, in dem das Datum gespeichert wird mit
        //! erhöhtem Reference Counter.
        DLLEXPORT Datum* getDatum() const;
        //! Gibt das Zeichnung zurück, in dem das Datum gespeichert wird ohne
        //! erhöhten Reference Counter.
        DLLEXPORT Datum* zDatum() const;
        //! Gibt das Zeichnung zurück, in dem die Uhrzeit gespeichert wird mit
        //! erhöhtem Reference Counter.
        DLLEXPORT Uhrzeit* getUhrzeit() const;
        //! Gibt das Zeichnung zurück, in dem die uhrzeit gespeichert wird ohne
        //! erhöhten Reference Counter.
        DLLEXPORT Uhrzeit* zUhrzeit() const;
        //! Überprüft, ob die gespeicherte Zeit kleiner als die übergebene Zeit
        //! ist. \param zeit Die zu überprüfende Zeit. \return (true) wenn die
        //! gespeicherte Zeit vor der übergebenen Zeit liegt. (false) sonnst.
        DLLEXPORT bool istKleiner(Zeit* zeit) const;
        //! Überprüft, ob die gespeicherte Zeit kleiner als die übergebene Zeit
        //! ist. \param jahr Das zu überprüfende Jahr. \param monat Der zu
        //! überprüfende Monat. \param tag Der zu überprüfende Tag. \param
        //! stunde Die zu überprüfende Stunde. \param minute Die zu überprüfende
        //! Minute. \param sekunde Die zu überprüfende Sekunde. \return (true)
        //! wenn die gespeicherte Zeit vor der übergebenen Zeit liegt. (false)
        //! sonnst.
        DLLEXPORT bool istKleiner(int jahr,
            int monat,
            int tag,
            int stunde,
            int minute,
            int sekunde) const;
        //! Überprüft, ob die gespeicherte Zeit kleiner als die übergebene Zeit
        //! ist. \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. \param zeit Eine Zeichenkette, die die zu
        //! überprüfende Zeit enthält. \return (true) wenn die gespeicherte Zeit
        //! vor der übergebenen Zeit liegt. (false) sonnst.
        DLLEXPORT bool istKleiner(const char* format, const char* zeit) const;
        //! Überprüft, ob die gespeicherte Zeit kleiner als die übergebene Zeit
        //! ist. \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. \param zeit Eine Text Zeichnung, welches die zu
        //! überprüfende Zeit enthält. \return (true) wenn die gespeicherte Zeit
        //! vor der übergebenen Zeit liegt. (false) sonnst.
        DLLEXPORT bool istKleiner(const char* format, Text* zeit) const;
        //! Überprüft, ob die gespeicherte Zeit größer als die übergebene Zeit
        //! ist. \param zeit Die zu überprüfende Zeit. \return (true) wenn die
        //! gespeicherte Zeit nach der übergebenen Zeit liegt. (false) sonnst.
        DLLEXPORT bool istLater(Zeit* zeit) const;
        //! Überprüft, ob die gespeicherte Zeit größer als die übergebene Zeit
        //! ist. \param jahr Das zu überprüfende Jahr. \param monat Der zu
        //! überprüfende Monat. \param tag Der zu überprüfende Tag. \param
        //! stunde Die zu überprüfende Stunde. \param minute Die zu überprüfende
        //! Minute. \param sekunde Die zu überprüfende Sekunde. \return (true)
        //! wenn die gespeicherte Zeit nach der übergebenen Zeit liegt. (false)
        //! sonnst.
        DLLEXPORT bool istLater(int jahr,
            int monat,
            int tag,
            int stunde,
            int minute,
            int sekunde) const;
        //! Überprüft, ob die gespeicherte Zeit größer als die übergebene Zeit
        //! ist. \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. \param zeit Eine Zeichenkette, die die zu
        //! überprüfende Zeit enthält. \return (true) wenn die gespeicherte Zeit
        //! nach der übergebenen Zeit liegt. (false) sonnst.
        DLLEXPORT bool istLater(const char* format, const char* zeit) const;
        //! Überprüft, ob die gespeicherte Zeit größer als die übergebene Zeit
        //! ist. \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. \param zeit Eine Text Zeichnung, welches die zu
        //! überprüfende Zeit enthält. \return (true) wenn die gespeicherte Zeit
        //! nach der übergebenen Zeit liegt. (false) sonnst.
        DLLEXPORT bool istLater(const char* format, Text* zeit) const;
    };

    //! Diese Klasse kann messen, wie viel Zeit zwischen zwei Zeitpunkten
    //! verstrichen ist
    class ZeitMesser : public virtual ReferenceCounter
    {
    private:
        double start;
        double ende;
        double messung;

    public:
        //! Erzeugt ein neues ZeitMesser Zeichnung
        DLLEXPORT ZeitMesser();
        //! Löscht das aktuelle Zeichnung
        DLLEXPORT ~ZeitMesser();
        //! legt den Startpunkt des zeitstoppens fest
        DLLEXPORT void messungStart();
        //! legt des Endpunkt der Zeitmessung fest
        DLLEXPORT void messungEnde();
        //! gibt den Abstand zwischen start und ende der Messung in Sekunden
        //! zurück
        DLLEXPORT double getSekunden() const;
        //! gibt den Abstand zwischen start und ende der Messung in Minuten
        //! zurück
        DLLEXPORT double getMinuten() const;
        //! gibt den Abstand zwischen start und ende der Messung in Stunden
        //! zurück
        DLLEXPORT double getStunden() const;
        //! gibt true zurück, wenn aktuell eine MEssung läuft
        DLLEXPORT bool isMeasuring() const;
    };

    //! gibt die aktuelle Uhrzeit zurück.
    DLLEXPORT Uhrzeit* getUhrzeit();
    //! gibt das aktuelle Datum zurück.
    DLLEXPORT Datum* getDatum();
    //! gibt die aktuelle Zeit( Datum und Uhrzeit ) zurück.
    DLLEXPORT Zeit* getZeit();
    //! prüft, ob jahr ein Schaltjahr ist.
    //! \param jahr Das zu überprüfende Jahr.
    //! \return (true), wenn das übergebene jahr ein Schaltjahr ist. (false)
    //! sonst.
    DLLEXPORT bool istSchaltjahr(int jahr);
} // namespace Framework

#endif