KSG-Framework/Zeit.cpp

#include "Zeit.h"
#include "Text.h"
#include <time.h>
#include <ctime>
#ifdef WIN32
#include "Fenster.h"
#else
#include <string.h>
#include <sys/time.h>
#endif

#ifdef WIN32

#if defined(_MSC_VER) || defined(_MSC_EXTENSIONS)
#define DELTA_EPOCH_IN_MICROSECS  11644473600000000Ui64
#else
#define DELTA_EPOCH_IN_MICROSECS  11644473600000000ULL
#endif

struct timeval
{
    long tv_sec;        // Sekunden seit dem 1.1.1970
    long tv_usec;       // und Mikrosekunden
};

struct timezone
{
    int tz_minuteswest; // minutes W of Greenwich
    int tz_dsttime;     // type of dst correction
};

int gettimeofday( struct timeval *tv, struct timezone *tz )
{
    FILETIME ft;
    unsigned __int64 tmpres = 0;
    static int tzflag;

    if( NULL != tv )
    {
        GetSystemTimeAsFileTime( &ft );

        tmpres |= ft.dwHighDateTime;
        tmpres <<= 32;
        tmpres |= ft.dwLowDateTime;

        //converting file time to unix epoch
        tmpres -= DELTA_EPOCH_IN_MICROSECS;
        tmpres /= 10;  //convert into microseconds
        tv->tv_sec = (long)( tmpres / 1000000UL );
        tv->tv_usec = (long)( tmpres % 1000000UL );
    }

    if( NULL != tz )
    {
        if( !tzflag )
        {
            _tzset();
            ++tzflag;
        }
        _get_timezone( ( long* )&( tz->tz_minuteswest ) );
        tz->tz_minuteswest /= 60;
        _get_daylight( &( tz->tz_dsttime ) );
    }

    return 0;
}

#endif


using namespace Framework;

// Inhalt der Uhrzeit Klasse aus Zeit.h
// Privat 
int Uhrzeit::update() // berechnet die neue Zeit
{
    int ret = 0;
    while( sekunde >= 60 )
    {
        sekunde -= 60;
        ++minute;
    }
    while( minute >= 60 )
    {
        minute -= 60;
        ++stunde;
    }
    while( stunde >= 24 )
    {
        stunde -= 24;
        ++ret;
    }
    while( sekunde < 0 )
    {
        sekunde += 60;
        --minute;
    }
    while( minute < 0 )
    {
        minute += 60;
        --stunde;
    }
    while( stunde < 0 )
    {
        stunde += 24;
        --ret;
    }
    return ret;
}

Uhrzeit::Uhrzeit()
    : stunde( 0 ),
    minute( 0 ),
    sekunde( 0 ),
    ref( 1 )
{}

int Uhrzeit::setUhrzeit( Uhrzeit *zeit ) // setzt die Uhrzeit
{
    stunde = zeit->getStunde();
    minute = zeit->getMinute();
    sekunde = zeit->getSekunde();
    zeit->release();
    return update();
}

int Uhrzeit::setUhrzeit( int stunde, int minute, int sekunde )
{
    this->stunde = stunde;
    this->minute = minute;
    this->sekunde = sekunde;
    return update();
}

int Uhrzeit::setUhrzeit( const char *format, const char *zeit ) // format Beispiele: "H:i:s", "H-i-s" (H=stunde,i=minute,s=sekunde)
{
    int flän = textLänge( format );
    char *ende = 0;
    for( const char *f = format; f < format + flän; ++f )
    {
        switch( *f )
        {
        case 'h':
            stunde = TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 'i':
            minute = TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 's':
            sekunde = TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        default:
            ++zeit;
            break;
        }
    }
    return update();
}

int Uhrzeit::setUhrzeit( const char *format, Text *zeit )
{
    int ret = setUhrzeit( format, zeit->getText() );
    zeit->release();
    return ret;
}

int Uhrzeit::setStunde( int stunde ) // setzt die Stunde
{
    this->stunde = stunde;
    return update();
}

int Uhrzeit::setMinute( int minute ) // setzt die Minute
{
    this->minute = minute;
    return update();
}

int Uhrzeit::setSekunde( int sekunde ) // setzt die Sekunde
{
    this->sekunde = sekunde;
    return update();
}

int Uhrzeit::plusUhrzeit( Uhrzeit *zeit ) // addiert die zeiten
{
    stunde += zeit->getStunde();
    minute += zeit->getMinute();
    sekunde += zeit->getSekunde();
    return update();
}

int Uhrzeit::plusUhrzeit( int stunde, int minute, int sekunde )
{
    this->stunde += stunde;
    this->minute += minute;
    this->sekunde += sekunde;
    return update();
}

int Uhrzeit::plusUhrzeit( const char *format, const char *zeit )
{
    int flän = textLänge( format );
    char *ende = 0;
    for( const char *f = format; f < format + flän; ++f )
    {
        switch( *f )
        {
        case 'h':
            stunde += TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 'i':
            minute += TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 's':
            sekunde += TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        default:
            ++zeit;
            break;
        }
    }
    return update();
}

int Uhrzeit::plusUhrzeit( const char *format, Text *zeit )
{
    int ret = plusUhrzeit( format, zeit->getText() );
    zeit->release();
    return ret;
}

int Uhrzeit::plusStunde( int stunde ) // addiert stunde Stunden
{
    this->stunde += stunde;
    return update();
}

