KSG-Framework/Timer.h

#ifndef Time_H
#define Time_H

#include "OperatingSystem.h"
#include "ReferenceCounter.h"

namespace Framework
{
    class Text;  //! Text.h
    class Clock; //! From this file
    class Date;  //! From this file
    class Time;  //! From this file
    class Timer; //! From this file

    //! This class stores a time of day in the form of hours, minutes and
    //! seconds
    class Clock : public virtual ReferenceCounter
    {
    private:
        __int64 stunde, minute, sekunde;
        int update();

    public:
        //! Creates a new Clock object with the default values 00:00:00
        DLLEXPORT Clock();

        //! Sets the time by copying.
        //! \param zeit The values for hour, minute and second are
        //! copied from this object.
        DLLEXPORT int setClock(Clock* zeit);
        //! Sets the time.
        //! \param stunde The hour of the new time.
        //! \param minute The minute of the new time.
        //! \param sekunde The second of the new time.
        //! \return The number of remaining days.
        //! Example: setClock( 30, 30, 30 ); return: 1, stored: 6:30:30
        DLLEXPORT int setClock(int stunde, int minute, int sekunde);
        //! Sets the time.
        //! \param format A string that determines the format of the
        //! time in (zeit). h=hour, i=minute, s=second. \param
        //! zeit A string containing the new time. \return The
        //! number of remaining days. Example: setClock( "h:i:s", "05:30:00" );
        //! Example: setClock( "h:i:s", "30:30:00" ); return: 1, stored:
        //! 6:30:00
        DLLEXPORT int setClock(const char* format, const char* zeit);
        //! Sets the time.
        //! \param format A string that determines the format of the
        //! time in (zeit). h=hour, i=minute, s=second. \param
        //! zeit A Text object containing the new time. \return The
        //! number of remaining days. Example: setClock( "h:i:s", new Text(
        //! "05:30:00" ) ); Example: setClock( "h:i:s", new Text( "30:30:00"
        //! ) ); return: 1, stored: 6:30:00
        DLLEXPORT int setClock(const char* format, Text* zeit);
        //! Sets the hour.
        //! \param stunde The hour to be stored.
        //! \return The number of remaining days.
        //! Example: setStunde( 30 ); return: 1 day, stored hours: 6
        DLLEXPORT int setStunde(int stunde);
        //! Sets the minute.
        //! \param minute The minute to be stored.
        //! \return The number of remaining days.
        //! Example: Old time: 23:50:10, setMinute( 80 ); return: 1,
        //! stored time: 01:10:10
        DLLEXPORT int setMinute(int minute);
        //! Sets the second.
        //! \param minute The second to be stored.
        //! \return The number of remaining days.
        //! Example: Old time: 23:59:10, setSekunde( 80 ); return: 1,
        //! stored time: 00:00:30
        DLLEXPORT int setSekunde(int sekunde);
        //! Calculates the sum of this and another time and stores the result.
        //! \param zeit The time whose values are to be added.
        //! \return The number of remaining days.
        //! Example: Old time: 19:40:18, plusClock( (10:05:30) ); return 1,
        //! stored time: 05:45:48
        DLLEXPORT int plusClock(Clock* zeit);
        //! Calculates the sum of this and another time and stores the result.
        //! \param stunde The hours to be added.
        //! \param minute The minutes to be added.
        //! \param sekunde The seconds to be added.
        //! \return The number of remaining days.
        //! Example: Old time: 19:40:18, plusClock( 10, 5, 30 ); return 1,
        //! stored time: 05:45:48
        DLLEXPORT int plusClock(int stunde, int minute, int sekunde);
        //! Calculates the sum of this and another time and stores the result.
        //! \param format A string that determines the format of the
        //! time in (zeit). h=hour, i=minute, s=second.
        //! \param zeit A string containing the time to add.
        //! \return The number of remaining days.
        //! Example: Old time: 19:40:18, plusClock( "h:i:s", "10:05:30" );
        //! return 1, stored time: 05:45:48
        DLLEXPORT int plusClock(const char* format, const char* zeit);
        //! Calculates the sum of this and another time and stores the result.
        //! \param format A string that determines the format of the
        //! time in (zeit). h=hour, i=minute, s=second.
        //! \param zeit A Text object containing the time to add.
        //! \return The number of remaining days.
        //! Example: Old time: 19:40:18, plusClock( "h:i:s", new Text(
        //! "10:05:30" ) ); return 1, stored time: 05:45:48
        DLLEXPORT int plusClock(const char* format, Text* zeit);
        //! Calculates the sum of this and another time and stores the result.
        //! \param stunde The hours to add.
        //! \return The number of remaining days.
        //! Example: Old time: 20:50:30, plusHour( 10 ); return 1,
        //! stored time: 6:50:30
        DLLEXPORT int plusHour(__int64 stunde);
        //! Calculates the sum of this and another time and stores the result.
        //! \param minute The minutes to add.
        //! \return The number of remaining days.
        //! Example: Old time: 23:50:30, plusMinute( 11 ); return 1,
        //! stored time: 00:01:30
        DLLEXPORT int plusMinute(__int64 minute);
        //! Calculates the sum of this and another time and stores the result.
        //! \param sekunde The seconds to add.
        //! \return The number of remaining days.
        //! Example: Old time: 23:59:30, plusSecond( 40 ); return 1,
        //! stored time: 00:00:10
        DLLEXPORT int plusSecond(__int64 sekunde);
        //! Subtracts a given time from this one and stores the result.
        //! \param zeit The time to subtract.
        //! \return The number of remaining days.
        //! Example: Old time: 10:40:18, minusClock( (19:05:30) ); return -1,
        //! stored time: 15:34:48
        DLLEXPORT int minusClock(Clock* zeit);
        //! Subtracts a given time from this one and stores the result.
        //! \param stunde The hours to subtract.
        //! \param minute The minutes to subtract.
        //! \param sekunde The seconds to subtract.
        //! \return The number of remaining days.
        //! Example: Old time: 10:40:18, minusClock( 19, 05, 30 );
        //! return -1, stored time: 15:34:48
        DLLEXPORT int minusClock(int stunde, int minute, int sekunde);
        //! Subtracts a given time from this one and stores the result.
        //! \param format A string that determines the format of the
        //! time in (zeit). h=hour, i=minute, s=second.
        //! \param zeit A string containing the time to subtract.
        //! \return The number of remaining days.
        //! Example: Old time: 10:40:18, minusClock( "h:i:s", "19:05:30" );
        //! return -1, stored time: 15:34:48
        DLLEXPORT int minusClock(const char* format, const char* zeit);
        //! Subtracts a given time from this one and stores the result.
        //! \param format A string that determines the format of the
        //! time in (zeit). h=hour, i=minute, s=second.
        //! \param zeit A Text object containing the time to subtract.
        //! \return The number of remaining days.
        //! Example: Old time: 10:40:18, minusClock( "h:i:s", new Text(
        //! "19:05:30" ) ); return -1, stored time: 15:34:48
        DLLEXPORT int minusClock(const char* format, Text* zeit);
        //! Subtracts a given time from this one and stores the result.
        //! \param stunde The hours to subtract.
        //! \return The number of remaining days.
        //! Example: Old time: 10:40:18, minusHour( 19 ); return -1,
        //! stored time: 15:40:18
        DLLEXPORT int minusHour(__int64 stunde);
        //! Subtracts a given time from this one and stores the result.
        //! \param minute The minutes to subtract.
        //! \return The number of remaining days.
        //! Example: Old time: 00:40:18, minusMinute( 50 ); return -1,
        //! stored time: 23:50:18
        DLLEXPORT int minusMinute(__int64 minute);
        //! Subtracts a given time from this one and stores the result.
        //! \param sekunde The seconds to subtract.
        //! \return The number of remaining days.
        //! Example: Old time: 00:00:20, minusSecond( 50 ); return -1,
        //! stored time: 23:59:30
        DLLEXPORT int minusSecond(__int64 sekunde);

