zeitverlauf_Versuch1.cpp

gehe zur Dokumentation dieser Datei

#include "zeitverlauf.h"

#include <strstream>
using std::ostrstream;

QTime MinSec (int mins, int secs){
        if (secs>=60) qDebug("ERROR: QTime MinSec secs>=60");
        return QTime(mins/60, mins%60, secs,0);
}

ostream& operator<< (ostream& os, const structGesamteEinschaetzung& rhs){
        os << rhs.Einschaetzung <<"\t"<< rhs.EinschaetzungDavor <<"\t";
    os << rhs.Dauer ;
        return os;
}

ZeitVerlauf::ZeitVerlauf () {
        Sinneinheiten.insert(QTime2Einschaetzung::value_type(QTime(0,0,0,0),null));
};

void ZeitVerlauf::anhaengen(const QTime &Endmoment, const EinschaetzungsSkala Einschaetzung){
        Sinneinheiten.insert(QTime2Einschaetzung::value_type(Endmoment,Einschaetzung));
}

QTime ZeitVerlauf::LetzterMoment(){
        QTime2Einschaetzung::iterator it=Sinneinheiten.end();
        it--;
        return it->first;
}

// obsolet (siehe ZeitVerlauf::GesamteEinschaetzung)
EinschaetzungsSkala ZeitVerlauf::Einschaetzung (const QTime &Endmoment){
        QTime2Einschaetzung::iterator it;
        it=Sinneinheiten.find(Endmoment);
        if (it==Sinneinheiten.end()) return null;
        else return it->second;
}

// obsolet (siehe ZeitVerlauf::GesamteEinschaetzung)
EinschaetzungsSkala ZeitVerlauf::EinschaetzungDavor (const QTime &Endmoment){
        QTime2Einschaetzung::iterator it;
        it=Sinneinheiten.find(Endmoment); 
        if (it==Sinneinheiten.end() || it==Sinneinheiten.begin()) 
                return null; // Intervallende existiert nicht oder schon am Intervallanfang
        it--;
        return it->second;
}

// obsolet (siehe ZeitVerlauf::GesamteEinschaetzung)
int ZeitVerlauf::Dauer (const QTime &Endmoment){
        QTime2Einschaetzung::iterator it2, it1;
        it2=Sinneinheiten.find(Endmoment);
        if (it2==Sinneinheiten.end()) return -2; // Intervallende existiert nicht
        if (it2==Sinneinheiten.begin()) return -1; // Intervallanfang existiert nicht
        it1=it2; it1--;
        return (it1->first).secsTo(it2->first);
};

structGesamteEinschaetzung ZeitVerlauf::GesamteEinschaetzung (const QTime &Endmoment){
        structGesamteEinschaetzung temp;

        QTime2Einschaetzung::iterator it2, it1;
        it2=Sinneinheiten.find(Endmoment);
        if (it2==Sinneinheiten.end())   // Intervallende existiert nicht
                return structGesamteEinschaetzung(null,null,-2); 
        if (it2==Sinneinheiten.begin()) // Intervallanfang existiert nicht
                return structGesamteEinschaetzung(null,null,-1); 
        temp.Einschaetzung=it2->second;
        it1=it2;  it1--;
        temp.EinschaetzungDavor=it1->second;
        temp.Dauer=(it1->first).secsTo(it2->first);
        return temp;
}

bool ZeitVerlauf::printGesamteEinschaetzung (const QTime &Endmoment, QString &ergebnis){
        structGesamteEinschaetzung ges;
        ges=GesamteEinschaetzung (Endmoment);
        
        ostrstream ss;
        ss << Endmoment.toString().latin1() ;
        if ( ges.Dauer<0 ) {
                ss << '\0';
                ergebnis=ss.str();
                return false;
        }
        ss <<"\t"<< ges <<'\0';
        ergebnis=ss.str();
        return true;
}
/*
bool printGesamtenZeitVerlauf (QString &ergebnis){
        bool korrekt=true;
        structGesamteEinschaetzung jetzt, vorher;
        ostrstream ss;
        QTime2Einschaetzung::iterator it;
        it=verlauf.begin();
        ss<<(*it).first.toString();

        for ( ; it!= verlauf.end(); ++it){
                ss<< (*it).first.toString();
                 (*theIterator).second);

*/