int Uhrzeit::plusMinute( int minute ) // addiert minute Minuten
{
    this->minute += minute;
    return update();
}

int Uhrzeit::plusSekunde( int sekunde ) // addiert sekunde Sekunden
{
    this->sekunde += sekunde;
    return update();
}

int Uhrzeit::minusUhrzeit( Uhrzeit *zeit ) // subtrahiert die zeiten
{
    stunde -= zeit->getStunde();
    minute -= zeit->getMinute();
    sekunde -= zeit->getSekunde();
    zeit->release();
    return update();
}

int Uhrzeit::minusUhrzeit( int stunde, int minute, int sekunde )
{
    this->stunde -= stunde;
    this->minute -= minute;
    this->sekunde -= sekunde;
    return update();
}

int Uhrzeit::minusUhrzeit( const char *format, const char *zeit )
{
    int flän = textLänge( format );
    char *ende = 0;
    for( const char *f = format; f < format + flän; ++f )
    {
        switch( *f )
        {
        case 'h':
            stunde -= TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 'i':
            minute -= TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 's':
            sekunde -= TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        default:
            ++zeit;
            break;
        }
    }
    return update();
}

int Uhrzeit::minusUhrzeit( const char *format, Text *zeit )
{
    int ret = plusUhrzeit( format, zeit->getText() );
    zeit->release();
    return ret;
}

int Uhrzeit::minusStunde( int stunde ) // subtrahiert stunde Stunden
{
    this->stunde -= stunde;
    return update();
}

int Uhrzeit::minusMinute( int minute ) // subtrahiert minute Minuten
{
    this->minute -= minute;
    return update();
}

int Uhrzeit::minusSekunde( int sekunde ) // subtrahiert sekunde Sekunden
{
    this->sekunde -= sekunde;
    return update();
}

// constant 
int Uhrzeit::getStunde() const // gibt die Stunde zurück
{
    return stunde;
}

int Uhrzeit::getMinute() const // gibt die Minute zurück
{
    return minute;
}

int Uhrzeit::getSekunde() const // gibt die Sekunde zurück
{
    return sekunde;
}

Text *Uhrzeit::getUhrzeit( const char *format ) const // gibt die Uhrzeit als Text formatiert zurück
{
    Text *ret = new Text( "" );
    int flän = textLänge( format );
    for( const char *f = format; f < format + flän; ++f )
    {
        switch( *f )
        {
        case 'h':
            ret->anhängen( stunde );
            break;
        case 'i':
            ret->anhängen( minute );
            break;
        case 's':
            ret->anhängen( sekunde );
            break;
        default:
            ret->anhängen( f, 1 );
            break;
        }
    }
    return ret;
}

bool Uhrzeit::istGleich( Uhrzeit *zeit ) const // prüft, ob die Uhrzeit gleich zeit ist
{
    bool ret = stunde == zeit->getStunde() &&
        minute == zeit->getMinute() &&
        sekunde == zeit->getSekunde();
    zeit->release();
    return ret;
}

bool Uhrzeit::istGleich( const char *format, const char *zeit ) const
{
    int st = stunde, min = minute, sek = sekunde;
    int flän = textLänge( format );
    char *ende = 0;
    for( const char *f = format; f < format + flän; ++f )
    {
        switch( *f )
        {
        case 'h':
            st = TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 'i':
            min = TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 's':
            sek = TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        default:
            ++zeit;
            break;
        }
    }
    bool ret = stunde == st &&
        minute == min &&
        sekunde == sek;
    return ret;
}

bool Uhrzeit::istGleich( const char *format, Text *zeit ) const
{
    bool ret = istGleich( format, zeit->getText() );
    zeit->release();
    return ret;
}

bool Uhrzeit::istGleich( int stunde, int minute, int sekunde ) const
{
    return this->stunde == stunde &&
        this->minute == minute &&
        this->sekunde == sekunde;
}

bool Uhrzeit::stundeGleich( int stunde ) const // prüft, ob die Stunde gleich stunde ist
{
    return this->stunde == stunde;
}

bool Uhrzeit::minuteGleich( int minute ) const // prüft, ob die Minute gleich minute ist
{
    return this->minute == minute;
}

bool Uhrzeit::sekundeGleich( int sekunde ) const // prüft, ob die Sekunde gleich sekunde ist
{
    return this->sekunde == sekunde;
}

bool Uhrzeit::istKleiner( Uhrzeit *zeit ) const // prüft, ob die Zeit kleiner als zeit ist
{
    bool ret = istKleiner( zeit->getStunde(), zeit->getMinute(), zeit->getSekunde() );
    zeit->release();
    return ret;
}

bool Uhrzeit::istKleiner( int stunde, int minute, int sekunde ) const
{
    if( this->stunde < stunde )
        return 1;
    else if( this->stunde == stunde )
    {
        if( this->minute < minute )
            return 1;
        else if( this->minute == minute )
        {
            if( this->sekunde < sekunde )
                return 1;
            else if( this->sekunde == sekunde )
                return 0;
            else
                return 0;
        }
        else
            return 0;
    }
    else
        return 0;
}

bool Uhrzeit::istKleiner( const char *format, const char *zeit ) const
{
    int st = stunde, min = minute, sek = sekunde;
    int flän = textLänge( format );
    char *ende = 0;
    for( const char *f = format; f < format + flän; ++f )
    {
        switch( *f )
        {
        case 'h':
            st = TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 'i':
            min = TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 's':
            sek = TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        default:
            ++zeit;
            break;
        }
    }
    return istKleiner( st, min, sek );
}