        //! Returns the hour.
        DLLEXPORT int getStunde() const;
        //! Returns the minute.
        DLLEXPORT int getMinute() const;
        //! Returns the second.
        DLLEXPORT int getSekunde() const;
        //! Returns the time formatted as text.
        //! \param format A string that determines the format of the
        //! returned time. h=hour, i=minute, s=second.
        //! Example: Time: 5:40:39, getClock( "h:i:s" ); return: "5:40:39"
        DLLEXPORT Text* getClock(const char* format) const;
        //! Checks if the time equals zeit.
        //! \param zeit The time to compare with.
        //! \return (true) if both times are equal. (false) if they
        //! are not equal.
        DLLEXPORT bool isEqual(Clock* zeit) const;
        //! Checks if the time equals zeit.
        //! \param format A string that determines the format of the
        //! time in (zeit). h=hour, i=minute, s=second. \param
        //! zeit A string containing the other time. \return
        //! (true) if both times are equal. (false) if they
        //! are not equal.
        DLLEXPORT bool isEqual(const char* format, const char* zeit) const;
        //! Checks if the time equals zeit.
        //! \param format A string that determines the format of the
        //! time in (zeit). h=hour, i=minute, s=second. \param
        //! zeit A Text object containing the other time.
        //! \return (true) if both times are equal. (false) if they
        //! are not equal.
        DLLEXPORT bool isEqual(const char* format, Text* zeit) const;
        //! Checks if the time equals the given time. Does not validate
        //! whether the given time is a valid time of day.
        //! \param stunde The hours of the time to check.
        //! \param minute The minutes of the time to check.
        //! \param sekunde The seconds of the time to check.
        //! \return (true) if both times are equal. (false) if they
        //! are not equal.
        DLLEXPORT bool isEqual(int stunde, int minute, int sekunde) const;
        //! Checks if the hour equals the given hour.
        //! \param stunde The hour to check.
        //! \return (true) if the hours are equal. (false) if they
        //! are not equal.
        DLLEXPORT bool hourEqual(int stunde) const;
        //! Checks if the minute equals the given minute.
        //! \param minute The minute to check.
        //! \return (true) if the minutes are equal. (false) if they
        //! are not equal.
        DLLEXPORT bool minuteEqual(int minute) const;
        //! Checks if the second equals the given second.
        //! \param sekunde The second to check.
        //! \return (true) if the seconds are equal. (false) if they
        //! are not equal.
        DLLEXPORT bool secondEqual(int sekunde) const;
        //! Checks if the time is less than zeit.
        //! \param zeit The time to check against.
        //! \return (true) if the stored time is less than the given
        //! time. (false) otherwise.
        //! Example: (5:30:00).isSmaller( (10:40:29) ); return true
        DLLEXPORT bool isSmaller(Clock* zeit) const;
        //! Checks if the time is less than the given time.
        //! \param stunde The hours of the time to check.
        //! \param minute The minutes of the time to check.
        //! \param sekunde The seconds of the time to check.
        //! \return (true) if the stored time is less than the given
        //! time. (false) otherwise.
        //! Example: (5:30:00).isSmaller( 10, 40, 29 ); return true
        DLLEXPORT bool isSmaller(int stunde, int minute, int sekunde) const;
        //! Checks if the time is less than the given time.
        //! \param format A string that determines the format of the
        //! time in (zeit). h=hour, i=minute, s=second. \param
        //! zeit A string containing the other time. \return
        //! (true) if the stored time is less than the given
        //! time. (false) otherwise.
        //! Example: (5:30:00).isSmaller( "h:i:s", "10:40:29" ); return true
        DLLEXPORT bool isSmaller(const char* format, const char* zeit) const;
        //! Checks if the time is less than the given time.
        //! \param format A string that determines the format of the
        //! time in (zeit). h=hour, i=minute, s=second. \param
        //! zeit A Text object containing the other time.
        //! \return (true) if the stored time is less than the given
        //! time. (false) otherwise.
        DLLEXPORT bool isSmaller(const char* format, Text* zeit) const;
        //! Checks if the time is greater than zeit.
        //! \param zeit The time to check against.
        //! \return (true) if the stored time is greater than the given
        //! time. (false) otherwise.
        //! Example: (5:30:00).isLater( (10:40:29) ); return false
        DLLEXPORT bool isLater(Clock* zeit) const;
        //! Checks if the time is greater than the given time.
        //! \param stunde The hours of the time to check.
        //! \param minute The minutes of the time to check.
        //! \param sekunde The seconds of the time to check.
        //! \return (true) if the stored time is greater than the given
        //! time. (false) otherwise.
        //! Example: (5:30:00).isLater( 10, 40, 29 ); return false
        DLLEXPORT bool isLater(int stunde, int minute, int sekunde) const;
        //! Checks if the time is greater than the given time.
        //! \param format A string that determines the format of the
        //! time in (zeit). h=hour, i=minute, s=second. \param
        //! zeit A string containing the other time. \return
        //! (true) if the stored time is greater than the given
        //! time. (false) otherwise.
        //! Example: (5:30:00).isLater( "h:i:s", "10:40:29" ); return false
        DLLEXPORT bool isLater(const char* format, const char* zeit) const;
        //! Checks if the time is greater than the given time.
        //! \param format A string that determines the format of the
        //! time in (zeit). h=hour, i=minute, s=second. \param
        //! zeit A Text object containing the other time.
        //! \return (true) if the stored time is greater than the given
        //! time. (false) otherwise.
        //! Example: (5:30:00).isLater( "h:i:s", "10:40:29" ); return false
        DLLEXPORT bool isLater(const char* format, Text* zeit) const;
    };