void ZeitVerlauf::testZeitverlauf(){
        anhaengen (MinSec(0,13), TL);
        anhaengen (MinSec(0,23), TNL);
        anhaengen (MinSec(0,37), KNL);
        anhaengen (MinSec(1,10), KL);
        qDebug("Einschätzung (0:00) %d", Einschaetzung(MinSec(0,0)) );
        qDebug("Einschätzung (0:13) %d", Einschaetzung(MinSec(0,13)) );
        qDebug("Einschätzung (0:23) %d", Einschaetzung(MinSec(0,23)) );
        qDebug("Einschätzung (0:37) %d", Einschaetzung(MinSec(0,37)) );
        qDebug("Einschätzung (1:10) %d", Einschaetzung(MinSec(1,10)) );
        qDebug("Einschätzung (1:11) %d", Einschaetzung(MinSec(1,11)) );

        qDebug("EinschätzungDavor (0:00) %d", EinschaetzungDavor(MinSec(0,0)) );
        qDebug("EinschätzungDavor (0:13) %d", EinschaetzungDavor(MinSec(0,13)) );
        qDebug("EinschätzungDavor (0:23) %d", EinschaetzungDavor(MinSec(0,23)) );
        qDebug("EinschätzungDavor (0:37) %d", EinschaetzungDavor(MinSec(0,37)) );
        qDebug("EinschätzungDavor (1:10) %d", EinschaetzungDavor(MinSec(1,10)) );
        qDebug("EinschätzungDavor (1:11) %d", EinschaetzungDavor(MinSec(1,11)) );

        qDebug("Dauer (0:00) %d", Dauer(MinSec(0,0)) );
        qDebug("Dauer (0:13) %d", Dauer(MinSec(0,13)) );
        qDebug("Dauer (0:23) %d", Dauer(MinSec(0,23)) );
        qDebug("Dauer (0:37) %d", Dauer(MinSec(0,37)) );
        qDebug("Dauer (1:10) %d", Dauer(MinSec(1,10)) );
        qDebug("Dauer (1:11) %d", Dauer(MinSec(1,11)) );

        qDebug("letzter Moment " + LetzterMoment().toString() );

    QTime EndMoment;
        structGesamteEinschaetzung ges;
        ostrstream ss;

        EndMoment=MinSec(1,10);
        ges=GesamteEinschaetzung(EndMoment);
        ss << EndMoment.toString().latin1() <<"\t"<< ges <<"\n"<<'\0';
        qDebug(ss.str());

        QString testString;     bool korrekt;
        korrekt=printGesamteEinschaetzung (MinSec(0,0), testString); qDebug(testString);
        korrekt=printGesamteEinschaetzung (MinSec(0,13), testString); qDebug(testString);
        korrekt=printGesamteEinschaetzung (MinSec(0,23), testString); qDebug(testString);
        korrekt=printGesamteEinschaetzung (MinSec(0,37), testString); qDebug(testString);
        korrekt=printGesamteEinschaetzung (MinSec(1,10), testString); qDebug(testString);
        korrekt=printGesamteEinschaetzung (MinSec(1,11), testString); qDebug(testString);
        korrekt=printGesamteEinschaetzung (MinSec(71,11), testString); qDebug(testString);
};

void testQTimeMap(){
        QTime2Einschaetzung verlauf;
        QTime2Einschaetzung::iterator theIterator;

        QTime Endzeitpunkt=QTime(0,1,12,0);
        verlauf.insert(QTime2Einschaetzung::value_type(Endzeitpunkt,TL));
        Endzeitpunkt=Endzeitpunkt.addSecs(7);
        verlauf.insert(QTime2Einschaetzung::value_type(Endzeitpunkt,KL));
        Endzeitpunkt=Endzeitpunkt.addSecs(-70);
        verlauf.insert(QTime2Einschaetzung::value_type(Endzeitpunkt,TNL));
        verlauf.insert(QTime2Einschaetzung::value_type(Endzeitpunkt,KNL));

    for (theIterator = verlauf.begin(); theIterator!= verlauf.end(); ++theIterator)
        qDebug((*theIterator).first.toString()+" %d", (*theIterator).second);

        QTime Endzeitpunkt2=Endzeitpunkt.addSecs(1);
        ;
        QTime2Einschaetzung::key_compare vergleiche=verlauf.key_comp();
        qDebug("vergleich<: %d",vergleiche(Endzeitpunkt, Endzeitpunkt2));
        qDebug("vergleich>=: %d",vergleiche(Endzeitpunkt2, Endzeitpunkt));

        qDebug("Bekannter Eintrag: %d",verlauf.find(QTime(0,1,19,0))->second);
        qDebug("Unbekannter Eintrag(=end()): %d",verlauf.find(QTime(0,1,18,0))->second);

        qDebug("bounds liefern gleichen, höheren key oder end()");
    theIterator=verlauf.lower_bound(QTime(0,1,11,0));
        qDebug("lower bound (1:11): "+ theIterator->first.toString());
        theIterator=verlauf.upper_bound(QTime(0,1,11,0));
        qDebug("upper bound (1:11): "+ theIterator->first.toString());

    theIterator=verlauf.lower_bound(QTime(0,1,20,0));
        qDebug("lower bound (1:20): "+ theIterator->first.toString());
        theIterator=verlauf.upper_bound(QTime(0,1,20,0));
        qDebug("upper bound (1:20): "+ theIterator->first.toString());

        qDebug("Bei Treffer: lower bound liefert gleichen, upper bound liefert höheren key (oder end())");
    theIterator=verlauf.lower_bound(QTime(0,1,12,0));
        qDebug("lower bound (1:12): "+ theIterator->first.toString());
        theIterator=verlauf.upper_bound(QTime(0,1,12,0));
        qDebug("upper bound (1:12): "+ theIterator->first.toString());
        theIterator=verlauf.upper_bound(QTime(0,1,19,0));
        qDebug("upper bound (1:19): "+ theIterator->first.toString());

        // Also für schon verbrauchten Zeitpunkten: 
        // Suche nach lower_bound(Reglerstand), rot wenn <> end();
};

---