bool Uhrzeit::istKleiner( const char *format, Text *zeit ) const
{
    bool ret = istKleiner( format, zeit->getText() );
    zeit->release();
    return ret;
}

bool Uhrzeit::istGrößer( Uhrzeit *zeit ) const // prüft, ob die Zeit größer als zeit ist
{
    bool ret = istGrößer( zeit->getStunde(), zeit->getMinute(), zeit->getSekunde() );
    zeit->release();
    return ret;
}

bool Uhrzeit::istGrößer( int stunde, int minute, int sekunde ) const
{
    if( this->stunde > stunde )
        return 1;
    else if( this->stunde == stunde )
    {
        if( this->minute > minute )
            return 1;
        else if( this->minute == minute )
        {
            if( this->sekunde > sekunde )
                return 1;
            else if( this->sekunde == sekunde )
                return 0;
            else
                return 0;
        }
        else
            return 0;
    }
    else
        return 0;
}

bool Uhrzeit::istGrößer( const char *format, const char *zeit ) const
{
    int st = stunde, min = minute, sek = sekunde;
    int flän = textLänge( format );
    char *ende = 0;
    for( const char *f = format; f < format + flän; ++f )
    {
        switch( *f )
        {
        case 'h':
            st = TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 'i':
            min = TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 's':
            sek = TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        default:
            ++zeit;
            break;
        }
    }
    return istGrößer( st, min, sek );
}

bool Uhrzeit::istGrößer( const char *format, Text *zeit ) const
{
    bool ret = istGrößer( format, zeit->getText() );
    zeit->release();
    return ret;
}

// Reference Counting 
Uhrzeit *Uhrzeit::getThis()
{
    ++ref;
    return this;
}

Uhrzeit *Uhrzeit::release()
{
    --ref;
    if( !ref )
        delete this;
    return 0;
}

// Inhalt der Datum Klasse aus Zeit.h
// Privat 
void Datum::update() // berechnet die neue Zeit
{
    while( monat > 12 )
    {
        monat -= 12;
        ++jahr;
    }
    while( monat <= 0 )
    {
        monat += 12;
        --jahr;
    }
    if( istSchaltjahr( jahr ) )
        maxTage[ 1 ] = 29;
    else
        maxTage[ 1 ] = 28;
    while( tag > maxTage[ monat - 1 ] )
    {
        tag -= maxTage[ monat - 1 ];
        ++monat;
        if( monat > 12 )
        {
            monat -= 12;
            ++jahr;
            if( istSchaltjahr( jahr ) )
                maxTage[ 1 ] = 29;
            else
                maxTage[ 1 ] = 28;
        }
    }
    while( tag <= 0 )
    {
        tag += maxTage[ ( monat - 2 > 0 ? monat - 2 : 11 ) ];
        --monat;
        if( monat <= 0 )
        {
            monat += 12;
            --jahr;
            if( istSchaltjahr( jahr ) )
                maxTage[ 1 ] = 29;
            else
                maxTage[ 1 ] = 28;
        }
    }
}

// Konstruktor 
Datum::Datum()
    : jahr( 0 ),
    monat( 0 ),
    tag( 0 ),
    ref( 1 )
{
    int maxT[] = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
    maxTage = new int[ 12 ];
    memcpy( maxTage, maxT, 12 * sizeof( int ) );
}

// Destruktor 
Datum::~Datum()
{
    delete[] maxTage;
}

// nicht constant 
void Datum::setDatum( Datum *datum ) // setzt das Datum
{
    jahr = datum->getJahr();
    monat = datum->getMonat();
    tag = datum->getTag();
    datum->release();
    update();
}

void Datum::setDatum( int jahr, int monat, int tag )
{
    this->jahr = jahr;
    this->monat = monat;
    this->tag = tag;
    update();
}

void Datum::setDatum( const char *format, const char *datum ) // format Beispiele: "Y:m:d", "Y-m-d" (Y=Jahr,m=Monat,d=tag)
{
    int flän = textLänge( format );
    char *ende = 0;
    for( const char *f = format; f < format + flän; ++f )
    {
        switch( *f )
        {
        case 'y':
            jahr = TextZuInt( (char*)datum, &ende, 10 );
            datum = ende;
            ende = 0;
            break;
        case 'm':
            monat = TextZuInt( (char*)datum, &ende, 10 );
            datum = ende;
            ende = 0;
            break;
        case 'd':
            tag = TextZuInt( (char*)datum, &ende, 10 );
            datum = ende;
            ende = 0;
            break;
        default:
            ++datum;
            break;
        }
    }
    update();
}

void Datum::setDatum( const char *format, Text *datum )
{
    setDatum( format, datum->getText() );
    datum->release();
}

void Datum::setJahr( int jahr ) // setzt das Jahr
{
    this->jahr = jahr;
    update();
}

void Datum::setMonat( int monat ) // setzt den Monat
{
    this->monat = monat;
    update();
}

void Datum::setTag( int tag ) // setzt den Tag
{
    this->tag = tag;
    update();
}

void Datum::plusDatum( Datum *datum ) // addiert das datum
{
    this->jahr += datum->getJahr();
    this->monat += datum->getMonat();
    this->tag += datum->getTag();
    datum->release();
    update();
}

void Datum::plusDatum( int jahr, int monat, int tag )
{
    this->jahr += jahr;
    this->monat += monat;
    this->tag += tag;
    update();
}

