//---------------------------------------------------------------------------

#ifndef UhrzeitH_238329
#define UhrzeitH_238329

/*

Diese Klasse liefert benötigte Zeitfunktionen um eine Tageszeit
anzuzeigen, berechnen und umzurechnen

Anwendung:
Uhrzeit.h evt. umbenennen und in den Include Pfad kopieren
(oder Pfad wo Header Dateien erwartet werden)
Uhrzeit.obj evt umbennen und in den Pfad für Objektdateien kopieren
Dem Compiler die Objektdatei bekanntgeben
Sollte in einer .cpp Datei die Uhrzeit gebraucht werden am Anfang:
#include "Uhrzeit.h"
und dann entweder using namespace mr;
oder jedesmal mit mr::Uhrzeit aufrufen

Bsp:

#include 
#include "Uhrzeit.h"
using namespace std;
using namespace mr;

int main ()
{
        Uhrzeit Guten_Morgen (10); //10 Uhr
        Uhrzeit Jetzt;
        Jetzt.SetZeit();          //stellt Jetzt auf aktuelle Zeit
        if (Jetzt < Guten_Morgen)
                std::cout << "Guten Morgen, es ist " << Jetzt << " Uhr";
        else
                cout << Jetzt << endl;
        cin.get();
        return 0;               //Teil OS mit, dass kein Fehler auftrat
}

*/



//Author: Markus Raab
//Firma:  Metropolitan

// 9. August 2001

#include 
#include 
#include 
using namespace std;

//---------------------------------------------------------------------------


using namespace std;

namespace mr
{

class  Uhrzeit
{
private:
        int itsStunden, itsMinuten, itsSekunden;

//---------------------------------------------------------------------------

public: // Funktionen

        Uhrzeit(int Stunden = 0, int Minuten = 0, int Sekunden = 0);

                //Ueberlauf beachten    (im Anhang A)
                //Default Werte         (im Anhang B)

        ~Uhrzeit();

        bool SetZeit();

                //speichert aktuelle Zeit in das Objekt

        bool SetZeit(int Stunden, int Minuten = 0, int Sekunden = 0);

                //setzt die Zeit auf diese Werte
                //Default Werte         (im Anhang B)
                //es muss aber 1 Wert vorhanden sein, sonst aktuelle Zeit
                //KEINE Verschiebung    (im Anhang C)

        bool AddZeit(int Stunden, int Minuten = 0, int Sekunden = 0);

                //Verschiebung          (im Anhang C)
                //bei Fehler wird die vorige Zeit wiederhergestellt und false
                //geliefert
                //Negative Zahlen haben undefiniertes Ergebnis!

        bool Save(ofstream & os) const;
        bool Load(ifstream & is);

                //Speicher und Laden    (im Anhang D)

        bool SetSekunden (int Sekunden);
        bool SetMinuten  (int Minuten);
        bool SetStunden  (int Stunden);

                //damit kann man die Sekunden, Minuten und Stunden einspeichern
                //bei Fehler wird der Wert auf 0 gesetzt und false geliefert
                //KEINE Verschiebung    (im Anhang C)

        bool SetString (string & String);
        bool SetChar   (char * Char);

                //Char oder string uebergeben
                //8 Zeichen lang xx.xx:xx (Zwischenzeichen beliebig)
                //achtung char muss 9 lang sein def: char test [9];

        bool AddSekunden (int Sekunden);
        bool AddMinuten  (int Minuten);
        bool AddStunden  (int Stunden);

                //Verschiebung:         (im Anhang C)

protected:

        void Sekunden     (int Sekunden) {itsSekunden = Sekunden;}
        void Minuten      (int Minuten)  {itsMinuten  = Minuten;}
        void Stunden      (int Stunden)  {itsStunden  = Stunden;}

                //Zeit wird OHNE JEDLICHE UBERPRUEFUNG uebergeben
                //ABSTURZGEFAHR, sollte NICHT verwendet werden!!!
                //Ist NUR fuer Abgeleitete Klassen, die einen schnellen
                //Zugriff benoetigen

public:

        int AsSekunden () const;
        int AsMinuten  () const;
        int AsStunden  () const;

                //liefert Zahlen in verschieden Einheiten z.B:
                //AsSekunden(): 1800 AsMinuten():30 AsStunden(): 0.5

        string AsString () const;
        void   AsChar   (char *) const;

                //liefert die Zeit als string ( includieren!) oder char*


//---------------------------------------------------------------------------

public:

        //definiert benoetigte Operatoren

        Uhrzeit operator -() const;

                //da negative Zeit nicht erlaubt, setzt der operator Zeit auf 0

        Uhrzeit operator + (const Uhrzeit & Time);
        Uhrzeit operator - (const Uhrzeit & Time);