    //! This class stores a date in the form of year, month and day
    class Date : public virtual ReferenceCounter
    {
    private:
        int jahr, monat, tag;
        int* maxTage;
        void update();

    public:
        //! Creates a new Date object with the default values 0.0.0.
        DLLEXPORT Date();
        //! Deletes the date.
        DLLEXPORT ~Date();

        //! Sets the date by copying.
        //! \param datum The date to store.
        DLLEXPORT void setDate(Date* datum);
        //! Sets the date to the given values.
        //! \param jahr The year of the new date.
        //! \param monat The month of the new date.
        //! \param tag The day of the new date.
        DLLEXPORT void setDate(int jahr, int monat, int tag);
        //! Sets the date to the given value.
        //! \param format A string specifying the format of the
        //! date in (datum). y=year, m=month, d=day. \param datum
        //! A string containing the new date.
        //! Example: setDate( "y-m-d", "2016-01-25" );
        DLLEXPORT void setDate(const char* format, const char* datum);
        //! Sets the date to the given value.
        //! \param format A string specifying the format of the
        //! date in (datum). y=year, m=month, d=day. \param datum
        //! A Text object containing the new date.
        //! Example: setDate( "y-m-d", new Text( "2016-01-25" ) );
        DLLEXPORT void setDate(const char* format, Text* datum);
        //! Changes the year of the date.
        //! \param jahr The new year.
        DLLEXPORT void setJahr(int jahr);
        //! Changes the month of the date.
        //! \param monat The new month.
        DLLEXPORT void setMonat(int monat);
        //! Changes the day of the date.
        //! \param tag The new day.
        DLLEXPORT void setTag(int tag);
        //! Adds the given date to the current date and stores the result.
        //! \param datum The date to add.
        //! Example: ( 1.11.1995 ).plusDate( ( 5.2.7 ) ); new date: 6.1.2003
        DLLEXPORT void plusDate(Date* datum);
        //! Adds the given date to the current date and stores the result.
        //! \param jahr The year to add. \param monat The month to add.
        //! \param tag The day to add.
        //! Example: ( 1.11.1995 ).plusDate( 7, 2, 5 ); new date: 6.1.2003
        DLLEXPORT void plusDate(int jahr, int monat, int tag);
        //! Adds the given date to the current date and stores the result.
        //! \param format A string specifying the format of the
        //! date in (datum). y=year, m=month, d=day.
        //! \param datum A string containing the date to add.
        //! Example: ( 1.11.1995 ).plusDate( "d.m.y", "5.2.7" );
        //! new date: 6.1.2003
        DLLEXPORT void plusDate(const char* format, const char* datum);
        //! Adds the given date to the current date and stores the result.
        //! \param format A string specifying the format of the
        //! date in (datum). y=year, m=month, d=day.
        //! \param datum A Text object containing the date to add.
        //! Example: ( 1.11.1995 ).plusDate( "d.m.y", new Text(
        //! "5.2.7" ) ); new date: 6.1.2003
        DLLEXPORT void plusDate(const char* format, Text* datum);
        //! Adds the given year to the current date and stores the result.
        //! \param jahr The year to add.
        //! Example: ( 1.11.1995 ).plusYear( 21 ); new date: 1.11.2016
        DLLEXPORT void plusYear(int jahr);
        //! Adds the given month to the current date and stores the result.
        //! \param monat The month to add.
        //! Example: ( 1.11.1995 ).plusMonth( 13 ); new date: 1.12.1996
        DLLEXPORT void plusMonth(int monat);
        //! Adds the given day to the current date and stores the result.
        //! \param tag The day to add.
        //! Example: ( 1.1.2000 ).plusDay( 32 ); new date: 2.2.2000
        DLLEXPORT void plusDay(int tag);
        //! Subtracts the given date from the current date and stores the
        //! result.
        //! \param datum The date to subtract.
        //! Example: ( 2.12.1996 ).minusDate( ( 1.1.1 ) ); new date: 1.11.1995
        DLLEXPORT void minusDate(Date* datum);
        //! Subtracts the given date from the current date and stores the
        //! result.
        //! \param jahr The year to subtract. \param monat The month to
        //! subtract.
        //! \param tag The day to subtract.
        //! Example: ( 2.12.1996 ).minusDate( 1, 1, 1 ); new date: 1.11.1995
        DLLEXPORT void minusDate(int jahr, int monat, int tag);
        //! Subtracts the given date from the current date and stores the
        //! result.
        //! \param format A string specifying the format of the
        //! date in (datum). y=year, m=month, d=day.
        //! \param datum A string containing the date to subtract.
        //! Example: ( 2.12.1996 ).minusDate( "d.m.y", "1.1.1" );
        //! new date: 1.11.1995
        DLLEXPORT void minusDate(const char* format, const char* datum);
        //! Subtracts the given date from the current date and stores the
        //! result.
        //! \param format A string specifying the format of the
        //! date in (datum). y=year, m=month, d=day.
        //! \param datum A Text object containing the date to subtract.
        //! Example: ( 2.12.1996 ).minusDate( "d.m.y", new Text(
        //! "1.1.1" ) ); new date: 1.11.1995
        DLLEXPORT void minusDate(const char* format, Text* datum);
        //! Subtracts the given year from the current date and stores the
        //! result.
        //! \param jahr The year to subtract.
        //! Example: ( 1.11.1996 ).minusYear( 1 ); new date: 1.11.1995
        DLLEXPORT void minusYear(int jahr);
        //! Subtracts the given month from the current date and stores the
        //! result.
        //! \param monat The month to subtract.
        //! Example: ( 1.12.1996 ).minusMonth( 13 ); new date: 1.11.1995
        DLLEXPORT void minusMonth(int monat);
        //! Subtracts the given day from the current date and stores the result.
        //! \param tag The day to subtract.
        //! Example: ( 5.2.2016 ).minusDay( 11 ); new date: 25.1.2016
        DLLEXPORT void minusDay(int tag);