void Datum::plusDatum( const char *format, const char *datum )
{
    int flän = textLänge( format );
    char *ende = 0;
    for( const char *f = format; f < format + flän; ++f )
    {
        switch( *f )
        {
        case 'y':
            jahr += TextZuInt( (char*)datum, &ende, 10 );
            datum = ende;
            ende = 0;
            break;
        case 'm':
            monat += TextZuInt( (char*)datum, &ende, 10 );
            datum = ende;
            ende = 0;
            break;
        case 'd':
            tag += TextZuInt( (char*)datum, &ende, 10 );
            datum = ende;
            ende = 0;
            break;
        default:
            ++datum;
            break;
        }
    }
    update();
}

void Datum::plusDatum( const char *format, Text *datum )
{
    plusDatum( format, datum->getText() );
    datum->release();
}

void Datum::plusJahr( int jahr ) // addiert jahr Jahre
{
    this->jahr += jahr;
    update();
}

void Datum::plusMonat( int monat ) // addiert monat Monate
{
    this->monat = monat;
    update();
}

void Datum::plusTag( int tag ) // addiert tag Tage
{
    this->tag += tag;
    update();
}

void Datum::minusDatum( Datum *datum ) // subtrahiert das datum
{
    jahr -= datum->getJahr();
    monat -= datum->getMonat();
    tag -= datum->getTag();
    datum->release();
    update();
}

void Datum::minusDatum( int jahr, int monat, int tag )
{
    this->jahr -= jahr;
    this->monat -= monat;
    this->tag -= tag;
    update();
}

void Datum::minusDatum( const char *format, const char *datum )
{
    int flän = textLänge( format );
    char *ende = 0;
    for( const char *f = format; f < format + flän; ++f )
    {
        switch( *f )
        {
        case 'y':
            jahr -= TextZuInt( (char*)datum, &ende, 10 );
            datum = ende;
            ende = 0;
            break;
        case 'm':
            monat -= TextZuInt( (char*)datum, &ende, 10 );
            datum = ende;
            ende = 0;
            break;
        case 'd':
            tag -= TextZuInt( (char*)datum, &ende, 10 );
            datum = ende;
            ende = 0;
            break;
        default:
            ++datum;
            break;
        }
    }
    update();
}

void Datum::minusDatum( const char *format, Text *datum )
{
    minusDatum( format, datum->getText() );
    datum->release();
}

void Datum::minusJahr( int jahr ) // subtrahiert jahr Jahre
{
    this->jahr -= jahr;
    update();
}

void Datum::minusMonat( int monat ) // subtrahiert monat Monate
{
    this->monat -= monat;
    update();
}

void Datum::minusTag( int tag ) // subtrahiert tag Tage
{
    this->tag -= tag;
    update();
}

// constant 
int Datum::getJahr() const // gibt das Jahr zurück
{
    return jahr;
}

int Datum::getMonat() const // gibt der Monat zurück
{
    return monat;
}

int Datum::getTag() const // gibt der Tag zurück
{
    return tag;
}

Text *Datum::getDatum( const char *format ) const // gibt das Datum als Text formatiert zurück
{
    Text *ret = new Text( "" );
    int flän = textLänge( format );
    for( const char *f = format; f < format + flän; ++f )
    {
        switch( *f )
        {
        case 'y':
            ret->anhängen( jahr );
            break;
        case 'm':
            ret->anhängen( monat );
            break;
        case 'd':
            ret->anhängen( tag );
            break;
        default:
            ret->anhängen( f, 1 );
            break;
        }
    }
    return ret;
}

bool Datum::istGleich( Datum *datum ) const // prüft, ob das Datum gleich datum ist
{
    bool ret = jahr == datum->getJahr() &&
        monat == datum->getMonat() &&
        tag == datum->getTag();
    datum->release();
    return ret;
}

bool Datum::istGleich( const char *format, const char *datum ) const
{
    int j = jahr, m = monat, t = tag;
    int flän = textLänge( format );
    char *ende = 0;
    for( const char *f = format; f < format + flän; ++f )
    {
        switch( *f )
        {
        case 'y':
            j = TextZuInt( (char*)datum, &ende, 10 );
            datum = ende;
            ende = 0;
            break;
        case 'm':
            m = TextZuInt( (char*)datum, &ende, 10 );
            datum = ende;
            ende = 0;
            break;
        case 'd':
            t = TextZuInt( (char*)datum, &ende, 10 );
            datum = ende;
            ende = 0;
            break;
        default:
            ++datum;
            break;
        }
    }
    bool ret = jahr == j &&
        monat == m &&
        tag == t;
    return ret;
}

bool Datum::istGleich( const char *format, Text *datum ) const
{
    bool ret = istGleich( format, datum->getText() );
    datum->release();
    return ret;
}

bool Datum::istGleich( int jahr, int monat, int tag ) const
{
    return this->jahr == jahr &&
        this->monat == monat &&
        this->tag == tag;
}

bool Datum::jahrGleich( int jahr ) const // prüft, ob das Jahr gleich jahr ist
{
    return this->jahr == jahr;
}

bool Datum::monatGleich( int monat ) const // prüft, ob der Monat gleich monat ist
{
    return this->monat == monat;
}

bool Datum::tagGleich( int tag ) const // prüft, ob der Tag gleich tag ist
{
    return this->tag == tag;
}

