KSG-Framework/Zeit.h

#ifndef Zeit_H
#define Zeit_H

#include "Betriebssystem.h"
#include <time.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
    {
    private:
        int stunde, minute, sekunde;
        int ref;
        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;
        //! Erhöht den Reference Counting Zähler
        //! \return this
        DLLEXPORT Uhrzeit *getThis();
        //! Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht
        //! \return 0
        DLLEXPORT Uhrzeit *release();
    };

    //! Diese Klasse speichert ein Datum in Form von Jahr, Monat und Tagen
    class Datum
    {
    private:
        int jahr, monat, tag;
        int ref;
        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;
        //! Erhöht den Reference Counting Zähler
        //! \return this
        DLLEXPORT Datum *getThis();
        //! Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht
        //! \return 0
        DLLEXPORT Datum *release();
    };

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

    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;
        //! Erhöht den Reference Counting Zähler
        //! \return this
        DLLEXPORT Zeit *getThis();
        //! Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht
        //! \return 0
        DLLEXPORT Zeit *release();
    };

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

    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;
        //! Erhöht den Reference Counting Zähler.
        //! \return this.
        DLLEXPORT ZeitMesser *getThis();
        //! Verringert den Reference Counting Zähler. Wenn der Zähler 0 erreicht, wird das Zeichnung automatisch gelöscht.
        //! \return 0.
        DLLEXPORT ZeitMesser *release();
    };

    //! 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 );
}

#endif