        //! Returns the year.
        DLLEXPORT int getJahr() const;
        //! Returns the month.
        DLLEXPORT int getMonat() const;
        //! Returns the day.
        DLLEXPORT int getTag() const;
        //! Returns the date as a Text object.
        //! \param format A string specifying the format of the
        //! returned date. y=year, m=month, d=day.
        //! Example: ( 1.11.1995 ).getDate( "y-m-d" ); return: "1995-11-1"
        DLLEXPORT Text* getDate(const char* format) const;
        //! Checks if the date equals the given date.
        //! \param datum The date to check.
        //! \return (true) if the given date matches the stored one.
        //! (false) otherwise.
        DLLEXPORT bool isEqual(Date* datum) const;
        //! Checks if the date equals the given date.
        //! \param format A string specifying the format of the
        //! date in (datum). y=year, m=month, d=day. \param datum
        //! A string containing the date to check. \return
        //! (true) if the given date matches the stored one.
        //! (false) otherwise.
        //! Example: ( 1.11.1995 ).isEqual( "y-m-d", "1995-11-1" ); return: true
        DLLEXPORT bool isEqual(const char* format, const char* datum) const;
        //! Checks if the date equals the given date.
        //! \param format A string specifying the format of the
        //! date in (datum). y=year, m=month, d=day. \param datum
        //! A Text object containing the date to check.
        //! \return (true) if the given date matches the stored one.
        //! (false) otherwise.
        //! Example: ( 1.11.1995 ).isEqual( "y-m-d", new Text( "1995-11-1" ) );
        //! return: true
        DLLEXPORT bool isEqual(const char* format, Text* datum) const;
        //! Checks if the date equals the given date.
        //! \param jahr The year of the date to check.
        //! \param monat The month of the date to check.
        //! \param tag The day of the date to check.
        //! \return (true) if the given date matches the stored one.
        //! (false) otherwise.
        //! Example: ( 1.11.1995 ).isEqual( 1995, 11, 1 ); return: true
        DLLEXPORT bool isEqual(int jahr, int monat, int tag) const;
        //! Checks if the year equals the given year.
        //! \param jahr The year to check.
        //! \return (true) if the given year matches the stored one.
        //! (false) otherwise.
        DLLEXPORT bool yearEqual(int jahr) const;
        //! Checks if the month equals the given month.
        //! \param monat The month to check.
        //! \return (true) if the given month matches the stored one.
        //! (false) otherwise.
        DLLEXPORT bool monthEqual(int monat) const;
        //! Checks if the day equals the given day.
        //! \param tag The day to check.
        //! \return (true) if the given day matches the stored one.
        //! (false) otherwise.
        DLLEXPORT bool dayEqual(int tag) const;
        //! Checks if the stored date is less than the given one.
        //! \param datum The date to check.
        //! \return (true) if the stored date is before the given one.
        //! (false) otherwise.
        //! Example: ( 1.11.1995 ).isSmaller( ( 23.1.2016 ) ); return true
        DLLEXPORT bool isSmaller(Date* datum) const;
        //! Checks if the stored date is less than the given one.
        //! \param jahr The year of the date to check.
        //! \param monat The month of the date to check.
        //! \param tag The day of the date to check.
        //! \return (true) if the stored date is before the given one.
        //! (false) otherwise.
        //! Example: ( 1.11.1995 ).isSmaller( 2016, 1, 23 ); return true
        DLLEXPORT bool isSmaller(int jahr, int monat, int tag) const;
        //! Checks if the stored date is less than the given one.
        //! \param format A string specifying the format of the
        //! date in (datum). y=year, m=month, d=day. \param datum
        //! A string containing the date to check. \return
        //! (true) if the stored date is before the given one.
        //! (false) otherwise.
        //! Example: ( 1.11.1995 ).isSmaller( "y, m, d", "2016, 1, 23" ); return
        //! true
        DLLEXPORT bool isSmaller(const char* format, const char* datum) const;
        //! Checks if the stored date is less than the given one.
        //! \param format A string specifying the format of the
        //! date in (datum). y=year, m=month, d=day. \param datum
        //! A Text object containing the date to check.
        //! \return (true) if the stored date is before the given one.
        //! (false) otherwise.
        //! Example: ( 1.11.1995 ).isSmaller( "y, m, d", new Text( "2016, 1, 23"
        //! ) ); return true
        DLLEXPORT bool isSmaller(const char* format, Text* datum) const;
        //! Checks if the stored date is greater than the given one.
        //! \param datum The date to check.
        //! \return (true) if the stored date is after the given one.
        //! (false) otherwise.
        //! Example: ( 1.11.1995 ).isLater( ( 23.1.2016 ) ); return false
        DLLEXPORT bool isLater(Date* datum) const;
        //! Checks if the stored date is greater than the given one.
        //! \param jahr The year of the date to check.
        //! \param monat The month of the date to check.
        //! \param tag The day of the date to check.
        //! \return (true) if the stored date is after the given one.
        //! (false) otherwise.
        //! Example: ( 1.11.1995 ).isLater( 2016, 1, 23 ); return false
        DLLEXPORT bool isLater(int jahr, int monat, int tag) const;
        //! Checks if the stored date is greater than the given one.
        //! \param format A string specifying the format of the
        //! date in (datum). y=year, m=month, d=day. \param datum
        //! A string containing the date to check. \return
        //! (true) if the stored date is after the given one.
        //! (false) otherwise.
        //! Example: ( 1.11.1995 ).isLater( "y, m, d", "2016, 1, 23" ); return
        //! false
        DLLEXPORT bool isLater(const char* format, const char* datum) const;
        //! Checks if the stored date is greater than the given one.
        //! \param format A string specifying the format of the
        //! date in (datum). y=year, m=month, d=day. \param datum
        //! A Text object containing the date to check.
        //! \return (true) if the stored date is after the given one.
        //! (false) otherwise.
        //! Example: ( 1.11.1995 ).isLater( "y, m, d", new Text( "2016, 1, 23" )
        //! ); return true
        DLLEXPORT bool isLater(const char* format, Text* datum) const;
    };