bool Datum::istKleiner( Datum *datum ) const // prüft, ob die Datum kleiner als datum ist
{
    bool ret = istKleiner( datum->getJahr(), datum->getMonat(), datum->getTag() );
    datum->release();
    return ret;
}

bool Datum::istKleiner( int jahr, int monat, int tag ) const
{
    if( this->jahr < jahr )
        return 1;
    else if( this->jahr == jahr )
    {
        if( this->monat < monat )
            return 1;
        else if( this->monat == monat )
        {
            if( this->tag < tag )
                return 1;
            else if( this->tag == tag )
                return 0;
            else
                return 0;
        }
        else
            return 0;
    }
    else
        return 0;
}

bool Datum::istKleiner( const char *format, const char *datum ) const
{
    int j = jahr, m = monat, t = tag;
    int flän = textLänge( format );
    char *ende = 0;
    for( const char *f = format; f < format + flän; ++f )
    {
        switch( *f )
        {
        case 'y':
            j = TextZuInt( (char*)datum, &ende, 10 );
            datum = ende;
            ende = 0;
            break;
        case 'm':
            m = TextZuInt( (char*)datum, &ende, 10 );
            datum = ende;
            ende = 0;
            break;
        case 'd':
            t = TextZuInt( (char*)datum, &ende, 10 );
            datum = ende;
            ende = 0;
            break;
        default:
            ++datum;
            break;
        }
    }
    return istKleiner( j, m, t );
}

bool Datum::istKleiner( const char *format, Text *datum ) const
{
    bool ret = istKleiner( format, datum->getText() );
    datum->release();
    return ret;
}

bool Datum::istGrößer( Datum *datum ) const // prüft, ob die Datum größer als datum ist
{
    bool ret = istGrößer( datum->getJahr(), datum->getMonat(), datum->getTag() );
    datum->release();
    return ret;
}

bool Datum::istGrößer( int jahr, int monat, int tag ) const
{
    if( this->jahr > jahr )
        return 1;
    else if( this->jahr == jahr )
    {
        if( this->monat > monat )
            return 1;
        else if( this->monat == monat )
        {
            if( this->tag > tag )
                return 1;
            else if( this->tag == tag )
                return 0;
            else
                return 0;
        }
        else
            return 0;
    }
    else
        return 0;
}

bool Datum::istGrößer( const char *format, const char *datum ) const
{
    int j = jahr, m = monat, t = tag;
    int flän = textLänge( format );
    char *ende = 0;
    for( const char *f = format; f < format + flän; ++f )
    {
        switch( *f )
        {
        case 'y':
            j = TextZuInt( (char*)datum, &ende, 10 );
            datum = ende;
            ende = 0;
            break;
        case 'm':
            m = TextZuInt( (char*)datum, &ende, 10 );
            datum = ende;
            ende = 0;
            break;
        case 'd':
            t = TextZuInt( (char*)datum, &ende, 10 );
            datum = ende;
            ende = 0;
            break;
        default:
            ++datum;
            break;
        }
    }
    return istGrößer( j, m, t );
}

bool Datum::istGrößer( const char *format, Text *datum ) const
{
    bool ret = istGrößer( format, datum->getText() );
    datum->release();
    return ret;
}

// Reference Counting 
Datum *Datum::getThis()
{
    ++ref;
    return this;
}

Datum *Datum::release()
{
    --ref;
    if( !ref )
        delete this;
    return 0;
}

// Inhalt der Zeit Klasse aus Zeit.h
// Konstruktor 
Zeit::Zeit()
    : datum( new Datum() ),
    uhrzeit( new Uhrzeit() ),
    ref( 1 )
{}

// Destruktor 
Zeit::~Zeit()
{
    datum->release();
    uhrzeit->release();
}

// nicht constant 
void Zeit::setZeit( Zeit *zeit ) // setzt die Zeit
{
    datum->setDatum( zeit->getDatum() );
    datum->plusTag( uhrzeit->setUhrzeit( zeit->getUhrzeit() ) );
    zeit->release();
}

void Zeit::setZeit( int jahr, int monat, int tag, int stunde, int minute, int sekunde )
{
    datum->setDatum( jahr, monat, tag );
    datum->plusTag( uhrzeit->setUhrzeit( stunde, minute, sekunde ) );
}

void Zeit::setZeit( const char *format, const char *zeit ) // format Beispiele: "Y:m:d H-i-s", "Y-m-d H:i:s" (Y=Jahr,m=Monat,d=tag,H=stunde,i=minute,s=sekunde)
{
    int y = datum->getJahr();
    int m = datum->getMonat();
    int d = datum->getTag();
    int h = uhrzeit->getStunde();
    int i = uhrzeit->getMinute();
    int s = uhrzeit->getSekunde();

    int flän = textLänge( format );
    char *ende = 0;
    for( const char *f = format; f < format + flän; ++f )
    {
        switch( *f )
        {
        case 'y':
            y = TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 'm':
            m = TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 'd':
            d = TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 'h':
            h = TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 'i':
            i = TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 's':
            s = TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        default:
            ++zeit;
            break;
        }
    }
    datum->setDatum( y, m, d );
    datum->plusTag( uhrzeit->setUhrzeit( h, i, s ) );
}

void Zeit::setZeit( const char *format, Text *zeit )
{
    setZeit( format, zeit->getText() );
    zeit->release();
}

void Zeit::setJahr( int jahr ) // setzt das Jahr
{
    datum->setJahr( jahr );
}

void Zeit::setMonat( int monat ) // setzt den Monat
{
    datum->setMonat( monat );
}