        Uhrzeit operator * (const Uhrzeit & Time);
        Uhrzeit operator / (const Uhrzeit & Time);

                //Operator / dividiert die Werte einzeln, sollte eine division
                //durch 0 sein, wird 0 als Ergebnis geliefert

        Uhrzeit & operator += (const Uhrzeit & Time);
        Uhrzeit & operator -= (const Uhrzeit & Time);

//---------------------------------------------------------------------------

public:

        //alle benoetigen Vergleichsoperatoren

        const bool operator >  (const Uhrzeit & Time);
        const bool operator <  (const Uhrzeit & Time);
        const bool operator <= (const Uhrzeit & Time);
        const bool operator >= (const Uhrzeit & Time);

        const bool operator == (const Uhrzeit & Time);
        const bool operator != (const Uhrzeit & Time);

public: //inline

        int GetSekunden () const {return itsSekunden;}
        int GetMinuten  () const {return itsMinuten ;}
        int GetStunden  () const {return itsStunden ;}
                //Einzelwerte koennen auch gelesen werden
};

//---------------------------------------------------------------------------

ostream& operator << (ostream & os, Uhrzeit & Time);
istream& operator >> (istream & is, Uhrzeit & Time);


/*

Bsp:
#include "Uhrzeit.h"
#include 
using namespace mr;

int main() {
        Uhrzeit Heute (10,20,30);
        std::cout << Heute;                //Gibt Datum auf Konsole
        std::cin >> Heute;                 //Liest neue Zeit ein (xx.xx.xx)
}

*/

} //MR ende

#endif // UhrzeitH_238329

/*

//---------------------------------------------------------------------------

Anhang A
Ueberlaufe werden folgendermassen behandelt

Ueberlauf bei Initialisierung
Die Stunden werden 0 gesetzt, sonst wird die gewuenscht Zeit angezeigt
z.b: Uhrzeit Abend (40,15,12) -> (00.15:12)
     Uhrzeit Frueh (20,12,10000000) -> (20.12:00)
ABER: handelt es sich um keinen Ueberlauf, wird die Zeit umgerechnet!!!!
z.b: Uhrzeit Click (12,15,80) -> (12.16:20)

Ueberlauf bei Rechenoperationen und bei AddSekunden, AddMinuten, AddStunden
Zeit bleibt gleich
z.B  Uhrzeit Termin1 (12,30,10); Termin1.AddSekunden (1000000);
      -> Termin1     (12.30:10);
ABER: handelt es sich um keinen Ueberlauf, wird die Zeit umgerechnet!!!!


//---------------------------------------------------------------------------

Anhang B
Default Werte

werden nur 2 Werte ubergeben:
Sekunden = 0
wird nur 1 Wert ubergeben:
Minuten = 0, Sekunden = 0
wird kein Wert ubergeben: (Default Konstruktor)
Stunden = 0, Minuten = 0, Sekunden = 0


//---------------------------------------------------------------------------

Anhang C
Verschiebung

Bei bestimmten Funktionen ist teilweise eine Verschiebung beabsichtigt.
Dabei handelt es sich um Weitergeben von Zahlen bei Ueberlauf von Sekunden
oder Minuten

Bsp:  Uhrzeit T1 (2,180,300) ->  T1 (05.06:00)
      weil 300 sec 6 Minuten sind (werden zu Stunden addiert)
      weil 180 min 3 Stunden sind (werden zu Stunden addiert)


//---------------------------------------------------------------------------

Anhang D
Speichern und Laden

Dazu muss eine ofstream Datei mit den Flags ios::binary | ios::out
geoeffnet werden.
Die "Datei" dann beim Speicher uebergeben
Beim Laden muss eine ifstream Datei mit denselben Flags
geoffnet werden.
Wichtig:  includieren und namespace std verwenden)
Bsp:

#include "Uhrzeit.h"
#include 
using namespace mr;
int main() {
        std::ofstream Datei ("[Laufwerk]:\\[Pfad]\\[Dateiname].[Anhang]"
                ,ios::binary | ios::out);
        Uhrzeit Jetzt; Jetzt.SetTime();
        Jetzt.Save (Datei);
        //ACHTUNG!!! wollen sie hier schon von der Datei lesen, muessen sie die
        //Datei schliessen!!! :
        Datei.close(); //eigentlich unnütz, da der Destruktor von ofstream diese
                        //aktion erledigt
}

Bsp:
#include "Uhrzeit.h"
#include 
using namespace mr;
int main() {
        std::ifstream Datei ("C:\\Hallo\\jetzt.dat", ios::binary | ios::out);
        Uhrzeit WieSpaet; WieSpaet.Load(Datei);
}

*/

//---------------------------------------------------------------------------