    //! This class combines the Date and Clock classes and thus stores
    //! a timestamp with year, month, day, hour, minute and second
    class Time : public virtual ReferenceCounter
    {
    private:
        Date* datum;
        Clock* uhrzeit;

    public:
        //! Creates a new Time with the default values 0.0.0 0:0:0.
        DLLEXPORT Time();
        //! Creates a new Time with the elapsed seconds since 1970.
        DLLEXPORT Time(__int64 timestamp);
        //! Deletes the current object.
        DLLEXPORT ~Time();
        //! Changes the stored time by copying the values from (zeit).
        //! \param zeit The new time.
        DLLEXPORT void setTime(Time* zeit);
        //! Changes the stored time.
        //! \param jahr The new year.
        //! \param monat The new month.
        //! \param tag The new day.
        //! \param stunde The new hour.
        //! \param minute The new minute.
        //! \param sekunde The new second.
        DLLEXPORT void setTime(
            int jahr, int monat, int tag, int stunde, int minute, int sekunde);
        //! Changes the stored time.
        //! \param format A string specifying the format of the new
        //! time in (zeit). y=year, m=month, d=day, h=hour,
        //! i=minute, s=second. \param zeit A string containing the new
        //! time. Example: setTime( "y-m-d h:i:s", "2016-1-25 21:59:30" );
        DLLEXPORT void setTime(const char* format, const char* zeit);
        //! Changes the stored time.
        //! \param format A string specifying the format of the new
        //! time in (zeit). y=year, m=month, d=day, h=hour,
        //! i=minute, s=second. \param zeit A Text object containing the
        //! new time. Example: setTime( "y-m-d h:i:s", new Text(
        //! "2016-1-25 21:59:30" ) );
        DLLEXPORT void setTime(const char* format, Text* zeit);
        //! Changes the stored year.
        //! \param jahr The new year.
        DLLEXPORT void setJahr(int jahr);
        //! Changes the stored month.
        //! \param monat The new month.
        DLLEXPORT void setMonat(int monat);
        //! Changes the stored day.
        //! \param tag The new day.
        DLLEXPORT void setTag(int tag);
        //! Changes the stored hour.
        //! \param stunde The new hour.
        DLLEXPORT void setStunde(int stunde);
        //! Changes the stored minute.
        //! \param minute The new minute.
        DLLEXPORT void setMinute(int minute);
        //! Changes the stored second.
        //! \param sekunde The new second.
        DLLEXPORT void setSekunde(int sekunde);
        //! Adds the given time and stores the result.
        //! \param zeit The time to add.
        DLLEXPORT void plusTime(Time* zeit);
        //! Adds the given time and stores the result.
        //! \param jahr The year to add.
        //! \param monat The month to add.
        //! \param tag The day to add.
        //! \param stunde The hour to add.
        //! \param minute The minute to add.
        //! \param sekunde The second to add.
        DLLEXPORT void plusTime(
            int jahr, int monat, int tag, int stunde, int minute, int sekunde);
        //! Adds the given time and stores the result.
        //! \param format A string specifying the format of the
        //! time in (zeit). y=year, m=month, d=day, h=hour,
        //! i=minute, s=second. \param zeit A string containing the
        //! time to add.
        DLLEXPORT void plusTime(const char* format, const char* zeit);
        //! Adds the given time and stores the result.
        //! \param format A string specifying the format of the
        //! time in (zeit). y=year, m=month, d=day, h=hour,
        //! i=minute, s=second. \param zeit A Text object containing the
        //! time to add.
        DLLEXPORT void plusTime(const char* format, Text* zeit);
        //! Adds the given time and stores the result.
        //! \param jahr The year to add.
        DLLEXPORT void plusYear(int jahr);
        //! Adds the given time and stores the result.
        //! \param monat The month to add.
        DLLEXPORT void plusMonth(int monat);
        //! Adds the given time and stores the result.
        //! \param tag The day to add.
        DLLEXPORT void plusDay(int tag);
        //! Adds the given time and stores the result.
        //! \param stunde The hour to add.
        DLLEXPORT void plusHour(__int64 stunde);
        //! Adds the given time and stores the result.
        //! \param minute The minute to add.
        DLLEXPORT void plusMinute(__int64 minute);
        //! Adds the given time and stores the result.
        //! \param sekunde The second to add.
        DLLEXPORT void plusSecond(__int64 sekunde);
        //! Subtracts the given time and stores the result.
        //! \param zeit The time to subtract.
        DLLEXPORT void minusTime(Time* zeit);
        //! Subtracts the given time and stores the result.
        //! \param jahr The year to subtract.
        //! \param monat The month to subtract.
        //! \param tag The day to subtract.
        //! \param stunde The hour to subtract.
        //! \param minute The minute to subtract.
        //! \param sekunde The second to subtract.
        DLLEXPORT void minusTime(
            int jahr, int monat, int tag, int stunde, int minute, int sekunde);
        //! Subtracts the given time and stores the result.
        //! \param format A string specifying the format of the
        //! time in (zeit). y=year, m=month, d=day, h=hour,
        //! i=minute, s=second. \param zeit A string containing the
        //! time to subtract.
        DLLEXPORT void minusTime(const char* format, const char* zeit);
        //! Subtracts the given time and stores the result.
        //! \param format A string specifying the format of the
        //! time in (zeit). y=year, m=month, d=day, h=hour,
        //! i=minute, s=second. \param zeit A Text object containing the
        //! time to subtract.
        DLLEXPORT void minusTime(const char* format, Text* zeit);
        //! Subtracts the given time and stores the result.
        //! \param jahr The year to subtract.
        DLLEXPORT void minusYear(int jahr);
        //! Subtracts the given time and stores the result.
        //! \param monat The month to subtract.
        DLLEXPORT void minusMonth(int monat);
        //! Subtracts the given time and stores the result.
        //! \param tag The day to subtract.
        DLLEXPORT void minusDay(int tag);
        //! Subtracts the given time and stores the result.
        //! \param stunde The hour to subtract.
        DLLEXPORT void minusHour(__int64 stunde);
        //! Subtracts the given time and stores the result.
        //! \param minute The minute to subtract.
        DLLEXPORT void minusMinute(__int64 minute);
        //! Subtracts the given time and stores the result.
        //! \param sekunde The second to subtract.
        DLLEXPORT void minusSecond(__int64 sekunde);
        //! Returns the stored time as text.
        //! \param format A string specifying the format of the
        //! returned time. y=year, m=month, d=day, h=hour,
        //! i=minute, s=second.
        DLLEXPORT Text* getTime(const char* format) const;
        //! Checks if the time equals the given time.
        //! \param zeit The time to check.
        //! \return (true) if the times are equal. (false) otherwise.
        DLLEXPORT bool isEqual(Time* zeit) const;
        //! Checks if the time equals the given time.
        //! \param format A string specifying the format of the
        //! time in (zeit). y=year, m=month, d=day, h=hour,
        //! i=minute, s=second. \param zeit A string containing the
        //! time to check. \return (true) if the times are equal.
        //! (false) otherwise.
        DLLEXPORT bool isEqual(const char* format, const char* zeit) const;
        //! Checks if the time equals the given time.
        //! \param format A string specifying the format of the
        //! time in (zeit). y=year, m=month, d=day, h=hour,
        //! i=minute, s=second. \param zeit A Text object containing the
        //! time to check. \return (true) if the times are equal.
        //! (false) otherwise.
        DLLEXPORT bool isEqual(const char* format, Text* zeit) const;
        //! Checks if the time equals the given time.
        //! \param jahr The year to check.
        //! \param monat The month to check.
        //! \param tag The day to check.
        //! \param stunde The hour to check.
        //! \param minute The minute to check.
        //! \param sekunde The second to check.
        //! \return (true) if the times are equal. (false) otherwise.
        DLLEXPORT bool isEqual(int jahr,
            int monat,
            int tag,
            int stunde,
            int minute,
            int sekunde) const;
        //! Returns the object storing the date with increased reference
        //! counter.
        DLLEXPORT Date* getDate() const;
        //! Returns the object storing the date without increased reference
        //! counter.
        DLLEXPORT Date* zDate() const;
        //! Returns the object storing the time of day with increased reference
        //! counter.
        DLLEXPORT Clock* getClock() const;
        //! Returns the object storing the time of day without increased
        //! reference counter.
        DLLEXPORT Clock* zClock() const;
        //! Checks if the stored time is less than the given time.
        //! \param zeit The time to check. \return (true)
        //! if the stored time is before the given time. (false)
        //! otherwise.
        DLLEXPORT bool isSmaller(Time* zeit) const;
        //! Checks if the stored time is less than the given time.
        //! \param jahr The year to check. \param monat The
        //! month to check. \param tag The day to check.
        //! \param stunde The hour to check. \param minute The
        //! minute to check. \param sekunde The second to check.
        //! \return (true) if the stored time is before the given time.
        //! (false) otherwise.
        DLLEXPORT bool isSmaller(int jahr,
            int monat,
            int tag,
            int stunde,
            int minute,
            int sekunde) const;
        //! Checks if the stored time is less than the given time.
        //! \param format A string specifying the format of the
        //! time in (zeit). y=year, m=month, d=day, h=hour,
        //! i=minute, s=second. \param zeit A string containing the
        //! time to check. \return (true) if the stored time is before
        //! the given time. (false) otherwise.
        DLLEXPORT bool isSmaller(const char* format, const char* zeit) const;
        //! Checks if the stored time is less than the given time.
        //! \param format A string specifying the format of the
        //! time in (zeit). y=year, m=month, d=day, h=hour,
        //! i=minute, s=second. \param zeit A Text object containing the
        //! time to check. \return (true) if the stored time is before
        //! the given time. (false) otherwise.
        DLLEXPORT bool isSmaller(const char* format, Text* zeit) const;
        //! Checks if the stored time is greater than the given time.
        //! \param zeit The time to check. \return (true)
        //! if the stored time is after the given time. (false)
        //! otherwise.
        DLLEXPORT bool isLater(Time* zeit) const;
        //! Checks if the stored time is greater than the given time.
        //! \param jahr The year to check. \param monat The
        //! month to check. \param tag The day to check.
        //! \param stunde The hour to check. \param minute The
        //! minute to check. \param sekunde The second to check.
        //! \return (true) if the stored time is after the given time.
        //! (false) otherwise.
        DLLEXPORT bool isLater(int jahr,
            int monat,
            int tag,
            int stunde,
            int minute,
            int sekunde) const;
        //! Checks if the stored time is greater than the given time.
        //! \param format A string specifying the format of the
        //! time in (zeit). y=year, m=month, d=day, h=hour,
        //! i=minute, s=second. \param zeit A string containing the
        //! time to check. \return (true) if the stored time is after
        //! the given time. (false) otherwise.
        DLLEXPORT bool isLater(const char* format, const char* zeit) const;
        //! Checks if the stored time is greater than the given time.
        //! \param format A string specifying the format of the
        //! time in (zeit). y=year, m=month, d=day, h=hour,
        //! i=minute, s=second. \param zeit A Text object containing the
        //! time to check. \return (true) if the stored time is after
        //! the given time. (false) otherwise.
        DLLEXPORT bool isLater(const char* format, Text* zeit) const;
    };