void Zeit::setTag( int tag ) // setzt den Tag
{
    datum->setTag( tag );
}

void Zeit::setStunde( int stunde ) // setzt die Stunde
{
    datum->plusTag( uhrzeit->setStunde( stunde ) );
}

void Zeit::setMinute( int minute ) // setzt die Minute
{
    datum->plusTag( uhrzeit->setMinute( minute ) );
}

void Zeit::setSekunde( int sekunde ) // setzt die Sekunde
{
    datum->plusTag( uhrzeit->setSekunde( sekunde ) );
}

void Zeit::plusZeit( Zeit *zeit ) // addiert die zeit
{
    datum->plusDatum( zeit->getDatum() );
    datum->plusTag( uhrzeit->plusUhrzeit( zeit->getUhrzeit() ) );
    zeit->release();
}

void Zeit::plusZeit( int jahr, int monat, int tag, int stunde, int minute, int sekunde )
{
    datum->plusDatum( jahr, monat, tag );
    datum->plusTag( uhrzeit->plusUhrzeit( stunde, minute, sekunde ) );
}

void Zeit::plusZeit( const char *format, const char *zeit )
{
    int y = datum->getJahr();
    int m = datum->getMonat();
    int d = datum->getTag();
    int h = uhrzeit->getStunde();
    int i = uhrzeit->getMinute();
    int s = uhrzeit->getSekunde();

    int flän = textLänge( format );
    char *ende = 0;
    for( const char *f = format; f < format + flän; ++f )
    {
        switch( *f )
        {
        case 'y':
            y += TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 'm':
            m += TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 'd':
            d += TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 'h':
            h += TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 'i':
            i += TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 's':
            s += TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        default:
            ++zeit;
            break;
        }
    }
    datum->setDatum( y, m, d );
    datum->plusTag( uhrzeit->setUhrzeit( h, i, s ) );
}

void Zeit::plusZeit( const char *format, Text *zeit )
{
    plusZeit( format, zeit->getText() );
    zeit->release();
}

void Zeit::plusJahr( int jahr ) // addiert jahr Jahre
{
    datum->plusJahr( jahr );
}

void Zeit::plusMonat( int monat ) // addiert monat Monate
{
    datum->plusMonat( monat );
}

void Zeit::plusTag( int tag ) // addiert tag Tage
{
    datum->plusTag( tag );
}

void Zeit::plusStunde( int stunde ) // addiert stunde Stunden
{
    datum->plusTag( uhrzeit->plusStunde( stunde ) );
}

void Zeit::plusMinute( int minute ) // addiert minute Minuten
{
    datum->plusTag( uhrzeit->plusMinute( minute ) );
}

void Zeit::plusSekunde( int sekunde ) // addiert sekunde Sekunden
{
    datum->plusTag( uhrzeit->plusSekunde( sekunde ) );
}

void Zeit::minusZeit( Zeit *zeit ) // subtrahiert die zeit
{
    datum->minusDatum( zeit->getDatum() );
    datum->plusTag( uhrzeit->minusUhrzeit( zeit->getUhrzeit() ) );
    zeit->release();
}

void Zeit::minusZeit( int jahr, int monat, int tag, int stunde, int minute, int sekunde )
{
    datum->minusDatum( jahr, monat, tag );
    datum->plusTag( uhrzeit->plusUhrzeit( stunde, minute, sekunde ) );
}

void Zeit::minusZeit( const char *format, const char *zeit )
{
    int y = datum->getJahr();
    int m = datum->getMonat();
    int d = datum->getTag();
    int h = uhrzeit->getStunde();
    int i = uhrzeit->getMinute();
    int s = uhrzeit->getSekunde();

    int flän = textLänge( format );
    char *ende = 0;
    for( const char *f = format; f < format + flän; ++f )
    {
        switch( *f )
        {
        case 'y':
            y -= TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 'm':
            m -= TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 'd':
            d -= TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 'h':
            h += TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 'i':
            i -= TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 's':
            s -= TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        default:
            ++zeit;
            break;
        }
    }
    datum->setDatum( y, m, d );
    datum->plusTag( uhrzeit->setUhrzeit( h, i, s ) );
}

void Zeit::minusZeit( const char *format, Text *zeit )
{
    minusZeit( format, zeit->getText() );
    zeit->release();
}

void Zeit::minusJahr( int jahr ) // subtrahiert jahr Jahre
{
    datum->minusJahr( jahr );
}

void Zeit::minusMonat( int monat ) // subtrahiert monat Monate
{
    datum->minusMonat( monat );
}

void Zeit::minusTag( int tag ) // subtrahiert tag Tage
{
    datum->minusTag( tag );
}

void Zeit::minusStunde( int stunde ) // subtrahiert stunde Stunden
{
    datum->plusTag( uhrzeit->minusStunde( stunde ) );
}

void Zeit::minusMinute( int minute ) // subtrahiert minute Minuten
{
    datum->plusTag( uhrzeit->minusMinute( minute ) );
}

void Zeit::minusSekunde( int sekunde ) // subtrahiert sekunde Sekunden
{
    datum->plusTag( uhrzeit->minusSekunde( sekunde ) );
}

// constant 
Text *Zeit::getZeit( const char *format ) const // gibt die Zeit als Text formatiert zurück
{
    Text *ret = new Text( "" );
    int flän = textLänge( format );
    for( const char *f = format; f < format + flän; ++f )
    {
        switch( *f )
        {
        case 'y':
            ret->anhängen( datum->getJahr() );
            break;
        case 'm':
            ret->anhängen( datum->getMonat() );
            break;
        case 'd':
            ret->anhängen( datum->getTag() );
            break;
        case 'h':
            ret->anhängen( uhrzeit->getStunde() );
            break;
        case 'i':
            ret->anhängen( uhrzeit->getMinute() );
            break;
        case 's':
            ret->anhängen( uhrzeit->getSekunde() );
            break;
        default:
            ret->anhängen( f, 1 );
        }
    }
    return ret;
}

bool Zeit::istGleich( Zeit *zeit ) const // prüft, ob die Uhrzeit gleich zeit ist
{
    bool ret = datum->istGleich( zeit->getDatum() ) && uhrzeit->istGleich( zeit->getUhrzeit() );
    zeit->release();
    return ret;
}

bool Zeit::istGleich( const char *format, const char *zeit ) const
{
    int y = datum->getJahr();
    int m = datum->getMonat();
    int d = datum->getTag();
    int h = uhrzeit->getStunde();
    int i = uhrzeit->getMinute();
    int s = uhrzeit->getSekunde();

    int flän = textLänge( format );
    char *ende = 0;
    for( const char *f = format; f < format + flän; ++f )
    {
        switch( *f )
        {
        case 'y':
            y = TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 'm':
            m = TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 'd':
            d = TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 'h':
            h = TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 'i':
            i = TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 's':
            s = TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        default:
            ++zeit;
            break;
        }
    }
    return datum->istGleich( y, m, d ) && uhrzeit->istGleich( h, i, s );
}

bool Zeit::istGleich( const char *format, Text *zeit ) const
{
    bool ret = istGleich( format, zeit->getText() );
    zeit->release();
    return ret;
}

bool Zeit::istGleich( int jahr, int monat, int tag, int stunde, int minute, int sekunde ) const
{
    return datum->istGleich( jahr, monat, tag ) && uhrzeit->istGleich( stunde, minute, sekunde );
}

Datum *Zeit::getDatum() const // gibt das Datum zurück
{
    return datum->getThis();
}

Datum *Zeit::zDatum() const
{
    return datum;
}

Uhrzeit *Zeit::getUhrzeit() const // gibt die Uhrzeit zurück
{
    return uhrzeit->getThis();
}

Uhrzeit *Zeit::zUhrzeit() const
{
    return uhrzeit;
}

bool Zeit::istKleiner( Zeit *zeit ) const // prüft, ob die Zeit kleiner als zeit ist
{
    if( datum->istKleiner( zeit->getDatum() ) )
    {
        zeit->release();
        return 1;
    }
    else if( datum->istGleich( zeit->getDatum() ) )
    {
        if( uhrzeit->istKleiner( zeit->getUhrzeit() ) )
        {
            zeit->release();
            return 1;
        }
        else
        {
            zeit->release();
            return 0;
        }
    }
    else
    {
        zeit->release();
        return 0;
    }
}

bool Zeit::istKleiner( int jahr, int monat, int tag, int stunde, int minute, int sekunde ) const
{
    if( datum->istKleiner( jahr, monat, tag ) )
        return 1;
    else if( datum->istGleich( jahr, monat, tag ) )
    {
        if( uhrzeit->istKleiner( stunde, minute, sekunde ) )
            return 1;
        else
            return 0;
    }
    else
        return 0;
}

bool Zeit::istKleiner( const char *format, const char *zeit ) const
{
    int y = datum->getJahr();
    int m = datum->getMonat();
    int d = datum->getTag();
    int h = uhrzeit->getStunde();
    int i = uhrzeit->getMinute();
    int s = uhrzeit->getSekunde();

    int flän = textLänge( format );
    char *ende = 0;
    for( const char *f = format; f < format + flän; ++f )
    {
        switch( *f )
        {
        case 'y':
            y = TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 'm':
            m = TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 'd':
            d = TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 'h':
            h = TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 'i':
            i = TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 's':
            s = TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        default:
            ++zeit;
            break;
        }
    }
    if( datum->istKleiner( y, m, d ) )
        return 1;
    else if( datum->istGleich( y, m, d ) )
    {
        if( uhrzeit->istKleiner( h, i, s ) )
            return 1;
        else
            return 0;
    }
    else
        return 0;
}

bool Zeit::istKleiner( const char *format, Text *zeit ) const
{
    bool ret = istKleiner( format, zeit->getText() );
    zeit->release();
    return ret;
}

bool Zeit::istGrößer( Zeit *zeit ) const // prüft, ob die Zeit größer als zeit ist
{
    if( datum->istGrößer( zeit->getDatum() ) )
    {
        zeit->release();
        return 1;
    }
    else if( datum->istGleich( zeit->getDatum() ) )
    {
        if( uhrzeit->istGrößer( zeit->getUhrzeit() ) )
        {
            zeit->release();
            return 1;
        }
        else
        {
            zeit->release();
            return 0;
        }
    }
    else
    {
        zeit->release();
        return 0;
    }
}

bool Zeit::istGrößer( int jahr, int monat, int tag, int stunde, int minute, int sekunde ) const
{
    if( datum->istGrößer( jahr, monat, tag ) )
        return 1;
    else if( datum->istGleich( jahr, monat, tag ) )
    {
        if( uhrzeit->istGrößer( stunde, minute, sekunde ) )
            return 1;
        else
            return 0;
    }
    else
        return 0;
}