    //! Diese Class kann messen, wie viel Time zwischen zwei TimePoints
    //! verstrichen ist
    class Timer : public virtual ReferenceCounter
    {
    private:
        double start;
        double ende;
        double messung;

    public:
        //! Creates a new Timer object
        DLLEXPORT Timer();
        //! Deletes the current object
        DLLEXPORT ~Timer();
        //! Sets the start point of the time measurement
        DLLEXPORT void measureStart();
        //! Sets the end point of the time measurement
        DLLEXPORT void measureEnd();
        //! Returns the interval between start and end of the measurement
        //! in seconds
        DLLEXPORT double getSekunden() const;
        //! Returns the interval between start and end of the measurement
        //! in minutes
        DLLEXPORT double getMinuten() const;
        //! Returns the interval between start and end of the measurement
        //! in hours
        DLLEXPORT double getStunden() const;
        //! Returns true if a measurement is currently running
        DLLEXPORT bool isMeasuring() const;
    };

    //! Returns the current time of day.
    DLLEXPORT Clock* getClock();
    //! Returns the current date.
    DLLEXPORT Date* getDate();
    //! Returns the current time (date and time of day).
    DLLEXPORT Time* getTime();
    //! Checks whether jahr is a leap year.
    //! \param jahr The year to check.
    //! \return (true) if the given year is a leap year. (false) otherwise.
    DLLEXPORT bool isLeapYear(int jahr);
} // namespace Framework

#endif