bool Zeit::istGrößer( const char *format, const char *zeit ) const
{
    int y = datum->getJahr();
    int m = datum->getMonat();
    int d = datum->getTag();
    int h = uhrzeit->getStunde();
    int i = uhrzeit->getMinute();
    int s = uhrzeit->getSekunde();

    int flän = textLänge( format );
    char *ende = 0;
    for( const char *f = format; f < format + flän; ++f )
    {
        switch( *f )
        {
        case 'y':
            y = TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 'm':
            m = TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 'd':
            d = TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 'h':
            h = TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 'i':
            i = TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        case 's':
            s = TextZuInt( (char*)zeit, &ende, 10 );
            zeit = ende;
            ende = 0;
            break;
        default:
            ++zeit;
            break;
        }
    }
    if( datum->istGrößer( y, m, d ) )
        return 1;
    else if( datum->istGleich( y, m, d ) )
    {
        if( uhrzeit->istGrößer( h, i, s ) )
            return 1;
        else
            return 0;
    }
    else
        return 0;
}

bool Zeit::istGrößer( const char *format, Text *zeit ) const
{
    bool ret = istGrößer( format, zeit->getText() );
    zeit->release();
    return ret;
}

// Reference Counting 
Zeit *Zeit::getThis()
{
    ++ref;
    return this;
}

Zeit *Zeit::release()
{
    --ref;
    if( !ref )
        delete this;
    return 0;
}

// Inhalt der ZeitMesser Klasse aus Zeit.h
// Konstruktor 
ZeitMesser::ZeitMesser()
    : start( 0 ),
    ende( 0 ),
    messung( 0 ),
    ref( 1 )
{}

// Destruktor 
ZeitMesser::~ZeitMesser()
{

}

// nicht constant 
void ZeitMesser::messungStart() // legt des Startpunkt der Zeitmessung fest
{
    timeval tv;
    gettimeofday( &tv, 0 );
    start = tv.tv_sec + tv.tv_usec / 1000000.0;
}

void ZeitMesser::messungEnde() // legt des Endpunkt der Zeitmessung fest
{
    timeval tv;
    gettimeofday( &tv, 0 );
    ende = tv.tv_sec + tv.tv_usec / 1000000.0;
    messung = ende - start;
}

// constant 
double ZeitMesser::getSekunden() const // gibt den sekundenabstand zwischen start und ende der Messung zurück
{
    return messung;
}

double ZeitMesser::getMinuten() const // gibt den minutenabstand zwischen start und ende der Messung zurück
{
    return messung / 60;
}

double ZeitMesser::getStunden() const // gibt den stundenabstand zwischen start und ende der Messung zurück
{
    return messung / 3600;
}

// Reference Counting 
ZeitMesser *ZeitMesser::getThis()
{
    ++ref;
    return this;
}

ZeitMesser *ZeitMesser::release()
{
    --ref;
    if( !ref )
        delete this;
    return 0;
}

// Globale Funktionen 
Uhrzeit *Framework::getUhrzeit() // gibt die aktuelle Uhrzeit zurück
{
#ifdef WIN32
    Uhrzeit *ret = new Uhrzeit();
    time_t Zeitstempel = time( 0 );
    tm now;
    localtime_s( &now, &Zeitstempel );
    ret->setUhrzeit( now.tm_hour, now.tm_min, now.tm_sec );
    return ret;
#else
    Uhrzeit *ret = new Uhrzeit();
    time_t Zeitstempel = time( 0 );
    tm *now = localtime( &Zeitstempel );
    ret->setUhrzeit( now->tm_hour, now->tm_min, now->tm_sec );
    return ret;
#endif
}

Datum *Framework::getDatum() // gibt das aktuelle Datum zurück
{
#ifdef WIN32
    Datum *ret = new Datum();
    time_t Zeitstempel = time( 0 );
    tm now;
    localtime_s( &now, &Zeitstempel );
    ret->setDatum( now.tm_year + 1900, now.tm_mon + 1, now.tm_mday );
    return ret;
#else
    Datum *ret = new Datum();
    time_t Zeitstempel = time( 0 );
    tm *now = localtime( &Zeitstempel );
    ret->setDatum( now->tm_year + 1900, now->tm_mon + 1, now->tm_mday );
    return ret;
#endif
}

Zeit *Framework::getZeit() // gibt die aktuelle Zeit( Datum und Uhrzeit ) zurück
{
#ifdef WIN32
    Zeit *ret = new Zeit();
    time_t Zeitstempel = time( 0 );
    tm now;
    localtime_s( &now, &Zeitstempel );
    ret->setZeit( now.tm_year + 1900, now.tm_mon + 1, now.tm_mday, now.tm_hour, now.tm_min, now.tm_sec );
    return ret;
#else
    Zeit *ret = new Zeit();
    time_t Zeitstempel = time( 0 );
    tm *now = localtime( &Zeitstempel );
    ret->setZeit( now->tm_year + 1900, now->tm_mon + 1, now->tm_mday, now->tm_hour, now->tm_min, now->tm_sec );
    return ret;
#endif
}

bool Framework::istSchaltjahr( int jahr ) // prüft, ob jahr ein Schaltjahr ist
{
    if( jahr % 4 == 0 )
    {
        if( jahr % 100 == 0 )
        {
            if( jahr % 400 == 0 )
                return true;
            else
                return false;
        }
        else
            return true;
    }
    else
        return false;
}